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 @@ ...@@ -3,10 +3,11 @@
// AndersonMixer.C // 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 "AndersonMixer.h"
#include "blas.h" #include "blas.h"
using namespace std;
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
void AndersonMixer::restart(void) void AndersonMixer::restart(void)
......
...@@ -3,15 +3,13 @@ ...@@ -3,15 +3,13 @@
// AndersonMixer.h // 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 #ifndef ANDERSONMIXER_H
#define ANDERSONMIXER_H #define ANDERSONMIXER_H
#include <valarray> #include <valarray>
#include <cassert> #include <cassert>
using namespace std;
#include "Context.h" #include "Context.h"
class AndersonMixer class AndersonMixer
...@@ -21,7 +19,7 @@ class AndersonMixer ...@@ -21,7 +19,7 @@ class AndersonMixer
double theta_max_; // maximum extrapolation double theta_max_; // maximum extrapolation
double theta_nc_; // negative curvature value double theta_nc_; // negative curvature value
valarray<double> flast_; // last residual std::valarray<double> flast_; // last residual
bool extrapolate_; // state variable bool extrapolate_; // state variable
public: public:
......
...@@ -3,7 +3,7 @@ ...@@ -3,7 +3,7 @@
// AngleConstraint.h // 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 #ifndef ANGLECONSTRAINT_H
#define ANGLECONSTRAINT_H #define ANGLECONSTRAINT_H
...@@ -11,11 +11,12 @@ ...@@ -11,11 +11,12 @@
#include "Constraint.h" #include "Constraint.h"
#include "D3vector.h" #include "D3vector.h"
#include <cassert> #include <cassert>
class AtomSet; class AtomSet;
class AngleConstraint : public Constraint class AngleConstraint : public Constraint
{ {
string name1_, name2_, name3_; std::string name1_, name2_, name3_;
int ia1_, ia2_, ia3_, is1_, is2_, is3_; int ia1_, ia2_, ia3_, is1_, is2_, is3_;
double m1_, m2_, m3_, m1_inv_, m2_inv_, m3_inv_; double m1_, m2_, m3_, m1_inv_, m2_inv_, m3_inv_;
double angle_, velocity_, force_, weight_, tol_; double angle_, velocity_, force_, weight_, tol_;
...@@ -26,8 +27,9 @@ class AngleConstraint : public Constraint ...@@ -26,8 +27,9 @@ class AngleConstraint : public Constraint
public: public:
AngleConstraint(string name, string name1, string name2, string name3, AngleConstraint(std::string name, std::string name1,
double angle, double velocity, double tolerance): std::string name2, std::string name3,
double angle, double velocity, double tolerance):
name1_(name1), name2_(name2), name3_(name3), name1_(name1), name2_(name2), name3_(name3),
velocity_(velocity), velocity_(velocity),
tol_(tolerance), m1_(0.0), m2_(0.0), m3_(0.0) tol_(tolerance), m1_(0.0), m2_(0.0), m3_(0.0)
...@@ -42,7 +44,7 @@ class AngleConstraint : public Constraint ...@@ -42,7 +44,7 @@ class AngleConstraint : public Constraint
weight_ = 1.0; weight_ = 1.0;
} }
string type(void) const { return "angle"; } std::string type(void) const { return "angle"; }
double value(void) const { return angle_; } double value(void) const { return angle_; }
double velocity(void) const { return velocity_; } double velocity(void) const { return velocity_; }
double force(void) const { return force_; } double force(void) const { return force_; }
...@@ -61,13 +63,13 @@ class AngleConstraint : public Constraint ...@@ -61,13 +63,13 @@ class AngleConstraint : public Constraint
void setup(const AtomSet& atoms); void setup(const AtomSet& atoms);
void update(double dt); void update(double dt);
bool enforce_r(const vector<vector<double> > &r0, bool enforce_r(const std::vector<std::vector<double> > &r0,
vector<vector<double> > &rp) const; std::vector<std::vector<double> > &rp) const;
bool enforce_v(const vector<vector<double> > &r0, bool enforce_v(const std::vector<std::vector<double> > &r0,
vector<vector<double> > &v0) const; std::vector<std::vector<double> > &v0) const;
void compute_force(const vector<vector<double> > &r0, void compute_force(const std::vector<std::vector<double> > &r0,
const vector<vector<double> > &f); const std::vector<std::vector<double> > &f);
ostream& print( ostream& os ); std::ostream& print( std::ostream& os );
}; };
#endif #endif
...@@ -3,29 +3,29 @@ ...@@ -3,29 +3,29 @@
// Atom.h: // 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 #ifndef ATOM_H
#define ATOM_H #define ATOM_H
#include "D3vector.h" #include "D3vector.h"
#include <string> #include <string>
using namespace std;
class Atom class Atom
{ {
private: private:
string name_; std::string name_;
string species_; std::string species_;
D3vector position_; D3vector position_;
D3vector velocity_; D3vector velocity_;
public: public:
Atom (string name, string species, D3vector position, D3vector velocity); Atom (std::string name, std::string species,
string name(void) { return name_; }; D3vector position, D3vector velocity);
string species(void) { return species_; }; std::string name(void) { return name_; };
std::string species(void) { return species_; };
D3vector position(void) { return position_; }; D3vector position(void) { return position_; };
D3vector velocity(void) { return velocity_; }; D3vector velocity(void) { return velocity_; };
void set_position(D3vector p) { position_ = p; }; void set_position(D3vector p) { position_ = p; };
...@@ -33,5 +33,5 @@ class Atom ...@@ -33,5 +33,5 @@ class Atom
void block(void) { velocity_ = D3vector(0.0,0.0,0.0); }; 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 #endif
...@@ -3,7 +3,7 @@ ...@@ -3,7 +3,7 @@
// AtomCmd.h: // 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 #ifndef ATOMCMD_H
#define ATOMCMD_H #define ATOMCMD_H
...@@ -11,8 +11,6 @@ ...@@ -11,8 +11,6 @@
#include <string> #include <string>
#include <cstdlib> #include <cstdlib>
#include <iostream> #include <iostream>
using namespace std;
#include "UserInterface.h" #include "UserInterface.h"
#include "Sample.h" #include "Sample.h"
......
...@@ -3,18 +3,18 @@ ...@@ -3,18 +3,18 @@
// AtomSet.h // 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 #ifndef ATOMSET_H
#define ATOMSET_H #define ATOMSET_H
#include "Context.h" #include "Context.h"
#include "Atom.h" #include "Atom.h"
//#include "Species.h" #include <vector>
#include <string>
#include <list> #include <list>
#include <map> #include <map>
#include <string> #include <string>
using namespace std;
class Species; class Species;
...@@ -25,45 +25,45 @@ class AtomSet ...@@ -25,45 +25,45 @@ class AtomSet
const Context& ctxt_; const Context& ctxt_;
int nel_; int nel_;
map<string,int> na_; // na_[sp_name]: number of atoms of species sp_name std::map<std::string,int> na_; // na_[sp_name]: number of at. of spec. sp_name
map<string,int> isp_; // isp_[sp_name]: index of species sp_name std::map<std::string,int> isp_; // isp_[sp_name]: index of species sp_name
map<string,int> is_; // is_[atom_name]: is index of atom atom_name std::map<std::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 std::map<std::string,int> ia_; // ia_[atom_name]: ia index of atom atom_name
vector<string> spname; // spname[is]: name of species is std::vector<std::string> spname; // spname[is]: name of species is
public: public:
AtomSet(const Context& ctxt) : ctxt_(ctxt), nel_(0) {} AtomSet(const Context& ctxt) : ctxt_(ctxt), nel_(0) {}
vector<vector<Atom *> > atom_list; // atom_list[is][ia] std::vector<std::vector<Atom *> > atom_list; // atom_list[is][ia]
vector<Species *> species_list; // species_list[is] std::vector<Species *> species_list; // species_list[is]
const Context& context(void) const { return ctxt_; } const Context& context(void) const { return ctxt_; }
bool addAtom(Atom *a); bool addAtom(Atom *a);
bool delAtom(string name); bool delAtom(std::string name);
bool addSpecies(Species *sp, string name); bool addSpecies(Species *sp, std::string name);
bool delSpecies(string name); bool delSpecies(std::string name);
bool reset(void); // remove all atoms and species bool reset(void); // remove all atoms and species
Atom *findAtom(string name) const; Atom *findAtom(std::string name) const;
Species *findSpecies(string name) const; Species *findSpecies(std::string name) const;
void listAtoms(void) const; void listAtoms(void) const;
void listSpecies(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 na(int is) const; // number of atoms of species is
int isp(const string& spname) const; // index of species spname int isp(const std::string& spname) const; // index of species spname
int is(const string& atom_name) const; int is(const std::string& atom_name) const;
int ia(const string& atom_name) const; int ia(const std::string& atom_name) const;
int nel(void) const { return nel_; }; int nel(void) const { return nel_; };
int nsp(void) const { return species_list.size(); } int nsp(void) const { return species_list.size(); }
void get_positions(vector<vector<double> >& tau) const; void get_positions(std::vector<std::vector<double> >& tau) const;
void set_positions(const vector<vector<double> >& tau); void set_positions(const std::vector<std::vector<double> >& tau);
void get_velocities(vector<vector<double> >& vel) const; void get_velocities(std::vector<std::vector<double> >& vel) const;
void set_velocities(const vector<vector<double> >& vel); void set_velocities(const std::vector<std::vector<double> >& vel);
void sync(void); void sync(void);
void reset_velocities(void); void reset_velocities(void);
D3vector vcm(void) const; D3vector vcm(void) const;
void reset_vcm(void); void reset_vcm(void);
int size(void) const; int size(void) const;
}; };
ostream& operator << ( ostream &os, const AtomSet &as ); std::ostream& operator << ( std::ostream &os, const AtomSet &as );
#endif #endif
...@@ -3,13 +3,14 @@ ...@@ -3,13 +3,14 @@
// AtomSetHandler.h // 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 #ifndef ATOMSETHANDLER_H
#define ATOMSETHANDLER_H #define ATOMSETHANDLER_H
#include "StructureHandler.h" #include "StructureHandler.h"
#include "D3vector.h" #include "D3vector.h"
#include <string>
class AtomSet; class AtomSet;
class Species; class Species;
...@@ -19,8 +20,8 @@ class AtomSetHandler : public StructureHandler ...@@ -19,8 +20,8 @@ class AtomSetHandler : public StructureHandler
private: private:
AtomSet& as_; AtomSet& as_;
string current_atom_name, current_atom_species; std::string current_atom_name, current_atom_species;
string current_species_name; std::string current_species_name;
D3vector current_atom_position, current_atom_velocity; D3vector current_atom_position, current_atom_velocity;
Species* current_species; Species* current_species;
...@@ -32,7 +33,7 @@ class AtomSetHandler : public StructureHandler ...@@ -32,7 +33,7 @@ class AtomSetHandler : public StructureHandler
// End of the root element in the structure being handled // End of the root element in the structure being handled
virtual void endElement(const XMLCh* const uri, const XMLCh* const localname, 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 // start a subhandler
virtual StructureHandler* startSubHandler(const XMLCh* const uri, virtual StructureHandler* startSubHandler(const XMLCh* const uri,
......
...@@ -3,23 +3,22 @@ ...@@ -3,23 +3,22 @@
// BLYPFunctional.h // 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 #ifndef BLYPFUNCTIONAL_H
#define BLYPFUNCTIONAL_H #define BLYPFUNCTIONAL_H
#include "XCFunctional.h" #include "XCFunctional.h"
#include <vector> #include <vector>
using namespace std;
class BLYPFunctional : public XCFunctional class BLYPFunctional : public XCFunctional
{ {
BLYPFunctional(); BLYPFunctional();
vector<double> _exc, _exc_up, _exc_dn; std::vector<double> _exc, _exc_up, _exc_dn;
vector<double> _vxc1, _vxc1_up, _vxc1_dn, std::vector<double> _vxc1, _vxc1_up, _vxc1_dn,
_vxc2, _vxc2_upup, _vxc2_updn, _vxc2_dnup, _vxc2_dndn; _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, void excblyp(double rho, double grad,
double *exc, double *vxc1, double *vxc2); double *exc, double *vxc1, double *vxc2);
...@@ -32,10 +31,10 @@ class BLYPFunctional : public XCFunctional ...@@ -32,10 +31,10 @@ class BLYPFunctional : public XCFunctional
public: public:
BLYPFunctional(const vector<vector<double> > &rhoe); BLYPFunctional(const std::vector<std::vector<double> > &rhoe);
bool isGGA() { return true; }; bool isGGA() { return true; };
string name() { return "BLYP"; }; std::string name() { return "BLYP"; };
void setxc(void); void setxc(void);
}; };
#endif #endif
...@@ -3,7 +3,7 @@ ...@@ -3,7 +3,7 @@
// BOSampleStepper.h // 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 #ifndef BOSAMPLESTEPPER_H
#define BOSAMPLESTEPPER_H #define BOSAMPLESTEPPER_H
...@@ -12,9 +12,9 @@ ...@@ -12,9 +12,9 @@
#include "EnergyFunctional.h" #include "EnergyFunctional.h"
#include "Sample.h" #include "Sample.h"
#include "Wavefunction.h" #include "Wavefunction.h"
class WavefunctionStepper; class WavefunctionStepper;
class IonicStepper; class IonicStepper;
using namespace std;
class BOSampleStepper : public SampleStepper class BOSampleStepper : public SampleStepper
{ {
......
...@@ -3,7 +3,7 @@ ...@@ -3,7 +3,7 @@
// Base64Transcoder.h // 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 #ifndef BASE64TRANSCODER_H
#define BASE64TRANSCODER_H #define BASE64TRANSCODER_H
...@@ -11,7 +11,7 @@ ...@@ -11,7 +11,7 @@
#include <iostream> #include <iostream>
#include <cstdio> #include <cstdio>
#include <string> #include <string>
using namespace std;
typedef unsigned char byte; typedef unsigned char byte;
class Base64Transcoder class Base64Transcoder
...@@ -26,10 +26,10 @@ class Base64Transcoder ...@@ -26,10 +26,10 @@ class Base64Transcoder
int decode(int nchars, const char* const from, byte* const to); int decode(int nchars, const char* const from, byte* const to);
void byteswap_double(size_t n, double* const x); void byteswap_double(size_t n, double* const x);
void byteswap_int(size_t n, int* const x); void byteswap_int(size_t n, int* const x);
int print(int nchars, const char* const buf, ostream& o); int print(int nchars, const char* const buf, std::ostream& o);
int print(const string buf, ostream& o); int print(const std::string buf, std::ostream& o);
int print(int nchars, const char* const buf, FILE* outfile); 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 // number of chars needed to encode nbytes bytes
int nchars(int nbytes) { return 4 * ( ( nbytes + 2 ) / 3 ); } int nchars(int nbytes) { return 4 * ( ( nbytes + 2 ) / 3 ); }
......
...@@ -3,7 +3,7 @@ ...@@ -3,7 +3,7 @@
// Basis.h // 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 #ifndef BASIS_H
#define BASIS_H #define BASIS_H
...@@ -89,7 +89,7 @@ class Basis ...@@ -89,7 +89,7 @@ class Basis
~Basis(void); ~Basis(void);
bool resize(const UnitCell& cell, const UnitCell& refcell, double ecut); 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 #endif
...@@ -3,7 +3,7 @@ ...@@ -3,7 +3,7 @@
// CPSampleStepper.h // 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 #ifndef CPSAMPLESTEPPER_H
#define CPSAMPLESTEPPER_H #define CPSAMPLESTEPPER_H
...@@ -15,7 +15,6 @@ ...@@ -15,7 +15,6 @@
#include "Wavefunction.h" #include "Wavefunction.h"
class MDWavefunctionStepper; class MDWavefunctionStepper;
class MDIonicStepper; class MDIonicStepper;
using namespace std;
class CPSampleStepper : public SampleStepper class CPSampleStepper : public SampleStepper
{ {
......
...@@ -3,16 +3,13 @@ ...@@ -3,16 +3,13 @@
// CellStepper.h: // 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 #ifndef CELLSTEPPER_H
#define CELLSTEPPER_H #define CELLSTEPPER_H
#include "Sample.h" #include "Sample.h"
#include <valarray> #include <valarray>
#include <iostream>
#include <iomanip>
using namespace std;
class CellStepper class CellStepper
{ {
...@@ -27,7 +24,7 @@ class CellStepper ...@@ -27,7 +24,7 @@ class CellStepper
CellStepper (Sample& s) : s_(s), atoms_(s.atoms), ekin_(0.0) {} 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; virtual void update_cell(void) = 0;
double ekin(void) const { return ekin_; } double ekin(void) const { return ekin_; }
......
...@@ -3,7 +3,7 @@ ...@@ -3,7 +3,7 @@
// ChargeDensity.h // 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 #ifndef CHARGEDENSITY_H
#define CHARGEDENSITY_H #define CHARGEDENSITY_H
...@@ -20,7 +20,7 @@ class Wavefunction; ...@@ -20,7 +20,7 @@ class Wavefunction;
class FourierTransform; class FourierTransform;
class Basis; class Basis;
typedef map<string,Timer> TimerMap; typedef std::map<std::string,Timer> TimerMap;
class ChargeDensity class ChargeDensity
{ {
...@@ -31,15 +31,15 @@ class ChargeDensity ...@@ -31,15 +31,15 @@ class ChargeDensity
const Wavefunction& wf_; const Wavefunction& wf_;
Basis* vbasis_; Basis* vbasis_;
FourierTransform* vft_; FourierTransform* vft_;
vector<FourierTransform*> ft_; // ft_[ikp]; std::vector<FourierTransform*> ft_; // ft_[ikp];
valarray<complex<double> > rhotmp; std::valarray<std::complex<double> > rhotmp;
public: public:
mutable TimerMap tmap; mutable TimerMap tmap;
vector<vector<double> > rhor; // rhor[ispin][i] std::vector<std::vector<double> > rhor; // rhor[ispin][i]
vector<vector<complex<double> > > rhog; // rhog[ispin][ig] std::vector<std::vector<std::complex<double> > > rhog; // rhog[ispin][ig]
void update_density(void); void update_density(void);
void update_rhor(void); void update_rhor(void);
......
...@@ -3,14 +3,13 @@ ...@@ -3,14 +3,13 @@
// ConfinementPotential.h // 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 #ifndef CONFINEMENTPOTENTIAL_H
#define CONFINEMENTPOTENTIAL_H #define CONFINEMENTPOTENTIAL_H
class Basis;
#include <valarray> #include <valarray>
using namespace std; class Basis;