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 SweepTwopdm::do_one(SweepParams &sweepParams, const bool &warmUp, const bool &forward, const bool &restart, const int &restartSize, int state)
{
Timer sweeptimer;
int integralIndex = 0;
if (dmrginp.hamiltonian() == BCS) {
pout << "Two PDM with BCS calculations is not implemented" << endl;
exit(0);
}
pout.precision(12);
SpinBlock system;
const int nroots = dmrginp.nroots();
std::vector<double> finalEnergy(nroots,0.);
std::vector<double> finalEnergy_spins(nroots,0.);
double finalError = 0.;
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);
if(!restart)
sweepParams.set_block_iter() = 0;
pout << "\t\t\t Starting block is :: " << endl << system << endl;
if (!restart)
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;
array_4d<double> twopdm(2*dmrginp.last_site(), 2*dmrginp.last_site(), 2*dmrginp.last_site(), 2*dmrginp.last_site());
twopdm.Clear();
save_twopdm_binary(twopdm, state, state);
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 (SHOW_MORE) pout << "system block" << endl << system << endl;
if (dmrginp.no_transform())
sweepParams.set_guesstype() = BASIC;
else if (!warmUp && sweepParams.get_block_iter() != 0)
sweepParams.set_guesstype() = TRANSFORM;
else if (!warmUp && sweepParams.get_block_iter() == 0 &&
((dmrginp.algorithm_method() == TWODOT_TO_ONEDOT && dmrginp.twodot_to_onedot_iter() != sweepParams.get_sweep_iter()) ||
dmrginp.algorithm_method() != TWODOT_TO_ONEDOT))
sweepParams.set_guesstype() = TRANSPOSE;
else
sweepParams.set_guesstype() = BASIC;
p1out << "\t\t\t Blocking and Decimating " << endl;
SpinBlock newSystem;
BlockAndDecimate (sweepParams, system, newSystem, warmUp, dot_with_sys, state);
for(int j=0;j<nroots;++j)
pout << "\t\t\t Total block energy for State [ " << j <<
" ] with " << sweepParams.get_keep_states()<<" :: " << sweepParams.get_lowest_energy()[j] <<endl;
finalEnergy_spins = ((sweepParams.get_lowest_energy()[0] < finalEnergy[0]) ? sweepParams.get_lowest_energy_spins() : finalEnergy_spins);
finalEnergy = ((sweepParams.get_lowest_energy()[0] < finalEnergy[0]) ? sweepParams.get_lowest_energy() : finalEnergy);
finalError = max(sweepParams.get_lowest_error(),finalError);
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());
}
//for(int j=0;j<nroots;++j)
{int j = state;
pout << "\t\t\t Finished Sweep with " << sweepParams.get_keep_states() << " states and sweep energy for State [ " << j
<< " ] with Spin [ " << dmrginp.molecule_quantum().get_s() << " ] :: " << finalEnergy[j] << endl;
}
pout << "\t\t\t Largest Error for Sweep with " << sweepParams.get_keep_states() << " states is " << finalError << endl;
pout << "\t\t\t ============================================================================ " << endl;
int i = state, j = state;
//for (int j=0; j<=i; j++) {
load_twopdm_binary(twopdm, i, j);
//calcenergy(twopdm, i);
save_twopdm_text(twopdm, i, j);
save_spatial_twopdm_text(twopdm, i, j);
save_spatial_twopdm_binary(twopdm, i, j);
// update the static number of iterations
++sweepParams.set_sweep_iter();
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 finalEnergy[0];
}
//before you start optimizing each state you want to initalize all the overlap matrices
void Sweep::InitializeOverlapSpinBlocks(SweepParams &sweepParams, const bool &forward, int stateA, int stateB)
{
SpinBlock system;
sweepParams.set_sweep_parameters();
if (forward)
pout << "\t\t\t Starting sweep "<< sweepParams.set_sweep_iter()<<" in forwards direction"<<endl;
else
pout << "\t\t\t Starting sweep "<< sweepParams.set_sweep_iter()<<" in backwards direction" << endl;
pout << "\t\t\t ============================================================================ " << endl;
int restartSize = 0; bool restart = false, warmUp = false;
InitBlocks::InitStartingBlock (system,forward, stateA, stateB, sweepParams.get_forward_starting_size(), sweepParams.get_backward_starting_size(), restartSize, restart, warmUp);
sweepParams.set_block_iter() = 0;
if (dmrginp.outputlevel() > 0)
pout << "\t\t\t Starting block is :: " << endl << system << endl;
SpinBlock::store (forward, system.get_sites(), system, stateA, stateB); // if restart, just restoring an existing block --
sweepParams.savestate(forward, system.get_sites().size());
bool dot_with_sys = true;
vector<int> syssites = system.get_sites();
if (dmrginp.outputlevel() > 0)
mcheck("at the very start of sweep"); // just timer
for (; sweepParams.get_block_iter() < sweepParams.get_n_iters(); ) // get_n_iters() returns the number of blocking iterations needed in one sweep
{
pout << "\t\t\t Block Iteration :: " << sweepParams.get_block_iter() << endl;
pout << "\t\t\t ----------------------------" << endl;
if (dmrginp.outputlevel() > 0) {
if (forward) pout << "\t\t\t Current direction is :: Forwards " << endl;
else pout << "\t\t\t Current direction is :: Backwards " << endl;
}
SpinBlock systemDot, environmentDot;
int systemDotStart, systemDotEnd;
int systemDotSize = sweepParams.get_sys_add() - 1;
if (forward)
{
systemDotStart = dmrginp.spinAdapted() ? *system.get_sites().rbegin () + 1 : (*system.get_sites().rbegin ())/2 + 1 ;
systemDotEnd = systemDotStart + systemDotSize;
}
else
{
systemDotStart = dmrginp.spinAdapted() ? system.get_sites()[0] - 1 : (system.get_sites()[0])/2 - 1 ;
systemDotEnd = systemDotStart - systemDotSize;
}
systemDot = SpinBlock(systemDotStart, systemDotEnd, true);
SpinBlock newSystem; // new system after blocking and decimating
newSystem.initialise_op_array(OVERLAP, false);
newSystem.setstoragetype(DISTRIBUTED_STORAGE);
newSystem.BuildSumBlock (NO_PARTICLE_SPIN_NUMBER_CONSTRAINT, system, systemDot);
std::vector<Matrix> brarotateMatrix, ketrotateMatrix;
LoadRotationMatrix(newSystem.get_sites(), brarotateMatrix, stateA);
LoadRotationMatrix(newSystem.get_sites(), ketrotateMatrix, stateB);
newSystem.transform_operators(brarotateMatrix, ketrotateMatrix);
system = newSystem;
if (dmrginp.outputlevel() > 0){
pout << system<<endl;
}
SpinBlock::store (forward, system.get_sites(), system, stateA, stateB);
++sweepParams.set_block_iter();
sweepParams.savestate(forward, syssites.size());
if (dmrginp.outputlevel() > 0)
mcheck("at the end of sweep iteration");
}
pout << "\t\t\t ============================================================================ " << endl;
// update the static number of iterations
return ;
}
void responseSweep(double sweep_tol, int targetState, vector<int>& projectors, vector<int>& baseStates)
{
double last_fe = 1.e6;
double last_be = 1.e6;
double old_fe = 0.;
double old_be = 0.;
SweepParams sweepParams;
bool direction, warmUp, restart;
int restartSize=0;
direction = true; //forward
warmUp = true; //startup sweep
restart = false; //not a restart
sweepParams.current_root() = -1;
algorithmTypes atype = dmrginp.algorithm_method();
dmrginp.set_algorithm_method() = ONEDOT;
//the baseState is the initial guess for the targetState
if (FULLRESTART) {
sweepParams.restorestate(direction, restartSize);
direction = !direction;
dmrginp.setGuessState() = targetState;
last_fe = SweepResponse::do_one(sweepParams, warmUp, direction, restart, restartSize, targetState, projectors, baseStates);
bool tempdirection;
sweepParams.restorestate(tempdirection, restartSize);
sweepParams.calc_niter();
sweepParams.set_sweep_iter() = 0;
sweepParams.set_restart_iter() = 0;
sweepParams.savestate(tempdirection, restartSize);
}
else if (RESTART) {
dmrginp.set_algorithm_method() = atype;
warmUp = false;
restart = true;
sweepParams.restorestate(direction, restartSize);
last_fe = SweepResponse::do_one(sweepParams, warmUp, direction, restart, restartSize, targetState, projectors, baseStates);
}
else
last_fe = SweepResponse::do_one(sweepParams, warmUp, direction, restart, restartSize, targetState, projectors, baseStates);
dmrginp.set_algorithm_method() = atype;
restart = false;
restartSize = 0;
warmUp = false;
while ( true)
{
old_fe = last_fe;
old_be = last_be;
if(dmrginp.max_iter() <= sweepParams.get_sweep_iter())
break;
last_be = SweepResponse::do_one(sweepParams, warmUp, !direction, restart, restartSize, targetState, projectors, baseStates);
p1out << "\t\t\t Finished Sweep Iteration "<<sweepParams.get_sweep_iter()<<endl;
if(dmrginp.max_iter() <= sweepParams.get_sweep_iter())
break;
last_fe = SweepResponse::do_one(sweepParams, warmUp, direction, restart, restartSize, targetState, projectors, baseStates);
pout << "\t\t\t Finished Sweep Iteration "<<sweepParams.get_sweep_iter()<<endl;
}
}
void dmrg(double sweep_tol)
{
double last_fe = 10.e6;
double last_be = 10.e6;
double old_fe = 0.;
double old_be = 0.;
SweepParams sweepParams;
int old_states=sweepParams.get_keep_states();
int new_states;
double old_error=0.0;
double old_energy=0.0;
// warm up sweep ...
bool dodiis = false;
int domoreIter = 0;
bool direction;
//this is regular dmrg calculation
if(!dmrginp.setStateSpecific()) {
sweepParams.current_root() = -1;
last_fe = Sweep::do_one(sweepParams, true, true, false, 0);
direction = false;
while ((fabs(last_fe - old_fe) > sweep_tol) || (fabs(last_be - old_be) > sweep_tol) ||
(dmrginp.algorithm_method() == TWODOT_TO_ONEDOT && dmrginp.twodot_to_onedot_iter()+1 >= sweepParams.get_sweep_iter()) )
{
old_fe = last_fe;
old_be = last_be;
if(dmrginp.max_iter() <= sweepParams.get_sweep_iter())
break;
last_be = Sweep::do_one(sweepParams, false, false, false, 0);
direction = true;
pout << "\t\t\t Finished Sweep Iteration "<<sweepParams.get_sweep_iter()<<endl;
if(dmrginp.max_iter() <= sweepParams.get_sweep_iter())
break;
//For obtaining the extrapolated energy
old_states=sweepParams.get_keep_states();
new_states=sweepParams.get_keep_states_ls();
last_fe = Sweep::do_one(sweepParams, false, true, false, 0);
direction = false;
new_states=sweepParams.get_keep_states();
pout << "\t\t\t Finished Sweep Iteration "<<sweepParams.get_sweep_iter()<<endl;
if (domoreIter == 2) {
dodiis = true;
break;
}
}
}
else { //this is state specific calculation
const int nroots = dmrginp.nroots();
bool direction=true;
int restartsize;
//sweepParams.restorestate(direction, restartsize);
//sweepParams.set_sweep_iter() = 0;
//sweepParams.set_restart_iter() = 0;
algorithmTypes atype;
pout << "STARTING STATE SPECIFIC CALCULATION "<<endl;
for (int i=0; i<nroots; i++) {
atype = dmrginp.algorithm_method();
dmrginp.set_algorithm_method() = ONEDOT;
sweepParams.current_root() = i;
p1out << "RUNNING GENERATE BLOCKS FOR STATE "<<i<<endl;
if (mpigetrank()==0) {
Sweep::InitializeStateInfo(sweepParams, direction, i);
Sweep::InitializeStateInfo(sweepParams, !direction, i);
Sweep::CanonicalizeWavefunction(sweepParams, direction, i);
Sweep::CanonicalizeWavefunction(sweepParams, !direction, i);
Sweep::CanonicalizeWavefunction(sweepParams, direction, i);
Sweep::InitializeStateInfo(sweepParams, direction, i);
Sweep::InitializeStateInfo(sweepParams, !direction, i);
}
for (int j=0; j<i ; j++) {
int integralIndex = 0;
Sweep::InitializeOverlapSpinBlocks(sweepParams, direction, i, j, integralIndex);
Sweep::InitializeOverlapSpinBlocks(sweepParams, !direction, i, j, integralIndex);
}
dmrginp.set_algorithm_method() = atype;
p1out << "RUNNING GENERATE BLOCKS FOR STATE "<<i<<endl;
SweepGenblock::do_one(sweepParams, false, !direction, false, 0, i, i);
sweepParams.set_sweep_iter() = 0;
sweepParams.set_restart_iter() = 0;
sweepParams.savestate(!direction, restartsize);
pout << "STATE SPECIFIC CALCULATION FOR STATE: "<<i<<endl;
dmrg_stateSpecific(sweep_tol, i);
pout << "STATE SPECIFIC CALCULATION FOR STATE: "<<i<<" FINSIHED"<<endl;
}
pout << "ALL STATE SPECIFIC CALCUALTIONS FINISHED"<<endl;
}
}
void restart(double sweep_tol, bool reset_iter)
{
double last_fe = 100.;
double last_be = 100.;
double old_fe = 0.;
double old_be = 0.;
bool direction;
int restartsize;
SweepParams sweepParams;
bool dodiis = false;
int domoreIter = 2;
sweepParams.restorestate(direction, restartsize);
if (!dmrginp.setStateSpecific()) {
if(reset_iter) { //this is when you restart from the start of the sweep
sweepParams.set_sweep_iter() = 0;
sweepParams.set_restart_iter() = 0;
}
if (restartwarm)
last_fe = Sweep::do_one(sweepParams, true, direction, true, restartsize);
else
last_fe = Sweep::do_one(sweepParams, false, direction, true, restartsize);
while ((fabs(last_fe - old_fe) > sweep_tol) || (fabs(last_be - old_be) > sweep_tol) ||
(dmrginp.algorithm_method() == TWODOT_TO_ONEDOT && dmrginp.twodot_to_onedot_iter()+1 >= sweepParams.get_sweep_iter()) )
{
old_fe = last_fe;
old_be = last_be;
if(dmrginp.max_iter() <= sweepParams.get_sweep_iter())
break;
last_be = Sweep::do_one(sweepParams, false, !direction, false, 0);
if(dmrginp.max_iter() <= sweepParams.get_sweep_iter())
break;
last_fe = Sweep::do_one(sweepParams, false, direction, false, 0);
}
}
else { //this is state specific calculation
const int nroots = dmrginp.nroots();
bool direction;
int restartsize;
sweepParams.restorestate(direction, restartsize);
//initialize state and canonicalize all wavefunctions
int currentRoot = sweepParams.current_root();
for (int i=0; i<nroots; i++) {
sweepParams.current_root() = i;
if (mpigetrank()==0) {
Sweep::InitializeStateInfo(sweepParams, direction, i);
Sweep::InitializeStateInfo(sweepParams, !direction, i);
Sweep::CanonicalizeWavefunction(sweepParams, direction, i);
Sweep::CanonicalizeWavefunction(sweepParams, !direction, i);
Sweep::CanonicalizeWavefunction(sweepParams, direction, i);
}
}
//now generate overlaps with all the previous wavefunctions
for (int i=0; i<currentRoot; i++) {
sweepParams.current_root() = i;
if (mpigetrank()==0) {
for (int j=0; j<i; j++) {
int integralIndex = 0;
Sweep::InitializeOverlapSpinBlocks(sweepParams, !direction, i, j, integralIndex);
Sweep::InitializeOverlapSpinBlocks(sweepParams, direction, i, j, integralIndex);
}
}
}
sweepParams.current_root() = currentRoot;
if (sweepParams.current_root() <0) {
p1out << "This is most likely not a restart calculation and should be done without the restart command!!"<<endl;
p1out << "Aborting!!"<<endl;
exit(0);
}
pout << "RESTARTING STATE SPECIFIC CALCULATION OF STATE "<<sweepParams.current_root()<<" AT SWEEP ITERATION "<<sweepParams.get_sweep_iter()<<endl;
//this is so that the iteration is not one ahead after generate block for restart
--sweepParams.set_sweep_iter(); sweepParams.savestate(direction, restartsize);
for (int i=sweepParams.current_root(); i<nroots; i++) {
sweepParams.current_root() = i;
p1out << "RUNNING GENERATE BLOCKS FOR STATE "<<i<<endl;
if (mpigetrank()==0) {
Sweep::InitializeStateInfo(sweepParams, direction, i);
Sweep::InitializeStateInfo(sweepParams, !direction, i);
Sweep::CanonicalizeWavefunction(sweepParams, direction, i);
Sweep::CanonicalizeWavefunction(sweepParams, !direction, i);
Sweep::CanonicalizeWavefunction(sweepParams, direction, i);
for (int j=0; j<i ; j++) {
int integralIndex = 0;
Sweep::InitializeOverlapSpinBlocks(sweepParams, direction, i, j, integralIndex);
Sweep::InitializeOverlapSpinBlocks(sweepParams, !direction, i, j, integralIndex);
}
}
SweepGenblock::do_one(sweepParams, false, !direction, false, 0, i, i);
p1out << "STATE SPECIFIC CALCULATION FOR STATE: "<<i<<endl;
dmrg_stateSpecific(sweep_tol, i);
p1out << "STATE SPECIFIC CALCULATION FOR STATE: "<<i<<" FINSIHED"<<endl;
sweepParams.set_sweep_iter() = 0;
sweepParams.set_restart_iter() = 0;
sweepParams.savestate(!direction, restartsize);
}
p1out << "ALL STATE SPECIFIC CALCUALTIONS FINISHED"<<endl;
}
if(dmrginp.max_iter() <= sweepParams.get_sweep_iter()){
pout << "\n\t\t\t Maximum sweep iterations achieved " << std::endl;
}
}
int calldmrg(char* input, char* output)
{
//sleep(15);
streambuf *backup;
backup = cout.rdbuf();
ofstream file;
if (output != 0) {
file.open(output);
pout.rdbuf(file.rdbuf());
}
license();
ReadInput(input);
MAX_THRD = dmrginp.thrds_per_node()[mpigetrank()];
#ifdef _OPENMP
omp_set_num_threads(MAX_THRD);
#endif
pout.precision (12);
//Initializing timer calls
dmrginp.initCumulTimer();
double sweep_tol = 1e-7;
sweep_tol = dmrginp.get_sweep_tol();
bool direction;
int restartsize;
SweepParams sweepParams;
SweepParams sweep_copy;
bool direction_copy; int restartsize_copy;
Matrix O, H;
switch(dmrginp.calc_type()) {
case (COMPRESS):
{
bool direction; int restartsize;
//sweepParams.restorestate(direction, restartsize);
//sweepParams.set_sweep_iter() = 0;
restartsize = 0;
int targetState, baseState, correctionVector, firstorderstate;
{
direction = true;
//base state is always defined
baseState = dmrginp.baseStates()[0];
//if targetstate is given use it otherwise use basestate+1
if(dmrginp.targetState() == -1)
targetState = dmrginp.baseStates()[0]+1;
else
targetState = dmrginp.targetState();
algorithmTypes atype = dmrginp.algorithm_method();
dmrginp.set_algorithm_method() = ONEDOT;
//initialize state info and canonicalize wavefunction is always done using onedot algorithm
if (mpigetrank()==0) {
Sweep::InitializeStateInfo(sweepParams, direction, baseState);
Sweep::InitializeStateInfo(sweepParams, !direction, baseState);
Sweep::CanonicalizeWavefunction(sweepParams, direction, baseState);
Sweep::CanonicalizeWavefunction(sweepParams, !direction, baseState);
Sweep::CanonicalizeWavefunction(sweepParams, direction, baseState);
}
dmrginp.set_algorithm_method() = atype;
}
//this genblock is required to generate all the nontranspose operators
dmrginp.setimplicitTranspose() = false;
SweepGenblock::do_one(sweepParams, false, false, false, restartsize, baseState, baseState);
compress(sweep_tol, targetState, baseState);
break;
}
case (RESPONSEBW):
{
//compressing the V|\Psi_0>, here \Psi_0 is the basestate and
//its product with V will have a larger bond dimension and is being compressed
//it is called the target state
dmrginp.setimplicitTranspose() = false;
sweepParams.restorestate(direction, restartsize);
algorithmTypes atype = dmrginp.algorithm_method();
dmrginp.set_algorithm_method() = ONEDOT;
if (mpigetrank()==0 && !RESTART && !FULLRESTART) {
for (int l=0; l<dmrginp.projectorStates().size(); l++) {
Sweep::InitializeStateInfo(sweepParams, direction, dmrginp.projectorStates()[l]);
Sweep::InitializeStateInfo(sweepParams, !direction, dmrginp.projectorStates()[l]);
Sweep::CanonicalizeWavefunction(sweepParams, direction, dmrginp.projectorStates()[l]);
Sweep::CanonicalizeWavefunction(sweepParams, !direction, dmrginp.projectorStates()[l]);
Sweep::CanonicalizeWavefunction(sweepParams, direction, dmrginp.projectorStates()[l]);
}
for (int l=0; l<dmrginp.baseStates().size(); l++) {
Sweep::InitializeStateInfo(sweepParams, direction, dmrginp.baseStates()[l]);
Sweep::InitializeStateInfo(sweepParams, !direction, dmrginp.baseStates()[l]);
Sweep::CanonicalizeWavefunction(sweepParams, direction, dmrginp.baseStates()[l]);
Sweep::CanonicalizeWavefunction(sweepParams, !direction, dmrginp.baseStates()[l]);
Sweep::CanonicalizeWavefunction(sweepParams, direction, dmrginp.baseStates()[l]);
}
}
dmrginp.set_algorithm_method() = atype;
pout << "DONE COMPRESSING THE CORRECTION VECTOR"<<endl;
pout << "NOW WE WILL OPTIMIZE THE RESPONSE WAVEFUNCTION"<<endl;
//finally now calculate the response state
responseSweep(sweep_tol, dmrginp.targetState(), dmrginp.projectorStates(), dmrginp.baseStates());
break;
}
case (RESPONSE):
{
//compressing the V|\Psi_0>, here \Psi_0 is the basestate and
//its product with V will have a larger bond dimension and is being compressed
//it is called the target state
dmrginp.setimplicitTranspose() = false;
sweepParams.restorestate(direction, restartsize);
algorithmTypes atype = dmrginp.algorithm_method();
dmrginp.set_algorithm_method() = ONEDOT;
if (mpigetrank()==0 && !RESTART && !FULLRESTART) {
for (int l=0; l<dmrginp.projectorStates().size(); l++) {
Sweep::InitializeStateInfo(sweepParams, direction, dmrginp.projectorStates()[l]);
Sweep::InitializeStateInfo(sweepParams, !direction, dmrginp.projectorStates()[l]);
Sweep::CanonicalizeWavefunction(sweepParams, direction, dmrginp.projectorStates()[l]);
Sweep::CanonicalizeWavefunction(sweepParams, !direction, dmrginp.projectorStates()[l]);
Sweep::CanonicalizeWavefunction(sweepParams, direction, dmrginp.projectorStates()[l]);
}
for (int l=0; l<dmrginp.baseStates().size(); l++) {
Sweep::InitializeStateInfo(sweepParams, direction, dmrginp.baseStates()[l]);
Sweep::InitializeStateInfo(sweepParams, !direction, dmrginp.baseStates()[l]);
Sweep::CanonicalizeWavefunction(sweepParams, direction, dmrginp.baseStates()[l]);
Sweep::CanonicalizeWavefunction(sweepParams, !direction, dmrginp.baseStates()[l]);
Sweep::CanonicalizeWavefunction(sweepParams, direction, dmrginp.baseStates()[l]);
}
}
dmrginp.set_algorithm_method() = atype;
pout << "DONE COMPRESSING THE CORRECTION VECTOR"<<endl;
pout << "NOW WE WILL OPTIMIZE THE RESPONSE WAVEFUNCTION"<<endl;
//finally now calculate the response state
responseSweep(sweep_tol, dmrginp.targetState(), dmrginp.projectorStates(), dmrginp.baseStates());
break;
}
case (CALCOVERLAP):
{
pout.precision(12);
if (mpigetrank() == 0) {
for (int istate = 0; istate<dmrginp.nroots(); istate++) {
bool direction;
int restartsize;
sweepParams.restorestate(direction, restartsize);
Sweep::InitializeStateInfo(sweepParams, !direction, istate);
Sweep::InitializeStateInfo(sweepParams, direction, istate);
Sweep::CanonicalizeWavefunction(sweepParams, direction, istate);
Sweep::CanonicalizeWavefunction(sweepParams, !direction, istate);
Sweep::CanonicalizeWavefunction(sweepParams, direction, istate);
}
for (int istate = 0; istate<dmrginp.nroots(); istate++)
for (int j=istate; j<dmrginp.nroots() ; j++) {
int integralIndex = 0;
Sweep::InitializeOverlapSpinBlocks(sweepParams, !direction, j, istate, integralIndex);
Sweep::InitializeOverlapSpinBlocks(sweepParams, direction, j, istate, integralIndex);
}
//Sweep::calculateAllOverlap(O);
}
break;
}
case (CALCHAMILTONIAN):
{
pout.precision(12);
for (int istate = 0; istate<dmrginp.nroots(); istate++) {
bool direction;
int restartsize;
sweepParams.restorestate(direction, restartsize);
if (mpigetrank() == 0) {
Sweep::InitializeStateInfo(sweepParams, !direction, istate);
Sweep::InitializeStateInfo(sweepParams, direction, istate);
Sweep::CanonicalizeWavefunction(sweepParams, !direction, istate);
Sweep::CanonicalizeWavefunction(sweepParams, direction, istate);
Sweep::CanonicalizeWavefunction(sweepParams, !direction, istate);
}
}
//Sweep::calculateHMatrixElements(H);
pout << "overlap "<<endl<<O<<endl;
pout << "hamiltonian "<<endl<<H<<endl;
break;
}
case (DMRG):
{
if (RESTART && !FULLRESTART)
restart(sweep_tol, reset_iter);
else if (FULLRESTART) {
fullrestartGenblock();
reset_iter = true;
sweepParams.restorestate(direction, restartsize);
sweepParams.calc_niter();
sweepParams.savestate(direction, restartsize);
restart(sweep_tol, reset_iter);
}
else if (BACKWARD) {
fullrestartGenblock();
reset_iter = true;
sweepParams.restorestate(direction, restartsize);
sweepParams.calc_niter();
sweepParams.savestate(direction, restartsize);
restart(sweep_tol, reset_iter);
}
else {
dmrg(sweep_tol);
}
break;
}
case (FCI):
Sweep::fullci(sweep_tol);
break;
case (TINYCALC):
Sweep::tiny(sweep_tol);
break;
case (ONEPDM):
Npdm::npdm(NPDM_ONEPDM);
if (dmrginp.hamiltonian() == BCS) {
Npdm::npdm(NPDM_PAIRMATRIX,true);
}
break;
case (TWOPDM):
Npdm::npdm(NPDM_TWOPDM);
break;
case (THREEPDM):
Npdm::npdm(NPDM_THREEPDM);
break;
case (FOURPDM):
Npdm::npdm(NPDM_FOURPDM);
break;
case (NEVPT2PDM):
Npdm::npdm(NPDM_NEVPT2);
break;
case(NEVPT2):
nevpt2::nevpt2();
break;
case(MPS_NEVPT):
mps_nevpt::mps_nevpt(sweep_tol);
break;
case(RESTART_MPS_NEVPT):
mps_nevpt::mps_nevpt(sweep_tol);
break;
case (RESTART_ONEPDM):
Npdm::npdm(NPDM_ONEPDM,true);
if (dmrginp.hamiltonian() == BCS) {
Npdm::npdm(NPDM_PAIRMATRIX,true);
}
break;
case (RESTART_TWOPDM):
Npdm::npdm(NPDM_TWOPDM,true);
break;
case (RESTART_THREEPDM):
Npdm::npdm(NPDM_THREEPDM,true);
break;
case (RESTART_FOURPDM):
Npdm::npdm(NPDM_FOURPDM,true);
break;
case (RESTART_NEVPT2PDM):
Npdm::npdm(NPDM_NEVPT2,true);
break;
case (TRANSITION_ONEPDM):
Npdm::npdm(NPDM_ONEPDM,false,true);
if (dmrginp.hamiltonian() == BCS) {
Npdm::npdm(NPDM_PAIRMATRIX,true,true);
}
break;
case (TRANSITION_TWOPDM):
Npdm::npdm(NPDM_TWOPDM,false,true);
break;
case (TRANSITION_THREEPDM):
Npdm::npdm(NPDM_THREEPDM,false,true);
break;
case (RESTART_T_ONEPDM):
Npdm::npdm(NPDM_ONEPDM,true,true);
if (dmrginp.hamiltonian() == BCS) {
Npdm::npdm(NPDM_PAIRMATRIX,true,true);
}
break;
case (RESTART_T_TWOPDM):
Npdm::npdm(NPDM_TWOPDM,true,true);
break;
case (RESTART_T_THREEPDM):
Npdm::npdm(NPDM_THREEPDM,true,true);
break;
case(RESTART_NEVPT2):
nevpt2::nevpt2_restart();
break;
//EL
case (DS1_ONEPDM):
Npdm::npdm(NPDM_DS1,false,true,true);
break;
case (RESTART_DS1_ONEPDM):
Npdm::npdm(NPDM_DS1,true,true,true);
break;
case (DS0_ONEPDM):
Npdm::npdm(NPDM_DS0,false,true,true);
break;
case (RESTART_DS0_ONEPDM):
Npdm::npdm(NPDM_DS0,true,true,true);
break;
//EL
default:
pout << "Invalid calculation types" << endl; abort();
}
cout.rdbuf(backup);
tcpu=globaltimer.totalcputime();twall=globaltimer.totalwalltime();
pout << setprecision(3) <<"\n\n\t\t\t BLOCK CPU Time (seconds): " << tcpu << endl;
pout << setprecision(3) <<"\t\t\t BLOCK Wall Time (seconds): " << twall << endl;
return 0;
}
double SpinAdapted::mps_nevpt::type1::do_one(SweepParams &sweepParams, const bool &warmUp, const bool &forward, const bool &restart, const int &restartSize, perturber& pb, int baseState)
{
int integralIndex = 0;
SpinBlock system;
system.nonactive_orb() = pb.orb();
const int nroots = dmrginp.nroots(sweepParams.get_sweep_iter());
std::vector<double> finalEnergy(nroots,-1.0e10);
std::vector<double> finalEnergy_spins(nroots,0.);
double finalError = 0.;
sweepParams.set_sweep_parameters();
// a new renormalisation sweep routine
if (forward)
if (dmrginp.outputlevel() > 0)
pout << "\t\t\t Starting sweep "<< sweepParams.set_sweep_iter()<<" in forwards direction"<<endl;
else
if (dmrginp.outputlevel() > 0)
{
pout << "\t\t\t Starting sweep "<< sweepParams.set_sweep_iter()<<" in backwards direction" << endl;
pout << "\t\t\t ============================================================================ " << endl;
}
InitBlocks::InitStartingBlock (system,forward, baseState, pb.wavenumber(), sweepParams.get_forward_starting_size(), sweepParams.get_backward_starting_size(), restartSize, restart, warmUp, integralIndex, pb.braquanta, pb.ketquanta);
if(!restart)
sweepParams.set_block_iter() = 0;
if (dmrginp.outputlevel() > 0)
pout << "\t\t\t Starting block is :: " << endl << system << endl;
SpinBlock::store (forward, system.get_sites(), system, pb.wavenumber(), baseState); // if restart, just restoring an existing block --
sweepParams.savestate(forward, system.get_sites().size());
bool dot_with_sys = true;
vector<int> syssites = system.get_sites();
if (restart)
{
if (forward && system.get_complementary_sites()[0] >= dmrginp.last_site()/2)
dot_with_sys = false;
if (!forward && system.get_sites()[0]-1 < dmrginp.last_site()/2)
dot_with_sys = false;
}
if (dmrginp.outputlevel() > 0)
mcheck("at the very start of sweep"); // just timer
for (; sweepParams.get_block_iter() < sweepParams.get_n_iters(); ) // get_n_iters() returns the number of blocking iterations needed in one sweep
{
if (dmrginp.outputlevel() > 0)
{
pout << "\t\t\t Block Iteration :: " << sweepParams.get_block_iter() << endl;
pout << "\t\t\t ----------------------------" << endl;
}
if (dmrginp.outputlevel() > 0) {
if (forward)
{
pout << "\t\t\t Current direction is :: Forwards " << endl;
}
else
{
pout << "\t\t\t Current direction is :: Backwards " << endl;
}
}
if (sweepParams.get_block_iter() != 0)
sweepParams.set_guesstype() = TRANSFORM;
else
sweepParams.set_guesstype() = TRANSPOSE;
if (dmrginp.outputlevel() > 0)
pout << "\t\t\t Blocking and Decimating " << endl;
SpinBlock newSystem; // new system after blocking and decimating
newSystem.nonactive_orb() = pb.orb();
//Need to substitute by:
// if (warmUp )
// Startup(sweepParams, system, newSystem, dot_with_sys, pb.wavenumber(), baseState);
// else {
// BlockDecimateAndCompress (sweepParams, system, newSystem, false, dot_with_sys, pb.wavenumber(), baseState);
// }
BlockDecimateAndCompress (sweepParams, system, newSystem, warmUp, dot_with_sys,pb, baseState);
//Need to substitute by?
system = newSystem;
if (dmrginp.outputlevel() > 0){
pout << system<<endl;
pout << system.get_braStateInfo()<<endl;
system.printOperatorSummary();
}
//system size is going to be less than environment size
if (forward && system.get_complementary_sites()[0] >= dmrginp.last_site()/2)
dot_with_sys = false;
if (!forward && system.get_sites()[0]-1 < dmrginp.last_site()/2)
dot_with_sys = false;
SpinBlock::store (forward, system.get_sites(), system, pb.wavenumber(), baseState);
syssites = system.get_sites();
if (dmrginp.outputlevel() > 0)
pout << "\t\t\t saving state " << syssites.size() << endl;
++sweepParams.set_block_iter();
#ifndef SERIAL
mpi::communicator world;
world.barrier();
#endif
sweepParams.savestate(forward, syssites.size());
if (dmrginp.outputlevel() > 0)
mcheck("at the end of sweep iteration");
}
//FIXME
//It does not seem necessary.
//when we are doing twodot, we still need to do the last sweep to make sure that the
//correctionVector and base wavefunction are propogated correctly across sweeps
// //especially when we switch from twodot to onedot algorithm
// if (!sweepParams.get_onedot() && !warmUp) {
// pout << "\t\t\t Block Iteration :: " << sweepParams.get_block_iter() << endl;
// pout << "\t\t\t ----------------------------" << endl;
// if (dmrginp.outputlevel() > 0) {
// if (forward)
// pout << "\t\t\t Current direction is :: Forwards " << endl;
// else
// pout << "\t\t\t Current direction is :: Backwards " << endl;
// }
// sweepParams.set_onedot() = true;
// sweepParams.set_env_add() = 0;
// bool dot_with_sys = true;
// WavefunctionCanonicalize(sweepParams, system, warmUp, dot_with_sys, targetState, baseState);
// sweepParams.set_onedot() = false;
// sweepParams.set_env_add() = 1;
// }
//
pout << "\t\t\t Largest Error for Sweep with " << sweepParams.get_keep_states() << " states is " << finalError << endl;
pout << "\t\t\t Largest overlap for Sweep with " << sweepParams.get_keep_states() << " states is " << finalEnergy[0] << endl;
sweepParams.set_largest_dw() = finalError;
pout << "\t\t\t ============================================================================ " << endl;
// update the static number of iterations
++sweepParams.set_sweep_iter();
return finalError;
}
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];
}
double SweepGenblock::do_one(SweepParams &sweepParams, const bool &warmUp, const bool &forward, const bool &restart, const int &restartSize, int stateA, int stateB)
{
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.;
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, stateA, stateB, sweepParams.get_forward_starting_size(), sweepParams.get_backward_starting_size(), restartSize, restart, warmUp, integralIndex);
if(!restart)
sweepParams.set_block_iter() = 0;
p2out << "\t\t\t Starting block is :: " << endl << system << endl;
//if (!restart)
SpinBlock::store (forward, system.get_sites(), system, stateA, stateB); // if restart, just restoring an existing block --
sweepParams.savestate(forward, system.get_sites().size());
bool dot_with_sys = true;
if (restart)
{
if (forward && system.get_complementary_sites()[0] >= dmrginp.last_site()/2)
dot_with_sys = false;
if (!forward && system.get_sites()[0]-1 < dmrginp.last_site()/2)
dot_with_sys = false;
}
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 (SHOW_MORE) pout << "system block" << endl << system << endl;
if (dmrginp.no_transform())
sweepParams.set_guesstype() = BASIC;
else if (!warmUp && sweepParams.get_block_iter() != 0)
sweepParams.set_guesstype() = TRANSFORM;
else if (!warmUp && sweepParams.get_block_iter() == 0 &&
((dmrginp.algorithm_method() == TWODOT_TO_ONEDOT && dmrginp.twodot_to_onedot_iter() != sweepParams.get_sweep_iter()) ||
dmrginp.algorithm_method() != TWODOT_TO_ONEDOT))
sweepParams.set_guesstype() = TRANSPOSE;
else
sweepParams.set_guesstype() = BASIC;
p1out << "\t\t\t Blocking and Decimating " << endl;
SpinBlock newSystem;
BlockAndDecimate (sweepParams, system, newSystem, warmUp, dot_with_sys, stateA, stateB);
system = newSystem;
//system size is going to be less than environment size
if (forward && system.get_complementary_sites()[0] >= dmrginp.last_site()/2)
dot_with_sys = false;
if (!forward && system.get_sites()[0]-1 < dmrginp.last_site()/2)
dot_with_sys = false;
SpinBlock::store (forward, system.get_sites(), system, stateA, stateB);
p1out << "\t\t\t saving state " << system.get_sites().size() << endl;
++sweepParams.set_block_iter();
//if (sweepParams.get_onedot())
//pout << "\t\t\tUsing one dot algorithm!!"<<endl;
sweepParams.savestate(forward, system.get_sites().size());
}
pout << "\t\t\t Finished Generate-Blocks Sweep. " << endl;
pout << "\t\t\t ============================================================================ " << endl;
// update the static number of iterations
++sweepParams.set_sweep_iter();
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 finalEnergy[0];
}
