src/lib/chemistry/qc/mbptr12/linearr12.h

//
// linearr12.h
//
// Copyright (C) 2003 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.
//

#ifdef __GNUG__
#pragma interface
#endif

#ifndef _chemistry_qc_mbptr12_linearr12_h
#define _chemistry_qc_mbptr12_linearr12_h

#include <string>
#include <chemistry/qc/basis/integral.h>
#include <chemistry/qc/basis/intdescr.h>
#include <chemistry/qc/basis/tbint.h>

namespace sc {
  namespace LinearR12 {

    enum Projector {Projector_0 = 0,
      Projector_1 = 1,
      Projector_2 = 2,
      Projector_3 = 3};
    enum StandardApproximation {
      //StdApprox_A = 0,
      StdApprox_Ap = 1,
      StdApprox_App = 2,
      StdApprox_B = 3,
      StdApprox_C = 4};
    enum ABSMethod {ABS_ABS = 0,
      ABS_ABSPlus = 1,
      ABS_CABS = 2,
      ABS_CABSPlus = 3};

    enum OrbitalProduct {
      OrbProd_ij = 0,
      OrbProd_pq = 1
    };

    enum PositiveDefiniteB {
      PositiveDefiniteB_no = 0,
      PositiveDefiniteB_yes = 1,
      PositiveDefiniteB_weak = 2
    };

    enum GeminalAmplitudeAnsatz {
      GeminalAmplitudeAnsatz_fullopt = 0,
      GeminalAmplitudeAnsatz_fixed = 1,
      GeminalAmplitudeAnsatz_scaledfixed = 2
    };

    class GeminalDescriptor : public RefCount {
      private:
        std::string type_;
        std::vector<std::string> params_;
      public:
        GeminalDescriptor();
        ~GeminalDescriptor(){}
        GeminalDescriptor(const std::string& type, const std::vector<std::string> &params);
        GeminalDescriptor(const GeminalDescriptor& source);
        std::string type() const;
        std::vector<std::string> params() const;
        void print(std::ostream &o=ExEnv::out0());
    };

    bool invalid(const Ref<GeminalDescriptor>& gdesc);
    bool R12(const Ref<GeminalDescriptor>& gdesc);
    bool STG(const Ref<GeminalDescriptor>& gdesc);
    bool G12(const Ref<GeminalDescriptor>& gdesc);
    double single_slater_exponent(const Ref<GeminalDescriptor>& gdesc);


    class CorrelationFactor : public RefCount {
      public:
        //typedef IntParamsG12::PrimitiveGeminal PrimitiveGeminal;
        //typedef IntParamsG12::ContractedGeminal ContractedGeminal;
        //typedef std::vector<ContractedGeminal> CorrelationParameters;

        CorrelationFactor(const std::string& label, const Ref<GeminalDescriptor> &geminaldescriptor);
        CorrelationFactor();
        virtual ~CorrelationFactor();

        // return true if this is equivalent to cf
        virtual bool equiv(const Ref<CorrelationFactor>& cf) const =0;

        const std::string& label() const;
        virtual unsigned int nfunctions() const;
        virtual unsigned int nprimitives(unsigned int c) const;

        virtual double value(unsigned int c, double r12) const =0;
        virtual double value(unsigned int c, double r12, double r1, double r2) const;

        virtual Ref<TwoBodyIntDescr> tbintdescr(const Ref<Integral>& IF, unsigned int f) const;
        virtual Ref<TwoBodyIntDescr> tbintdescr(const Ref<Integral>& IF, unsigned int fbra, unsigned int fket) const;
        virtual unsigned int max_num_tbint_types() const =0;

        //
        // These functions are used to map the logical type of integrals ([T1,F12], etc.) to concrete types as produced by TwoBodyInt
        //

        virtual TwoBodyInt::tbint_type tbint_type_eri() const;
        virtual TwoBodyInt::tbint_type tbint_type_f12() const;
        virtual TwoBodyInt::tbint_type tbint_type_t1f12() const;
        virtual TwoBodyInt::tbint_type tbint_type_t2f12() const;
        virtual TwoBodyInt::tbint_type tbint_type_f12eri() const;
        virtual TwoBodyInt::tbint_type tbint_type_f12f12() const;
        virtual TwoBodyInt::tbint_type tbint_type_f12t1f12() const;
        virtual TwoBodyInt::tbint_type tbint_type_f12f12_anti() const;

