本文整理汇总了C++中SweepParams::get_sys_add方法的典型用法代码示例。如果您正苦于以下问题:C++ SweepParams::get_sys_add方法的具体用法?C++ SweepParams::get_sys_add怎么用?C++ SweepParams::get_sys_add使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类SweepParams
的用法示例。
在下文中一共展示了SweepParams::get_sys_add方法的6个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: BlockAndDecimate
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);
}
示例2: BlockAndDecimate
void SweepOnepdm::BlockAndDecimate (SweepParams &sweepParams, SpinBlock& system, SpinBlock& newSystem, const bool &useSlater, const bool& dot_with_sys)
{
//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 = *system.get_sites().rbegin () + 1;
systemDotEnd = systemDotStart + systemDotSize;
}
else
{
systemDotStart = system.get_sites() [0] - 1;
systemDotEnd = systemDotStart - systemDotSize;
}
vector<int> spindotsites(2);
spindotsites[0] = systemDotStart;
spindotsites[1] = systemDotEnd;
systemDot = SpinBlock(systemDotStart, systemDotEnd);
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.get_sys_add(), dmrginp.direct(), DISTRIBUTED_STORAGE, true, true);
InitBlocks::InitNewEnvironmentBlock(environment, systemDot, newEnvironment, system, systemDot,
sweepParams.get_sys_add(), sweepParams.get_env_add(), forward, dmrginp.direct(),
sweepParams.get_onedot(), nexact, useSlater, 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> solutions(nroots);
for(int i=0;i<nroots;++i)
{
StateInfo newInfo;
solutions[i].LoadWavefunctionInfo (newInfo, newSystem.get_sites(), i);
}
#ifndef SERIAL
mpi::communicator world;
mpi::broadcast(world,solutions,0);
#endif
#ifdef SERIAL
const int numprocs = 1;
#endif
#ifndef SERIAL
const int numprocs = world.size();
#endif
compute_onepdm(solutions, system, systemDot, newSystem, newEnvironment, big, numprocs);
}
示例3: InitializeOverlapSpinBlocks
//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 ;
}
示例4: bratracedMatrix
void SpinAdapted::mps_nevpt::type1::BlockDecimateAndCompress (SweepParams &sweepParams, SpinBlock& system, SpinBlock& newSystem, const bool &useSlater, const bool& dot_with_sys, perturber& pb, int baseState)
{
int sweepiter = sweepParams.get_sweep_iter();
if (dmrginp.outputlevel() > 0) {
mcheck("at the start of block and decimate");
pout << "\t\t\t dot with system "<<dot_with_sys<<endl;
pout <<endl<< "\t\t\t Performing Blocking"<<endl;
}
// figure out if we are going forward or backwards
dmrginp.guessgenT -> start();
bool forward = (system.get_sites() [0] == 0);
SpinBlock systemDot;
SpinBlock environment, environmentDot, newEnvironment;
SpinBlock big;
environment.nonactive_orb() = pb.orb();
newEnvironment.nonactive_orb() = pb.orb();
int systemDotStart, systemDotEnd;
int environmentDotStart, environmentDotEnd, environmentStart, environmentEnd;
int systemDotSize = sweepParams.get_sys_add() - 1;
int environmentDotSize = sweepParams.get_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;
}
else
{
systemDotStart = dmrginp.spinAdapted() ? system.get_sites()[0] - 1 : (system.get_sites()[0])/2 - 1 ;
systemDotEnd = systemDotStart - systemDotSize;
environmentDotStart = systemDotEnd - 1;
environmentDotEnd = environmentDotStart - environmentDotSize;
}
systemDot = SpinBlock(systemDotStart, systemDotEnd, pb.orb());
environmentDot = SpinBlock(environmentDotStart, environmentDotEnd, pb.orb());
Sweep::makeSystemEnvironmentBigBlocks(system, systemDot, newSystem, environment, environmentDot, newEnvironment, big, sweepParams, dot_with_sys, useSlater, system.get_integralIndex(), pb.wavenumber(), baseState,pb.braquanta,pb.ketquanta);
//analyse_operator_distribution(big);
dmrginp.guessgenT -> stop();
dmrginp.multiplierT -> start();
std::vector<Matrix> rotatematrix;
if (dmrginp.outputlevel() > 0)
mcheck("");
if (dmrginp.outputlevel() > 0) {
if (!dot_with_sys && sweepParams.get_onedot()) { pout << "\t\t\t System Block"<<system; }
else pout << "\t\t\t System Block"<<newSystem;
pout << "\t\t\t Environment Block"<<newEnvironment<<endl;
pout << "\t\t\t Solving wavefunction "<<endl;
}
std::vector<Wavefunction> solution; solution.resize(1);
std::vector<Wavefunction> outputState; outputState.resize(1);
DiagonalMatrix e;
//read the 0th wavefunction which we keep on the ket side because by default the ket stateinfo is used to initialize wavefunction
//also when you use spinblock operators to multiply a state, it does so from the ket side i.e. H|ket>
//GuessWave::guess_wavefunctions(solution, e, big, sweepParams.set_guesstype(), sweepParams.get_onedot(), dot_with_sys, 0.0, baseState);
GuessWave::guess_wavefunctions(solution[0], e, big, sweepParams.set_guesstype(), sweepParams.get_onedot(), baseState, dot_with_sys, 0.0);
#ifndef SERIAL
mpi::communicator world;
broadcast(world, solution, 0);
#endif
outputState[0].AllowQuantaFor(big.get_leftBlock()->get_braStateInfo(), big.get_rightBlock()->get_braStateInfo(),pb.braquanta);
outputState[0].set_onedot(sweepParams.get_onedot());
outputState[0].Clear();
if (pb.type() == TwoPerturbType::Va)
big.multiplyCDD_sum(solution[0],&(outputState[0]),MAX_THRD);
if (pb.type() == TwoPerturbType::Vi)
big.multiplyCCD_sum(solution[0],&(outputState[0]),MAX_THRD);
//davidson_f(solution[0], outputState[0]);
SpinBlock newbig;
if (sweepParams.get_onedot() && !dot_with_sys)
{
InitBlocks::InitNewSystemBlock(system, systemDot, newSystem, baseState, pb.wavenumber(), systemDot.size(), dmrginp.direct(), system.get_integralIndex(), DISTRIBUTED_STORAGE, false, true,NO_PARTICLE_SPIN_NUMBER_CONSTRAINT,pb.braquanta,pb.ketquanta);
InitBlocks::InitBigBlock(newSystem, environment, newbig,pb.braquanta,pb.ketquanta);
Wavefunction tempwave = outputState[0];
GuessWave::onedot_shufflesysdot(big.get_braStateInfo(), newbig.get_braStateInfo(), outputState[0], tempwave);
outputState[0] = tempwave;
tempwave = solution[0];
GuessWave::onedot_shufflesysdot(big.get_ketStateInfo(), newbig.get_ketStateInfo(), solution[0], tempwave);
solution[0] = tempwave;
big.get_rightBlock()->clear();
big.clear();
}
else
newbig = big;
//.........这里部分代码省略.........
示例5: BlockAndDecimate
void SweepGenblock::BlockAndDecimate (SweepParams &sweepParams, SpinBlock& system, SpinBlock& newSystem, const bool &useSlater, const bool& dot_with_sys, int stateA, int stateB)
{
if (dmrginp.outputlevel() > 0)
mcheck("at the start of block and decimate");
p1out << "\t\t\t Performing Blocking"<<endl;
dmrginp.guessgenT -> start();
// figure out if we are going forward or backwards
bool forward = (system.get_sites() [0] == 0);
SpinBlock systemDot;
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;
dmrginp.sysdotmake->start();
systemDot = SpinBlock(systemDotStart, systemDotEnd, system.get_integralIndex(), stateA==stateB);
dmrginp.sysdotmake->stop();
const int nexact = forward ? sweepParams.get_forward_starting_size() : sweepParams.get_backward_starting_size();
dmrginp.guessgenT -> stop();
dmrginp.datatransfer -> start();
system.addAdditionalCompOps();
dmrginp.datatransfer -> stop();
dmrginp.initnewsystem->start();
InitBlocks::InitNewSystemBlock(system, systemDot, newSystem, stateA, stateB, sweepParams.get_sys_add(), dmrginp.direct(), system.get_integralIndex(), DISTRIBUTED_STORAGE, dot_with_sys, true);
dmrginp.initnewsystem->stop();
pout << "\t\t\t System Block"<<newSystem;
newSystem.printOperatorSummary();
std::vector<Matrix> leftrotateMatrix, rightrotateMatrix;
LoadRotationMatrix (newSystem.get_sites(), leftrotateMatrix, stateA);
LoadRotationMatrix (newSystem.get_sites(), rightrotateMatrix, stateB);
#ifndef SERIAL
mpi::communicator world;
broadcast(world, leftrotateMatrix, 0);
broadcast(world, rightrotateMatrix, 0);
#endif
p1out <<"\t\t\t Performing Renormalization "<<endl<<endl;
dmrginp.operrotT->start();
if (stateB == stateA)
newSystem.transform_operators(leftrotateMatrix);
else
newSystem.transform_operators(leftrotateMatrix, rightrotateMatrix);
dmrginp.operrotT->stop();
if (dmrginp.outputlevel() > 0)
//mcheck("after rotation and transformation of block");
p2out <<newSystem<<endl;
newSystem.printOperatorSummary();
//mcheck("After renorm transform");
p2out << *dmrginp.guessgenT<<" "<<*dmrginp.multiplierT<<" "<<*dmrginp.operrotT<< " "<<globaltimer.totalwalltime()<<" timer "<<endl;
p2out << *dmrginp.makeopsT<<" "<<*dmrginp.initnewsystem<<" "<<*dmrginp.sysdotmake<<" "<<*dmrginp.buildcsfops<<" makeops "<<endl;
p2out << *dmrginp.datatransfer<<" datatransfer "<<endl;
p2out <<"oneindexopmult twoindexopmult Hc couplingcoeff"<<endl;
p2out << *dmrginp.oneelecT<<" "<<*dmrginp.twoelecT<<" "<<*dmrginp.hmultiply<<" "<<*dmrginp.couplingcoeff<<" hmult"<<endl;
p2out << *dmrginp.buildsumblock<<" "<<*dmrginp.buildblockops<<" build block"<<endl;
p2out << *dmrginp.blockintegrals<<" "<<*dmrginp.blocksites<<" "<<*dmrginp.statetensorproduct<<" "<<*dmrginp.statecollectquanta<<" "<<*dmrginp.buildsumblock<<" "<<*dmrginp.builditeratorsT<<" "<<*dmrginp.diskio<<" build sum block"<<endl;
p2out << "addnoise S_0_opxop S_1_opxop S_2_opxop"<<endl;
p3out << *dmrginp.addnoise<<" "<<*dmrginp.s0time<<" "<<*dmrginp.s1time<<" "<<*dmrginp.s2time<<endl;
}
示例6: BlockAndDecimate
void SweepGenblock::BlockAndDecimate (SweepParams &sweepParams, SpinBlock& system, SpinBlock& newSystem, const bool &useSlater, const bool& dot_with_sys, int stateA, int stateB)
{
if (dmrginp.outputlevel() > 0)
mcheck("at the start of block and decimate");
pout << "\t\t\t Performing Blocking"<<endl;
dmrginp.guessgenT -> start();
// figure out if we are going forward or backwards
bool forward = (system.get_sites() [0] == 0);
SpinBlock systemDot;
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, stateA==stateB);
const int nexact = forward ? sweepParams.get_forward_starting_size() : sweepParams.get_backward_starting_size();
system.addAdditionalCompOps();
InitBlocks::InitNewSystemBlock(system, systemDot, newSystem, stateA, stateB, sweepParams.get_sys_add(), dmrginp.direct(), DISTRIBUTED_STORAGE, dot_with_sys, true);
pout << "\t\t\t System Block"<<newSystem;
if (dmrginp.outputlevel() > 0)
newSystem.printOperatorSummary();
std::vector<Matrix> leftrotateMatrix, rightrotateMatrix;
LoadRotationMatrix (newSystem.get_sites(), leftrotateMatrix, stateA);
LoadRotationMatrix (newSystem.get_sites(), rightrotateMatrix, stateB);
#ifndef SERIAL
mpi::communicator world;
broadcast(world, leftrotateMatrix, 0);
broadcast(world, rightrotateMatrix, 0);
#endif
pout <<"\t\t\t Performing Renormalization "<<endl<<endl;
if (stateB == stateA)
newSystem.transform_operators(leftrotateMatrix);
else
newSystem.transform_operators(leftrotateMatrix, rightrotateMatrix);
if (dmrginp.outputlevel() > 0)
//mcheck("after rotation and transformation of block");
if (dmrginp.outputlevel() > 0)
pout <<newSystem<<endl;
if (dmrginp.outputlevel() > 0)
newSystem.printOperatorSummary();
//mcheck("After renorm transform");
}