Psi4
Classes | Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
psi::DF_Helper Class Reference

#include <df_helper.h>

Classes

struct  stream
 

Public Member Functions

 DF_Helper (std::shared_ptr< BasisSet > primary, std::shared_ptr< BasisSet > aux)
 
 ~DF_Helper ()
 
void set_method (std::string method)
 
std::string get_method ()
 
void set_nthreads (size_t nthreads)
 
size_t get_nthreads ()
 
void set_memory (size_t doubles)
 
size_t get_memory ()
 
size_t get_AO_size ()
 Returns the number of doubles in the screened AO integrals. More...
 
void set_AO_core (bool core)
 
bool get_AO_core ()
 
void set_MO_core (bool core)
 
bool get_MO_core ()
 
void set_schwarz_cutoff (double cutoff)
 schwarz screening cutoff (defaults to 1e-12) More...
 
double get_schwarz_cutoff ()
 
void set_metric_pow (double pow)
 fitting metric power (defaults to -0.5) More...
 
double get_metric_pow ()
 
void hold_met (bool hold)
 
bool get_hold_met ()
 
void set_JK_hint (bool hint)
 
size_t get_JK_hint ()
 
void initialize ()
 Initialize the object. More...
 
void print_header ()
 print tons of useful info More...
 
void add_space (std::string key, SharedMatrix space)
 
void add_transformation (std::string name, std::string key1, std::string key2, std::string order="Qpq")
 
void transform ()
 invoke transformations More...
 
void fill_tensor (std::string name, SharedMatrix M)
 
void fill_tensor (std::string name, SharedMatrix M, std::vector< size_t > a1)
 
void fill_tensor (std::string name, SharedMatrix M, std::vector< size_t > a1, std::vector< size_t > a2)
 
void fill_tensor (std::string name, SharedMatrix M, std::vector< size_t > a1, std::vector< size_t > a2, std::vector< size_t > a3)
 
void fill_tensor (std::string name, double *b, std::vector< size_t > a1, std::vector< size_t > a2, std::vector< size_t > a3)
 
void fill_tensor (std::string name, double *b, std::vector< size_t > a1, std::vector< size_t > a2)
 
void fill_tensor (std::string name, double *b, std::vector< size_t > a1)
 
void fill_tensor (std::string name, double *b)
 
SharedMatrix get_tensor (std::string name)
 
SharedMatrix get_tensor (std::string name, std::vector< size_t > a1)
 
SharedMatrix get_tensor (std::string name, std::vector< size_t > a1, std::vector< size_t > a2)
 
SharedMatrix get_tensor (std::string name, std::vector< size_t > a1, std::vector< size_t > a2, std::vector< size_t > a3)
 
void add_disk_tensor (std::string key, std::tuple< size_t, size_t, size_t > dimensions)
 
void write_disk_tensor (std::string name, SharedMatrix M)
 
void write_disk_tensor (std::string name, SharedMatrix M, std::vector< size_t > a1)
 
void write_disk_tensor (std::string name, SharedMatrix M, std::vector< size_t > a1, std::vector< size_t > a2)
 
void write_disk_tensor (std::string name, SharedMatrix M, std::vector< size_t > a1, std::vector< size_t > a2, std::vector< size_t > a3)
 
void write_disk_tensor (std::string name, double *b, std::vector< size_t > a1, std::vector< size_t > a2, std::vector< size_t > a3)
 
void write_disk_tensor (std::string name, double *b, std::vector< size_t > a1, std::vector< size_t > a2)
 
void write_disk_tensor (std::string name, double *b, std::vector< size_t > a1)
 
void write_disk_tensor (std::string name, double *b)
 
void transpose (std::string name, std::tuple< size_t, size_t, size_t > order)
 tranpose a tensor after it has been written More...
 
void clear_spaces ()
 clear spaces More...
 
void clear_all ()
 clears spaces and transformations More...
 
size_t get_space_size (std::string key)
 get sizes, shapes of tensors More...
 
size_t get_tensor_size (std::string key)
 
std::tuple< size_t, size_t,
size_t > 
get_tensor_shape (std::string key)
 
size_t get_naux ()
 
void build_JK (std::vector< SharedMatrix > Cleft, std::vector< SharedMatrix > Cright, std::vector< SharedMatrix > J, std::vector< SharedMatrix > K)
 builds J/K More...
 

Protected Member Functions

std::pair< size_t, size_t > identify_order ()
 
