sto_elecond.h

Go to the documentation of this file.

#ifndef STOELECOND_H
#define STOELECOND_H
 
#include "source_hamilt/hamilt.h"
#include "source_pw/module_pwdft/elecond.h"
#include "source_pw/module_stodft/sto_wf.h"
#include "source_hsolver/hsolver_pw_sdft.h"
 
template <typename FPTYPE, typename Device> 
class Sto_EleCond : protected EleCond<FPTYPE, Device>
{
  public:
#ifdef __ENABLE_FLOAT_FFTW
    using lowTYPE = float; // Here we use float to accelerate the calculation, which is enough for the accuracy
#else
    using lowTYPE = double;
#endif
    using lcomplex = std::complex<lowTYPE>;
    using resmem_lcomplex_op = base_device::memory::resize_memory_op<std::complex<lowTYPE>, Device>; 
    using delmem_lcomplex_op = base_device::memory::delete_memory_op<std::complex<lowTYPE>, Device>;
    using cpymem_lcomplex_op = base_device::memory::synchronize_memory_op<std::complex<lowTYPE>, Device, Device>;
    using castmem_lcomplex_op = base_device::memory::cast_memory_op<std::complex<lowTYPE>, std::complex<FPTYPE>, Device, Device>;
    using cpymem_complex_op = base_device::memory::synchronize_memory_op<std::complex<FPTYPE>, Device, Device>;
  public:
    Sto_EleCond(UnitCell* p_ucell_in,
                K_Vectors* p_kv_in,
                elecstate::ElecState* p_elec_in,
                ModulePW::PW_Basis_K* p_wfcpw_in,
                psi::Psi<std::complex<FPTYPE>, Device>* p_psi_in,
                pseudopot_cell_vnl* p_ppcell_in,
                hamilt::Hamilt<std::complex<FPTYPE>, Device>* p_hamilt_in,
                StoChe<FPTYPE, Device>& stoche,
                Stochastic_WF<std::complex<FPTYPE>, Device>* p_stowf_in);
    ~Sto_EleCond(){
        delete hamilt_sto_;
    };
    void decide_nche(const FPTYPE dt, const FPTYPE cond_thr, const int& fd_nche, FPTYPE try_emin, FPTYPE try_emax);
    void sKG(const int& smear_type,
             const double& fwhmin,
             const double& wcut,
             const double& dw_in,
             const double& dt_in,
             const bool& nonlocal,
             const int& npart_sto);
 
  protected:
    int nbands_ks = 0;    
    int nbands_sto = 0;   
    int cond_nche = 0;    
    int fd_nche = 0;      
    int cond_dtbatch = 0; 
    hamilt::Hamilt<std::complex<FPTYPE>, Device>* p_hamilt = nullptr; 
    Stochastic_WF<std::complex<FPTYPE>, Device>* p_stowf = nullptr;   
    Sto_Func<FPTYPE> stofunc;                                         
 
    hamilt::HamiltSdftPW<std::complex<FPTYPE>, Device>* p_hamilt_sto = nullptr; 
    hamilt::HamiltSdftPW<std::complex<lowTYPE>, Device>* hamilt_sto_ = nullptr; 
    lowTYPE low_emin_ = 0;                                                      
    lowTYPE low_emax_ = 0;                                                      
  protected:
    void cal_jmatrix(hamilt::HamiltSdftPW<std::complex<lowTYPE>, Device>* hamilt,
                     const psi::Psi<std::complex<lowTYPE>, Device>& kspsi_all,
                     const psi::Psi<std::complex<lowTYPE>, Device>& vkspsi,
                     const double* en,
                     const double* en_all,
                     std::complex<FPTYPE>* leftfact,
                     std::complex<FPTYPE>* rightfact,
                     psi::Psi<std::complex<lowTYPE>, Device>& leftchi,
                     psi::Psi<std::complex<lowTYPE>, Device>& rightchi,
                     psi::Psi<std::complex<lowTYPE>, Device>& left_hchi,
                     psi::Psi<std::complex<lowTYPE>, Device>& right_hchi,
                     psi::Psi<std::complex<lowTYPE>, Device>& batch_vchi,
                     psi::Psi<std::complex<lowTYPE>, Device>& batch_vhchi,
#ifdef __MPI
                     psi::Psi<std::complex<lowTYPE>, Device>& chi_all,
                     psi::Psi<std::complex<lowTYPE>, Device>& hchi_all,
                     void* gatherinfo_ks,
                     void* gatherinfo_sto,
#endif
                     const int& bsize_psi,
                     std::complex<lowTYPE>* j1,
                     std::complex<lowTYPE>* j2,
                     std::complex<lowTYPE>* tmpj,
                     hamilt::Velocity<lowTYPE, Device>& velop,
                     const int& ik,
                     const std::complex<lowTYPE>& factor,
                     const int bandinfo[6]);
};
#endif // ELECOND_H