psicc.h

//
// psicc.h
//
// Copyright (C) 2002 Edward Valeev
//
// Author: Edward Valeev <evaleev@vt.edu>
// Maintainer: EV
//
// 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_psicc_h
#define _chemistry_qc_psi_psicc_h
 
#include <chemistry/qc/psi/psiwfn.h>
#include <chemistry/qc/wfn/spin.h>
#include <math/distarray4/distarray4.h>
 
namespace sc {
  
 
  class PsiCC : public PsiCorrWavefunction {
 
      Ref<OrbitalSpace> occ_act_sb_[NSpinCases1];
      Ref<OrbitalSpace> vir_act_sb_[NSpinCases1];
      RefSCMatrix T1_[NSpinCases1];
      RefSCMatrix T2_[NSpinCases2];
      Ref<DistArray4> T2_da4_[NSpinCases2];
      RefSCMatrix Tau2_[NSpinCases2];
      RefSCMatrix Lambda1_[NSpinCases1];
      RefSCMatrix Lambda2_[NSpinCases2];
      Ref<DistArray4> Lambda2_da4_[NSpinCases2];
 
      Ref<OrbitalSpace> occ_sb_[NSpinCases1];
 
    protected:
      // set to true if want to run only if Psi3 and MPQC orbitals match exactly up to a phase
      static const bool use_sparsemap_only_ = false;
 
      RefSCMatrix T1(SpinCase1 spin, const std::string& L);
      RefSCMatrix T2(SpinCase2 spin, const std::string& L);
      Ref<DistArray4> T2_distarray4(SpinCase2 spin, const std::string& L);
 
      // get the T1 amplitudes (frozen core size) from
      // non frozen core PSI CCSD density calculation as compute_1rdm = true
      RefSCMatrix T1_fzc(SpinCase1 spin, const std::string& dpdlabel);
      // get the T2 amplitudes (frozen core size) from
      // non frozen core PSI CCSD density calculation as compute_1rdm = true
      Ref<DistArray4> T2_distarray4_fzc(SpinCase2 spin12,
                                        const std::string& dpdlabel);
 
      // read PSI3 ccsd one-particle density of spincase spin
      RefSCMatrix Onerdm(SpinCase1 spin);
      // read PSI3 relaxation 1e density of spincase spin
      RefSCMatrix Onerdm_relax_X(SpinCase1 spin);
      // test
      RefSCMatrix Onerdm_relax_D(SpinCase1 spin);
//      void compute_onerdm_relax(RefSCMatrix& Dorbs_alpha,
//                                RefSCMatrix& Dorbs_beta);
 
#if 0
      RefSCMatrix
          transform_T1(
                       const SparseMOIndexMap& occ_act_map,
                       const SparseMOIndexMap& vir_act_map,
                       const RefSCMatrix& T1,
                       const Ref<SCMatrixKit>& kit = SCMatrixKit::default_matrixkit()) const;
      RefSCMatrix
          transform_T2(
                       const SparseMOIndexMap& occ1_act_map,
                       const SparseMOIndexMap& occ2_act_map,
                       const SparseMOIndexMap& vir1_act_map,
                       const SparseMOIndexMap& vir2_act_map,
                       const RefSCMatrix& T2,
                       const Ref<SCMatrixKit>& kit = SCMatrixKit::default_matrixkit()) const;
      RefSCMatrix
          transform_T1(
                       const RefSCMatrix& occ_act_tform,
                       const RefSCMatrix& vir_act_tform,
                       const RefSCMatrix& T1,
                       const Ref<SCMatrixKit>& kit = SCMatrixKit::default_matrixkit()) const;
      RefSCMatrix
          transform_T2(
                       const RefSCMatrix& occ1_act_tform,
                       const RefSCMatrix& occ2_act_tform,
                       const RefSCMatrix& vir1_act_tform,
                       const RefSCMatrix& vir2_act_tform,
                       const RefSCMatrix& T2,
                       const Ref<SCMatrixKit>& kit = SCMatrixKit::default_matrixkit()) const;
#endif
      void compare_T2(const RefSCMatrix& T2, const RefSCMatrix& T2_ref, SpinCase2 spin12,
                      unsigned int no1, unsigned int no2, unsigned int nv1,
                      unsigned int nv2, double zero = 1e-8) const;
 
      void dpd_start();
      void dpd_stop();
 
      const Ref<OrbitalSpace>& occ_act_sb(SpinCase1 spin);
      const Ref<OrbitalSpace>& vir_act_sb(SpinCase1 spin);
 
      const Ref<OrbitalSpace>& occ_sb(SpinCase1 spin);
 
      int maxiter_;   //< max number of CC iterations
      static const int default_maxiter = 50;
      
      bool diis_;
      int diis_nvector_;
 
    public:
      PsiCC(const Ref<KeyVal>&);
      PsiCC(StateIn&);
      ~PsiCC();
      void save_data_state(StateOut&);
 
      virtual const RefSCMatrix& T1(SpinCase1 spin1);
      virtual const RefSCMatrix& T2(SpinCase2 spin2);
      virtual Ref<DistArray4> T2_da4(SpinCase2 spin2, std::string dpdkey = "t");
      virtual const RefSCMatrix& Tau2(SpinCase2 spin2);
      virtual const RefSCMatrix& Lambda1(SpinCase1 spin1);
      virtual const RefSCMatrix& Lambda2(SpinCase2 spin2);
      virtual Ref<DistArray4> Lambda2_da4(SpinCase2 spin2);
 
      void obsolete();
  };
  
 
  class PsiCCSD : public PsiCC {
    protected:
      void write_input(int conv);
      double pccsd_alpha_;
      double pccsd_beta_;
      double pccsd_gamma_;
    public:
      PsiCCSD(const Ref<KeyVal>&);
      PsiCCSD(StateIn&);
      ~PsiCCSD();
      void save_data_state(StateOut&);
      bool analytic_gradient_implemented() const;
  };
  
 
  class PsiCCSD_T : public PsiCC {
    protected:
      void write_input(int conv);
    public:
      PsiCCSD_T(const Ref<KeyVal>&);
      PsiCCSD_T(StateIn&);
      ~PsiCCSD_T();
 
      void save_data_state(StateOut&);
  };
 
  class PsiCC2 : public PsiCC {
    protected:
      void write_input(int conv);
    public:
      PsiCC2(const Ref<KeyVal>&);
      PsiCC2(StateIn&);
      ~PsiCC2();
 
      void save_data_state(StateOut&);
  };
  
 
  class PsiCC3 : public PsiCC {
    protected:
      void write_input(int conv);
    public:
      PsiCC3(const Ref<KeyVal>&);
      PsiCC3(StateIn&);
      ~PsiCC3();
 
      void save_data_state(StateOut&);
  };
 
} // namespace
 
#endif /* header guard */