psi::psimrcc::CCBLAS Class Reference

#include <blas.h>

Public Types
typedef std::vector< std::string >	strvec
typedef std::vector< int >	intvec
typedef std::vector< std::pair < int, int > >	intpairvec
typedef std::deque< CCOperation >	OpDeque
Public Member Functions
void	add_Matrix (char *cstr)
void	add_Matrix (std::string str)
void	add_index (char *cstr)
void	solve (char *cstr)
void	solve (std::string str)
void	solve_zero_two_diagonal (char *cstr)
void	zero_right_four_diagonal (char *cstr)
void	zero_left_four_diagonal (char *cstr)
void	zero_non_doubly_occupied (char *cstr)
void	zero_non_external (char *cstr)
void	reduce_spaces (char *out, char *in)
void	append (char *cstr)
void	append (std::string str)
void	append_zero_two_diagonal (char *cstr)
void	compute ()
int	compute_storage_strategy ()
void	show_storage ()
void	diis_add (std::string amps, std::string delta_amps)
void	diis_save_t_amps (int cycle)
void	diis (int cycle)
void	print (char *cstr)
void	print_ref (string &str)
void	print_memory ()
CCIndex *	get_index (char *cstr)
CCIndex *	get_index (std::string &str)
CCMatTmp	get_MatTmp (std::string str, int reference, DiskOpt disk_option)
CCMatTmp	get_MatTmp (std::string str, DiskOpt disk_option)
CCMatTmp	get_MatTmp (CCMatrix *Matrix, DiskOpt disk_option)
CCMatIrTmp	get_MatIrTmp (std::string str, int reference, int irrep, DiskOpt disk_option)
CCMatIrTmp	get_MatIrTmp (std::string str, int irrep, DiskOpt disk_option)
CCMatIrTmp	get_MatIrTmp (CCMatrix *Matrix, int irrep, DiskOpt disk_option)
double	get_scalar (std::string str)
double	get_scalar (char *cstr, int reference)
double	get_scalar (std::string &str, int reference)
void	set_scalar (char *cstr, int reference, double value)
void	set_scalar (std::string &str, int reference, double value)
MatrixMap &	get_MatrixMap ()

---

Detailed Description

Author:

Francesco A. Evangelista and Andrew C. Simmonett <frank@ccc.uga.edu>

Definition at line 38 of file blas.h.

---

Member Function Documentation

void psi::psimrcc::CCBLAS::solve

(

char *

cstr

)

Read and compute an expression

Parameters:

cstr

Definition at line 19 of file blas_solve.cc.

{
  string str(cstr);
  solve(str);
}

void psi::psimrcc::CCBLAS::solve_zero_two_diagonal

(

char *

cstr

)

store a zero_two_diagonal operation and executing it

Parameters:

str

Definition at line 222 of file blas_solve.cc.

References append_zero_two_diagonal(), and compute().

{
  append_zero_two_diagonal(cstr);
  compute();
}

void psi::psimrcc::CCBLAS::append

(

char *

cstr

)

Read and store expressions without computing them

Parameters:

cstr

Definition at line 39 of file blas_solve.cc.

{
  string str(cstr);
  append(str);
}

void psi::psimrcc::CCBLAS::append_zero_two_diagonal

(

char *

cstr

)

store a zero_two_diagonal operation without executing it

Parameters:

cstr

Definition at line 206 of file blas_solve.cc.

References psi::psimrcc::MOInfo::get_matrix_names().

Referenced by solve_zero_two_diagonal().

{
  string str(cstr);
  // To zero diagonals of things like "Fae[v][v]{u}"
  vector<string> names = moinfo->get_matrix_names(str);
  for(int n=0;n<names.size();n++){
    CCMatrix* Matrix = get_Matrix(names[n]);
    CCOperation op(0.0,"","","zero_two_diagonal",Matrix,NULL,NULL,work[0],buffer[0]);
    operations.push_back(op);
  }
}

void psi::psimrcc::CCBLAS::compute

(

)

Flush the operation deque Flush the operation deque in a memory smart way!

Definition at line 81 of file blas_solve.cc.

Referenced by solve_zero_two_diagonal().

