ABACUS develop
Atomic-orbital Based Ab-initio Computation at UStc
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
hsolver::Diago_DavSubspace< T, Device > Class Template Reference

#include <diago_dav_subspace.h>

Collaboration diagram for hsolver::Diago_DavSubspace< T, Device >:

Public Types

using HPsiFunc = std::function< void(T *, T *, const int, const int)>
 

Public Member Functions

 Diago_DavSubspace (const std::vector< Real > &precondition_in, const int &nband_in, const int &nbasis_in, const int &david_ndim_in, const double &diag_thr_in, const int &diag_nmax_in, const bool &need_subspace_in, const diag_comm_info &diag_comm_in, const int diago_dav_method_in, const int block_size_in)
 
 ~Diago_DavSubspace ()
 
int diag (const HPsiFunc &hpsi_func, const HPsiFunc &spsi_func, T *psi_in, const int psi_in_dmax, Real *eigenvalue_in, const std::vector< double > &ethr_band, const bool &scf_type)
 

Private Types

using Real = typename GetTypeReal< T >::type
 
using resmem_complex_op = base_device::memory::resize_memory_op< T, Device >
 
using delmem_complex_op = base_device::memory::delete_memory_op< T, Device >
 
using setmem_complex_op = base_device::memory::set_memory_op< T, Device >
 
using resmem_real_op = base_device::memory::resize_memory_op< Real, Device >
 
using delmem_real_op = base_device::memory::delete_memory_op< Real, Device >
 
using setmem_real_op = base_device::memory::set_memory_op< Real, Device >
 
using resmem_real_h_op = base_device::memory::resize_memory_op< Real, base_device::DEVICE_CPU >
 
using delmem_real_h_op = base_device::memory::delete_memory_op< Real, base_device::DEVICE_CPU >
 
using setmem_real_h_op = base_device::memory::set_memory_op< Real, base_device::DEVICE_CPU >
 
using syncmem_var_h2d_op = base_device::memory::synchronize_memory_op< Real, Device, base_device::DEVICE_CPU >
 
using syncmem_var_d2h_op = base_device::memory::synchronize_memory_op< Real, base_device::DEVICE_CPU, Device >
 
using syncmem_complex_op = base_device::memory::synchronize_memory_op< T, Device, Device >
 
using castmem_complex_op = base_device::memory::cast_memory_op< std::complex< double >, T, Device, Device >
 
using syncmem_h2d_op = base_device::memory::synchronize_memory_op< T, Device, base_device::DEVICE_CPU >
 
using syncmem_d2h_op = base_device::memory::synchronize_memory_op< T, base_device::DEVICE_CPU, Device >
 

Private Member Functions

void cal_grad (const HPsiFunc &hpsi_func, const HPsiFunc &spsi_func, const int &dim, const int &nbase, const int &notconv, T *psi_iter, T *hphi, T *spsi, T *vcc, const int *unconv, std::vector< Real > *eigenvalue_iter)
 
void cal_elem (const int &dim, int &nbase, const int &notconv, const T *psi_iter, const T *sphi, const T *hphi, T *hcc, T *scc)
 
void refresh (const int &dim, const int &nband, int &nbase, const Real *eigenvalue, T *psi_iter, T *hphi, T *sphi, T *hcc, T *scc, T *vcc)
 
void diag_zhegvx (const int &nbase, const int &nband, T *hcc, T *scc, const int &nbase_x, std::vector< Real > *eigenvalue_iter, T *vcc)
 
int diag_once (const HPsiFunc &hpsi_func, const HPsiFunc &spsi_func, T *psi_in, const int psi_in_dmax, Real *eigenvalue_in, const std::vector< double > &ethr_band)
 
bool test_exit_cond (const int &ntry, const int &notconv, const bool &scf)
 

Private Attributes

const diag_comm_info diag_comm
 for MPI communication
 
const double diag_thr
 the threshold for this electronic iteration
 
const int iter_nmax
 maximal iteration number
 
const bool is_subspace
 is diagH_subspace needed?
 
const int n_band = 0
 the first dimension of the matrix to be diagonalized
 
const int dim = 0
 the second dimension of the matrix to be diagonalized
 
const int nbase_x = 0
 the maximum dimension of the reduced basis set
 
const std::vector< Real > & precondition
 precondition for diag
 
Reald_precondition = nullptr
 
int notconv = 0
 record for how many bands not have convergence eigenvalues
 
Tpsi_in_iter = nullptr
 
Thphi = nullptr
 the product of H and psi in the reduced basis set
 
Tsphi = nullptr
 the product of S and psi in the reduced basis set
 
Thcc = nullptr
 Hamiltonian on the reduced basis.
 
Tscc = nullptr
 Overlap on the reduced basis.
 
Tvcc = nullptr
 Eigenvectors on the reduced basis.
 
