psici.h

//
// psici.h
//
// Copyright (C) 2008 Martin Torheyden
//
// Author: Martin Torheyden <mtorhey@vt.edu>
//
// This file is part of the SC Toolkit.
//
// The SC Toolkit is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// The SC Toolkit is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with the SC Toolkit; see the file COPYING.LIB.  If not, write to
// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
//
// The U.S. Government is granted a limited license as per AL 91-7.
//
 
#ifndef _chemistry_qc_psi_psici_h
#define _chemistry_qc_psi_psici_h
 
#include <chemistry/qc/psi/psiwfn.h>
#include <chemistry/qc/wfn/spin.h>
 
namespace sc {
 
  class PsiRASCI : public PsiCorrWavefunction {
    public:
      PsiRASCI(const Ref<KeyVal> &keyval);
      PsiRASCI(StateIn &s);
      ~PsiRASCI();
      void save_data_state(StateOut &s);
      void compute();
      void print(std::ostream&) const;
 
      double magnetic_moment() const;
 
      const std::vector<unsigned int>& ras1() const { return ras1_; }
      const std::vector<unsigned int>& ras2() const { return ras2_; }
      const std::vector<unsigned int>& ras3() const { return ras3_; }
      unsigned int ras3_max() const { return ras3_max_; }
 
      RefSymmSCMatrix mo_density(SpinCase1 spin); // mo_density is overloaded because detci
                                                  // reports density in active orbitals only; it reports ORDM in OBS (!)
      const Ref<OrbitalSpace>& orbs_sb(SpinCase1 spin);
      const Ref<OrbitalSpace>& occ(SpinCase1 spin);
      RefSymmSCMatrix onepdm_occ(SpinCase1 spin);
      RefSymmSCMatrix twopdm_occ(SpinCase2 spin);
      RefSymmSCMatrix twopdm_occ();
 
    protected:
 
      bool opdm_print_;   
      bool tpdm_print_;   
      int root_;          
      int multiplicity_;  
      int nroots_;        
      int target_sym_;    
      int h0_blocksize_;  
      bool repl_otf_;     
 
      // this data may need to be modified by RASSCF
      int energy_convergence_;
      int convergence_;
      int maxiter_;       
 
      Ref<OrbitalSpace> orbs_sb_[NSpinCases1];
      Ref<OrbitalSpace> occ_[NSpinCases1];
 
      RefSymmSCMatrix onepdm_occ_[NSpinCases1];
      RefSymmSCMatrix twopdm_occ_[NSpinCases2];
      RefSymmSCMatrix twopdm_sf_occ_;
 
      // optional RAS info
      // it is initialized automatically
      std::vector<unsigned int> ras1_;
      std::vector<unsigned int> ras2_;
      std::vector<unsigned int> ras3_;
      int ras1_max_;   //< max number of holes in RAS1; in PsiRASCI, defaults to 2; in PsiRASSCF, defaults to 0. It appears that this keyword is created pratically as
                       // an 'alias' to ex_lvl in Psi3, but ras1_max_ is a better name than ex_lvl
      int ras3_max_;   //< max number of electrons in RAS3; in PsiRASCI, defaults to 2; in PsiRASSCF, defaults to 0
 
      double scf_levelshift_;      
      int scf_stop_levelshift_;    
 
      Ref<OneBodyWavefunction> valence_obwfn_;
 
      std::vector<unsigned int> moorder_;
 
      void write_input(int convergence);
      void write_rasci_input(int convergence, bool rasscf);
 
      std::vector<unsigned int> map_density_to_sb();
  };
 
  class PsiRASSCF : public PsiRASCI {
    public:
      PsiRASSCF(const Ref<KeyVal>& kv);
      PsiRASSCF(StateIn&);
      ~PsiRASSCF();
      void save_data_state(StateOut&);
      void compute();
      void print(std::ostream&) const;
 
    private:
      static ClassDesc class_desc_;
 
      int rasscf_energy_convergence_;
      int rasscf_convergence_;
      int rasscf_maxiter_;    //< max number of iterations in rasscf
      int rasscf_target_sym_; //< target symmetry
      int diis_start_; 
      double max_step_;
 
 
      bool state_average_;   //< state average?
      bool relax_core_;
 
      bool run_detci_only_;  // hack to allow running state-averaged RASSCF
 
      void write_input(int convergence);
 
  };
 
 
}
 
#endif /*_chemistry_qc_psi_psici_h*/