haatombasis.h

Go to the documentation of this file.

#ifndef HAATOMBASIS_H
#define HAATOMBASIS_H

#include "hastring.h"
#include "haio.h"
#include "halinalg.h"
#include "haatom.h"

class InternalBasis;
class AtomCollection;

struct b_type;

class GauShell 
{
public:
  GauShell();
  GauShell(int new_l_ang, const int NGauss);
  GauShell(int new_l_ang, const HaMat_double& cf_new);
//  GauShell(GauShell & OldShell);
  virtual ~GauShell();

  int GetL() const { return l_ang;} 
    
  const char* GetShellSymbol() const;        
   
  const char* GetShellFunSymbol(int ifun); 
  int GetNBfunc() const;             
  int GetNBfuncCart() const;         

  int GetNumGauss(void) const;             
  bool SetNumGauss(const int NGauss);      
  
  bool SetCoef(const double* NewCoef);           
  bool SetCoef(const HaMat_double& new_cf_mat);  
  const HaMat_double& GetCoef() const { return coef;} 

  double GetExp( int ig) { return coef(1,ig); }  
  double GetCoef( int ig ) { return coef(2,ig); } 

  void SaveGaussianInp(ostream& os) const;       
  // Comparisons operators (for STD library)
  bool operator == (const GauShell & rhs) const;
  bool operator  < (const GauShell & rhs) const;

  double FunPointVal(const double x, const double y, const double z, 
                         const double* coef, const int num_coef ) const;                                                

  int Normalize(); 

protected:

  bool spherical_fun_flag; 
                         
  int l_ang;          
  int NumGauss;       
  bool DestroyCoef();
  HaMat_double coef;  
                  
};

typedef vector<GauShell> ShellsType;

class HaPseudoPot;

class HaAtomBasis
{

  friend class HaQCMod;

public:
  HaAtomBasis();
  HaAtomBasis(const HaString& NewBasName, const HaString& NewAtomType);
  HaAtomBasis(const HaString& NewBasName, HaAtom* aptr );
  HaAtomBasis(const HaAtomBasis & ref);
  virtual ~HaAtomBasis(){}

  HaAtomBasis& copy_from(const HaAtomBasis & ref);    
  int SetForAtom(const char* BasName, HaAtom* aptr ); 

  const char* GetBasName() const;            
  bool SetBasName(const HaString & name);    

  bool           SetAtHost(HaAtom* new_phatm);
        HaAtom*  GetAtHost();
  const HaAtom*  GetAtHost() const;

  bool SetFromGaussianInp(istream& is);
  void SaveGaussianInp(ostream& os) const;
  

  const HaString& GetAtomType() const;
  bool SetAtomType(const HaString& atype); 
  int GetNBfunc() const;    
  int GetNBfuncCart() const;         

  bool AddShell(GauShell & shl);         
//  int Normalize(); //!< Normalize coefficients of all shells of the Atomic Basis
  
  void clear();                          
  void clear_coef() { Shells.clear(); }  

  void SetPseudoPotName(const HaString& new_pot_name);
  bool SetPseudoPotFromName(); 
                               // Name of the PseudoPotential and the name of the atom
  void SetPseudoPotPtr(const HaPseudoPot* new_ppot);
  const HaPseudoPot* GetPseudoPot() const { return ppot; } 
  bool IsSetPseudoPot() const { return (ppot != NULL); }

  int GetNumElectr()const; 


  // Comparisons operators (for STD list)
  bool operator == (const HaAtomBasis & rhs) const;
  bool operator <  (const HaAtomBasis & rhs) const;

  bool Print_info(ostream &sout, const int level) const; 

protected:
  HaAtom* phatm;           
  HaString BasName;        
  HaString AtomType;       
  HaString PseudoName;     
  const HaPseudoPot* ppot; 
public:
  vector<GauShell> Shells; 
};



class GauBasisSet: public vector<HaAtomBasis>
{
public:
        GauBasisSet();
        ~GauBasisSet(); 

        typedef vector<HaAtomBasis>::iterator AtomBasIterator;

//      int AddAtomBas(PureBasisSet* pset, HaString& name, HaAtom* aptr); //!< Add Atom Basis Set

        int LoadToGaussianBas(b_type& gaub) const; 

        int LoadToGaussianBCommon() const;  
        int LoadToGaussianB2Common() const; 
        InternalBasis* CreateIPackBas();   
        vector<HaAtom*> host_atoms;

        int GetNBfunc() const;             
    int GetNBfuncCart() const;         
        int pure_fun_flag;                 

        int InitForMolSet(const char* bname, HaMolSet* pmset); 
    int InitForAtoms(const char* bname, AtomCollection* at_coll); 
        HaAtomBasis* AddBasisToAtom(const char* BasName, HaAtom* aptr); 

        static int CalcOvlpMat(GauBasisSet* pbas1, GauBasisSet* pbas2, HaMat_double& ovlp_mat); 
};



#endif /* !HAATOMBASIS_H */

---