void print_order ()
 
void prepare_AO ()
 
void prepare_AO_core ()
 
void compute_AO_Q (const size_t start, const size_t stop, double *Mp, std::vector< std::shared_ptr< TwoBodyAOInt >> eri)
 
void compute_AO_p (const size_t start, const size_t stop, double *Mp, std::vector< std::shared_ptr< TwoBodyAOInt >> eri)
 
void compute_AO_p_symm (const size_t start, const size_t stop, double *Mp, std::vector< std::shared_ptr< TwoBodyAOInt >> eri)
 
void contract_metric_AO_core_symm (double *Qpq, double *metp, size_t begin, size_t end)
 
void grab_AO (const size_t start, const size_t stop, double *Mp)
 
void prepare_blocking ()
 
std::pair< size_t, size_t > pshell_blocks_for_AO_build (const size_t mem, size_t symm, std::vector< std::pair< size_t, size_t >> &b)
 
std::pair< size_t, size_t > Qshell_blocks_for_transform (const size_t mem, size_t wtmp, size_t wfinal, std::vector< std::pair< size_t, size_t >> &b)
 
void prepare_sparsity ()
 
void prepare_metric ()
 
void prepare_metric_core ()
 
double * metric_prep_core (double pow)
 
std::string return_metfile (double pow)
 
std::string compute_metric (double pow)
 
void contract_metric (std::string file, double *metp, double *Mp, double *Fp, const size_t tots)
 
void contract_metric_core (std::string file)
 
void contract_metric_AO (double *Mp)
 
void contract_metric_AO_core (double *Qpq, double *metp)
 
void transform_core ()
 
void transform_disk ()
 
FILE * stream_check (std::string filename, std::string op)
 
void put_tensor (std::string file, double *b, std::pair< size_t, size_t > a1, std::pair< size_t, size_t > a2, std::pair< size_t, size_t > a3, std::string op)
 
void put_tensor (std::string file, double *b, const size_t start1, const size_t stop1, const size_t start2, const size_t stop2, std::string op)
 
void get_tensor_ (std::string file, double *b, std::pair< size_t, size_t > a1, std::pair< size_t, size_t > a2, std::pair< size_t, size_t > a3)
 
void get_tensor_ (std::string file, double *b, const size_t start1, const size_t stop1, const size_t start2, const size_t stop2)
 
void put_tensor_AO (std::string file, double *Mp, size_t size, size_t start, std::string op)
 
void get_tensor_AO (std::string file, double *Mp, size_t size, size_t start)
 
void filename_maker (std::string name, size_t a0, size_t a1, size_t a2, size_t op=0)
 
void AO_filename_maker (size_t i)
 
void check_file_key (std::string)
 
void check_file_tuple (std::string name, std::pair< size_t, size_t > t0, std::pair< size_t, size_t > t1, std::pair< size_t, size_t > t2)
 
void check_matrix_size (std::string name, SharedMatrix M, std::pair< size_t, size_t > t0, std::pair< size_t, size_t > t1, std::pair< size_t, size_t > t2)
 
void transpose_core (std::string name, std::tuple< size_t, size_t, size_t > order)
 
void transpose_disk (std::string name, std::tuple< size_t, size_t, size_t > order)
 
void compute_JK (std::vector< SharedMatrix > Cleft, std::vector< SharedMatrix > Cright, std::vector< SharedMatrix > J, std::vector< SharedMatrix > K)
 
void compute_D (std::vector< SharedMatrix > &D, std::vector< SharedMatrix > Cleft, std::vector< SharedMatrix > Cright)
 
void compute_J (std::vector< SharedMatrix > D, std::vector< SharedMatrix > J, double *Mp, double *T1p, double *T2p, std::vector< std::vector< double >> D_buffers, size_t bcount, size_t block_size)
 
void compute_J_symm (std::vector< SharedMatrix > D, std::vector< SharedMatrix > J, double *Mp, double *T1p, double *T2p, std::vector< std::vector< double >> D_buffers, size_t bcount, size_t block_size)
 
void compute_K (std::vector< SharedMatrix > Cleft, std::vector< SharedMatrix > Cright, std::vector< SharedMatrix > K, double *Tp, double *Jtmp, double *Mp, size_t bcount, size_t block_size, std::vector< std::vector< double >> C_buffers, std::vector< SharedMatrix > D, std::vector< SharedMatrix > J)
 
