template<> void Op_component<CreCreDesComp>::build_iterators(SpinBlock& b) { if (b.get_sites().size () == 0) return; // blank construction (used in unset_initialised() Block copy construction, for use with STL) const double screen_tol = dmrginp.oneindex_screen_tol(); vector< int > screened_cdd_ix = (dmrginp.hamiltonian() == BCS) ? screened_cddcomp_indices(b.get_complementary_sites(), b.get_sites(), v_1, *b.get_twoInt(), v_cc, v_cccc, v_cccd, screen_tol) : screened_cddcomp_indices(b.get_complementary_sites(), b.get_sites(), v_1, *b.get_twoInt(), screen_tol); m_op.set_indices(screened_cdd_ix, dmrginp.last_site()); std::vector<int> orbs(1); for (int i = 0; i < m_op.local_nnz(); ++i) { orbs[0] = m_op.get_local_indices()[i]; m_op.get_local_element(i).resize(1); m_op.get_local_element(i)[0]=boost::shared_ptr<CreCreDesComp>(new CreCreDesComp); SparseMatrix& op = *m_op.get_local_element(i)[0]; op.set_orbs() = orbs; op.set_initialised() = true; op.set_fermion() = true; //op.set_deltaQuantum() = SpinQuantum(1, SpinOf(orbs[0]), SymmetryOfSpatialOrb(orbs[0]) ); if (dmrginp.hamiltonian() == BCS) { op.resize_deltaQuantum(4); SpinQuantum qorb = getSpinQuantum(orbs[0]); op.set_deltaQuantum(0) = qorb; op.set_deltaQuantum(1) = SpinQuantum(3, qorb.get_s(), qorb.get_symm()); op.set_deltaQuantum(2) = SpinQuantum(-1, qorb.get_s(), qorb.get_symm()); op.set_deltaQuantum(3) = SpinQuantum(-3, qorb.get_s(), qorb.get_symm()); } else { op.set_deltaQuantum(1, getSpinQuantum(orbs[0])); } } }
template<> void Op_component<CreCreComp>::build_iterators(SpinBlock& b) { if (b.get_sites().size () == 0) return; // blank construction (used in unset_initialised() Block copy construction, for use with STL) const double screen_tol = dmrginp.twoindex_screen_tol(); vector< pair<int, int> > screened_dd_ix = (dmrginp.hamiltonian() == BCS) ? screened_dd_indices(b.get_complementary_sites(), b.get_sites(), *b.get_twoInt(), v_cc, v_cccc, v_cccd, screen_tol) : screened_dd_indices(b.get_complementary_sites(), b.get_sites(), *b.get_twoInt(), screen_tol); m_op.set_pair_indices(screened_dd_ix, dmrginp.last_site()); std::vector<int> orbs(2); for (int i = 0; i < m_op.local_nnz(); ++i) { orbs = m_op.unmap_local_index(i); std::vector<boost::shared_ptr<CreCreComp> >& vec = m_op.get_local_element(i); SpinQuantum spin1 = getSpinQuantum(orbs[0]); SpinQuantum spin2 = getSpinQuantum(orbs[1]); std::vector<SpinQuantum> spinvec = spin1+spin2; vec.resize(spinvec.size()); for (int j=0; j<spinvec.size(); j++) { vec[j]=boost::shared_ptr<CreCreComp>(new CreCreComp); SparseMatrix& op = *vec[j]; op.set_orbs() = orbs; op.set_initialised() = true; op.set_fermion() = false; op.set_deltaQuantum(1, spinvec[j]); } } }
template<> void Op_component<Des>::build_iterators(SpinBlock& b) { if (b.get_sites().size () == 0) return; // blank construction (used in unset_initialised() Block copy construction, for use with STL) const double screen_tol = dmrginp.oneindex_screen_tol(); std::vector<int> screened_d_ix = screened_d_indices(b.get_sites(), b.get_complementary_sites(), v_1, *b.get_twoInt(), screen_tol); m_op.set_indices(screened_d_ix, dmrginp.last_site()); std::vector<int> orbs(1); for (int i = 0; i < m_op.local_nnz(); ++i) { orbs[0] = m_op.get_local_indices()[i]; m_op.get_local_element(i).resize(1); m_op.get_local_element(i)[0]=boost::shared_ptr<Des>(new Des); SparseMatrix& op = *m_op.get_local_element(i)[0]; op.set_orbs() = orbs; op.set_initialised() = true; op.set_fermion() = true; op.set_deltaQuantum(1, -getSpinQuantum(orbs[0]));//SpinQuantum(1, 1, SymmetryOfSpatialOrb(orbs[0])); op.set_quantum_ladder()["(D)"] = { op.get_deltaQuantum(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; }
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]; }