void SpinAdapted::InitBlocks::InitNewEnvironmentBlock(SpinBlock &environment, SpinBlock& environmentDot, SpinBlock &newEnvironment, const SpinBlock &system, SpinBlock &systemDot, int leftState, int rightState, const int &sys_add, const int &env_add, const bool &forward, const bool &direct, const bool &onedot, const bool &nexact, const bool &useSlater, int integralIndex, bool haveNormops, bool haveCompops, const bool& dot_with_sys, int constraint, const std::vector<SpinQuantum>& braquanta, const std::vector<SpinQuantum>& ketquanta) { // now initialise environment Dot int systemDotStart, systemDotEnd, environmentDotStart, environmentDotEnd, environmentStart, environmentEnd; int systemDotSize = sys_add - 1; int environmentDotSize = env_add - 1; if (forward) { systemDotStart = dmrginp.spinAdapted() ? *system.get_sites().rbegin () + 1 : (*system.get_sites().rbegin ())/2 + 1 ; systemDotEnd = systemDotStart + systemDotSize; environmentDotStart = systemDotEnd + 1; environmentDotEnd = environmentDotStart + environmentDotSize; environmentStart = environmentDotEnd + 1; environmentEnd = dmrginp.spinAdapted() ? dmrginp.last_site() - 1 : dmrginp.last_site()/2 - 1; } else { systemDotStart = dmrginp.spinAdapted() ? system.get_sites()[0] - 1 : (system.get_sites()[0])/2 - 1 ; systemDotEnd = systemDotStart - systemDotSize; environmentDotStart = systemDotEnd - 1; environmentDotEnd = environmentDotStart - environmentDotSize; environmentStart = environmentDotEnd - 1; environmentEnd = 0; } std::vector<int> environmentSites; environmentSites.resize(abs(environmentEnd - environmentStart) + 1); for (int i = 0; i < abs(environmentEnd - environmentStart) + 1; ++i) *(environmentSites.begin () + i) = min(environmentStart,environmentEnd) + i; // now initialise environment if (useSlater) { // for FCI StateInfo system_stateinfo = system.get_stateInfo(); StateInfo sysdot_stateinfo = systemDot.get_stateInfo(); StateInfo tmp; TensorProduct (system_stateinfo, sysdot_stateinfo, tmp, NO_PARTICLE_SPIN_NUMBER_CONSTRAINT); // tmp has the system+dot quantum numbers tmp.CollectQuanta (); // exact environment if (dmrginp.do_fci() || environmentSites.size() == nexact) { if ((!dot_with_sys && onedot) || !onedot) { // environment has dot environment.set_integralIndex() = integralIndex; environment.default_op_components(!forward, leftState==rightState); environment.setstoragetype(DISTRIBUTED_STORAGE); environment.BuildTensorProductBlock(environmentSites); // exact block SpinBlock::store (true, environmentSites, environment, leftState, rightState); } else { // environment has no dot, so newEnv = Env newEnvironment.set_integralIndex() = integralIndex; newEnvironment.default_op_components(!forward, leftState==rightState); newEnvironment.setstoragetype(DISTRIBUTED_STORAGE); newEnvironment.BuildTensorProductBlock(environmentSites); SpinBlock::store (true, environmentSites, newEnvironment, leftState, rightState); } } else if (dmrginp.warmup() == LOCAL2 || dmrginp.warmup() == LOCAL3 || dmrginp.warmup() == LOCAL4) { int nactiveSites, ncoreSites; if (dmrginp.warmup() == LOCAL2) { nactiveSites = 1; } else if (dmrginp.warmup() == LOCAL3) { nactiveSites = 2; } else if (dmrginp.warmup() == LOCAL4) { nactiveSites = 3; } if (dot_with_sys && onedot) { nactiveSites += 1; } if (nactiveSites > environmentSites.size()) { nactiveSites = environmentSites.size(); } ncoreSites = environmentSites.size() - nactiveSites; // figure out what sites are in the active and core sites int environmentActiveEnd = forward ? environmentStart + nactiveSites - 1 : environmentStart - nactiveSites + 1; int environmentCoreStart = forward ? environmentActiveEnd + 1 : environmentActiveEnd - 1; std::vector<int> activeSites(nactiveSites), coreSites(ncoreSites); for (int i = 0; i < nactiveSites; ++i) { activeSites[i] = min(environmentStart,environmentActiveEnd) + i; } for (int i = 0; i < ncoreSites; ++i) { coreSites[i] = min(environmentCoreStart,environmentEnd) + i; } SpinBlock environmentActive, environmentCore; environmentActive.nonactive_orb() = system.nonactive_orb(); environmentCore.nonactive_orb() = system.nonactive_orb(); if (coreSites.size() > 0) { environmentActive.set_integralIndex() = integralIndex; environmentCore.set_integralIndex() = integralIndex; environmentActive.default_op_components(!forward, leftState==rightState); environmentActive.setstoragetype(DISTRIBUTED_STORAGE); environmentCore.default_op_components(!forward, leftState==rightState); environmentCore.setstoragetype(DISTRIBUTED_STORAGE); environmentActive.BuildTensorProductBlock(activeSites); environmentCore.BuildSingleSlaterBlock(coreSites); dmrginp.datatransfer -> start(); environmentCore.addAdditionalCompOps(); environmentActive.addAdditionalCompOps(); dmrginp.datatransfer -> stop(); if ((!dot_with_sys && onedot) || !onedot) { environment.set_integralIndex() = integralIndex; environment.default_op_components(!forward, leftState == rightState); environment.setstoragetype(DISTRIBUTED_STORAGE); environment.BuildSumBlock(constraint, environmentCore, environmentActive,braquanta,ketquanta); } else { newEnvironment.set_integralIndex() = integralIndex; newEnvironment.default_op_components(direct, environmentCore, environmentActive, haveNormops, haveCompops, leftState == rightState); newEnvironment.setstoragetype(DISTRIBUTED_STORAGE); newEnvironment.BuildSumBlock(constraint, environmentCore, environmentActive,braquanta,ketquanta); if (dmrginp.outputlevel() > 0) { pout << "\t\t\t NewEnvironment block " << endl << newEnvironment << endl; newEnvironment.printOperatorSummary(); } } } else { // no core if ((!dot_with_sys && onedot) || !onedot) { environment.set_integralIndex() = integralIndex; environment.default_op_components(!forward, leftState==rightState); environment.setstoragetype(DISTRIBUTED_STORAGE); environment.BuildTensorProductBlock(environmentSites); // exact block } else { newEnvironment.set_integralIndex() = integralIndex; newEnvironment.default_op_components(!forward, leftState==rightState); newEnvironment.setstoragetype(DISTRIBUTED_STORAGE); newEnvironment.BuildTensorProductBlock(environmentSites); } } } else { //used for warmup guess environemnt std::vector<SpinQuantum> quantumNumbers; std::vector<int> distribution; std::map<SpinQuantum, int> quantaDist; std::map<SpinQuantum, int>::iterator quantaIterator; bool environmentComplementary = !forward; StateInfo tmp2; // tmp is the quantum numbers of newSystem (sys + sysdot) if (onedot) tmp.quanta_distribution (quantumNumbers, distribution, true); else { StateInfo environmentdot_stateinfo = environmentDot.get_stateInfo(); TensorProduct (tmp, environmentdot_stateinfo, tmp2, constraint); tmp2.CollectQuanta (); tmp2.quanta_distribution (quantumNumbers, distribution, true); } for (int i = 0; i < distribution.size (); ++i) { quantaIterator = quantaDist.find(quantumNumbers[i]); if (quantaIterator != quantaDist.end()) distribution[i] += quantaIterator->second; distribution [i] /= 4; distribution [i] += 1; if (distribution [i] > dmrginp.nquanta()) distribution [i] = dmrginp.nquanta(); if(quantaIterator != quantaDist.end()) { quantaIterator->second = distribution[i]; } else { quantaDist[quantumNumbers[i]] = distribution[i]; } } if (dmrginp.outputlevel() > 0) pout << "\t\t\t Quantum numbers and states used for warm up :: " << endl << "\t\t\t "; quantumNumbers.clear(); quantumNumbers.reserve(distribution.size()); distribution.clear();distribution.reserve(quantumNumbers.size()); std::map<SpinQuantum, int>::iterator qit = quantaDist.begin(); for (; qit != quantaDist.end(); qit++) { quantumNumbers.push_back( qit->first); distribution.push_back(qit->second); if (dmrginp.outputlevel() > 0) { pout << quantumNumbers.back() << " = " << distribution.back() << ", "; if (! (quantumNumbers.size() - 6) % 6) pout << endl << "\t\t\t "; } } pout << endl; if(dot_with_sys && onedot) { newEnvironment.set_integralIndex() = integralIndex; newEnvironment.BuildSlaterBlock (environmentSites, quantumNumbers, distribution, false, false); } else { environment.set_integralIndex() = integralIndex; environment.BuildSlaterBlock (environmentSites, quantumNumbers, distribution, false, haveNormops); } } } else { if (dmrginp.outputlevel() > 0) pout << "\t\t\t Restoring block of size " << environmentSites.size () << " from previous iteration" << endl; if(dot_with_sys && onedot) { newEnvironment.set_integralIndex() = integralIndex; SpinBlock::restore (!forward, environmentSites, newEnvironment, leftState, rightState); } else { environment.set_integralIndex() = integralIndex; SpinBlock::restore (!forward, environmentSites, environment, leftState, rightState); } if (dmrginp.outputlevel() > 0) mcheck(""); } // now initialise newEnvironment if (!dot_with_sys || !onedot) { dmrginp.datatransfer -> start(); environment.addAdditionalCompOps(); dmrginp.datatransfer -> stop(); newEnvironment.set_integralIndex() = integralIndex; newEnvironment.default_op_components(direct, environment, environmentDot, haveNormops, haveCompops, leftState==rightState); newEnvironment.setstoragetype(DISTRIBUTED_STORAGE); newEnvironment.BuildSumBlock (constraint, environment, environmentDot,braquanta,ketquanta); if (dmrginp.outputlevel() > -1) { pout << "\t\t\t Environment block " << endl << environment << endl; environment.printOperatorSummary(); pout << "\t\t\t NewEnvironment block " << endl << newEnvironment << endl; newEnvironment.printOperatorSummary(); } } else if (dmrginp.outputlevel() > 0) { pout << "\t\t\t Environment block " << endl << newEnvironment << endl; newEnvironment.printOperatorSummary(); } }
void SpinAdapted::InitBlocks::InitStartingBlock (SpinBlock& startingBlock, const bool &forward, int leftState, int rightState, const int & forward_starting_size, const int &backward_starting_size, const int& restartSize, const bool &restart, const bool& warmUp, int integralIndex, const vector<SpinQuantum>& braquanta, const vector<SpinQuantum>& ketquanta) { if (restart && restartSize != 1) { int len = restart? restartSize : forward_starting_size; vector<int> sites(len); if (forward) for (int i=0; i<len; i++) sites[i] = i; else for (int i=0; i<len; i++) sites[i] = dmrginp.last_site() - len +i ; if (restart) SpinBlock::restore (forward, sites, startingBlock, leftState, rightState); else SpinBlock::restore (true, sites, startingBlock, leftState, rightState); } else if (forward) { if(startingBlock.nonactive_orb().size()!=0) startingBlock = SpinBlock(0, forward_starting_size - 1,startingBlock.nonactive_orb() , true); else startingBlock = SpinBlock(0, forward_starting_size - 1, integralIndex, leftState==rightState, true); if (dmrginp.add_noninteracting_orbs() && dmrginp.molecule_quantum().get_s().getirrep() != 0 && dmrginp.spinAdapted()) { SpinQuantum s = dmrginp.molecule_quantum(); s = SpinQuantum(s.get_s().getirrep(), s.get_s(), IrrepSpace(0)); int qs = 1, ns = 1; StateInfo addstate(ns, &s, &qs); SpinBlock dummyblock(addstate, integralIndex); SpinBlock newstartingBlock; newstartingBlock.set_integralIndex() = integralIndex; newstartingBlock.default_op_components(false, startingBlock, dummyblock, true, true, leftState==rightState); newstartingBlock.setstoragetype(LOCAL_STORAGE); if( braquanta.size()!= 0) newstartingBlock.BuildSumBlock(NO_PARTICLE_SPIN_NUMBER_CONSTRAINT, startingBlock, dummyblock,braquanta,ketquanta); else newstartingBlock.BuildSumBlock(NO_PARTICLE_SPIN_NUMBER_CONSTRAINT, startingBlock, dummyblock); startingBlock.clear(); startingBlock = newstartingBlock; } } else { std::vector<int> backwardSites; if(dmrginp.spinAdapted()) { for (int i = 0; i < backward_starting_size; ++i) backwardSites.push_back (dmrginp.last_site() - i - 1); } else { for (int i = 0; i < backward_starting_size; ++i) backwardSites.push_back (dmrginp.last_site()/2 - i - 1); } sort (backwardSites.begin (), backwardSites.end ()); startingBlock.set_integralIndex() = integralIndex; startingBlock.default_op_components(false, leftState==rightState); startingBlock.BuildTensorProductBlock (backwardSites); } }