ABACUS develop
Atomic-orbital Based Ab-initio Computation at UStc
Loading...
Searching...
No Matches
Classes | Namespaces | Typedefs | Functions
LRI_CV_Tools.h File Reference
#include "source_base/abfs-vector3_order.h"
#include "source_lcao/module_ri/abfs.h"
#include <RI/global/Array_Operator.h>
#include <RI/global/Tensor.h>
#include <array>
#include <cstddef>
#include <map>
#include <vector>
#include "LRI_CV_Tools.hpp"
#include "write_ri_cv.hpp"
Include dependency graph for LRI_CV_Tools.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  LRI_CV_Tools::is_std_array< T >
 
struct  LRI_CV_Tools::is_std_array< std::array< T, N > >
 
struct  LRI_CV_Tools::is_tensor< T >
 
struct  LRI_CV_Tools::is_tensor< RI::Tensor< T > >
 
struct  LRI_CV_Tools::TinType< RI::Tensor< T > >
 
struct  LRI_CV_Tools::TinType< std::array< RI::Tensor< T >, N > >
 
struct  LRI_CV_Tools::plus< T >
 

Namespaces

namespace  LRI_CV_Tools
 

Typedefs

using LRI_CV_Tools::TC = std::array< int, 3 >
 
using LRI_CV_Tools::TAC = std::pair< int, TC >
 
template<typename T >
using LRI_CV_Tools::TLRI = std::map< int, std::map< TAC, RI::Tensor< T > > >
 

Functions

template<typename Tdata >
RI::Tensor< Tdata > LRI_CV_Tools::cal_I (const RI::Tensor< Tdata > &m)
 
template<typename Tdata >
std::vector< std::vector< RI::Tensor< Tdata > > > LRI_CV_Tools::cal_I (const std::vector< std::vector< RI::Tensor< Tdata > > > &ms)
 
template<typename Tdata >
RI::Tensor< Tdata > LRI_CV_Tools::transform_Rm (const RI::Tensor< Tdata > &V)
 
template<typename Tdata >
std::array< RI::Tensor< Tdata >, 3 > LRI_CV_Tools::transform_Rm (const std::array< RI::Tensor< Tdata >, 3 > &dV)
 
template<typename Tdata >
bool LRI_CV_Tools::exist (const RI::Tensor< Tdata > &V)
 
template<typename T , std::size_t N>
bool LRI_CV_Tools::exist (const std::array< T, N > &dV)
 
template<typename Tdata >
RI::Tensor< Tdata > LRI_CV_Tools::mul1 (const RI::Tensor< Tdata > &t1, const RI::Tensor< Tdata > &t2)
 
template<typename T >
std::array< T, 3 > LRI_CV_Tools::mul1 (const std::array< T, 3 > &t1, const T &t2)
 
template<typename Tdata >
std::vector< RI::Tensor< Tdata > > LRI_CV_Tools::mul2 (const std::vector< std::vector< RI::Tensor< Tdata > > > &mat, const std::vector< RI::Tensor< Tdata > > &vec)
 
template<typename T1 , typename T2 >
std::array< T2, 3 > LRI_CV_Tools::mul2 (const T1 &t1, const std::array< T2, 3 > &t2)
 
template<typename T >
RI::Tensor< TLRI_CV_Tools::mul2 (const T &t1, const RI::Tensor< T > &t2)
 
template<typename T , typename TkeyA , typename TkeyB , typename Tvalue >
std::map< TkeyA, std::map< TkeyB, Tvalue > > LRI_CV_Tools::mul2 (const T &t1, const std::map< TkeyA, std::map< TkeyB, Tvalue > > &t2)
 
template<typename T , std::size_t N>
std::vector< std::array< T, N > > LRI_CV_Tools::minus (const std::vector< std::array< T, N > > &v1, const std::vector< std::array< T, N > > &v2)
 