Device * ctx = {}
 device type of psi
 
base_device::DEVICE_CPU * cpu_ctx = {}
 
base_device::AbacusDevice_t device = {}
 
int diag_subspace
 
int diago_subspace_bs = 0
 
const Tone = nullptr
 
const Tzero = nullptr
 
const Tneg_one = nullptr
 
const T one_ = static_cast<T>(1.0)
 
const T zero_ = static_cast<T>(0.0)
 
const T neg_one_ = static_cast<T>(-1.0)
 

Member Typedef Documentation

◆ castmem_complex_op

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::castmem_complex_op = base_device::memory::cast_memory_op<std::complex<double>, T, Device, Device>
private

◆ delmem_complex_op

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::delmem_complex_op = base_device::memory::delete_memory_op<T, Device>
private

◆ delmem_real_h_op

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::delmem_real_h_op = base_device::memory::delete_memory_op<Real, base_device::DEVICE_CPU>
private

◆ delmem_real_op

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::delmem_real_op = base_device::memory::delete_memory_op<Real, Device>
private

◆ HPsiFunc

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::HPsiFunc = std::function<void(T*, T*, const int, const int)>

◆ Real

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::Real = typename GetTypeReal<T>::type
private

◆ resmem_complex_op

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::resmem_complex_op = base_device::memory::resize_memory_op<T, Device>
private

◆ resmem_real_h_op

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::resmem_real_h_op = base_device::memory::resize_memory_op<Real, base_device::DEVICE_CPU>
private

◆ resmem_real_op

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::resmem_real_op = base_device::memory::resize_memory_op<Real, Device>
private

◆ setmem_complex_op

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::setmem_complex_op = base_device::memory::set_memory_op<T, Device>
private

◆ setmem_real_h_op

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::setmem_real_h_op = base_device::memory::set_memory_op<Real, base_device::DEVICE_CPU>
private

◆ setmem_real_op

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::setmem_real_op = base_device::memory::set_memory_op<Real, Device>
private

◆ syncmem_complex_op

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::syncmem_complex_op = base_device::memory::synchronize_memory_op<T, Device, Device>
private

◆ syncmem_d2h_op

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::syncmem_d2h_op = base_device::memory::synchronize_memory_op<T, base_device::DEVICE_CPU, Device>
private

◆ syncmem_h2d_op

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::syncmem_h2d_op = base_device::memory::synchronize_memory_op<T, Device, base_device::DEVICE_CPU>
private

◆ syncmem_var_d2h_op

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::syncmem_var_d2h_op = base_device::memory::synchronize_memory_op<Real, base_device::DEVICE_CPU, Device>
private

◆ syncmem_var_h2d_op

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
using hsolver::Diago_DavSubspace< T, Device >::syncmem_var_h2d_op = base_device::memory::synchronize_memory_op<Real, Device, base_device::DEVICE_CPU>
private

Constructor & Destructor Documentation

◆ Diago_DavSubspace()

template<typename T , typename Device >
Diago_DavSubspace::Diago_DavSubspace ( const std::vector< Real > &  precondition_in,
const int &  nband_in,
const int &  nbasis_in,
const int &  david_ndim_in,
const double &  diag_thr_in,
const int &  diag_nmax_in,
const bool &  need_subspace_in,
const diag_comm_info diag_comm_in,
const int  diago_dav_method_in,
const int  block_size_in 
)

◆ ~Diago_DavSubspace()

template<typename T , typename Device >
Diago_DavSubspace::~Diago_DavSubspace ( )

Member Function Documentation

◆ cal_elem()

template<typename T , typename Device >
void Diago_DavSubspace::cal_elem ( const int &  dim,
int &  nbase,
const int &  notconv,
const T psi_iter,
const T sphi,
const T hphi,
T hcc,
T scc 
)
private
Here is the call graph for this function:

◆ cal_grad()

template<typename T , typename Device >
void Diago_DavSubspace::cal_grad ( const HPsiFunc hpsi_func,
const HPsiFunc spsi_func,
const int &  dim,
const int &  nbase,
const int &  notconv,
T psi_iter,
T hphi,
T spsi,
T vcc,
const int *  unconv,
std::vector< Real > *  eigenvalue_iter 
)
private
Here is the call graph for this function:

◆ diag()

template<typename T , typename Device >
int Diago_DavSubspace::diag ( const HPsiFunc hpsi_func,
const HPsiFunc spsi_func,
T psi_in,
const int  psi_in_dmax,
Real eigenvalue_in,
const std::vector< double > &  ethr_band,
const bool &  scf_type 
)

record the times of trying iterative diagonalization

Here is the caller graph for this function:

◆ diag_once()