std::tuple< size_t, size_t,
size_t, size_t > 
Qshell_blocks_for_JK_build (std::vector< std::pair< size_t, size_t >> &b, std::vector< SharedMatrix > Cleft, std::vector< SharedMatrix > Cright)
 

Protected Attributes

std::shared_ptr< BasisSetprimary_
 
std::shared_ptr< BasisSetaux_
 
size_t nao_
 
size_t naux_
 
size_t memory_ = 256000000
 
std::string method_ = "STORE"
 
bool direct_
 
bool AO_core_ = 1
 
bool MO_core_ = 0
 
size_t nthreads_ = 1
 
double cutoff_ = 1e-12
 
double tolerance_ = 0.0
 
double condition_ = 1e-12
 
double mpower_ = -0.5
 
bool hold_met_ = false
 
bool JK_hint_ = false
 
bool built = false
 
bool transformed_ = false
 
std::pair< size_t, size_t > info_
 
bool ordered_ = 0
 
std::vector< double > Ppq_
 
std::map< double, SharedMatrixmetrics_
 
std::vector< size_t > small_skips_
 
std::vector< size_t > big_skips_
 
std::vector< size_t > symm_skips_
 
std::vector< size_t > symm_sizes_
 
std::vector< size_t > symm_agg_sizes_
 
size_t pshells_
 
size_t Qshells_
 
std::vector< size_t > pshell_aggs_
 
std::vector< size_t > Qshell_aggs_
 
std::vector< size_t > schwarz_fun_mask_
 
std::vector< size_t > schwarz_shell_mask_
 
std::vector< size_t > schwarz_fun_count_
 
std::vector< std::pair< double,
std::string > > 
metric_keys_
 
std::map< std::string,
std::tuple< SharedMatrix,
size_t > > 
spaces_
 
std::map< std::string,
std::tuple< std::string,
std::string, size_t > > 
transf_
 
std::map< std::string,
std::vector< double > > 
transf_core_
 
std::vector< std::pair
< std::string, size_t > > 
sorted_spaces_
 
std::vector< std::string > order_
 
std::vector< std::string > bspace_
 
std::vector< size_t > strides_
 
std::map< std::string, streamfile_status_
 
std::map< std::string,
std::tuple< std::string,
std::string > > 
files_
 
std::map< std::string,
std::tuple< size_t, size_t,
size_t > > 
sizes_
 
std::map< std::string,
std::tuple< size_t, size_t,
size_t > > 
tsizes_
 
std::map< std::string,
std::string > 
AO_files_
 
std::vector< size_t > AO_file_sizes_
 
std::vector< std::string > AO_names_
 

Constructor & Destructor Documentation

psi::DF_Helper::DF_Helper ( std::shared_ptr< BasisSet primary,
std::shared_ptr< BasisSet aux 
)
psi::DF_Helper::~DF_Helper ( )

Member Function Documentation

void psi::DF_Helper::add_disk_tensor ( std::string  key,
std::tuple< size_t, size_t, size_t >  dimensions 
)

Add a 3-index disk tensor (that is not a transformation)

Parameters
namename of tensor - used to be accessed later
dimensionsshape of tensor
void psi::DF_Helper::add_space ( std::string  key,
SharedMatrix  space 
)

Add transformation space with key

Parameters
keyused to access space orbitals
spaceorbital space matrix
void psi::DF_Helper::add_transformation ( std::string  name,
std::string  key1,
std::string  key2,
std::string  order = "Qpq" 
)

Add transformation with name using two space keys

Parameters
nameused to access transformed integrals
key1left oribtal space
key2right oribtal space
orderfor direct builds of "Qpq" and "pqQ" forms only
void psi::DF_Helper::AO_filename_maker ( size_t  i)
protected
void psi::DF_Helper::build_JK ( std::vector< SharedMatrix Cleft,
std::vector< SharedMatrix Cright,
std::vector< SharedMatrix J,
std::vector< SharedMatrix K 
)

builds J/K

void psi::DF_Helper::check_file_key ( std::string  name)
protected
void psi::DF_Helper::check_file_tuple ( std::string  name,
std::pair< size_t, size_t >  t0,
std::pair< size_t, size_t >  t1,
std::pair< size_t, size_t >  t2 
)
protected
void psi::DF_Helper::check_matrix_size ( std::string  name,
SharedMatrix  M,
std::pair< size_t, size_t >  t0,
std::pair< size_t, size_t >  t1,
std::pair< size_t, size_t >  t2 
)
protected
void psi::DF_Helper::clear_all ( )

