op_exx_lcao.h

Go to the documentation of this file.

#ifndef OPEXXLCAO_H
#define OPEXXLCAO_H
 
#ifdef __EXX
 
#include "operator_lcao.h"
#include "source_cell/klist.h"
#include "source_hamilt/module_xc/exx_info.h"
 
#include <RI/global/Tensor.h>
#include <RI/ri/Cell_Nearest.h>
 
namespace hamilt
{
 
#ifndef __OPEXXTEMPLATE
#define __OPEXXTEMPLATE
 
template <class T>
class OperatorEXX : public T
{
};
 
#endif
enum Add_Hexx_Type
{
    R,
    k
};
template <typename TK, typename TR>
class OperatorEXX<OperatorLCAO<TK, TR>> : public OperatorLCAO<TK, TR>
{
    using TAC = std::pair<int, std::array<int, 3>>;
 
  public:
    OperatorEXX<OperatorLCAO<TK, TR>>(
        HS_Matrix_K<TK>* hsk_in,
        hamilt::HContainer<TR>* hR_in,
        const UnitCell& ucell,
        const K_Vectors& kv_in,
        std::vector<std::map<int, std::map<TAC, RI::Tensor<double>>>>* Hexxd_in = nullptr,
        std::vector<std::map<int, std::map<TAC, RI::Tensor<std::complex<double>>>>>* Hexxc_in = nullptr,
        Add_Hexx_Type add_hexx_type_in = Add_Hexx_Type::R,
        const int istep_in = 0,
        int* two_level_step_in = nullptr,
        const bool restart_in = false);
 
    virtual void contributeHk(int ik) override;
    virtual void contributeHR() override;
 
  private:
    Add_Hexx_Type add_hexx_type = Add_Hexx_Type::R;
    int current_spin = 0;
    bool HR_fixed_done = false;
    bool initial_gga_done = false; // Taoni Bao add 2026-05-18, to fix RT-TDDFT EXX missing problem in the evolution
 
    std::vector<std::map<int, std::map<TAC, RI::Tensor<double>>>>* Hexxd = nullptr;
    std::vector<std::map<int, std::map<TAC, RI::Tensor<std::complex<double>>>>>* Hexxc = nullptr;
 
    int* two_level_step = nullptr;
    bool restart = false;
 
    const int istep = 0; // the ion step
 
    void add_loaded_Hexx(const int ik);
 
    const UnitCell& ucell;
 
    const K_Vectors& kv;
 
    // if k points has no shift, use cell_nearest to reduce the memory cost
    RI::Cell_Nearest<int, int, 3, double, 3> cell_nearest;
    bool use_cell_nearest = true;
 
    std::vector<std::vector<double>> Hexxd_k_load;
    std::vector<std::vector<std::complex<double>>> Hexxc_k_load;
};
 
using TAC = std::pair<int, std::array<int, 3>>;
 
RI::Cell_Nearest<int, int, 3, double, 3> init_cell_nearest(const UnitCell& ucell, const std::array<int, 3>& Rs_period);
 
// allocate according to the read-in HexxR, used in nscf
template <typename Tdata, typename TR>
void reallocate_hcontainer(const std::vector<std::map<int, std::map<TAC, RI::Tensor<Tdata>>>>& Hexxs,
                           HContainer<TR>* hR,
                           const RI::Cell_Nearest<int, int, 3, double, 3>* const cell_nearest = nullptr);
 
template <typename TR>
void reallocate_hcontainer(const int nat,
                           HContainer<TR>* hR,
                           const std::array<int, 3>& Rs_period,
                           const RI::Cell_Nearest<int, int, 3, double, 3>* const cell_nearest = nullptr);
 
} // namespace hamilt
#endif // __EXX
#include "op_exx_lcao.hpp"
#endif // OPEXXLCAO_H