td_pot_hybrid.h

Go to the documentation of this file.

#ifndef TD_POT_HYBRID_H
#define TD_POT_HYBRID_H
#include "source_basis/module_ao/parallel_orbitals.h"
#include "source_basis/module_nao/two_center_integrator.h"
#include "source_cell/klist.h"
#include "source_cell/module_neighbor/sltk_grid_driver.h"
#include "source_cell/unitcell.h"
#include "source_lcao/module_operator_lcao/operator_lcao.h"
#include "source_lcao/module_hcontainer/hcontainer.h"
#include <vector>
#include "source_io/cal_r_overlap_R.h"
#include "source_lcao/module_rt/td_info.h"
#include "source_estate/module_pot/H_TDDFT_pw.h"
 
namespace hamilt
{
 
#ifndef __TD_POT_HYBRIDTEMPLATE
#define __TD_POT_HYBRIDTEMPLATE
 
template <class T>
class TD_pot_hybrid : public T
{
};
 
#endif
 
template <typename TK, typename TR>
class TD_pot_hybrid<OperatorLCAO<TK, TR>> : public OperatorLCAO<TK, TR>
{
  public:
    TD_pot_hybrid<OperatorLCAO<TK, TR>>(HS_Matrix_K<TK>* hsk_in,
                                      const K_Vectors* kv_in,
                                      HContainer<TR>* hR_in,
                                      HContainer<TR>* SR_in,
                                      const LCAO_Orbitals& orb,
                                      const UnitCell* ucell_in,
                                      const std::vector<double>& orb_cutoff,
                                      const Grid_Driver* GridD_in,
                                      const TwoCenterIntegrator* intor);
 
    ~TD_pot_hybrid<OperatorLCAO<TK, TR>>();
 
    virtual void contributeHR() override;
    //ETD
    virtual void contributeHk(int ik) override;
    //ETD
 
    virtual void set_HR_fixed(void*) override;
 
 
  private:
    const UnitCell* ucell = nullptr;
    std::vector<double> orb_cutoff_;
    const LCAO_Orbitals& orb_;
 
    hamilt::HContainer<TR>* HR_fixed = nullptr;
 
    hamilt::HContainer<TR>* SR = nullptr;
 
    const TwoCenterIntegrator* intor_ = nullptr;
 
    bool allocated = false;
 
    bool HR_fixed_done = false;
    //tddft part
    static cal_r_overlap_R r_calculator;
    //ETD
    //std::vector<std::complex<double>> hk_hybrid;
    //ETD
    ModuleBase::Vector3<double> cart_At;
    ModuleBase::Vector3<double> Et;
 
 
    void initialize_HR(const Grid_Driver* GridD_in);
 
    void init_td();
    void update_td();
 
    void calculate_HR();
 
    void cal_HR_IJR(const int& iat1,
                    const int& iat2,
                    const Parallel_Orbitals* paraV,
                    const ModuleBase::Vector3<double>& dtau,
                    TR* hr_mat_p,
                    TR* sr_p);
 
    std::vector<AdjacentAtomInfo> adjs_all;
};
 
} // namespace hamilt
#endif