void Onepdm_container::calculate_spatial_npdm()
{
//const std::vector<int>& ro = dmrginp.reorder_vector();
//mpi::communicator world;
if( mpigetrank() == 0) {
for(int k=0;k<spatial_onepdm.dim1();++k)
for(int l=0;l<spatial_onepdm.dim2();++l)
spatial_onepdm(k,l)= onepdm(2*k,2*l)+onepdm(2*k+1,2*l+1);
}
}
void Onepdm_container::save_npdm_text(const int &i, const int &j)
{
if( mpigetrank() == 0)
{
char file[5000];
sprintf (file, "%s%s%d.%d%s", dmrginp.save_prefix().c_str(),"/onepdm.", i, j,".txt");
ofstream ofs(file);
ofs << onepdm.dim1() << endl;
double trace = 0.0;
for(int k=0;k<onepdm.dim1();++k)
for(int l=0;l<onepdm.dim2();++l) {
ofs << boost::format("%d %d %20.14e\n") % k % l % onepdm(k,l);
if ( k==l ) trace += onepdm(k,l);
}
ofs.close();
pout << "Spin-orbital 1PDM trace = " << trace << "\n";
}
}
void Onepdm_container::update_full_spin_array( std::vector< std::pair< std::vector<int>, double > >& spin_batch )
{
for (auto it = spin_batch.begin(); it != spin_batch.end(); ++it) {
int i = (it->first)[0];
int j = (it->first)[1];
double val = it->second;
// if ( abs(val) > 1e-8 ) std::cout << "so-onepdm val: i,j = " << i << "," << j << "\t\t" << val << endl;
// std::cout << "so-onepdm val: i,j = " << i << "," << j << "\t\t" << val << endl;
// Test for duplicates
if ( onepdm(i, j) != 0.0 ) {
cout << "WARNING: Already calculated "<<i<<" "<<j<<endl;
cout << "earlier value: "<<onepdm(i,j)<<endl<< "new value: "<<val<<endl;
abort();
}
if ( abs(val) > NUMERICAL_ZERO ) onepdm(i,j) = val;
}
}
double SweepOnepdm::do_one(SweepParams &sweepParams, const bool &warmUp, const bool &forward, const bool &restart, const int &restartSize)
{
SpinBlock system;
const int nroots = dmrginp.nroots();
std::vector<double> finalEnergy(nroots,0.);
std::vector<double> finalEnergy_spins(nroots,0.);
double finalError = 0.;
Matrix onepdm(2*dmrginp.last_site(), 2*dmrginp.last_site());onepdm=0.0;
for (int i=0; i<nroots; i++)
for (int j=0; j<=i; j++)
save_onepdm_binary(onepdm, i ,j);
sweepParams.set_sweep_parameters();
// a new renormalisation sweep routine
pout << ((forward) ? "\t\t\t Starting renormalisation sweep in forwards direction" : "\t\t\t Starting renormalisation sweep in backwards direction") << endl;
pout << "\t\t\t ============================================================================ " << endl;
InitBlocks::InitStartingBlock (system,forward, sweepParams.get_forward_starting_size(), sweepParams.get_backward_starting_size(), restartSize, restart, warmUp);
sweepParams.set_block_iter() = 0;
pout << "\t\t\t Starting block is :: " << endl << system << endl;
SpinBlock::store (forward, system.get_sites(), system); // if restart, just restoring an existing block --
sweepParams.savestate(forward, system.get_sites().size());
bool dot_with_sys = true;
sweepParams.set_guesstype() = TRANSPOSE;
SpinBlock newSystem;
BlockAndDecimate (sweepParams, system, newSystem, warmUp, dot_with_sys);
pout.precision(12);
pout << "\t\t\t The lowest sweep energy : "<< sweepParams.get_lowest_energy()[0]+dmrginp.get_coreenergy()<<endl;
pout << "\t\t\t ============================================================================ " << endl;
for (int i=0; i<nroots; i++)
for (int j=0; j<=i; j++) {
load_onepdm_binary(onepdm, i ,j);
accumulate_onepdm(onepdm);
save_onepdm_spatial_text(onepdm, i ,j);
save_onepdm_text(onepdm, i ,j);
save_onepdm_spatial_binary(onepdm, i ,j);
}
return sweepParams.get_lowest_energy()[0];
}
void Onepdm_container::update_full_spin_array( std::vector< std::pair< std::vector<int>, double > >& spin_batch )
{
const std::vector<int>& ro = dmrginp.reorder_vector();
for (auto it = spin_batch.begin(); it != spin_batch.end(); ++it) {
int i0 = (it->first)[0];
int j0 = (it->first)[1];
int i= ro.at(i0/2)*2 + i0%2;
int j= ro.at(j0/2)*2 + j0%2;
double val = it->second;
// if ( abs(val) > 1e-8 ) pout << "so-onepdm val: i,j = " << i << "," << j << "\t\t" << val << endl;
// pout << "so-onepdm val: i,j = " << i << "," << j << "\t\t" << val << endl;
// Test for duplicates
if ( abs(val) > NUMERICAL_ZERO ) onepdm(i,j) = val;
}
}
void Onepdm_container::accumulate_npdm()
{
#ifndef SERIAL
array_2d<double> tmp_recv;
mpi::communicator world;
if( mpigetrank() == 0) {
for(int i=1;i<calc.size();++i) {
calc.recv(i, i, tmp_recv);
for(int k=0;k<onepdm.dim1();++k)
for(int l=0;l<onepdm.dim2();++l)
if( abs(tmp_recv(k,l)) > NUMERICAL_ZERO ) onepdm(k,l) = tmp_recv(k,l);
}
}
else {
calc.send(0, mpigetrank(), onepdm);
}
#endif
}
double SweepOnepdm::do_one(SweepParams &sweepParams, const bool &warmUp, const bool &forward, const bool &restart, const int &restartSize, int state)
{
Timer sweeptimer;
int integralIndex = 0;
SpinBlock system;
const int nroots = dmrginp.nroots();
std::vector<double> finalEnergy(nroots,0.);
std::vector<double> finalEnergy_spins(nroots,0.);
double finalError = 0.;
int pdmsize = dmrginp.spinAdapted() ? 2*dmrginp.last_site() : dmrginp.last_site();
Matrix onepdm(pdmsize, pdmsize);onepdm=0.0;
Matrix pairmat;
if (dmrginp.hamiltonian() == BCS) {
pairmat.ReSize(pdmsize, pdmsize);
pairmat = 0.0;
save_pairmat_binary(pairmat, state, state);
}
save_onepdm_binary(onepdm, state ,state);
sweepParams.set_sweep_parameters();
// a new renormalisation sweep routine
pout << ((forward) ? "\t\t\t Starting renormalisation sweep in forwards direction" : "\t\t\t Starting renormalisation sweep in backwards direction") << endl;
pout << "\t\t\t ============================================================================ " << endl;
InitBlocks::InitStartingBlock (system,forward, sweepParams.current_root(), sweepParams.current_root(), sweepParams.get_forward_starting_size(), sweepParams.get_backward_starting_size(), restartSize, restart, warmUp, integralIndex);
sweepParams.set_block_iter() = 0;
pout << "\t\t\t Starting block is :: " << endl << system << endl;
SpinBlock::store (forward, system.get_sites(), system, sweepParams.current_root(), sweepParams.current_root()); // if restart, just restoring an existing block --
sweepParams.savestate(forward, system.get_sites().size());
bool dot_with_sys = true;
sweepParams.set_guesstype() = TRANSPOSE;
for (; sweepParams.get_block_iter() < sweepParams.get_n_iters(); )
{
pout << "\n\t\t\t Block Iteration :: " << sweepParams.get_block_iter() << endl;
pout << "\t\t\t ----------------------------" << endl;
if (forward)
p1out << "\t\t\t Current direction is :: Forwards " << endl;
else
p1out << "\t\t\t Current direction is :: Backwards " << endl;
if (sweepParams.get_block_iter() == 0)
sweepParams.set_guesstype() = TRANSPOSE;
else
sweepParams.set_guesstype() = TRANSFORM;
p1out << "\t\t\t Blocking and Decimating " << endl;
SpinBlock newSystem;
BlockAndDecimate (sweepParams, system, newSystem, warmUp, dot_with_sys, state);
pout.precision(12);
system = newSystem;
pout << system<<endl;
SpinBlock::store (forward, system.get_sites(), system, sweepParams.current_root(), sweepParams.current_root());
p1out << "\t\t\t saving state " << system.get_sites().size() << endl;
++sweepParams.set_block_iter();
//sweepParams.savestate(forward, system.get_sites().size());
}
pout << "\t\t\t The lowest sweep energy : "<< sweepParams.get_lowest_energy()[0] << endl;
pout << "\t\t\t ============================================================================ " << endl;
load_onepdm_binary(onepdm, state ,state);
accumulate_onepdm(onepdm);
save_onepdm_spatial_text(onepdm, state, state);
save_onepdm_text(onepdm, state, state);
save_onepdm_spatial_binary(onepdm, state, state);
if (dmrginp.hamiltonian() == BCS) {
load_pairmat_binary(pairmat, state, state);
accumulate_onepdm(pairmat);
// FIXME write out text version
// only <D{ia}D{jb}> is in the matrix
save_pairmat_text(pairmat , state, state);
}
ecpu = sweeptimer.elapsedcputime(); ewall = sweeptimer.elapsedwalltime();
pout << "\t\t\t Elapsed Sweep CPU Time (seconds): " << setprecision(3) << ecpu << endl;
pout << "\t\t\t Elapsed Sweep Wall Time (seconds): " << setprecision(3) << ewall << endl;
return sweepParams.get_lowest_energy()[0];
}