Main Page Class Hierarchy Compound List File List Compound Members Related Pages

# psiwfn.h

    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