{

//   fprintf(outfile,"\n\nsmart_compute::size of current deque = %d",operations.size());
// 
//   fprintf(outfile,"\nsmart_compute::content of the deque:");
//   for(OpDeque::iterator it = operations.begin();it!=operations.end();++it){
//     fprintf(outfile,"\n");
//     it->print();
//   }

//   // Create a map with all the target matrices and how many times they appear
//   map<string,int> target_count;
//   for(OpDeque::iterator it = operations.begin();it!=operations.end();++it){
//     if(it->get_A_Matrix()!=NULL)
//       target_count[it->get_A_Matrix()->get_label()]++;
//   }
//   // Create a map with all the source matrices and how many times they appear
//   map<string,int> source_count;
//   for(OpDeque::iterator it = operations.begin();it!=operations.end();++it){
//     if(it->get_B_Matrix()!=NULL)
//       source_count[it->get_B_Matrix()->get_label()]++;
//     if(it->get_C_Matrix()!=NULL)
//       source_count[it->get_C_Matrix()->get_label()]++;
//   }
// 
//   // Create a map with all the intermediates defined as matrices that appear a source and target
//     map<string,int> intermediates_count;
//   for(map<string,int>::iterator it=matrix_count.begin();it!=matrix_count.end();++it){
//     map<string,int>::iterator target_it = target_count.find(it->first);
//     map<string,int>::iterator source_it = source_count.find(it->first);
//     if( (target_it!=target_count.end()) && (source_it!=source_count.end()))
//       intermediates_count[source_it->first]=source_it->second;
//   }
// 
//   // Print the map for debugging purposes
//   fprintf(outfile,"\n\nsmart_compute::printing the matrix_count map");
//   for(map<string,int>::iterator it=matrix_count.begin();it!=matrix_count.end();++it){
//     fprintf(outfile,"\n %s(%d)",it->first.c_str(),it->second);
//   }
// 
//   // Print the map for debugging purposes
//   fprintf(outfile,"\n\nsmart_compute::printing the target_count map");
//   for(map<string,int>::iterator it=target_count.begin();it!=target_count.end();++it){
//     fprintf(outfile,"\n %s(%d)",it->first.c_str(),it->second);
//   }
// 
//   // Print the map for debugging purposes
//   fprintf(outfile,"\n\nsmart_compute::printing the source_count map");
//   for(map<string,int>::iterator it=source_count.begin();it!=source_count.end();++it){
//     fprintf(outfile,"\n %s(%d)",it->first.c_str(),it->second);
//   }
// 
//   // Print the map for debugging purposes
//   fprintf(outfile,"\n\nsmart_compute::printing the intermediates_count map");
//   for(map<string,int>::iterator it=intermediates_count.begin();it!=intermediates_count.end();++it){
//     fprintf(outfile,"\n %s(%d)",it->first.c_str(),it->second);
//   }  

//   map<string,bool> matrix_on_disk;
//   map<string,bool> matrix_in_core;
//   for(map<string,int>::iterator it=matrix_count.begin();it!=matrix_count.end();++it){
//     if(it->first[0]=='<'
//     matrix_on_disk[it->first]=false;
//     matrix_on_disk[it->first]=false;
//   }

//   for(OpDeque::iterator it = operations.begin();it!=operations.end();++it){
//     
//   }
//   static int memory_for_solve = 0;
// 
//   for(OpDeque::iterator it = operations.begin();it!=operations.end();++it){
//     int nop = distance(it-operations.begin());
//     fprintf(outfile,"\nI will process operation #%3d",nop);
//     int memA=0;
//     if(it->get_A_Matrix()!=NULL){
//       memA=it->get_A_Matrix()->get_memory();
//     }
//   }

  // Create a map with all the required matrices and how many times they appear

  for(OpDeque::iterator it = operations.begin();it!=operations.end();++it){
    if(it->get_A_Matrix()!=NULL){
      matrices_in_deque[it->get_A_Matrix()]++;
      matrices_in_deque_target[it->get_A_Matrix()]++;
    }
    if(it->get_B_Matrix()!=NULL){
      matrices_in_deque[it->get_B_Matrix()]++;
      matrices_in_deque_source[it->get_B_Matrix()]++;
    }
    if(it->get_C_Matrix()!=NULL){
      matrices_in_deque[it->get_C_Matrix()]++;
      matrices_in_deque_source[it->get_C_Matrix()]++;
    }
  }
  while(!operations.empty()){
    // Read the element
    CCOperation& op = operations.front();
    // Compute the operation
    op.compute();

    // Decrease the counters for the matrices to be processed
    if(op.get_A_Matrix()!=NULL){
      matrices_in_deque[op.get_A_Matrix()]--;
      matrices_in_deque_target[op.get_A_Matrix()]--;
    }
    if(op.get_B_Matrix()!=NULL){
      matrices_in_deque[op.get_B_Matrix()]--;
      matrices_in_deque_source[op.get_B_Matrix()]--;
    }
    if(op.get_C_Matrix()!=NULL){
      matrices_in_deque[op.get_C_Matrix()]--;
      matrices_in_deque_source[op.get_C_Matrix()]--;
    }
    // Eliminate the element
    operations.pop_front();
  }
}