template<typename TkeyA , typename TkeyB , typename Tvalue , std::size_t N>
std::array< std::map< TkeyA, std::map< TkeyB, Tvalue > >, NLRI_CV_Tools::minus (std::array< std::map< TkeyA, std::map< TkeyB, Tvalue > >, N > &v1, std::array< std::map< TkeyA, std::map< TkeyB, Tvalue > >, N > &v2)
 
template<typename TkeyA , typename TkeyB , typename Tvalue , std::size_t N>
std::map< TkeyA, std::map< TkeyB, std::array< Tvalue, N > > > LRI_CV_Tools::minus (std::map< TkeyA, std::map< TkeyB, std::array< Tvalue, N > > > &v1, std::map< TkeyA, std::map< TkeyB, std::array< Tvalue, N > > > &v2)
 
template<typename TkeyA , typename TkeyB , typename Tvalue >
std::map< TkeyA, std::map< TkeyB, Tvalue > > LRI_CV_Tools::minus (std::map< TkeyA, std::map< TkeyB, Tvalue > > &v1, std::map< TkeyA, std::map< TkeyB, Tvalue > > &v2)
 
template<typename T , std::size_t N>
std::vector< std::array< T, N > > LRI_CV_Tools::add (const std::vector< std::array< T, N > > &v1, const std::vector< std::array< T, N > > &v2)
 
template<typename TkeyA , typename TkeyB , typename Tvalue , std::size_t N>
std::array< std::map< TkeyA, std::map< TkeyB, Tvalue > >, NLRI_CV_Tools::add (std::array< std::map< TkeyA, std::map< TkeyB, Tvalue > >, N > &v1, std::array< std::map< TkeyA, std::map< TkeyB, Tvalue > >, N > &v2)
 
template<typename TkeyA , typename TkeyB , typename Tvalue , std::size_t N>
std::map< TkeyA, std::map< TkeyB, std::array< Tvalue, N > > > LRI_CV_Tools::add (std::map< TkeyA, std::map< TkeyB, std::array< Tvalue, N > > > &v1, std::map< TkeyA, std::map< TkeyB, std::array< Tvalue, N > > > &v2)
 
template<typename TkeyA , typename TkeyB , typename Tvalue >
std::map< TkeyA, std::map< TkeyB, Tvalue > > LRI_CV_Tools::add (std::map< TkeyA, std::map< TkeyB, Tvalue > > &v1, std::map< TkeyA, std::map< TkeyB, Tvalue > > &v2)
 
template<typename T , std::size_t N>
std::array< T, NLRI_CV_Tools::negative (const std::array< T, N > &v_in)
 
template<typename Tdata >
RI::Tensor< Tdata > LRI_CV_Tools::transpose12 (const RI::Tensor< Tdata > &c_in)
 
template<typename T , std::size_t N>
std::array< T, NLRI_CV_Tools::transpose12 (const std::array< T, N > &c_in)
 
template<typename T , std::size_t N>
std::array< std::vector< T >, NLRI_CV_Tools::change_order (std::vector< std::array< T, N > > &&ds_in)
 
template<typename T , std::size_t N>
std::vector< std::array< T, N > > LRI_CV_Tools::change_order (std::array< std::vector< T >, N > &&ds_in)
 
template<typename T , std::size_t N>
std::array< std::vector< std::vector< T > >, NLRI_CV_Tools::change_order (std::vector< std::vector< std::array< T, N > > > &&ds_in)
 
template<typename TkeyA , typename TkeyB , typename Tvalue , std::size_t N>
std::array< std::map< TkeyA, std::map< TkeyB, Tvalue > >, NLRI_CV_Tools::change_order (std::map< TkeyA, std::map< TkeyB, std::array< Tvalue, N > > > &&ds_in)
 
template<typename TkeyA , typename TkeyB , typename Tvalue , std::size_t N>
std::map< TkeyA, std::map< TkeyB, std::array< Tvalue, N > > > LRI_CV_Tools::change_order (std::array< std::map< TkeyA, std::map< TkeyB, Tvalue > >, N > &&ds_in)
 
template<typename Tcell >
std::array< Tcell, 3 > LRI_CV_Tools::cal_latvec_range (const double &rcut_times, const UnitCell &ucell, const std::vector< double > &orb_cutoff)
 
