overlap.h

Go to the documentation of this file.

#ifndef W_ABACUS_DEVELOP_ABACUS_DEVELOP_SOURCE_MODULE_HAMILT_LCAO_HAMILT_LCAODFT_OPERATOR_LCAO_OVERLAP_H
#define W_ABACUS_DEVELOP_ABACUS_DEVELOP_SOURCE_MODULE_HAMILT_LCAO_HAMILT_LCAODFT_OPERATOR_LCAO_OVERLAP_H
#include "source_basis/module_ao/parallel_orbitals.h"
#include "source_basis/module_nao/two_center_integrator.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>
 
namespace hamilt
{
 
#ifndef __OVERLAPTEMPLATE
#define __OVERLAPTEMPLATE
 
template <class T>
class Overlap : public T
{
};
 
#endif
 
template <typename TK, typename TR>
class Overlap<OperatorLCAO<TK, TR>> : public OperatorLCAO<TK, TR>
{
  public:
    Overlap<OperatorLCAO<TK, TR>>(HS_Matrix_K<TK>* hsk_in,
                                     const std::vector<ModuleBase::Vector3<double>>& kvec_d_in,
                                     hamilt::HContainer<TR>* hR_in,
                                     hamilt::HContainer<TR>* SR_in,
                                     const UnitCell* ucell_in,
                                     const std::vector<double>& orb_cutoff,
                                     const Grid_Driver* GridD_in,
                                     const TwoCenterIntegrator* intor);
 
    ~Overlap();
 
    virtual void contributeHR() override;
 
    virtual void contributeHk(int ik) override;
 
    TK* getSk();
 
    void cal_force_stress(const bool cal_force,
                          const bool cal_stress,
                          const HContainer<double>* dmR,
                          ModuleBase::matrix& force,
                          ModuleBase::matrix& stress);
 
  private:
    const UnitCell* ucell = nullptr;
 
    std::vector<double> orb_cutoff_;
 
    hamilt::HContainer<TR>* SR = nullptr;
 
    const TwoCenterIntegrator* intor_ = nullptr;
 
    const Grid_Driver* gridD = nullptr;
 
    bool SR_fixed_done = false;
 
    void initialize_SR(const Grid_Driver* GridD_in);
 
    void calculate_SR();
 
    void cal_SR_IJR(const int& iat1,
                    const int& iat2,
                    const Parallel_Orbitals* paraV,
                    const ModuleBase::Vector3<double>& dtau,
                    TR* data_pointer);
 
    void cal_force_IJR(const int& iat1,
                       const int& iat2,
                       const Parallel_Orbitals* paraV,
                       const std::unordered_map<int, std::vector<double>>& nlm1_all,
                       const std::unordered_map<int, std::vector<double>>& nlm2_all,
                       const hamilt::BaseMatrix<TR>* dmR_pointer,
                       double* force1,
                       double* force2);
 
    void cal_stress_IJR(const int& iat1,
                        const int& iat2,
                        const Parallel_Orbitals* paraV,
                        const std::unordered_map<int, std::vector<double>>& nlm1_all,
                        const std::unordered_map<int, std::vector<double>>& nlm2_all,
                        const hamilt::BaseMatrix<TR>* dmR_pointer,
                        const ModuleBase::Vector3<double>& dis1,
                        const ModuleBase::Vector3<double>& dis2,
                        double* stress);
 
    // if k vector is not changed, then do nothing and return
    // default of kvec_d_old is (-10,-10,-10), which is not a valid k vector
    ModuleBase::Vector3<double> kvec_d_old = ModuleBase::Vector3<double>(-10, -10, -10);
 
  public:
    hamilt::HContainer<TR>* calculate_SR_async(const UnitCell& ucell, const double md_dt, const Parallel_Orbitals* paraV);
 
    void output_SR_async_csr(const int istep, hamilt::HContainer<TR>* SR_async, const int precision = 8);
};
 
} // namespace hamilt
#endif