clears spaces and transformations

void psi::DF_Helper::clear_spaces ( )

clear spaces

void psi::DF_Helper::compute_AO_p ( const size_t  start,
const size_t  stop,
double *  Mp,
std::vector< std::shared_ptr< TwoBodyAOInt >>  eri 
)
protected
void psi::DF_Helper::compute_AO_p_symm ( const size_t  start,
const size_t  stop,
double *  Mp,
std::vector< std::shared_ptr< TwoBodyAOInt >>  eri 
)
protected
void psi::DF_Helper::compute_AO_Q ( const size_t  start,
const size_t  stop,
double *  Mp,
std::vector< std::shared_ptr< TwoBodyAOInt >>  eri 
)
protected
void psi::DF_Helper::compute_D ( std::vector< SharedMatrix > &  D,
std::vector< SharedMatrix Cleft,
std::vector< SharedMatrix Cright 
)
protected
void psi::DF_Helper::compute_J ( std::vector< SharedMatrix D,
std::vector< SharedMatrix J,
double *  Mp,
double *  T1p,
double *  T2p,
std::vector< std::vector< double >>  D_buffers,
size_t  bcount,
size_t  block_size 
)
protected
void psi::DF_Helper::compute_J_symm ( std::vector< SharedMatrix D,
std::vector< SharedMatrix J,
double *  Mp,
double *  T1p,
double *  T2p,
std::vector< std::vector< double >>  D_buffers,
size_t  bcount,
size_t  block_size 
)
protected
void psi::DF_Helper::compute_JK ( std::vector< SharedMatrix Cleft,
std::vector< SharedMatrix Cright,
std::vector< SharedMatrix J,
std::vector< SharedMatrix K 
)
protected
void psi::DF_Helper::compute_K ( std::vector< SharedMatrix Cleft,
std::vector< SharedMatrix Cright,
std::vector< SharedMatrix K,
double *  Tp,
double *  Jtmp,
double *  Mp,
size_t  bcount,
size_t  block_size,
std::vector< std::vector< double >>  C_buffers,
std::vector< SharedMatrix D,
std::vector< SharedMatrix J 
)
protected
std::string psi::DF_Helper::compute_metric ( double  pow)
protected
void psi::DF_Helper::contract_metric ( std::string  file,
double *  metp,
double *  Mp,
double *  Fp,
const size_t  tots 
)
protected
void psi::DF_Helper::contract_metric_AO ( double *  Mp)
protected
void psi::DF_Helper::contract_metric_AO_core ( double *  Qpq,
double *  metp 
)
protected
void psi::DF_Helper::contract_metric_AO_core_symm ( double *  Qpq,
double *  metp,
size_t  begin,
size_t  end 
)
protected
void psi::DF_Helper::contract_metric_core ( std::string  file)
protected
void psi::DF_Helper::filename_maker ( std::string  name,
size_t  a0,
size_t  a1,
size_t  a2,
size_t  op = 0 
)
protected
void psi::DF_Helper::fill_tensor ( std::string  name,
SharedMatrix  M 
)

Fill a SharedMatrix with three index pairs. Slice the same way you do in python.

Parameters
namename of transformation to be accessed
MSharedMatrix you want to be filled Recursive signitures were added if you want a full 3rd index, 2nd and 3rd index, etc. For example, fill_tensor("ia", M, (0, 15)) will get you ia[0:15, :, :] I will check to make sure your slice sizes are not larger than the matrix bounds, but be prepared for a runtime throw.
void psi::DF_Helper::fill_tensor ( std::string  name,
SharedMatrix  M,
std::vector< size_t >  a1 
)
void psi::DF_Helper::fill_tensor ( std::string  name,
SharedMatrix  M,
std::vector< size_t >  a1,
std::vector< size_t >  a2 
)
void psi::DF_Helper::fill_tensor ( std::string  name,
SharedMatrix  M,
std::vector< size_t >  a1,
std::vector< size_t >  a2,
std::vector< size_t >  a3 
)
void psi::DF_Helper::fill_tensor ( std::string  name,
double *  b,
std::vector< size_t >  a1,
std::vector< size_t >  a2,
std::vector< size_t >  a3 
)

Fill a buffer with three index pairs. Same concept as fill_tensor.

