/*!
* \brief Receive the fitness of an individuals group from evaluator node.
* \param ioDeme Deme to update by the receive fitness.
* \param ioContext Current context of the evolution.
*/
void HPC::RecvFitnessFromEvaluatorOp::operate(Deme& ioDeme, Context& ioContext)
{
Beagle_StackTraceBeginM();
ProcessingBuffer::Handle lBuffer = castHandleT<ProcessingBuffer>(ioDeme.getMember("ProcessingBuffer"));
Beagle_NonNullPointerAssertM(lBuffer);
Individual::Handle lOldIndividualHandle = ioContext.getIndividualHandle();
unsigned int lOldIndividualIndex = ioContext.getIndividualIndex();
prepareStats(ioDeme,ioContext);
unsigned int lNbEvaluators = mComm->getNbrOfRelation("Child");
unsigned int lNbIndividualInt = lBuffer->size() / lNbEvaluators;
unsigned int lNbIndividualFrac = lBuffer->size() % lNbEvaluators;
unsigned int lNbIndividualTotal = 0;
for(int i = 0; i < lNbEvaluators; ++i ){
int lNbIndividual = lNbIndividualInt;
if(i < lNbIndividualFrac)
++lNbIndividual;
std::string lFitnessString;
mComm->receive(lFitnessString, "Fitness", "Child", i);
Beagle_LogDetailedM(
ioContext.getSystem().getLogger(),
"receive", "Beagle::HPC::RecvFitnessFromEvaluatorOp",
std::string("Evolver receive fitness from his ")+uint2ordinal(i+1)+
std::string(" evaluator") + std::string(" of ") + uint2str(lNbEvaluators)
);
std::istringstream lInStream(lFitnessString);
PACC::XML::Document lDocument(lInStream);
const Factory& lFactory = ioContext.getSystem().getFactory();
Fitness::Alloc::Handle lFitnessAlloc =
castHandleT<Fitness::Alloc>(lFactory.getConceptAllocator("Fitness"));
for(PACC::XML::ConstIterator lIter = lDocument.getFirstRoot()->getFirstChild(); lIter; ++lIter){
ioContext.setIndividualIndex(lNbIndividualTotal);
ioContext.setIndividualHandle(ioDeme[lNbIndividualTotal]);
if((*lBuffer)[lNbIndividualTotal]->getFitness() == 0)
(*lBuffer)[lNbIndividualTotal]->setFitness( castHandleT<Fitness>(lFitnessAlloc->allocate()) );
(*lBuffer)[lNbIndividualTotal]->getFitness()->read(lIter);
++lNbIndividualTotal;
updateStats(1,ioContext);
}
}
Beagle_LogDetailedM(
ioContext.getSystem().getLogger(),
"receive", "Beagle::HPC::RecvFitnessFromEvaluatorOp",
std::string("Evolver receive all its fitness.")
);
ioContext.setIndividualIndex(lOldIndividualIndex);
ioContext.setIndividualHandle(lOldIndividualHandle);
Beagle_StackTraceEndM("void RecvFitnessFromEvaluatorOp::operate(Deme& ioDeme, Context& ioContext)");
}
/*!
* \brief Copy individual using the system.
* \param inOriginal Individual to copy into current.
* \param ioSystem Evolutionary system.
*/
void Individual::copy(const Individual& inOriginal, System& ioSystem)
{
Beagle_StackTraceBeginM();
const Factory& lFactory = ioSystem.getFactory();
// Copy members
mMemberMap.clear();
for(MemberMap::const_iterator lIterMap=inOriginal.mMemberMap.begin();
lIterMap!=inOriginal.mMemberMap.end(); ++lIterMap) {
Member::Handle lOrigMember = castHandleT<Member>(lIterMap->second);
const std::string& lMemberType = lOrigMember->getType();
Member::Alloc::Handle lMemberAlloc =
castHandleT<Member::Alloc>(lFactory.getAllocator(lMemberType));
Member::Handle lMember = castHandleT<Member>(lMemberAlloc->allocate());
lMember->copy(*lOrigMember, ioSystem);
mMemberMap[lIterMap->first] = lMember;
}
// Copy fitness
if(inOriginal.getFitness() == NULL) {
mFitness = NULL;
} else {
const std::string& lFitnessType = inOriginal.getFitness()->getType();
Fitness::Alloc::Handle lFitnessAlloc =
castHandleT<Fitness::Alloc>(lFactory.getAllocator(lFitnessType));
mFitness = castHandleT<Fitness>(lFitnessAlloc->allocate());
mFitness->copy(*inOriginal.getFitness(), ioSystem);
}
// Copy genotypes
resize(inOriginal.size());
for(unsigned int i=0; i<inOriginal.size(); ++i) {
const std::string& lGenotypeType = inOriginal[i]->getType();
Genotype::Alloc::Handle lGenotypeAlloc =
castHandleT<Genotype::Alloc>(lFactory.getAllocator(lGenotypeType));
(*this)[i] = castHandleT<Genotype>(lGenotypeAlloc->allocate());
(*this)[i]->copy(*inOriginal[i], ioSystem);
}
Beagle_StackTraceEndM();
}
/*!
* \brief Read fitness of an individual from an XML node.
* \param inIter XML iterator to read the individual's fitness from.
* \param ioContext Evolutionary context.
* \throw Beagle::IOException If the format is not respected.
*/
void Individual::readFitness(PACC::XML::ConstIterator inIter, Context& ioContext)
{
Beagle_StackTraceBeginM();
const Factory& lFactory = ioContext.getSystem().getFactory();
for(PACC::XML::ConstIterator lIter=inIter; lIter; ++lIter) {
if((lIter->getType() != PACC::XML::eData) || (lIter->getValue() != "Fitness")) continue;
const std::string& lFitnessType = lIter->getAttribute("type");
Fitness::Alloc::Handle lFitnessAlloc = NULL;
if(lFitnessType.empty()) {
const std::string& lFitnessValid = lIter->getAttribute("valid");
if(lFitnessValid == "no") {
mFitness = NULL;
break;
}
lFitnessAlloc = castHandleT<Fitness::Alloc>(lFactory.getConceptAllocator("Fitness"));
if(lFitnessAlloc == NULL) {
std::ostringstream lOSS;
lOSS << "Fitness object can't be read, ";
lOSS << "it appears that its type is not given and that there is not ";
lOSS << "valid concept allocator associated to it!";
throw Beagle_IOExceptionNodeM(*lIter, lOSS.str());
}
} else {
lFitnessAlloc = castHandleT<Fitness::Alloc>(lFactory.getAllocator(lFitnessType));
if(lFitnessAlloc == NULL) {
std::ostringstream lOSS;
lOSS << "Type '" << lFitnessType << "' associated to fitness object ";
lOSS << "is not valid!";
throw Beagle_IOExceptionNodeM(*lIter, lOSS.str());
}
}
mFitness = castHandleT<Fitness>(lFitnessAlloc->allocate());
mFitness->readWithContext(lIter, ioContext);
break;
}
Beagle_StackTraceEndM();
}