void TwoParticleGF::compute(bool clear, const boost::mpi::communicator & comm) { if (Status < Prepared) throw (exStatusMismatch()); if (Status >= Computed) return; if (!Vanishing) { // Create a "skeleton" class with pointers to part that can call a compute method pMPI::mpi_skel<ComputeAndClearWrap> skel; bool fill_container = m_data_.NBosonic() > 0 && m_data_.NFermionic() > 0; skel.parts.reserve(parts.size()); for (size_t i=0; i<parts.size(); i++) { skel.parts.push_back(ComputeAndClearWrap(&m_data_, parts[i], clear, fill_container, 1)); }; std::map<pMPI::JobId, pMPI::WorkerId> job_map = skel.run(comm, true); // actual running - very costly int rank = comm.rank(); int comm_size = comm.size(); // Start distributing data //DEBUG(comm.rank() << getIndex(0) << getIndex(1) << getIndex(2) << getIndex(3) << " Start distributing data"); comm.barrier(); if (!clear) { for (size_t p = 0; p<parts.size(); p++) { boost::mpi::broadcast(comm, parts[p]->NonResonantTerms, job_map[p]); boost::mpi::broadcast(comm, parts[p]->ResonantTerms, job_map[p]); if (rank == job_map[p]) { parts[p]->Status = TwoParticleGFPart::Computed; }; }; comm.barrier(); } }; Status = Computed; }
BlockNumber FieldOperator::getLeftIndex(BlockNumber RightIndex) const { if (Status < Prepared) { ERROR("FieldOperator is not prepared yet."); throw (exStatusMismatch()); } BlocksBimap::right_const_iterator it = LeftRightBlocks.right.find(RightIndex); return (it != LeftRightBlocks.right.end()) ? it->second : ERROR_BLOCK_NUMBER; }
bool HamiltonianPart::reduce(RealType ActualCutoff) { if ( Status < Computed ) throw (exStatusMismatch()); InnerQuantumState counter=0; for (counter=0; (counter< (unsigned int)Eigenvalues.size() && Eigenvalues[counter]<=ActualCutoff); ++counter){}; std::cout << "Left " << counter << " eigenvalues : " << std::endl; if (counter) {std::cout << Eigenvalues.head(counter) << std::endl << "_________" << std::endl; Eigenvalues = Eigenvalues.head(counter); H = H.topLeftCorner(counter,counter); return true; } else return false; }
void FieldOperator::compute(const boost::mpi::communicator& comm) { if (Status < Prepared) throw (exStatusMismatch()); if (Status >= Computed) return; if (!comm.rank()) INFO_NONEWLINE("Computing " << *O << " in eigenbasis of the Hamiltonian: "); /* pMPI::mpi_skel<pMPI::ComputeWrap<FieldOperatorPart>> skel; skel.parts.resize(parts.size()); for (size_t i=0; i<parts.size(); i++) { skel.parts[i] = pMPI::ComputeWrap<FieldOperatorPart>(*parts[i]);}; std::map<pMPI::JobId, pMPI::WorkerId> job_map = skel.run(comm, true); // actual running - very costly int rank = comm.rank(); int comm_size = comm.size(); // Start distributing data comm.barrier(); for (size_t p = 0; p<parts.size(); p++) { int nelem = 0; if (rank == job_map[p]) nelem = parts[p]->elementsColMajor.nonZeros(); boost::mpi::broadcast(comm, nelem, job_map[p]); auto data = parts[p]->elementsColMajor.data(); // Eigen::internal::CompressedStorage auto& value_start = data.value(0); auto& index_start = data.index(0); if (comm.rank()) parts[p]->elementsColMajor.resize(nelem); exit(0); //boost::mpi::broadcast(comm, parts[p]->elementsColMajor.data(), nelem, job_map[p]); if (rank == job_map[p]) { parts[p]->Status = FieldOperatorPart::Computed; }; }; comm.barrier(); */ size_t Size = parts.size(); for (size_t BlockIn = 0; BlockIn < Size; BlockIn++){ INFO_NONEWLINE( (int) ((1.0*BlockIn/Size) * 100 ) << " " << std::flush); parts[BlockIn]->compute(); }; INFO(""); Status = Computed; }
Symmetrizer::QuantumNumbers StatesClassification::getQuantumNumbers(BlockNumber in) const { if ( Status < Computed ) { ERROR("StatesClassification is not computed yet."); throw (exStatusMismatch()); }; if (BlockToQuantum.count(in)) return BlockToQuantum.find(in)->second; throw (exWrongState()); return BlockToQuantum.find(0)->second; }
const FockState StatesClassification::getFockState( QuantumNumbers in, InnerQuantumState m) const { if ( Status < Computed ) { ERROR("StatesClassification is not computed yet."); throw (exStatusMismatch()); }; return getFockState(getBlockNumber(in),m); }
const FockState StatesClassification::getFockState( BlockNumber in, InnerQuantumState m) const { if ( Status < Computed ) { ERROR("StatesClassification is not computed yet."); throw (exStatusMismatch()); }; if (int(in) < StatesContainer.size()) if ( m < StatesContainer[in].size()) return StatesContainer[in][m]; ERROR("Couldn't find state numbered " << m << " in block " << in); throw (exWrongState()); return ERROR_FOCK_STATE; }
const size_t StatesClassification::getBlockSize( BlockNumber in ) const { if ( Status < Computed ) { ERROR("StatesClassification is not computed yet."); throw (exStatusMismatch()); }; return this->getFockStates(in).size(); }
const std::vector<FockState>& StatesClassification::getFockStates( QuantumNumbers in ) const { if ( Status < Computed ) { ERROR("StatesClassification is not computed yet."); throw (exStatusMismatch()); }; std::map<QuantumNumbers,BlockNumber>::const_iterator it=QuantumToBlock.find(in); if (it != QuantumToBlock.end()) return this->getFockStates(it->second); else throw (exWrongState()); }
FieldOperatorPart& FieldOperator::getPartFromLeftIndex(const QuantumNumbers& in) const { if (Status < Prepared) { ERROR("FieldOperator is not prepared yet."); throw (exStatusMismatch()); } return *parts[mapPartsFromLeft.find(S.getBlockNumber(in))->second]; }
const InnerQuantumState StatesClassification::getInnerState(FockState state) const { if ( Status < Computed ) { ERROR("StatesClassification is not computed yet."); throw (exStatusMismatch()); }; if ( state.to_ulong() > StateSize ) { throw (exWrongState()); return StateSize; }; BlockNumber block = this->getBlockNumber(state); for (InnerQuantumState n=0; n<StatesContainer[block].size(); n++ ) { if ( StatesContainer[block][n]== state) { return n; } } throw (exWrongState()); return StateSize; }
RealType HamiltonianPart::getMinimumEigenvalue() const { if ( Status < Computed ) throw (exStatusMismatch()); return Eigenvalues.minCoeff(); }
VectorType HamiltonianPart::getEigenState(InnerQuantumState state) const { if ( Status < Computed ) throw (exStatusMismatch()); return H.col(state); }
const RealVectorType& HamiltonianPart::getEigenValues() const { if ( Status < Computed ) throw (exStatusMismatch()); return Eigenvalues; }
RealType HamiltonianPart::getEigenValue(InnerQuantumState state) const // return Eigenvalues(state) { if ( Status < Computed ) throw (exStatusMismatch()); return Eigenvalues(state); }
BlockNumber StatesClassification::getBlockNumber(QuantumNumbers in) const { if ( Status < Computed ) { ERROR("StatesClassification is not computed yet."); throw (exStatusMismatch()); }; return (QuantumToBlock.count(in))?QuantumToBlock.find(in)->second:ERROR_BLOCK_NUMBER; }
FieldOperator::BlocksBimap const& FieldOperator::getBlockMapping() const { if (Status < Prepared) { ERROR("FieldOperator is not prepared yet."); throw (exStatusMismatch()); } return LeftRightBlocks; }
BlockNumber StatesClassification::getBlockNumber(QuantumState in) const { if ( Status < Computed ) { ERROR("StatesClassification is not computed yet."); throw (exStatusMismatch()); }; if ( in > StateSize ) { throw exWrongState(); }; return StateBlockIndex[in]; }
const std::vector<FockState>& StatesClassification::getFockStates( BlockNumber in ) const { if ( Status < Computed ) { ERROR("StatesClassification is not computed yet."); throw (exStatusMismatch()); }; return StatesContainer[in]; }
const InnerQuantumState StatesClassification::getInnerState(QuantumState state) const { if ( Status < Computed ) { ERROR("StatesClassification is not computed yet."); throw (exStatusMismatch()); }; if ( state > StateSize ) { throw (exWrongState()); return StateSize; }; return this->getInnerState(FockState(IndexSize, state)); }
FieldOperatorPart& FieldOperator::getPartFromRightIndex(BlockNumber in) const { if (Status < Prepared) { ERROR("FieldOperator is not prepared yet."); throw (exStatusMismatch()); } return *parts[mapPartsFromRight.find(in)->second]; }