Parameters
namename of transformation to be accessed
bpointer to allocated memory Be cautious, this function does not bound check your buffer against the tuples provied.
void psi::DF_Helper::fill_tensor ( std::string  name,
double *  b,
std::vector< size_t >  a1,
std::vector< size_t >  a2 
)
void psi::DF_Helper::fill_tensor ( std::string  name,
double *  b,
std::vector< size_t >  a1 
)
void psi::DF_Helper::fill_tensor ( std::string  name,
double *  b 
)
bool psi::DF_Helper::get_AO_core ( )
inline
size_t psi::DF_Helper::get_AO_size ( )
inline

Returns the number of doubles in the screened AO integrals.

bool psi::DF_Helper::get_hold_met ( )
inline
size_t psi::DF_Helper::get_JK_hint ( )
inline
size_t psi::DF_Helper::get_memory ( )
inline
std::string psi::DF_Helper::get_method ( )
inline
double psi::DF_Helper::get_metric_pow ( )
inline
bool psi::DF_Helper::get_MO_core ( )
inline
size_t psi::DF_Helper::get_naux ( )
inline
size_t psi::DF_Helper::get_nthreads ( )
inline
double psi::DF_Helper::get_schwarz_cutoff ( )
inline
size_t psi::DF_Helper::get_space_size ( std::string  key)

get sizes, shapes of tensors

SharedMatrix psi::DF_Helper::get_tensor ( std::string  name)

return a SharedMatrix, I take care of sizing for you.

Parameters
namename of transformation to be accessed I always compound the 2nd and 3rd indices. For example, get_tensor("ia", (0:15), (0:5), (0:5)) will return a SharedMatrix of size (15, 25), so be careful if you plan to use Matrix::gemm
SharedMatrix psi::DF_Helper::get_tensor ( std::string  name,
std::vector< size_t >  a1 
)
SharedMatrix psi::DF_Helper::get_tensor ( std::string  name,
std::vector< size_t >  a1,
std::vector< size_t >  a2 
)
SharedMatrix psi::DF_Helper::get_tensor ( std::string  name,
std::vector< size_t >  a1,
std::vector< size_t >  a2,
std::vector< size_t >  a3 
)
void psi::DF_Helper::get_tensor_ ( std::string  file,
double *  b,
std::pair< size_t, size_t >  a1,
std::pair< size_t, size_t >  a2,
std::pair< size_t, size_t >  a3 
)
protected
void psi::DF_Helper::get_tensor_ ( std::string  file,
double *  b,
const size_t  start1,
const size_t  stop1,
const size_t  start2,
const size_t  stop2 
)
protected
void psi::DF_Helper::get_tensor_AO ( std::string  file,
double *  Mp,
size_t  size,
size_t  start 
)
protected
std::tuple< size_t, size_t, size_t > psi::DF_Helper::get_tensor_shape ( std::string  key)
size_t psi::DF_Helper::get_tensor_size ( std::string  key)
void psi::DF_Helper::grab_AO ( const size_t  start,
const size_t  stop,
double *  Mp 
)
protected
void psi::DF_Helper::hold_met ( bool  hold)
inline

Sets the fitting metric to be held in core (defaults to FALSE)

Parameters
holdTRUE if metrics are to be held in core. Memory contraints adapt accordingly.
std::pair< size_t, size_t > psi::DF_Helper::identify_order ( )
protected
void psi::DF_Helper::initialize ( )

Initialize the object.

double * psi::DF_Helper::metric_prep_core ( double  pow)
protected
void psi::DF_Helper::prepare_AO ( )
protected
void psi::DF_Helper::prepare_AO_core ( )
protected
void psi::DF_Helper::prepare_blocking ( )
protected
void psi::DF_Helper::prepare_metric ( )
protected
void psi::DF_Helper::prepare_metric_core ( )
protected
void psi::DF_Helper::prepare_sparsity ( )
protected
void psi::DF_Helper::print_header ( )

print tons of useful info

