Commit e2341411 by Francois Gygi

cleanup namespaces in headers. Reduced dependency on Sample.h. Moved

facs, sigmas parameters to ConfinementPotential.


git-svn-id: http://qboxcode.org/svn/qb/trunk@489 cba15fb0-1239-40c8-b417-11db7ca47a34
parent 111a6e6b
......@@ -3,10 +3,11 @@
// AndersonMixer.C
//
////////////////////////////////////////////////////////////////////////////////
// $Id: AndersonMixer.C,v 1.3 2004-12-18 23:23:58 fgygi Exp $
// $Id: AndersonMixer.C,v 1.4 2007-03-17 01:14:00 fgygi Exp $
#include "AndersonMixer.h"
#include "blas.h"
using namespace std;
////////////////////////////////////////////////////////////////////////////////
void AndersonMixer::restart(void)
......
......@@ -3,15 +3,13 @@
// AndersonMixer.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: AndersonMixer.h,v 1.3 2004-12-18 23:23:27 fgygi Exp $
// $Id: AndersonMixer.h,v 1.4 2007-03-17 01:14:00 fgygi Exp $
#ifndef ANDERSONMIXER_H
#define ANDERSONMIXER_H
#include <valarray>
#include <cassert>
using namespace std;
#include "Context.h"
class AndersonMixer
......@@ -21,7 +19,7 @@ class AndersonMixer
double theta_max_; // maximum extrapolation
double theta_nc_; // negative curvature value
valarray<double> flast_; // last residual
std::valarray<double> flast_; // last residual
bool extrapolate_; // state variable
public:
......
......@@ -3,7 +3,7 @@
// AngleConstraint.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: AngleConstraint.h,v 1.2 2005-09-16 23:08:11 fgygi Exp $
// $Id: AngleConstraint.h,v 1.3 2007-03-17 01:14:00 fgygi Exp $
#ifndef ANGLECONSTRAINT_H
#define ANGLECONSTRAINT_H
......@@ -11,11 +11,12 @@
#include "Constraint.h"
#include "D3vector.h"
#include <cassert>
class AtomSet;
class AngleConstraint : public Constraint
{
string name1_, name2_, name3_;
std::string name1_, name2_, name3_;
int ia1_, ia2_, ia3_, is1_, is2_, is3_;
double m1_, m2_, m3_, m1_inv_, m2_inv_, m3_inv_;
double angle_, velocity_, force_, weight_, tol_;
......@@ -26,7 +27,8 @@ class AngleConstraint : public Constraint
public:
AngleConstraint(string name, string name1, string name2, string name3,
AngleConstraint(std::string name, std::string name1,
std::string name2, std::string name3,
double angle, double velocity, double tolerance):
name1_(name1), name2_(name2), name3_(name3),
velocity_(velocity),
......@@ -42,7 +44,7 @@ class AngleConstraint : public Constraint
weight_ = 1.0;
}
string type(void) const { return "angle"; }
std::string type(void) const { return "angle"; }
double value(void) const { return angle_; }
double velocity(void) const { return velocity_; }
double force(void) const { return force_; }
......@@ -61,13 +63,13 @@ class AngleConstraint : public Constraint
void setup(const AtomSet& atoms);
void update(double dt);
bool enforce_r(const vector<vector<double> > &r0,
vector<vector<double> > &rp) const;
bool enforce_v(const vector<vector<double> > &r0,
vector<vector<double> > &v0) const;
void compute_force(const vector<vector<double> > &r0,
const vector<vector<double> > &f);
ostream& print( ostream& os );
bool enforce_r(const std::vector<std::vector<double> > &r0,
std::vector<std::vector<double> > &rp) const;
bool enforce_v(const std::vector<std::vector<double> > &r0,
std::vector<std::vector<double> > &v0) const;
void compute_force(const std::vector<std::vector<double> > &r0,
const std::vector<std::vector<double> > &f);
std::ostream& print( std::ostream& os );
};
#endif
......@@ -3,29 +3,29 @@
// Atom.h:
//
////////////////////////////////////////////////////////////////////////////////
// $Id: Atom.h,v 1.2 2003-05-16 16:14:00 fgygi Exp $
// $Id: Atom.h,v 1.3 2007-03-17 01:14:00 fgygi Exp $
#ifndef ATOM_H
#define ATOM_H
#include "D3vector.h"
#include <string>
using namespace std;
class Atom
{
private:
string name_;
string species_;
std::string name_;
std::string species_;
D3vector position_;
D3vector velocity_;
public:
Atom (string name, string species, D3vector position, D3vector velocity);
string name(void) { return name_; };
string species(void) { return species_; };
Atom (std::string name, std::string species,
D3vector position, D3vector velocity);
std::string name(void) { return name_; };
std::string species(void) { return species_; };
D3vector position(void) { return position_; };
D3vector velocity(void) { return velocity_; };
void set_position(D3vector p) { position_ = p; };
......@@ -33,5 +33,5 @@ class Atom
void block(void) { velocity_ = D3vector(0.0,0.0,0.0); };
};
ostream& operator << ( ostream &os, Atom &a );
std::ostream& operator << ( std::ostream &os, Atom &a );
#endif
......@@ -3,7 +3,7 @@
// AtomCmd.h:
//
////////////////////////////////////////////////////////////////////////////////
// $Id: AtomCmd.h,v 1.6 2005-04-29 18:12:37 fgygi Exp $
// $Id: AtomCmd.h,v 1.7 2007-03-17 01:14:00 fgygi Exp $
#ifndef ATOMCMD_H
#define ATOMCMD_H
......@@ -11,8 +11,6 @@
#include <string>
#include <cstdlib>
#include <iostream>
using namespace std;
#include "UserInterface.h"
#include "Sample.h"
......
......@@ -3,18 +3,18 @@
// AtomSet.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: AtomSet.h,v 1.14 2007-01-27 23:44:59 fgygi Exp $
// $Id: AtomSet.h,v 1.15 2007-03-17 01:14:00 fgygi Exp $
#ifndef ATOMSET_H
#define ATOMSET_H
#include "Context.h"
#include "Atom.h"
//#include "Species.h"
#include <vector>
#include <string>
#include <list>
#include <map>
#include <string>
using namespace std;
class Species;
......@@ -25,45 +25,45 @@ class AtomSet
const Context& ctxt_;
int nel_;
map<string,int> na_; // na_[sp_name]: number of atoms of species sp_name
map<string,int> isp_; // isp_[sp_name]: index of species sp_name
map<string,int> is_; // is_[atom_name]: is index of atom atom_name
map<string,int> ia_; // ia_[atom_name]: ia index of atom atom_name
vector<string> spname; // spname[is]: name of species is
std::map<std::string,int> na_; // na_[sp_name]: number of at. of spec. sp_name
std::map<std::string,int> isp_; // isp_[sp_name]: index of species sp_name
std::map<std::string,int> is_; // is_[atom_name]: is index of atom atom_name
std::map<std::string,int> ia_; // ia_[atom_name]: ia index of atom atom_name
std::vector<std::string> spname; // spname[is]: name of species is
public:
AtomSet(const Context& ctxt) : ctxt_(ctxt), nel_(0) {}
vector<vector<Atom *> > atom_list; // atom_list[is][ia]
vector<Species *> species_list; // species_list[is]
std::vector<std::vector<Atom *> > atom_list; // atom_list[is][ia]
std::vector<Species *> species_list; // species_list[is]
const Context& context(void) const { return ctxt_; }
bool addAtom(Atom *a);
bool delAtom(string name);
bool addSpecies(Species *sp, string name);
bool delSpecies(string name);
bool delAtom(std::string name);
bool addSpecies(Species *sp, std::string name);
bool delSpecies(std::string name);
bool reset(void); // remove all atoms and species
Atom *findAtom(string name) const;
Species *findSpecies(string name) const;
Atom *findAtom(std::string name) const;
Species *findSpecies(std::string name) const;
void listAtoms(void) const;
void listSpecies(void) const;
int na(const string& spname) const; // number of atoms of species spname
int na(const std::string& spname) const; // number of atoms of species spname
int na(int is) const; // number of atoms of species is
int isp(const string& spname) const; // index of species spname
int is(const string& atom_name) const;
int ia(const string& atom_name) const;
int isp(const std::string& spname) const; // index of species spname
int is(const std::string& atom_name) const;
int ia(const std::string& atom_name) const;
int nel(void) const { return nel_; };
int nsp(void) const { return species_list.size(); }
void get_positions(vector<vector<double> >& tau) const;
void set_positions(const vector<vector<double> >& tau);
void get_velocities(vector<vector<double> >& vel) const;
void set_velocities(const vector<vector<double> >& vel);
void get_positions(std::vector<std::vector<double> >& tau) const;
void set_positions(const std::vector<std::vector<double> >& tau);
void get_velocities(std::vector<std::vector<double> >& vel) const;
void set_velocities(const std::vector<std::vector<double> >& vel);
void sync(void);
void reset_velocities(void);
D3vector vcm(void) const;
void reset_vcm(void);
int size(void) const;
};
ostream& operator << ( ostream &os, const AtomSet &as );
};
std::ostream& operator << ( std::ostream &os, const AtomSet &as );
#endif
......@@ -3,13 +3,14 @@
// AtomSetHandler.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: AtomSetHandler.h,v 1.1 2003-05-16 16:14:00 fgygi Exp $
// $Id: AtomSetHandler.h,v 1.2 2007-03-17 01:14:00 fgygi Exp $
#ifndef ATOMSETHANDLER_H
#define ATOMSETHANDLER_H
#include "StructureHandler.h"
#include "D3vector.h"
#include <string>
class AtomSet;
class Species;
......@@ -19,8 +20,8 @@ class AtomSetHandler : public StructureHandler
private:
AtomSet& as_;
string current_atom_name, current_atom_species;
string current_species_name;
std::string current_atom_name, current_atom_species;
std::string current_species_name;
D3vector current_atom_position, current_atom_velocity;
Species* current_species;
......@@ -32,7 +33,7 @@ class AtomSetHandler : public StructureHandler
// End of the root element in the structure being handled
virtual void endElement(const XMLCh* const uri, const XMLCh* const localname,
const XMLCh* const qname, string& content);
const XMLCh* const qname, std::string& content);
// start a subhandler
virtual StructureHandler* startSubHandler(const XMLCh* const uri,
......
......@@ -3,23 +3,22 @@
// BLYPFunctional.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: BLYPFunctional.h,v 1.2 2004-09-14 22:24:11 fgygi Exp $
// $Id: BLYPFunctional.h,v 1.3 2007-03-17 01:14:00 fgygi Exp $
#ifndef BLYPFUNCTIONAL_H
#define BLYPFUNCTIONAL_H
#include "XCFunctional.h"
#include <vector>
using namespace std;
class BLYPFunctional : public XCFunctional
{
BLYPFunctional();
vector<double> _exc, _exc_up, _exc_dn;
vector<double> _vxc1, _vxc1_up, _vxc1_dn,
std::vector<double> _exc, _exc_up, _exc_dn;
std::vector<double> _vxc1, _vxc1_up, _vxc1_dn,
_vxc2, _vxc2_upup, _vxc2_updn, _vxc2_dnup, _vxc2_dndn;
vector<double> _grad_rho[3], _grad_rho_up[3], _grad_rho_dn[3];
std::vector<double> _grad_rho[3], _grad_rho_up[3], _grad_rho_dn[3];
void excblyp(double rho, double grad,
double *exc, double *vxc1, double *vxc2);
......@@ -32,10 +31,10 @@ class BLYPFunctional : public XCFunctional
public:
BLYPFunctional(const vector<vector<double> > &rhoe);
BLYPFunctional(const std::vector<std::vector<double> > &rhoe);
bool isGGA() { return true; };
string name() { return "BLYP"; };
std::string name() { return "BLYP"; };
void setxc(void);
};
#endif
......@@ -3,7 +3,7 @@
// BOSampleStepper.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: BOSampleStepper.h,v 1.4 2004-10-28 16:54:51 fgygi Exp $
// $Id: BOSampleStepper.h,v 1.5 2007-03-17 01:14:00 fgygi Exp $
#ifndef BOSAMPLESTEPPER_H
#define BOSAMPLESTEPPER_H
......@@ -12,9 +12,9 @@
#include "EnergyFunctional.h"
#include "Sample.h"
#include "Wavefunction.h"
class WavefunctionStepper;
class IonicStepper;
using namespace std;
class BOSampleStepper : public SampleStepper
{
......
......@@ -3,7 +3,7 @@
// Base64Transcoder.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: Base64Transcoder.h,v 1.3 2004-12-08 19:02:10 fgygi Exp $
// $Id: Base64Transcoder.h,v 1.4 2007-03-17 01:14:00 fgygi Exp $
#ifndef BASE64TRANSCODER_H
#define BASE64TRANSCODER_H
......@@ -11,7 +11,7 @@
#include <iostream>
#include <cstdio>
#include <string>
using namespace std;
typedef unsigned char byte;
class Base64Transcoder
......@@ -26,10 +26,10 @@ class Base64Transcoder
int decode(int nchars, const char* const from, byte* const to);
void byteswap_double(size_t n, double* const x);
void byteswap_int(size_t n, int* const x);
int print(int nchars, const char* const buf, ostream& o);
int print(const string buf, ostream& o);
int print(int nchars, const char* const buf, std::ostream& o);
int print(const std::string buf, std::ostream& o);
int print(int nchars, const char* const buf, FILE* outfile);
int print(const string buf, FILE* outfile);
int print(const std::string buf, FILE* outfile);
// number of chars needed to encode nbytes bytes
int nchars(int nbytes) { return 4 * ( ( nbytes + 2 ) / 3 ); }
......
......@@ -3,7 +3,7 @@
// Basis.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: Basis.h,v 1.5 2003-02-04 19:21:30 fgygi Exp $
// $Id: Basis.h,v 1.6 2007-03-17 01:14:00 fgygi Exp $
#ifndef BASIS_H
#define BASIS_H
......@@ -89,7 +89,7 @@ class Basis
~Basis(void);
bool resize(const UnitCell& cell, const UnitCell& refcell, double ecut);
void print(ostream& os);
void print(std::ostream& os);
};
ostream& operator << ( ostream& os, Basis& b );
std::ostream& operator << ( std::ostream& os, Basis& b );
#endif
......@@ -3,7 +3,7 @@
// CPSampleStepper.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: CPSampleStepper.h,v 1.3 2004-09-14 22:24:11 fgygi Exp $
// $Id: CPSampleStepper.h,v 1.4 2007-03-17 01:14:00 fgygi Exp $
#ifndef CPSAMPLESTEPPER_H
#define CPSAMPLESTEPPER_H
......@@ -15,7 +15,6 @@
#include "Wavefunction.h"
class MDWavefunctionStepper;
class MDIonicStepper;
using namespace std;
class CPSampleStepper : public SampleStepper
{
......
......@@ -3,16 +3,13 @@
// CellStepper.h:
//
////////////////////////////////////////////////////////////////////////////////
// $Id: CellStepper.h,v 1.1 2004-03-11 21:58:10 fgygi Exp $
// $Id: CellStepper.h,v 1.2 2007-03-17 01:14:00 fgygi Exp $
#ifndef CELLSTEPPER_H
#define CELLSTEPPER_H
#include "Sample.h"
#include <valarray>
#include <iostream>
#include <iomanip>
using namespace std;
class CellStepper
{
......@@ -27,7 +24,7 @@ class CellStepper
CellStepper (Sample& s) : s_(s), atoms_(s.atoms), ekin_(0.0) {}
virtual void compute_new_cell(const valarray<double>& sigma) = 0;
virtual void compute_new_cell(const std::valarray<double>& sigma) = 0;
virtual void update_cell(void) = 0;
double ekin(void) const { return ekin_; }
......
......@@ -3,7 +3,7 @@
// ChargeDensity.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: ChargeDensity.h,v 1.4 2004-11-10 22:31:43 fgygi Exp $
// $Id: ChargeDensity.h,v 1.5 2007-03-17 01:14:00 fgygi Exp $
#ifndef CHARGEDENSITY_H
#define CHARGEDENSITY_H
......@@ -20,7 +20,7 @@ class Wavefunction;
class FourierTransform;
class Basis;
typedef map<string,Timer> TimerMap;
typedef std::map<std::string,Timer> TimerMap;
class ChargeDensity
{
......@@ -31,15 +31,15 @@ class ChargeDensity
const Wavefunction& wf_;
Basis* vbasis_;
FourierTransform* vft_;
vector<FourierTransform*> ft_; // ft_[ikp];
valarray<complex<double> > rhotmp;
std::vector<FourierTransform*> ft_; // ft_[ikp];
std::valarray<std::complex<double> > rhotmp;
public:
mutable TimerMap tmap;
vector<vector<double> > rhor; // rhor[ispin][i]
vector<vector<complex<double> > > rhog; // rhog[ispin][ig]
std::vector<std::vector<double> > rhor; // rhor[ispin][i]
std::vector<std::vector<std::complex<double> > > rhog; // rhog[ispin][ig]
void update_density(void);
void update_rhor(void);
......
......@@ -3,14 +3,13 @@
// ConfinementPotential.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: ConfinementPotential.h,v 1.2 2007-01-27 23:47:56 fgygi Exp $
// $Id: ConfinementPotential.h,v 1.3 2007-03-17 01:14:00 fgygi Exp $
#ifndef CONFINEMENTPOTENTIAL_H
#define CONFINEMENTPOTENTIAL_H
class Basis;
#include <valarray>
using namespace std;
class Basis;
class ConfinementPotential
{
......@@ -18,7 +17,7 @@ class ConfinementPotential
double ecuts_, facs_, sigmas_;
const Basis& basis_;
valarray<double> fstress_, dfstress_;
std::valarray<double> fstress_, dfstress_;
public:
......@@ -26,8 +25,8 @@ class ConfinementPotential
double sigmas(void) const { return sigmas_; }
double ecuts(void) const { return ecuts_; }
const valarray<double>& fstress(void) const { return fstress_; }
const valarray<double>& dfstress(void) const { return dfstress_; }
const std::valarray<double>& fstress(void) const { return fstress_; }
const std::valarray<double>& dfstress(void) const { return dfstress_; }
void update(void);
......
......@@ -3,7 +3,7 @@
// Constraint.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: Constraint.h,v 1.2 2005-09-16 23:08:11 fgygi Exp $
// $Id: Constraint.h,v 1.3 2007-03-17 01:14:00 fgygi Exp $
#ifndef CONSTRAINT_H
#define CONSTRAINT_H
......@@ -11,7 +11,6 @@
#include <string>
#include <vector>
#include <cassert>
using namespace std;
class AtomSet;
......@@ -19,12 +18,12 @@ class Constraint
{
protected:
string name_; // constraint name
vector<string> names_; // names of atoms involved in the constraint
std::string name_; // constraint name
std::vector<std::string> names_; // names of atoms involved in the constraint
public:
virtual string type(void) const = 0;
virtual std::string type(void) const = 0;
virtual double value(void) const = 0;
virtual double velocity(void) const = 0;
virtual double force(void) const = 0;
......@@ -32,23 +31,23 @@ class Constraint
virtual double tolerance(void) const = 0;
virtual void set_value(double value) = 0;
virtual void set_velocity(double velocity) = 0;
virtual bool enforce_r(const vector<vector<double> > &r0,
vector<vector<double> > &rp) const = 0;
virtual bool enforce_v(const vector<vector<double> > &r0,
vector<vector<double> > &v0) const = 0;
virtual void compute_force(const vector<vector<double> > &r0,
const vector<vector<double> > &f) = 0;
virtual bool enforce_r(const std::vector<std::vector<double> > &r0,
std::vector<std::vector<double> > &rp) const = 0;
virtual bool enforce_v(const std::vector<std::vector<double> > &r0,
std::vector<std::vector<double> > &v0) const = 0;
virtual void compute_force(const std::vector<std::vector<double> > &r0,
const std::vector<std::vector<double> > &f) = 0;
virtual void update(double dt) = 0;
virtual void setup(const AtomSet& atoms) = 0;
virtual ostream& print(ostream &os) = 0;
string name(void) const { return name_; }
string names(int i) const
virtual std::ostream& print(std::ostream &os) = 0;
std::string name(void) const { return name_; }
std::string names(int i) const
{
assert( i >= 0 && i < names_.size() );
return names_[i];
}
};
ostream& operator << ( ostream &os, Constraint &c );
std::ostream& operator << ( std::ostream &os, Constraint &c );
#endif
......@@ -3,14 +3,13 @@
// ConstraintSet.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: ConstraintSet.h,v 1.2 2005-09-16 23:08:11 fgygi Exp $
// $Id: ConstraintSet.h,v 1.3 2007-03-17 01:14:00 fgygi Exp $
#ifndef CONSTRAINTSET_H
#define CONSTRAINTSET_H
#include <vector>
#include <string>
using namespace std;
class Atom;
class AtomSet;
......@@ -22,7 +21,7 @@ class ConstraintSet
private:
const Context& ctxt_;
vector<Constraint *> constraint_list;
std::vector<Constraint *> constraint_list;
public:
......@@ -30,15 +29,15 @@ class ConstraintSet
bool define_constraint(AtomSet &atoms, int argc, char **argv);
bool set_constraint(int argc, char **argv);
bool delete_constraint(int argc, char **argv);
void list_constraints(ostream &os);
void list_constraints(std::ostream &os);
int size(void) const { return constraint_list.size(); }
void enforce(AtomSet& atoms);
void enforce_r(const vector<vector<double> > &r0,
vector<vector<double> > &rp);
void enforce_v(const vector<vector<double> > &r0,
vector<vector<double> > &v0);
void compute_forces(const vector<vector<double> > &r0,
const vector<vector<double> > &f);
void enforce_r(const std::vector<std::vector<double> > &r0,
std::vector<std::vector<double> > &rp);
void enforce_v(const std::vector<std::vector<double> > &r0,
std::vector<std::vector<double> > &v0);
void compute_forces(const std::vector<std::vector<double> > &r0,
const std::vector<std::vector<double> > &f);
void update_constraints(double dt);
void setup(AtomSet& atoms);
};
......
......@@ -3,20 +3,20 @@
// Context.C
//
////////////////////////////////////////////////////////////////////////////////
// $Id: Context.C,v 1.12 2006-03-07 07:03:46 fgygi Exp $
// $Id: Context.C,v 1.13 2007-03-17 01:14:00 fgygi Exp $
#include "Context.h"
#include <iostream>
#include <iomanip>
#include <cmath>
#include <cassert>
#include <string>
using namespace std;
#include <vector>
#ifdef SCALAPACK
#include "blacs.h"
#endif
#include "Context.h"
using namespace std;
#ifndef SCALAPACK
void Cblacs_pinfo(int *mypnum, int *nprocs)
......
......@@ -3,15 +3,13 @@
// Context.h
//
////////////////////////////////////////////////////////////////////////////////
// $Id: Context.h,v 1.8 2004-11-10 22:34:17 fgygi Exp $
// $Id: Context.h,v 1.9 2007-03-17 01:14:00 fgygi Exp $
#ifndef CONTEXT_H
#define CONTEXT_H
#include <iosfwd>
#include <vector>
#include <string>
using namespace std;
#if USE_MPI
#include <mpi.h>
......@@ -120,9 +118,9 @@ class Context
int* a, int lda,int rsrc, int csrc) const;
void ibcast_recv(int m, int n, int* a, int lda,int rsrc, int csrc) const;
void string_send(string& s, int rdest, int cdest) const;
void string_recv(string& s, int rsrc, int csrc) const;
void string_bcast(string& s, int isrc) const;
void string_send(std::string& s, int rdest, int cdest) const;
void string_recv(std::string& s, int rsrc, int csrc) const;
void string_bcast(std::string& s, int isrc) const;
bool operator==(const Context& ctxt) const;
......@@ -148,8 +146,8 @@ class Context
Context(const Context& ctxt);
Context& operator=(const Context& rhs);
void print(ostream& os) const;
void print(std::ostream& os) const;
};
ostream& operator << ( ostream& os, const Context& ctxt );
std::ostream& operator << ( std::ostream& os, const Context& ctxt );
#endif