        void print(std::ostream& os = ExEnv::out0()) const;
        Ref<GeminalDescriptor> geminaldescriptor();

      protected:
        std::string label_;
        Ref<GeminalDescriptor> geminaldescriptor_;

        virtual void print_params(std::ostream& os, unsigned int f) const;

    };

    class NullCorrelationFactor : public CorrelationFactor {
      public:
      NullCorrelationFactor();

      bool equiv(const Ref<CorrelationFactor>& cf) const;
      unsigned int max_num_tbint_types() const { return 1; }
      double value(unsigned int c, double r12) const;
    };

    class R12CorrelationFactor : public CorrelationFactor {
      public:
      R12CorrelationFactor();

      bool equiv(const Ref<CorrelationFactor>& cf) const;
      unsigned int max_num_tbint_types() const { return 4; }
      TwoBodyInt::tbint_type tbint_type_f12() const;
      TwoBodyInt::tbint_type tbint_type_t1f12() const;
      TwoBodyInt::tbint_type tbint_type_t2f12() const;
      Ref<TwoBodyIntDescr> tbintdescr(const Ref<Integral>& IF, unsigned int f) const;
      double value(unsigned int c, double r12) const;
    };

    template <class IntParam>
    struct CorrParamCompare {
        typedef typename IntParam::PrimitiveGeminal PrimitiveGeminal;
        typedef typename IntParam::ContractedGeminal ContractedGeminal;
        typedef std::vector<ContractedGeminal> ContractedGeminals;

        // 2 parameters are equivalent if their values differ by less than epsilon
        static double epsilon;
        static bool equiv(const ContractedGeminals& A, const ContractedGeminals& B);

    private:
        static bool equiv(const PrimitiveGeminal& A, const PrimitiveGeminal& B);
    };
    template <class IntParam> double CorrParamCompare<IntParam>::epsilon(1e-6);

    class G12CorrelationFactor : public CorrelationFactor {
      public:
      typedef IntParamsG12::PrimitiveGeminal PrimitiveGeminal;
      typedef IntParamsG12::ContractedGeminal ContractedGeminal;
      typedef std::vector<ContractedGeminal> CorrelationParameters;

      G12CorrelationFactor(const CorrelationParameters& params, const Ref<GeminalDescriptor> &geminaldescriptor = 0);

      bool equiv(const Ref<CorrelationFactor>& cf) const;
      unsigned int nfunctions() const;
      const ContractedGeminal& function(unsigned int c) const;
      unsigned int nprimitives(unsigned int c) const;
      const PrimitiveGeminal& primitive(unsigned int c, unsigned int p) const;
      unsigned int max_num_tbint_types() const { return 6; }
      TwoBodyInt::tbint_type tbint_type_f12() const;
      TwoBodyInt::tbint_type tbint_type_f12eri() const;
      TwoBodyInt::tbint_type tbint_type_t1f12() const;
      TwoBodyInt::tbint_type tbint_type_t2f12() const;
      TwoBodyInt::tbint_type tbint_type_f12f12() const;
      TwoBodyInt::tbint_type tbint_type_f12t1f12() const;
      Ref<TwoBodyIntDescr> tbintdescr(const Ref<Integral>& IF, unsigned int f) const;
      Ref<TwoBodyIntDescr> tbintdescr(const Ref<Integral>& IF, unsigned int fbra, unsigned int fket) const;
      double value(unsigned int c, double r12) const;

    private:
      CorrelationParameters params_;

        void print_params(std::ostream& os, unsigned int f) const;

    };

    class G12NCCorrelationFactor : public CorrelationFactor {
      public:
      typedef IntParamsG12::PrimitiveGeminal PrimitiveGeminal;
      typedef IntParamsG12::ContractedGeminal ContractedGeminal;
      typedef std::vector<ContractedGeminal> CorrelationParameters;

      G12NCCorrelationFactor(const CorrelationParameters& params, const Ref<GeminalDescriptor> &geminaldescriptor = 0);

