esolver_lrtd_lcao.h

Go to the documentation of this file.

#pragma once
#include "source_esolver/esolver_fp.h"
#include "source_io/module_parameter/input_parameter.h"
#include "source_cell/unitcell.h"
#include "source_hamilt/hamilt.h"
#include "source_estate/elecstate.h"
#include "source_hamilt/hamilt.h"
#include "source_estate/elecstate_lcao.h"
 
#include <vector>   //future tensor
#include <memory>
 
#include "source_esolver/esolver_ks_lcao.h" //for the move constructor
#include "source_lcao/module_gint/gint_gamma.h"
#include "source_lcao/module_gint/gint_k.h"
#include "source_lcao/module_gint/grid_technique.h"
#include "source_estate/module_dm/density_matrix.h"
#include "source_lcao/module_lr/potentials/pot_hxc_lrtd.h"
#include "source_lcao/module_lr/hamilt_casida.h"
#include "source_lcao/module_gint/temp_gint/gint_info.h"
#ifdef __EXX
// #include <RI/physics/Exx.h>
#include "source_lcao/module_ri/Exx_LRI.h"
#endif
namespace LR
{
    template<typename T, typename TR = double>
    class ESolver_LR : public ModuleESolver::ESolver_FP
    {
    public:
        ESolver_LR(ModuleESolver::ESolver_KS_LCAO<T, TR>&& ks_sol, const Input_para& inp, UnitCell& ucell);
        ESolver_LR(const Input_para& inp, UnitCell& ucell);
        ~ESolver_LR() {
            delete this->psi_ks;
        }
 
        // initialize sth. independent of the ground state
        virtual void before_all_runners(UnitCell& ucell, const Input_para& inp) override {};
        virtual void runner(UnitCell& ucell, int istep) override;
        virtual void after_all_runners(UnitCell& ucell) override;
 
        virtual double cal_energy()  override { return 0.0; };
        virtual void cal_force(UnitCell& ucell, ModuleBase::matrix& force) override {};
        virtual void cal_stress(UnitCell& ucell, ModuleBase::matrix& stress) override {};
 
      protected:
        const Input_para& input;
        const UnitCell& ucell;
        Grid_Driver gd;
        std::vector<double> orb_cutoff_;
 
        // not to use ElecState because 2-particle state is quite different from 1-particle state.
        // implement a independent one (ExcitedState) to pack physical properties if needed.
        // put the components of ElecState here: 
        std::vector<std::shared_ptr<PotHxcLR>> pot;
 
        // ground state info 
 
        psi::Psi<T>* psi_ks = nullptr;
 
        ModuleBase::matrix eig_ks;
 
        std::vector<ct::Tensor> X;
        int nloc_per_band = 1;
 
        std::vector<int> nocc;   
        int nocc_in = 1;    
        int nocc_max = 1;   
        std::vector<int> nvirt;   
        int nvirt_in = 1;   
        int nbands = 2;
        int nbasis = 2;
        std::vector<int> npairs;
        int nstates = 1;
        int nspin = 1;
        int nk = 1;
        int nupdown = 0;
        bool openshell = false;
        std::string xc_kernel;
 
        Grid_Technique gt_;
        Gint_Gamma gint_g_;
        Gint_k gint_k_;
        typename TGint<T>::type* gint_ = nullptr;
        #ifndef __OLD_GINT
        std::unique_ptr<ModuleGint::GintInfo> gint_info_ = nullptr;
        #endif
        void set_gint();
 
        Parallel_2D paraC_;
        std::vector<Parallel_2D> paraX_;
        Parallel_Orbitals paraMat_;
 
        TwoCenterBundle two_center_bundle_;
 
        void setup_eigenvectors_X();
        void set_X_initial_guess();
 
        void read_ks_wfc();
        void read_ks_chg(Charge& chg);
 
        void init_pot(const Charge& chg_gs);
 
        void parameter_check() const;
        void set_dimension();
        void reset_dim_spin2();
 
#ifdef __EXX
        std::shared_ptr<Exx_LRI<T>> exx_lri = nullptr;
        void move_exx_lri(std::shared_ptr<Exx_LRI<double>>&);
        void move_exx_lri(std::shared_ptr<Exx_LRI<std::complex<double>>>&);
        Exx_Info& exx_info;
#endif
    };
}