psiwfn.h Source File

00001 
00002 #ifdef __GNUC__
00003 #pragma interface
00004 #endif
00005 
00006 #ifndef _chemistry_qc_psi_psiwfn_h
00007 #define _chemistry_qc_psi_psiwfn_h
00008 
00009 #include <chemistry/qc/wfn/wfn.h>
00010 #include <chemistry/qc/psi/psiexenv.h>
00011 
00012 namespace sc {
00013 
00015 
00020 class PsiWavefunction: public Wavefunction {
00021 
00022     Ref<PsiExEnv> exenv_;
00023 
00024     int* read_occ(const Ref<KeyVal> &keyval, const char *name, int nirrep);
00025 
00026   protected:
00027     int nirrep_;
00028     int *docc_;
00029     int *socc_;
00030     int *frozen_docc_;
00031     int *frozen_uocc_;
00032     int multp_;
00033     int charge_;
00034     char *memory_;
00036     virtual void write_input(int conv) =0;
00037 
00038   public:
00053     PsiWavefunction(const Ref<KeyVal>&);
00054     PsiWavefunction(StateIn&);
00055     ~PsiWavefunction();
00056 
00057     void save_data_state(StateOut&);
00058 
00061     virtual void write_basic_input(int conv);
00062     void compute();
00063     void print(std::ostream&o=ExEnv::out0()) const;
00064     RefSymmSCMatrix density();
00065     int nelectron();
00066 
00068     Ref<PsiExEnv> get_psi_exenv() const { return exenv_; };
00070     Ref<PsiInput> get_psi_input() const { return exenv_->get_psi_input(); };
00071 };
00072 
00075 
00076 class PsiSCF: public PsiWavefunction {
00077   public:
00078     PsiSCF(const Ref<KeyVal>&);
00079     PsiSCF(StateIn&);
00080     ~PsiSCF();
00081     void save_data_state(StateOut&);
00082 
00083     enum RefType {rhf, hsoshf, uhf};
00085     virtual PsiSCF::RefType reftype() const =0;
00086 };
00087 
00090 
00091 class PsiCLHF: public PsiSCF {
00092   protected:
00093     void write_input(int conv);
00094   public:
00095     PsiCLHF(const Ref<KeyVal>&);
00096     PsiCLHF(StateIn&);
00097     ~PsiCLHF();
00098 
00099     void write_basic_input(int conv);
00100     int spin_polarized() { return 0;};
00101     int gradient_implemented() const { return 1;};
00102     PsiSCF::RefType reftype() const { return rhf;};
00103 };
00104 
00107 
00108 class PsiHSOSHF: public PsiSCF {
00109   protected:
00110     void write_input(int conv);
00111   public:
00112     PsiHSOSHF(const Ref<KeyVal>&);
00113     PsiHSOSHF(StateIn&);
00114     ~PsiHSOSHF();
00115 
00116     void write_basic_input(int conv);
00117     int spin_polarized() { return 0;};
00118     int gradient_implemented() const { return 1;};
00119     PsiSCF::RefType reftype() const { return hsoshf;};
00120 };
00121 
00124 
00125 class PsiUHF: public PsiSCF {
00126   protected:
00127     void write_input(int conv);
00128   public:
00129     PsiUHF(const Ref<KeyVal>&);
00130     PsiUHF(StateIn&);
00131     ~PsiUHF();
00132 
00133     void write_basic_input(int conv);
00134     int spin_polarized() { return 1;};
00135     int gradient_implemented() const { return 1;};
00136     PsiSCF::RefType reftype() const { return uhf;};
00137 };
00138 
00141 
00142 class PsiCCSD: public PsiWavefunction {
00143     Ref<PsiSCF> reference_;
00144   protected:
00145     void write_input(int conv);
00146   public:
00147     PsiCCSD(const Ref<KeyVal>&);
00148     PsiCCSD(StateIn&);
00149     ~PsiCCSD();
00150     void save_data_state(StateOut&);
00151     int spin_polarized() { return reference_->spin_polarized();};
00152     int gradient_implemented() const;
00153 };
00154 
00157 
00158 class PsiCCSD_T: public PsiWavefunction {
00159     Ref<PsiSCF> reference_;
00160   protected:
00161     void write_input(int conv);
00162   public:
00163     PsiCCSD_T(const Ref<KeyVal>&);
00164     PsiCCSD_T(StateIn&);
00165     ~PsiCCSD_T();
00166 
00167     void save_data_state(StateOut&);
00168     int spin_polarized() { return reference_->spin_polarized();};
00169     int gradient_implemented() const;
00170 };
00171 
00172 }
00173 
00174 #endif