/*! * \brief Return a pointer to a vector of newly created individuals. */ Individual::Bag::Handle SCHNAPS::Simulation::PopulationManager::getIndividuals() { schnaps_StackTraceBeginM(); schnaps_NonNullPointerAssertM(mGenerator); unsigned long lCurrentTime = mGenerator->getClock().getValue(); std::pair<PopulationManager::const_iterator, PopulationManager::const_iterator> lSources = this->equal_range(lCurrentTime); // if nothing to generate at current time if (lSources.first == lSources.second) { return NULL; } unsigned int lStartingIndex = mGenerator->getEnvironment().getPopulation().size(); std::stringstream lPrefix; int lSubPopNumber = 0; Individual::Bag::Handle lIndividuals = new Individual::Bag(); Individual::Bag::Handle lSubPop; for (PopulationManager::const_iterator lIt = lSources.first; lIt != lSources.second; lIt++) { // assign new prefix to sub-population lPrefix.str(""); lPrefix << "I_" << lCurrentTime << "_" << lSubPopNumber++; mPrefixes[lPrefix.str()] = lIt->second; // generate sub-population lSubPop = mGenerator->generate(lIt->second.mProfile, lIt->second.mSize, lPrefix.str(), lStartingIndex); lStartingIndex += lSubPop->size(); // add new individuals to time step population lIndividuals->insert(lIndividuals->end(), lSubPop->begin(), lSubPop->end()); } if(mGenerator->getSystem().getParameters().hasParameter(CONTACTS_FLAG) || mGenerator->getSystem().getParameters().hasParameter(NBCONTACTS_VARIABLE)) mGenerator->generateContacts(lIndividuals); return lIndividuals; schnaps_StackTraceEndM("SCHNAPS::Simulation::Individual::Bag::Handle SCHNAPS::Simulation::PopulationManager::getIndividuals()"); }
/*! * \brief Apply the recombination operation on a breeding pool, returning a recombined individual. * \param inBreedingPool Breeding pool to use for the recombination operation. * \param inChild Node handle associated to child node in the breeder tree. * \param ioContext Evolutionary context of the recombination operation. * \return Recombined individual. */ Individual::Handle RecombinationOp::breed(Individual::Bag& inBreedingPool, BreederNode::Handle inChild, Context& ioContext) { Beagle_StackTraceBeginM(); // Generate parents for recombination. Individual::Bag::Handle lParents = new Individual::Bag; if(inChild == NULL) { const unsigned int lNbGenerated = (mNumberRecomb->getWrappedValue()==0) ? inBreedingPool.size() : minOf<unsigned int>(inBreedingPool.size(), mNumberRecomb->getWrappedValue()); if(lNbGenerated == inBreedingPool.size()) (*lParents) = inBreedingPool; else { std::vector<unsigned int> lIndices(inBreedingPool.size()); for(unsigned int i=0; i<lIndices.size(); ++i) lIndices[i] = i; std::random_shuffle(lIndices.begin(), lIndices.end(), ioContext.getSystem().getRandomizer()); for(unsigned int i=0; i<lNbGenerated; ++i) { lParents->push_back(inBreedingPool[lIndices[i]]); } } } else { Beagle_NonNullPointerAssertM(inChild->getBreederOp()); const unsigned int lNbGenerated = (mNumberRecomb->getWrappedValue()==0) ? inBreedingPool.size() : minOf<unsigned int>(inBreedingPool.size(), mNumberRecomb->getWrappedValue()); for(unsigned int i=0; i<lNbGenerated; ++i) { Individual::Handle lIndiv = inChild->getBreederOp()->breed(inBreedingPool, inChild->getFirstChild(), ioContext); lParents->push_back(lIndiv); } } // Log parents selected for recombination. Beagle_LogVerboseM( ioContext.getSystem().getLogger(), std::string("Recombining ")+uint2str(lParents->size())+std::string(" individuals together") ); // Do recombination operation on parent and get the resulting child. Individual::Handle lChildIndiv = recombine(*lParents, ioContext); if(lChildIndiv->getFitness() != NULL) { lChildIndiv->getFitness()->setInvalid(); } // Log information to history, if it is used. History::Handle lHistory = castHandleT<History>(ioContext.getSystem().haveComponent("History")); if(lHistory != NULL) { std::vector<HistoryID> lParentNames; for(unsigned int i=0; i<lParents->size(); ++i) { HistoryID::Handle lHID = castHandleT<HistoryID>(lParents->at(i)->getMember("HistoryID")); if(lHID != NULL) lParentNames.push_back(*lHID); } lHistory->incrementHistoryVar(*lChildIndiv); lHistory->trace(ioContext, lParentNames, lChildIndiv, getName(), "recombination"); } return lChildIndiv; Beagle_StackTraceEndM(); }
/*! * \brief Apply the recombination operation on the deme. * \param ioDeme Current deme of individuals to recombine. * \param ioContext Context of the evolution. */ void RecombinationOp::operate(Deme& ioDeme, Context& ioContext) { Beagle_StackTraceBeginM(); Beagle_ValidateParameterM(mRecombProba->getWrappedValue()>=0.0, mRecombProbaName, "<0"); Beagle_LogTraceM( ioContext.getSystem().getLogger(), std::string("Recombining individuals of the ")+ uint2ordinal(ioContext.getDemeIndex()+1)+" deme" ); Beagle_LogVerboseM( ioContext.getSystem().getLogger(), std::string("Recombining individuals with probability ")+ dbl2str(mRecombProba->getWrappedValue()) ); History::Handle lHistory = castHandleT<History>(ioContext.getSystem().haveComponent("History")); Individual::Bag lRecombinedIndiv(ioDeme.size()); for(unsigned int i=0; i<lRecombinedIndiv.size(); ++i) { if(ioContext.getSystem().getRandomizer().rollUniform() <= mRecombProba->getWrappedValue()) { Individual::Bag::Handle lParents = new Individual::Bag; const unsigned int lNbGenerated = (mNumberRecomb->getWrappedValue()==0) ? ioDeme.size() : minOf<unsigned int>(ioDeme.size(), mNumberRecomb->getWrappedValue()); if(lNbGenerated == ioDeme.size()) (*lParents) = ioDeme; else { std::vector<unsigned int> lIndices(ioDeme.size()); for(unsigned int j=0; j<lIndices.size(); ++j) lIndices[j] = j; std::random_shuffle(lIndices.begin(), lIndices.end(), ioContext.getSystem().getRandomizer()); for(unsigned int j=0; j<lNbGenerated; ++j) { lParents->push_back(ioDeme[lIndices[j]]); } } lRecombinedIndiv[i] = recombine(*lParents, ioContext); if(lRecombinedIndiv[i]->getFitness() != NULL) { lRecombinedIndiv[i]->getFitness()->setInvalid(); } // Log and update history. Beagle_LogVerboseM( ioContext.getSystem().getLogger(), std::string("The ")+uint2ordinal(i+1)+ std::string(" individual as been replaced by recombination") ); if(lHistory != NULL) { std::vector<HistoryID> lParentNames; for(unsigned int j=0; j<lParents->size(); ++j) { HistoryID::Handle lHID = castHandleT<HistoryID>(lParents->at(j)->getMember("HistoryID")); if(lHID != NULL) lParentNames.push_back(*lHID); } lHistory->incrementHistoryVar(*lRecombinedIndiv[i]); lHistory->trace(ioContext, lParentNames, lRecombinedIndiv[i], getName(), "recombination"); } } } for(unsigned int i=0; i<ioDeme.size(); ++i) { if(lRecombinedIndiv[i] != NULL) ioDeme[i] = lRecombinedIndiv[i]; } Beagle_StackTraceEndM(); }