td_ekinetic_lcao.h

Go to the documentation of this file.

#ifndef TDEKINETIC_H
#define TDEKINETIC_H
#include "source_base/timer.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_lcao/module_hcontainer/hcontainer.h"
#include "source_lcao/module_rt/td_info.h"
#include "operator_lcao.h"
#include <vector>
 
 
namespace hamilt
{
 
#ifndef __TDEKINETICTEMPLATE
#define __TDEKINETICTEMPLATE
 
template <class T>
class TDEkinetic : public T
{
};
 
#endif
 
 
template <typename TK, typename TR>
class TDEkinetic<OperatorLCAO<TK,TR>> : public OperatorLCAO<TK, TR>
{
  public:
    TDEkinetic<OperatorLCAO<TK, TR>>(HS_Matrix_K<TK>* hsk_in,
                                     hamilt::HContainer<TR>* hR_in,
                                     const K_Vectors* kv_in,
                                     const UnitCell* ucell_in,
                                     const std::vector<double>& orb_cutoff,
                                     const Grid_Driver* GridD_in,
                                     const TwoCenterIntegrator* intor);
    ~TDEkinetic();
 
    virtual void contributeHR() override;
 
    virtual void contributeHk(int ik) override;
 
    void update_td();
 
    void initialize_HR(const Grid_Driver* GridD);
 
    void initialize_HR_tmp();
 
    void cal_HR_IJR(const int& iat1,
                    const int& iat2,
                    const Parallel_Orbitals* paraV,
                    const ModuleBase::Vector3<double>& dtau,
                    std::complex<double>* hr_mat_p,
                    std::complex<double>** current_mat_p);
 
    void calculate_HR();
 
    virtual void set_HR_fixed(void*) override;
 
 
  private:
 
    const UnitCell* ucell = nullptr;
 
    std::vector<double> orb_cutoff_;
    
    HContainer<TR>* SR = nullptr;
 
    HContainer<std::complex<double>>* hR_tmp = nullptr;
 
    const Grid_Driver* Grid = nullptr;
 
    const K_Vectors* kv;
 
    void td_ekinetic_scalar(std::complex<double>* Hloc, const TR& Sloc, int nnr);
 
    void td_ekinetic_grad(std::complex<double>* Hloc, int nnr, ModuleBase::Vector3<double> grad_overlap);
 
    const TwoCenterIntegrator* intor_ = nullptr;
 
    ModuleBase::Vector3<double> cart_At;
 
    std::vector<AdjacentAtomInfo> adjs_all;
 
    bool hR_tmp_done = false;
 
    bool allocated = false;
 
    bool output_hR_done = false;
};
 
} // namespace hamilt
#endif