//Initialize stateinfo using the rotation matrices
void SpinAdapted::Sweep::InitializeStateInfo(SweepParams &sweepParams, const bool &forward, int currentstate)
{
sweepParams.set_sweep_parameters();
sweepParams.set_block_iter() = 0;
std::vector<int> sites;
int new_site, wave_site;
if (forward)
new_site = 0;
else
new_site = dmrginp.spinAdapted() ? dmrginp.last_site()-1 : dmrginp.last_site()/2-1;
if (dmrginp.spinAdapted())
sites.push_back(new_site);
else {
sites.push_back(2*new_site);
sites.push_back(2*new_site+1);
std::sort(sites.begin(), sites.end());
}
//only need statinfos
StateInfo stateInfo1; makeStateInfo(stateInfo1, new_site);
StateInfo::store(forward, sites, stateInfo1, currentstate);
for (; sweepParams.get_block_iter() < sweepParams.get_n_iters(); ) {
if (forward)
new_site++;
else
new_site--;
if (dmrginp.spinAdapted())
sites.push_back(new_site);
else {
sites.push_back(2*new_site);
sites.push_back(2*new_site+1);
std::sort(sites.begin(), sites.end());
}
StateInfo siteState, newState1;
makeStateInfo(siteState, new_site);
TensorProduct(stateInfo1, siteState, newState1, NO_PARTICLE_SPIN_NUMBER_CONSTRAINT);
newState1.CollectQuanta();
//make the newstate
std::vector<Matrix> rotation1;
LoadRotationMatrix (sites, rotation1, currentstate);
StateInfo renormState1;
SpinAdapted::StateInfo::transform_state(rotation1, newState1, renormState1);
StateInfo::store(forward, sites, renormState1, currentstate);
stateInfo1 = renormState1;
++sweepParams.set_block_iter();
}
}
void SweepTwopdm::BlockAndDecimate (SweepParams &sweepParams, SpinBlock& system, SpinBlock& newSystem, const bool &useSlater, const bool& dot_with_sys, int state)
{
//mcheck("at the start of block and decimate");
// figure out if we are going forward or backwards
dmrginp.guessgenT -> start();
bool forward = (system.get_sites() [0] == 0);
SpinBlock systemDot;
SpinBlock envDot;
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;
}
vector<int> spindotsites(2);
spindotsites[0] = systemDotStart;
spindotsites[1] = systemDotEnd;
//if (useSlater) {
systemDot = SpinBlock(systemDotStart, systemDotEnd, system.get_integralIndex(), true);
//SpinBlock::store(true, systemDot.get_sites(), systemDot);
//}
//else
//SpinBlock::restore(true, spindotsites, systemDot);
SpinBlock environment, environmentDot, newEnvironment;
int environmentDotStart, environmentDotEnd, environmentStart, environmentEnd;
const int nexact = forward ? sweepParams.get_forward_starting_size() : sweepParams.get_backward_starting_size();
system.addAdditionalCompOps();
InitBlocks::InitNewSystemBlock(system, systemDot, newSystem, sweepParams.current_root(), sweepParams.current_root(), sweepParams.get_sys_add(), dmrginp.direct(), system.get_integralIndex(), DISTRIBUTED_STORAGE, true, true);
InitBlocks::InitNewEnvironmentBlock(environment, systemDot, newEnvironment, system, systemDot, sweepParams.current_root(), sweepParams.current_root(),
sweepParams.get_sys_add(), sweepParams.get_env_add(), forward, dmrginp.direct(),
sweepParams.get_onedot(), nexact, useSlater, system.get_integralIndex(), true, true, true);
SpinBlock big;
newSystem.set_loopblock(true);
system.set_loopblock(false);
newEnvironment.set_loopblock(false);
InitBlocks::InitBigBlock(newSystem, newEnvironment, big);
const int nroots = dmrginp.nroots();
std::vector<Wavefunction> solution(1);
DiagonalMatrix e;
GuessWave::guess_wavefunctions(solution[0], e, big, sweepParams.get_guesstype(), true, state, true, 0.0);
#ifndef SERIAL
mpi::communicator world;
mpi::broadcast(world, solution, 0);
#endif
std::vector<Matrix> rotateMatrix;
DensityMatrix tracedMatrix(newSystem.get_stateInfo());
tracedMatrix.allocate(newSystem.get_stateInfo());
tracedMatrix.makedensitymatrix(solution, big, std::vector<double>(1,1.0), 0.0, 0.0, false);
rotateMatrix.clear();
if (!mpigetrank())
double error = makeRotateMatrix(tracedMatrix, rotateMatrix, sweepParams.get_keep_states(), sweepParams.get_keep_qstates());
#ifndef SERIAL
mpi::broadcast(world,rotateMatrix,0);
#endif
#ifdef SERIAL
const int numprocs = 1;
#endif
#ifndef SERIAL
const int numprocs = world.size();
#endif
if (sweepParams.get_block_iter() == 0)
compute_twopdm_initial(solution, system, systemDot, newSystem, newEnvironment, big, numprocs, state);
compute_twopdm_sweep(solution, system, systemDot, newSystem, newEnvironment, big, numprocs, state);
if (sweepParams.get_block_iter() == sweepParams.get_n_iters() - 1)
compute_twopdm_final(solution, system, systemDot, newSystem, newEnvironment, big, numprocs, state);
SaveRotationMatrix (newSystem.get_sites(), rotateMatrix, state);
//for(int i=0;i<dmrginp.nroots();++i)
solution[0].SaveWavefunctionInfo (big.get_stateInfo(), big.get_leftBlock()->get_sites(), state);
newSystem.transform_operators(rotateMatrix);
}
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];
}
//Canonicalize wavefunction, takes the wavefunction and does a sweep to update all the roation matrices so that we get a consistent wavefunction along the whole sweep
void SpinAdapted::Sweep::CanonicalizeWavefunction(SweepParams &sweepParams, const bool &forward, int currentstate)
{
sweepParams.set_sweep_parameters();
sweepParams.set_block_iter() = 0;
std::vector<int> sites;
int new_site, wave_site;
if (forward) {
pout << "\t\t\t Starting sweep "<< sweepParams.set_sweep_iter()<<" in forwards direction"<<endl;
new_site = 0;
}
else {
pout << "\t\t\t Starting sweep "<< sweepParams.set_sweep_iter()<<" in backwards direction" << endl;
new_site = dmrginp.spinAdapted() ? dmrginp.last_site()-1 : dmrginp.last_site()/2-1;
}
pout << "\t\t\t ============================================================================ " <<
endl;
if (dmrginp.spinAdapted())
sites.push_back(new_site);
else {
sites.push_back(2*new_site);
sites.push_back(2*new_site+1);
std::sort(sites.begin(), sites.end());
}
//only need statinfos
StateInfo stateInfo1; makeStateInfo(stateInfo1, new_site);
for (; sweepParams.get_block_iter() < sweepParams.get_n_iters(); ) {
pout << "\t\t\t Block Iteration :: " << sweepParams.get_block_iter() << endl;
pout << "\t\t\t ----------------------------" << endl;
if (forward) {
new_site++;
wave_site = new_site+1;
pout << "\t\t\t Current direction is :: Forwards " << endl;
}
else {
new_site--;
wave_site = new_site-1;
pout << "\t\t\t Current direction is :: Backwards " << endl;
}
std::vector<int> complementarySites, spindotsites(1, new_site), oldsites = sites, oldcomplement;
if (dmrginp.spinAdapted())
sites.push_back(new_site);
else {
sites.push_back(2*new_site);
sites.push_back(2*new_site+1);
std::sort(sites.begin(), sites.end());
}
getComplementarySites(sites, complementarySites);
getComplementarySites(oldsites, oldcomplement);
StateInfo siteState, newState1, bigstate, envstate;
makeStateInfo(siteState, new_site);
TensorProduct(stateInfo1, siteState, newState1, NO_PARTICLE_SPIN_NUMBER_CONSTRAINT);
newState1.CollectQuanta();
Wavefunction w; w.set_deltaQuantum() = dmrginp.effective_molecule_quantum_vec();
w.set_onedot(true);
if (!dmrginp.spinAdapted()) {
std::vector<int> spinSites(complementarySites.size()/2, 0);
for (int s=0; s<spinSites.size(); s++)
spinSites[s] = complementarySites[2*s]/2;
StateInfo::restore(!forward, spinSites, envstate, currentstate);
}
else
StateInfo::restore(!forward, complementarySites, envstate, currentstate);
TensorProduct(newState1, envstate, bigstate, PARTICLE_SPIN_NUMBER_CONSTRAINT);
if (sweepParams.get_block_iter() == 0)
GuessWave::transpose_previous_wavefunction(w, bigstate, complementarySites, spindotsites, currentstate, true, true);
else
GuessWave::transform_previous_wavefunction(w, bigstate, oldsites, oldcomplement, currentstate, true, true);
w.SaveWavefunctionInfo(bigstate, sites, currentstate);
//make the newstate
std::vector<Matrix> rotation1;
DensityMatrix tracedMatrix;
tracedMatrix.allocate(*bigstate.leftStateInfo);
operatorfunctions::MultiplyProduct(w, Transpose(const_cast<Wavefunction&> (w)), tracedMatrix, 1.0);
int largeNumber = 1000000;
if (!mpigetrank())
double error = makeRotateMatrix(tracedMatrix, rotation1, largeNumber, sweepParams.get_keep_qstates());
SaveRotationMatrix (sites, rotation1, currentstate);
StateInfo renormState1;
SpinAdapted::StateInfo::transform_state(rotation1, newState1, renormState1);
StateInfo::store(forward, sites, renormState1, currentstate);
stateInfo1 = renormState1;
++sweepParams.set_block_iter();
}
}
//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 ;
}
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;
}
void SweepOnepdm::BlockAndDecimate (SweepParams &sweepParams, SpinBlock& system, SpinBlock& newSystem, const bool &useSlater, const bool& dot_with_sys, int state)
{
//mcheck("at the start of block and decimate");
// figure out if we are going forward or backwards
dmrginp.guessgenT -> start();
bool forward = (system.get_sites() [0] == 0);
SpinBlock systemDot;
SpinBlock envDot;
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;
}
vector<int> spindotsites(2);
spindotsites[0] = systemDotStart;
spindotsites[1] = systemDotEnd;
systemDot = SpinBlock(systemDotStart, systemDotEnd, system.get_integralIndex(), true);
SpinBlock environment, environmentDot, newEnvironment;
int environmentDotStart, environmentDotEnd, environmentStart, environmentEnd;
const int nexact = forward ? sweepParams.get_forward_starting_size() : sweepParams.get_backward_starting_size();
newSystem.set_integralIndex() = system.get_integralIndex();
newSystem.default_op_components(dmrginp.direct(), system, systemDot, false, false, true);
newSystem.erase(CRE_CRE_DESCOMP);
newSystem.erase(CRE_CRE);
newSystem.erase(HAM);
newSystem.setstoragetype(DISTRIBUTED_STORAGE_FOR_ONEPDM);
newSystem.BuildSumBlock (NO_PARTICLE_SPIN_NUMBER_CONSTRAINT, system, systemDot);
if (dmrginp.outputlevel() > 0) {
pout << "\t\t\t NewSystem block " << endl << newSystem << endl;
newSystem.printOperatorSummary();
}
InitBlocks::InitNewEnvironmentBlock(environment, systemDot, newEnvironment, system, systemDot, sweepParams.current_root(), sweepParams.current_root(),
sweepParams.get_sys_add(), sweepParams.get_env_add(), forward, dmrginp.direct(),
sweepParams.get_onedot(), nexact, useSlater, system.get_integralIndex(), false, false, true);
SpinBlock big;
newSystem.set_loopblock(true);
system.set_loopblock(false);
newEnvironment.set_loopblock(false);
InitBlocks::InitBigBlock(newSystem, newEnvironment, big);
const int nroots = dmrginp.nroots();
std::vector<Wavefunction> solution(1);
DiagonalMatrix e;
GuessWave::guess_wavefunctions(solution[0], e, big, sweepParams.get_guesstype(), true, state, true, 0.0);
#ifndef SERIAL
mpi::communicator world;
mpi::broadcast(world, solution, 0);
#endif
std::vector<Matrix> rotateMatrix;
DensityMatrix tracedMatrix(newSystem.get_stateInfo());
tracedMatrix.allocate(newSystem.get_stateInfo());
tracedMatrix.makedensitymatrix(solution, big, std::vector<double>(1,1.0), 0.0, 0.0, false);
rotateMatrix.clear();
if (!mpigetrank())
double error = makeRotateMatrix(tracedMatrix, rotateMatrix, sweepParams.get_keep_states(), sweepParams.get_keep_qstates());
#ifndef SERIAL
mpi::broadcast(world,rotateMatrix,0);
#endif
#ifdef SERIAL
const int numprocs = 1;
#endif
#ifndef SERIAL
const int numprocs = world.size();
#endif
Matrix onepdm;
load_onepdm_binary(onepdm, state ,state);
Matrix pairmat;
if (dmrginp.hamiltonian() == BCS)
load_pairmat_binary(pairmat, state ,state);
if (sweepParams.get_block_iter() == 0) {
//this is inface a combination of 2_0_0, 1_1_0 and 0_2_0
p2out << "\t\t\t compute 2_0_0"<<endl;
compute_one_pdm_2_0_0(solution[0], solution[0], big, onepdm);
if (dmrginp.hamiltonian() == BCS)
compute_pair_2_0_0(solution[0], solution[0], big, pairmat);
p2out << "\t\t\t compute 1_1_0"<<endl;
compute_one_pdm_1_1_0(solution[0], solution[0], big, onepdm);
if (dmrginp.hamiltonian() == BCS)
compute_pair_1_1_0(solution[0], solution[0], big, pairmat);
}
p2out << "\t\t\t compute 0_2_0"<<endl;
compute_one_pdm_0_2_0(solution[0], solution[0], big, onepdm);
if (dmrginp.hamiltonian() == BCS)
compute_pair_0_2_0(solution[0], solution[0], big, pairmat);
p2out << "\t\t\t compute 1_1"<<endl;
compute_one_pdm_1_1(solution[0], solution[0], big, onepdm);
if (dmrginp.hamiltonian() == BCS)
compute_pair_1_1(solution[0], solution[0], big, pairmat);
if (sweepParams.get_block_iter() == sweepParams.get_n_iters() - 1) {
p2out << "\t\t\t compute 0_2"<<endl;
compute_one_pdm_0_2(solution[0], solution[0], big, onepdm);
if (dmrginp.hamiltonian() == BCS)
compute_pair_0_2(solution[0], solution[0], big, pairmat);
}
accumulate_onepdm(onepdm);
save_onepdm_binary(onepdm, state, state);
if (dmrginp.hamiltonian() == BCS) {
accumulate_onepdm(pairmat);
save_pairmat_binary(pairmat, state, state);
}
SaveRotationMatrix (newSystem.get_sites(), rotateMatrix, state);
solution[0].SaveWavefunctionInfo (big.get_stateInfo(), big.get_leftBlock()->get_sites(), state);
newSystem.transform_operators(rotateMatrix);
}
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];
}
void SweepGenblock::do_one(SweepParams &sweepParams, const bool &forward, int stateA, int stateB)
{
Timer sweeptimer;
int integralIndex = 0;
SpinBlock system;
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(), 0, false, false, integralIndex);
sweepParams.set_block_iter() = 0;
p2out << "\t\t\t Starting block is :: " << endl << system << endl;
bool dot_with_sys = true;
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 (dmrginp.no_transform())
sweepParams.set_guesstype() = BASIC;
else if ( sweepParams.get_block_iter() != 0)
sweepParams.set_guesstype() = TRANSFORM;
else if ( sweepParams.get_block_iter() == 0 )
sweepParams.set_guesstype() = TRANSPOSE;
else
sweepParams.set_guesstype() = BASIC;
p1out << "\t\t\t Blocking and Decimating " << endl;
SpinBlock newSystem;
BlockAndDecimate (sweepParams, system, newSystem, false, dot_with_sys, stateA, stateB);
system = newSystem;
SpinBlock::store(forward, system.get_sites(), system, stateA, stateB);
//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;
++sweepParams.set_block_iter();
}
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;
}
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];
}