template<typename T , typename Device >
int Diago_DavSubspace::diag_once ( const HPsiFunc hpsi_func,
const HPsiFunc spsi_func,
T psi_in,
const int  psi_in_dmax,
Real eigenvalue_in,
const std::vector< double > &  ethr_band 
)
private
Here is the call graph for this function:

◆ diag_zhegvx()

template<typename T , typename Device >
void Diago_DavSubspace::diag_zhegvx ( const int &  nbase,
const int &  nband,
T hcc,
T scc,
const int &  nbase_x,
std::vector< Real > *  eigenvalue_iter,
T vcc 
)
private
Here is the call graph for this function:

◆ refresh()

template<typename T , typename Device >
void Diago_DavSubspace::refresh ( const int &  dim,
const int &  nband,
int &  nbase,
const Real eigenvalue,
T psi_iter,
T hphi,
T sphi,
T hcc,
T scc,
T vcc 
)
private
Here is the call graph for this function:

◆ test_exit_cond()

template<typename T , typename Device >
bool Diago_DavSubspace::test_exit_cond ( const int &  ntry,
const int &  notconv,
const bool &  scf 
)
private

Member Data Documentation

◆ cpu_ctx

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
base_device::DEVICE_CPU* hsolver::Diago_DavSubspace< T, Device >::cpu_ctx = {}
private

◆ ctx

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
Device* hsolver::Diago_DavSubspace< T, Device >::ctx = {}
private

device type of psi

◆ d_precondition

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
Real* hsolver::Diago_DavSubspace< T, Device >::d_precondition = nullptr
private

◆ device

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
base_device::AbacusDevice_t hsolver::Diago_DavSubspace< T, Device >::device = {}
private

◆ diag_comm

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
const diag_comm_info hsolver::Diago_DavSubspace< T, Device >::diag_comm
private

for MPI communication

◆ diag_subspace

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
int hsolver::Diago_DavSubspace< T, Device >::diag_subspace
private

◆ diag_thr

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
const double hsolver::Diago_DavSubspace< T, Device >::diag_thr
private

the threshold for this electronic iteration

◆ diago_subspace_bs

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
int hsolver::Diago_DavSubspace< T, Device >::diago_subspace_bs = 0
private

◆ dim

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
const int hsolver::Diago_DavSubspace< T, Device >::dim = 0
private

the second dimension of the matrix to be diagonalized

◆ hcc

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
T* hsolver::Diago_DavSubspace< T, Device >::hcc = nullptr
private

Hamiltonian on the reduced basis.

◆ hphi

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
T* hsolver::Diago_DavSubspace< T, Device >::hphi = nullptr
private

the product of H and psi in the reduced basis set

◆ is_subspace

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
const bool hsolver::Diago_DavSubspace< T, Device >::is_subspace
private

is diagH_subspace needed?

◆ iter_nmax

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
const int hsolver::Diago_DavSubspace< T, Device >::iter_nmax
private

maximal iteration number

◆ n_band

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
const int hsolver::Diago_DavSubspace< T, Device >::n_band = 0
private

the first dimension of the matrix to be diagonalized

◆ nbase_x

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
const int hsolver::Diago_DavSubspace< T, Device >::nbase_x = 0
private

the maximum dimension of the reduced basis set

◆ neg_one

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
const T * hsolver::Diago_DavSubspace< T, Device >::neg_one = nullptr
private

◆ neg_one_

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
const T hsolver::Diago_DavSubspace< T, Device >::neg_one_ = static_cast<T>(-1.0)
private

◆ notconv

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
int hsolver::Diago_DavSubspace< T, Device >::notconv = 0
private

record for how many bands not have convergence eigenvalues

◆ one

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
const T* hsolver::Diago_DavSubspace< T, Device >::one = nullptr
private

◆ one_

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
const T hsolver::Diago_DavSubspace< T, Device >::one_ = static_cast<T>(1.0)
private

◆ precondition

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
const std::vector<Real>& hsolver::Diago_DavSubspace< T, Device >::precondition
private

precondition for diag

◆ psi_in_iter

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
T* hsolver::Diago_DavSubspace< T, Device >::psi_in_iter = nullptr
private

◆ scc

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
T* hsolver::Diago_DavSubspace< T, Device >::scc = nullptr
private

Overlap on the reduced basis.

◆ sphi

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
T* hsolver::Diago_DavSubspace< T, Device >::sphi = nullptr
private

the product of S and psi in the reduced basis set

◆ vcc

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
T* hsolver::Diago_DavSubspace< T, Device >::vcc = nullptr
private

Eigenvectors on the reduced basis.

◆ zero

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
const T * hsolver::Diago_DavSubspace< T, Device >::zero = nullptr
private

◆ zero_

template<typename T = std::complex<double>, typename Device = base_device::DEVICE_CPU>
const T hsolver::Diago_DavSubspace< T, Device >::zero_ = static_cast<T>(0.0)
private

The documentation for this class was generated from the following files: