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];
}
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];
}