void psi::DF_Helper::print_order ( )
protected
std::pair< size_t, size_t > psi::DF_Helper::pshell_blocks_for_AO_build ( const size_t  mem,
size_t  symm,
std::vector< std::pair< size_t, size_t >> &  b 
)
protected
void psi::DF_Helper::put_tensor ( std::string  file,
double *  b,
std::pair< size_t, size_t >  a1,
std::pair< size_t, size_t >  a2,
std::pair< size_t, size_t >  a3,
std::string  op 
)
protected
void psi::DF_Helper::put_tensor ( std::string  file,
double *  b,
const size_t  start1,
const size_t  stop1,
const size_t  start2,
const size_t  stop2,
std::string  op 
)
protected
void psi::DF_Helper::put_tensor_AO ( std::string  file,
double *  Mp,
size_t  size,
size_t  start,
std::string  op 
)
protected
std::tuple< size_t, size_t, size_t, size_t > psi::DF_Helper::Qshell_blocks_for_JK_build ( std::vector< std::pair< size_t, size_t >> &  b,
std::vector< SharedMatrix Cleft,
std::vector< SharedMatrix Cright 
)
protected
std::pair< size_t, size_t > psi::DF_Helper::Qshell_blocks_for_transform ( const size_t  mem,
size_t  wtmp,
size_t  wfinal,
std::vector< std::pair< size_t, size_t >> &  b 
)
protected
std::string psi::DF_Helper::return_metfile ( double  pow)
protected
void psi::DF_Helper::set_AO_core ( bool  core)
inline

Sets the AO integrals to in-core. (Defaults to TRUE)

Parameters
coreTrue to indicate in-core DF_Helper will keep track of this memory. NOTE: DF_Helper will automatically revert to on-disk if the sizes of the AO integrals is greater than 90% of the memory it controlls.
void psi::DF_Helper::set_JK_hint ( bool  hint)
inline

Enahnces memory usage if all Cleft = Cright in JK builds

Parameters
hintTRUE if all Cleft = Cright Only use if equality is ALWAYS true. Redundant computations are always avoided
void psi::DF_Helper::set_memory ( size_t  doubles)
inline

Indicates the memory (in doubles) DF_Helper gets to control specifies number of doubles given for memory defaults to 256,000,000 (2.04GB)

void psi::DF_Helper::set_method ( std::string  method)
inline

Specify workflow for transforming and contracting integrals

Parameters
method(STORE or DIRECT) to indicate workflow DIRECT: pre-transform integrals before metric contraction STORE: contract and save AO integrals before transforming (defaults to STORE)
void psi::DF_Helper::set_metric_pow ( double  pow)
inline

fitting metric power (defaults to -0.5)

void psi::DF_Helper::set_MO_core ( bool  core)
inline

Sets the MO integrals to in-core. (Defaults to FALSE)

Parameters
coreTrue to indicate in-core DF_Helper will not keep track of this memory. If a seg fault occurs, the MOs were bigger than you thought!
void psi::DF_Helper::set_nthreads ( size_t  nthreads)
inline

Tells DF_Helper how many threads to spawn in parallel regions

Parameters
nthreadsspecifies number of threads to use oversubcription is possible
void psi::DF_Helper::set_schwarz_cutoff ( double  cutoff)
inline

schwarz screening cutoff (defaults to 1e-12)

FILE * psi::DF_Helper::stream_check ( std::string  filename,
std::string  op 
)
protected
void psi::DF_Helper::transform ( )

invoke transformations

void psi::DF_Helper::transform_core ( )
protected
void psi::DF_Helper::transform_disk ( )
protected
void psi::DF_Helper::transpose ( std::string  name,
std::tuple< size_t, size_t, size_t >  order 
)

tranpose a tensor after it has been written

void psi::DF_Helper::transpose_core ( std::string  name,
std::tuple< size_t, size_t, size_t >  order 
)
protected
void psi::DF_Helper::transpose_disk ( std::string  name,
std::tuple< size_t, size_t, size_t >  order 
)
protected
void psi::DF_Helper::write_disk_tensor ( std::string  name,
SharedMatrix  M 
)

Write to a 3-index disk tensor from a SharedMatrix Can be a transformation if you want to overwrite one.

Parameters
namename of tensor - used to be accessed later
MSharedMatrix with contents to write to disk tensor Bound checks are performed
void psi::DF_Helper::write_disk_tensor ( std::string  name,
SharedMatrix  M,
std::vector< size_t >  a1 
)
void psi::DF_Helper::write_disk_tensor ( std::string  name,
SharedMatrix  M,
std::vector< size_t >  a1,
std::vector< size_t >  a2 
)
void psi::DF_Helper::write_disk_tensor ( std::string  name,
SharedMatrix  M,
std::vector< size_t >  a1,
std::vector< size_t >  a2,
std::vector< size_t >  a3 
)
void psi::DF_Helper::write_disk_tensor ( std::string  name,
double *  b,
std::vector< size_t >  a1,
std::vector< size_t >  a2,
std::vector< size_t >  a3 
)