      bool equiv(const Ref<CorrelationFactor>& cf) const;
      unsigned int nfunctions() const;
      const ContractedGeminal& function(unsigned int c) const;
      unsigned int nprimitives(unsigned int c) const;
      const PrimitiveGeminal& primitive(unsigned int c, unsigned int p) const;
      unsigned int max_num_tbint_types() const { return 6; }
      TwoBodyInt::tbint_type tbint_type_f12() const;
      TwoBodyInt::tbint_type tbint_type_f12eri() const;
      TwoBodyInt::tbint_type tbint_type_f12f12() const;
      TwoBodyInt::tbint_type tbint_type_f12t1f12() const;
      TwoBodyInt::tbint_type tbint_type_f12f12_anti() const;
      Ref<TwoBodyIntDescr> tbintdescr(const Ref<Integral>& IF, unsigned int f) const;
      Ref<TwoBodyIntDescr> tbintdescr(const Ref<Integral>& IF, unsigned int fbra, unsigned int fket) const;
      double value(unsigned int c, double r12) const;

      static ContractedGeminal product(const ContractedGeminal& A,
                                       const ContractedGeminal& B);

    private:
      CorrelationParameters params_;

      void print_params(std::ostream& os, unsigned int f) const;

    };

    class GenG12CorrelationFactor : public CorrelationFactor {
      public:
      typedef IntParamsGenG12::PrimitiveGeminal PrimitiveGeminal;
      typedef IntParamsGenG12::ContractedGeminal ContractedGeminal;
      typedef std::vector<ContractedGeminal> CorrelationParameters;

      GenG12CorrelationFactor(const CorrelationParameters& params);

      bool equiv(const Ref<CorrelationFactor>& cf) const;
      unsigned int nfunctions() const;
      const ContractedGeminal& function(unsigned int c) const;
      unsigned int nprimitives(unsigned int c) const;
      const PrimitiveGeminal& primitive(unsigned int c, unsigned int p) const;
      unsigned int max_num_tbint_types() const { return 4; }
      TwoBodyInt::tbint_type tbint_type_f12() const;
      TwoBodyInt::tbint_type tbint_type_f12eri() const;
      TwoBodyInt::tbint_type tbint_type_f12f12() const;
      TwoBodyInt::tbint_type tbint_type_f12t1f12() const;
      Ref<TwoBodyIntDescr> tbintdescr(const Ref<Integral>& IF, unsigned int f) const;
      Ref<TwoBodyIntDescr> tbintdescr(const Ref<Integral>& IF, unsigned int fbra, unsigned int fket) const;
      double value(unsigned int c, double r12) const;
      double value(unsigned int c, double r12, double r1, double r2) const;

    private:
      CorrelationParameters params_;

      void print_params(std::ostream& os, unsigned int f) const;

    };

    class GeminalDescriptorFactory : public RefCount {
      private:
        const char* invalid_id_;  // = "invalid"
        const char* r12_id_;  // = "R12"
        const char* stg_id_;  // = "STG"
        const char* g12_id_;  // = "G12"
      public:
        GeminalDescriptorFactory();
        Ref<GeminalDescriptor> null_geminal();
        Ref<GeminalDescriptor> r12_geminal();
        Ref<GeminalDescriptor> slater_geminal(double gamma);
        Ref<GeminalDescriptor> slater_geminal(const std::vector<double> &gamma);
        Ref<GeminalDescriptor> gaussian_geminal(double gamma);
        Ref<GeminalDescriptor> contracted_gaussian_geminal(const std::vector<double> &coeff,
                                                           const std::vector<double> &gamma);
        Ref<GeminalDescriptor> gaussian_geminal(const LinearR12::G12CorrelationFactor::CorrelationParameters &corrparams);
    };

    template <class CorrFactor, class Fitter>
    Ref<CorrelationFactor> stg_to_g12(const Fitter& fitter, double gamma, int k=0);

    Ref<CorrelationFactor> ang_to_geng12(double alpha);

    template <class Fitter>
    Ref<CorrelationFactor> angstg_to_geng12(const Fitter& fitter, double alpha, double gamma, int k=0);

    template <class Fitter>
    Ref<CorrelationFactor> angplusstg_to_geng12(const Fitter& fitter, double alpha, double gamma, int k=0);

    template <class CF> Ref<CF> direct_product(const Ref<CF>& A, const Ref<CF>& B);

  }

}

#endif

// Local Variables:
// mode: c++
// c-file-style: "CLJ"
// End:

---