template<typename TA , typename Tcell , typename Tdata >
std::map< int, std::map< int, std::map< Abfs::Vector3_Order< double >, RI::Tensor< Tdata > > > > LRI_CV_Tools::get_CVws (const UnitCell &ucell, const std::map< TA, std::map< std::pair< TA, std::array< Tcell, 3 > >, RI::Tensor< Tdata > > > &CVs)
 
template<typename TA , typename Tcell , typename Tdata >
std::map< int, std::map< int, std::map< Abfs::Vector3_Order< double >, std::array< RI::Tensor< Tdata >, 3 > > > > LRI_CV_Tools::get_dCVws (const UnitCell &ucell, const std::map< TA, std::map< std::pair< TA, std::array< Tcell, 3 > >, std::array< RI::Tensor< Tdata >, 3 > > > &dCVs)
 
template<typename TA , typename TC , typename Tdata >
std::array< std::array< std::map< TA, std::map< std::pair< TA, TC >, RI::Tensor< Tdata > > >, 3 >, 3 > LRI_CV_Tools::cal_dMRs (const UnitCell &ucell, const std::array< std::map< TA, std::map< std::pair< TA, TC >, RI::Tensor< Tdata > > >, 3 > &dMs)
 
template<typename T >
TLRI< TLRI_CV_Tools::read_Cs_ao (const std::string &file_path, const double &threshold=1e-10)
 
template<typename T >
void LRI_CV_Tools::write_Cs_ao (const TLRI< T > &Vs, const std::string &file_path)
 
template<typename T >
TLRI< TLRI_CV_Tools::read_Vs_abf (const std::string &file_path, const double &threshold=1e-10)
 
template<typename T >
void LRI_CV_Tools::write_Vs_abf (const TLRI< T > &Vs, const std::string &file_path)
 
template<typename Tdata , typename = std::enable_if_t<!is_std_array<Tdata>::value>>
void LRI_CV_Tools::init_elem (Tdata &data, const size_t ndim0, const size_t ndim1)
 
template<typename T , std::size_t N>
void LRI_CV_Tools::init_elem (std::array< RI::Tensor< T >, N > &data, const size_t ndim0, const size_t ndim1)
 
template<typename Tdata , typename = std::enable_if_t<!is_std_array<Tdata>::value && !is_tensor<Tdata>::value>>
void LRI_CV_Tools::add_elem (Tdata &data, const Tdata &val, const Tdata &frac)
 
template<typename T , std::size_t N>
void LRI_CV_Tools::add_elem (std::array< T, N > &data, const T &val, const T &frac)
 
template<typename Tdata , typename = std::enable_if_t<is_tensor<Tdata>::value>>
void LRI_CV_Tools::add_elem (const Tdata &data, const int lmp, const int lmq, const typename TinType< Tdata >::type &val, const typename TinType< Tdata >::type &frac)
 
template<typename T , std::size_t N>
void LRI_CV_Tools::add_elem (std::array< RI::Tensor< T >, N > &data, const int lmp, const int lmq, const std::array< T, N > &val, const T &frac)
 
template<typename Tdata , typename = std::enable_if_t<is_tensor<Tdata>::value>>
void LRI_CV_Tools::add_elem (Tdata &data, const int lmp0, const int lmq0, const Tdata &val, const int lmp1, const int lmq1, const typename TinType< Tdata >::type &frac)
 
template<typename T , std::size_t N>
void LRI_CV_Tools::add_elem (std::array< RI::Tensor< T >, N > &data, const int lmp0, const int lmq0, const std::array< RI::Tensor< T >, N > &val, const int lmp1, const int lmq1, const T &frac)
 
template<typename Tout , typename Tin >
RI::Tensor< Tout > LRI_CV_Tools::convert (RI::Tensor< Tin > &&data)
 
template<typename Tout , typename Tin , std::size_t N>
std::array< RI::Tensor< Tout >, NLRI_CV_Tools::convert (std::array< RI::Tensor< Tin >, N > &&data)