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];
}