Write to a 3-index disk tensor from a buffer Can be a transformation if you want to overwrite one.

Parameters
namename of tensor - used to be accessed later
MSharedMatrix with contents to write to disk tensor No bound checking on buffer is performed, use caution!
void psi::DF_Helper::write_disk_tensor ( std::string  name,
double *  b,
std::vector< size_t >  a1,
std::vector< size_t >  a2 
)
void psi::DF_Helper::write_disk_tensor ( std::string  name,
double *  b,
std::vector< size_t >  a1 
)
void psi::DF_Helper::write_disk_tensor ( std::string  name,
double *  b 
)

Member Data Documentation

bool psi::DF_Helper::AO_core_ = 1
protected
std::vector<size_t> psi::DF_Helper::AO_file_sizes_
protected
std::map<std::string, std::string> psi::DF_Helper::AO_files_
protected
std::vector<std::string> psi::DF_Helper::AO_names_
protected
std::shared_ptr<BasisSet> psi::DF_Helper::aux_
protected
std::vector<size_t> psi::DF_Helper::big_skips_
protected
std::vector<std::string> psi::DF_Helper::bspace_
protected
bool psi::DF_Helper::built = false
protected
double psi::DF_Helper::condition_ = 1e-12
protected
double psi::DF_Helper::cutoff_ = 1e-12
protected
bool psi::DF_Helper::direct_
protected
std::map<std::string, stream> psi::DF_Helper::file_status_
protected
std::map<std::string, std::tuple<std::string, std::string> > psi::DF_Helper::files_
protected
bool psi::DF_Helper::hold_met_ = false
protected
std::pair<size_t, size_t> psi::DF_Helper::info_
protected
bool psi::DF_Helper::JK_hint_ = false
protected
size_t psi::DF_Helper::memory_ = 256000000
protected
std::string psi::DF_Helper::method_ = "STORE"
protected
std::vector<std::pair<double, std::string> > psi::DF_Helper::metric_keys_
protected
std::map<double, SharedMatrix> psi::DF_Helper::metrics_
protected
bool psi::DF_Helper::MO_core_ = 0
protected
double psi::DF_Helper::mpower_ = -0.5
protected
size_t psi::DF_Helper::nao_
protected
size_t psi::DF_Helper::naux_
protected
size_t psi::DF_Helper::nthreads_ = 1
protected
std::vector<std::string> psi::DF_Helper::order_
protected
bool psi::DF_Helper::ordered_ = 0
protected
std::vector<double> psi::DF_Helper::Ppq_
protected
std::shared_ptr<BasisSet> psi::DF_Helper::primary_
protected
std::vector<size_t> psi::DF_Helper::pshell_aggs_
protected
size_t psi::DF_Helper::pshells_
protected
std::vector<size_t> psi::DF_Helper::Qshell_aggs_
protected
size_t psi::DF_Helper::Qshells_
protected
std::vector<size_t> psi::DF_Helper::schwarz_fun_count_
protected
std::vector<size_t> psi::DF_Helper::schwarz_fun_mask_
protected
std::vector<size_t> psi::DF_Helper::schwarz_shell_mask_
protected
std::map<std::string, std::tuple<size_t, size_t, size_t> > psi::DF_Helper::sizes_
protected
std::vector<size_t> psi::DF_Helper::small_skips_
protected
std::vector<std::pair<std::string, size_t> > psi::DF_Helper::sorted_spaces_
protected
std::map<std::string, std::tuple<SharedMatrix, size_t> > psi::DF_Helper::spaces_
protected
std::vector<size_t> psi::DF_Helper::strides_
protected
std::vector<size_t> psi::DF_Helper::symm_agg_sizes_
protected
std::vector<size_t> psi::DF_Helper::symm_sizes_
protected
std::vector<size_t> psi::DF_Helper::symm_skips_
protected
double psi::DF_Helper::tolerance_ = 0.0
protected
std::map<std::string, std::tuple<std::string, std::string, size_t> > psi::DF_Helper::transf_
protected
std::map<std::string, std::vector<double> > psi::DF_Helper::transf_core_
protected
bool psi::DF_Helper::transformed_ = false
protected
std::map<std::string, std::tuple<size_t, size_t, size_t> > psi::DF_Helper::tsizes_
protected

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