int psi::psimrcc::CCBLAS::compute_storage_strategy

(

)

This routine computes which quantities have to be initially stored in memory and which on disk

Definition at line 248 of file blas.cc.

References psi::psimrcc::MOInfo::get_nirreps().

Referenced by psi::psimrcc::CCManyBody::generate_integrals().

{
  fprintf(outfile,"\n#CC ----------------------------------");
  fprintf(outfile,"\n#CC    Computing Storage Strategy");
  fprintf(outfile,"\n#CC ----------------------------------");

  double available_memory     = mem->get_free_memory();
  double fraction_for_in_core = 0.97; // Fraction of the total available memory that may be used
  double storage_memory       = available_memory * fraction_for_in_core;
  double fully_in_core_memory = 0.0;
  double integrals_memory     = 0.0;
  double fock_memory          = 0.0;
  double others_memory        = 0.0;

  fprintf(outfile,"\n#CC Input memory                                = %10.2f Mb",mem->get_total_memory());
  fprintf(outfile,"\n#CC Free memory                                 = %10.2f Mb",available_memory);
  fprintf(outfile,"\n#CC Free memory available for matrices          = %10.2f Mb (%3.0f%s of free_memory)",storage_memory,fraction_for_in_core*100.0,"%");

  // Gather the memory requirements for all the CCMAtrix object
  // and divide the integrals from all the other matrices.
  // At the same time compute the memory requirements for
  // a fully in-core algorithm.
  vector<pair<double,pair<CCMatrix*,int> > > integrals;
  vector<pair<double,pair<CCMatrix*,int> > > fock;
  vector<pair<double,pair<CCMatrix*,int> > > others;
  for(MatrixMap::iterator it=matrices.begin();it!=matrices.end();++it){
    for(int h=0;h<moinfo->get_nirreps();++h){
      double block_memory = it->second->get_memorypi(h);
      if(it->second->is_integral()){
        integrals.push_back(make_pair(block_memory,make_pair(it->second,h)));
        integrals_memory += block_memory;
      }else if(it->second->is_fock()){
        fock.push_back(make_pair(block_memory,make_pair(it->second,h)));
        fock_memory += block_memory;
      }else{
        others.push_back(make_pair(block_memory,make_pair(it->second,h)));
        others_memory += block_memory;
      }
      fully_in_core_memory += block_memory;
    }
  }
  fprintf(outfile,"\n#CC Memory required by fock matrices            = %10.2f Mb",fock_memory);
  fprintf(outfile,"\n#CC Memory required by integrals                = %10.2f Mb",integrals_memory);
  fprintf(outfile,"\n#CC Memory required by other matrices           = %10.2f Mb",others_memory);
  fprintf(outfile,"\n#CC Memory required for full in-core algorithm  = %10.2f Mb",fully_in_core_memory);

  // Check if you may use a fully in core algorithm
  full_in_core = false;
  int strategy = 0;
  if(fully_in_core_memory < storage_memory ){
    full_in_core = true;
    fprintf(outfile,"\n#CC PSIMRCC will perform a full in-core computation");
    strategy = 0;
  }else{
    if(others_memory < storage_memory ){
      fprintf(outfile,"\n#CC PSIMRCC will store some integrals out-of-core");
      strategy = 1;
    }else{
      fprintf(outfile,"\n#CC PSIMRCC will store all integrals and some other matrices out-of-core");
      strategy = 2;
      fprintf(outfile,"\n#CC CCBLAS::compute_storage_strategy(): Strategy #2 is not implemented yet");
      fflush(outfile);
      exit(1);
    }
  }
  sort(integrals.begin(),integrals.end());
  sort(others.begin(),others.end());
  for(int i=0;i<fock.size();i++){
    // Store all the fock matrices in core and allocate them
    storage_memory -= fock[i].first;
    load_irrep(fock[i].second.first,fock[i].second.second);
  }
  // Let the CCBlas class worry about allocating matrices
  int number_of_others_on_disk = 0;
  for(int i=0;i<others.size();i++){
    // Check if this matrix can be stored in core
    if(others[i].first < storage_memory){
      storage_memory -= others[i].first;
      load_irrep(others[i].second.first,others[i].second.second);
    }else{
      number_of_others_on_disk++;
    }
  }
  int number_of_integrals_on_disk = 0;
  for(int i=0;i<integrals.size();i++){
    // Check if this matrix can be stored in core
    if(integrals[i].first < storage_memory){
      storage_memory -= integrals[i].first;
      load_irrep(integrals[i].second.first,integrals[i].second.second);
    }else{
      number_of_integrals_on_disk++;
    }
  }

  DEBUGGING(1,
    fprintf(outfile,"\n#CC -------------------- Fock matrices -------------------------");
    for(int i=0;i<fock.size();i++){
      if(fock[i].first > 1.0e-5){
        fprintf(outfile,"\n#CC %-32s irrep %d   %6.2f Mb --> ",fock[i].second.first->get_label().c_str(),
                                                      fock[i].second.second,
                                                      fock[i].first);
        fprintf(outfile,"%s",fock[i].second.first->is_block_allocated(fock[i].second.second) ? "in-core" : "out-of-core");
      }
    }
    fprintf(outfile,"\n#CC -------------------- Other matrices ------------------------");    
    for(int i=0;i<others.size();i++){
      if(others[i].first > 1.0e-5){
        fprintf(outfile,"\n#CC %-32s irrep %d   %6.2f Mb --> ",others[i].second.first->get_label().c_str(),
                                                      others[i].second.second,
                                                      others[i].first);
        fprintf(outfile,"%s",others[i].second.first->is_block_allocated(others[i].second.second) ? "in-core" : "out-of-core");
      }
    }
    fprintf(outfile,"\n#CC -------------------- Integrals -----------------------------");
    for(int i=0;i<integrals.size();i++){
      if(integrals[i].first > 1.0e-5){
        fprintf(outfile,"\n#CC %-32s irrep %d   %6.2f Mb --> ",integrals[i].second.first->get_label().c_str(),
                                                      integrals[i].second.second,
                                                      integrals[i].first);
        fprintf(outfile,"%s",integrals[i].second.first->is_block_allocated(integrals[i].second.second) ? "in-core" : "out-of-core");
      }
    }
    fprintf(outfile,"\n\n");
  );

  if(!full_in_core){
    fprintf(outfile,"\n#CC Out-of-core algorithm will store %d other matrices on disk",number_of_others_on_disk);
    fprintf(outfile,"\n#CC Out-of-core algorithm will store %d integrals on disk",number_of_integrals_on_disk);
  }
  return(strategy);
}

void psi::psimrcc::CCBLAS::show_storage

(

)

This routine computes which quantities have to be initially stored in memory and which on disk

Definition at line 383 of file blas.cc.

References psi::psimrcc::MOInfo::get_nirreps().

{
  DEBUGGING(1,
    fprintf(outfile,"\n#CC ----------------------------------");
    fprintf(outfile,"\n#CC            Show Storage ");
    fprintf(outfile,"\n#CC ----------------------------------");

    for(MatrixMap::iterator it=matrices.begin();it!=matrices.end();++it){
      for(int h=0;h<moinfo->get_nirreps();++h){
        double block_memory = it->second->get_memorypi(h);
        fprintf(outfile,"\n#CC %-32s irrep %d   %6.2f Mb",it->second->get_label().c_str(),h,block_memory);
        fprintf(outfile," is %s",it->second->is_block_allocated(h) ? "allocated" : "not allocated");
        fprintf(outfile,"%s",it->second->is_out_of_core(h) ? "(out-of-core)" : "");
  
      }
    }
  )
}

---

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

• blas.h
• blas.cc
• blas_algorithms.cc
• blas_diis.cc
• blas_interface.cc
• blas_parser.cc
• blas_solve.cc

---