/*!
* \brief Construct a GA Generational evolver.
* \param inEvalOp Evaluation operator.
* \param inInitSize Size of the GA bit strings.
* \deprecated Use EvolverBitString(EvaluationOp::Handle,unsigned int) constructor instead.
* \throw Beagle::RunTimeException If init size vector has more than one value.
*/
Beagle::MPI::GA::EvolverBitString::EvolverBitString(EvaluationOp::Handle inEvalOp, UIntArray inInitSize) : Beagle::MPI::Evolver(inEvalOp)
{
addOperator(inEvalOp);
if(inInitSize.size()==0) addOperator(new Beagle::GA::InitBitStrOp(0));
else if(inInitSize.size()==1) addOperator(new Beagle::GA::InitBitStrOp(inInitSize[0]));
else {
std::ostringstream lOSS;
lOSS << "Initialization of bit string individuals with more than one bit string ";
lOSS << "is no more valid. You should use individuals made of one bit string, or ";
lOSS << "define your own bit string initialization operator.";
throw Beagle_RunTimeExceptionM(lOSS.str());
}
addOperator(new Beagle::GA::CrossoverOnePointBitStrOp);
addOperator(new Beagle::GA::CrossoverTwoPointsBitStrOp);
addOperator(new Beagle::GA::CrossoverUniformBitStrOp);
addOperator(new Beagle::GA::MutationFlipBitStrOp);
addBootStrapOp("IfThenElseOp");
IfThenElseOp::Handle lITE = castHandleT<IfThenElseOp>(getBootStrapSet().back());
lITE->setConditionTag("ms.restart.file");
lITE->setConditionValue("");
lITE->insertPositiveOp("GA-InitBitStrOp", getOperatorMap());
lITE->insertPositiveOp(inEvalOp->getName(), getOperatorMap());
lITE->insertPositiveOp("StatsCalcFitnessSimpleOp", getOperatorMap());
lITE->insertNegativeOp("MilestoneReadOp", getOperatorMap());
addBootStrapOp("TermMaxGenOp");
addBootStrapOp("MilestoneWriteOp");
addMainLoopOp("SelectTournamentOp");
addMainLoopOp("GA-CrossoverOnePointBitStrOp");
addMainLoopOp("GA-MutationFlipBitStrOp");
addMainLoopOp(inEvalOp->getName());
addMainLoopOp("MigrationRandomRingOp");
addMainLoopOp("StatsCalcFitnessSimpleOp");
addMainLoopOp("TermMaxGenOp");
addMainLoopOp("MilestoneWriteOp");
}
/*!
* \brief Configure evolver with anisotropic (\mu,\lambda) self-adaptive evolution strategy algorithm.
* \param ioEvolver Evolver modified by setting the algorithm.
* \param ioSystem Evolutionary system.
*/
void SAES::Algorithm::configure(Evolver& ioEvolver, System& ioSystem)
{
Beagle_StackTraceBeginM();
// Get reference to the factory
const Factory& lFactory = ioSystem.getFactory();
// Get name and allocator of used operators
std::string lEvalOpName = lFactory.getConceptTypeName("EvaluationOp");
EvaluationOp::Alloc::Handle lEvalOpAlloc =
castHandleT<EvaluationOp::Alloc>(lFactory.getAllocator(lEvalOpName));
std::string lSelectOpName = "SelectRandomOp";
EC::SelectionOp::Alloc::Handle lSelectOpAlloc =
castHandleT<EC::SelectionOp::Alloc>(lFactory.getAllocator(lSelectOpName));
std::string lInitOpName = lFactory.getConceptTypeName("InitializationOp");
EC::InitializationOp::Alloc::Handle lInitOpAlloc =
castHandleT<EC::InitializationOp::Alloc>(lFactory.getAllocator(lInitOpName));
std::string lMutOpName = "SAES-MutationOp";
EC::MutationOp::Alloc::Handle lMutOpAlloc =
castHandleT<EC::MutationOp::Alloc>(lFactory.getAllocator(lMutOpName));
std::string lMigOpName = lFactory.getConceptTypeName("MigrationOp");
EC::MigrationOp::Alloc::Handle lMigOpAlloc =
castHandleT<EC::MigrationOp::Alloc>(lFactory.getAllocator(lMigOpName));
std::string lStatsCalcOpName = lFactory.getConceptTypeName("StatsCalculateOp");
EC::StatsCalculateOp::Alloc::Handle lStatsCalcOpAlloc =
castHandleT<EC::StatsCalculateOp::Alloc>(lFactory.getAllocator(lStatsCalcOpName));
std::string lTermOpName = lFactory.getConceptTypeName("TerminationOp");
EC::TerminationOp::Alloc::Handle lTermOpAlloc =
castHandleT<EC::TerminationOp::Alloc>(lFactory.getAllocator(lTermOpName));
std::string lMsWriteOpName = "MilestoneWriteOp";
EC::MilestoneWriteOp::Alloc::Handle lMsWriteOpAlloc =
castHandleT<EC::MilestoneWriteOp::Alloc>(lFactory.getAllocator(lMsWriteOpName));
std::string lMCLOpName = "EC-MuCommaLambdaOp";
EC::MuCommaLambdaOp::Alloc::Handle lMCLOpAlloc =
castHandleT<EC::MuCommaLambdaOp::Alloc>(lFactory.getAllocator(lMCLOpName));
// Clear bootstrap and mainloop sets
ioEvolver.getBootStrapSet().clear();
ioEvolver.getMainLoopSet().clear();
// Set the boostrap operator set
EC::InitializationOp::Handle lInitOpBS = castHandleT<EC::InitializationOp>(lInitOpAlloc->allocate());
lInitOpBS->setName(lInitOpName);
ioEvolver.getBootStrapSet().push_back(lInitOpBS);
EvaluationOp::Handle lEvalOpBS = castHandleT<EvaluationOp>(lEvalOpAlloc->allocate());
lEvalOpBS->setName(lEvalOpName);
ioEvolver.getBootStrapSet().push_back(lEvalOpBS);
EC::StatsCalculateOp::Handle lStatsCalcOpBS = castHandleT<EC::StatsCalculateOp>(lStatsCalcOpAlloc->allocate());
lStatsCalcOpBS->setName(lStatsCalcOpName);
ioEvolver.getBootStrapSet().push_back(lStatsCalcOpBS);
EC::TerminationOp::Handle lTermOpBS = castHandleT<EC::TerminationOp>(lTermOpAlloc->allocate());
lTermOpBS->setName(lTermOpName);
ioEvolver.getBootStrapSet().push_back(lTermOpBS);
EC::MilestoneWriteOp::Handle lMsWriteOpBS = castHandleT<EC::MilestoneWriteOp>(lMsWriteOpAlloc->allocate());
lMsWriteOpBS->setName(lMsWriteOpName);
ioEvolver.getBootStrapSet().push_back(lMsWriteOpBS);
// Set the mainloop operator set
EC::MuCommaLambdaOp::Handle lMCLOp = castHandleT<EC::MuCommaLambdaOp>(lMCLOpAlloc->allocate());
lMCLOp->setName(lMCLOpName);
// Set breeder tree
BreederNode::Handle lEvalNode = new BreederNode;
lMCLOp->setRootNode(lEvalNode);
lEvalNode->setBreederOp(castHandleT<EvaluationOp>(lEvalOpAlloc->allocate()));
lEvalNode->getBreederOp()->setName(lEvalOpName);
BreederNode::Handle lMutNode = new BreederNode;
lEvalNode->setFirstChild(lMutNode);
lMutNode->setBreederOp(castHandleT<EC::MutationOp>(lMutOpAlloc->allocate()));
lMutNode->getBreederOp()->setName(lMutOpName);
BreederNode::Handle lSelectMutNode = new BreederNode;
lMutNode->setFirstChild(lSelectMutNode);
lSelectMutNode->setBreederOp(castHandleT<EC::SelectionOp>(lSelectOpAlloc->allocate()));
lSelectMutNode->getBreederOp()->setName(lSelectOpName);
// Set remaining operators of mainloop
EC::MigrationOp::Handle lMigOpML = castHandleT<EC::MigrationOp>(lMigOpAlloc->allocate());
lMigOpML->setName(lMigOpName);
ioEvolver.getMainLoopSet().push_back(lMigOpML);
EC::StatsCalculateOp::Handle lStatsCalcOpML =
castHandleT<EC::StatsCalculateOp>(lStatsCalcOpAlloc->allocate());
lStatsCalcOpML->setName(lStatsCalcOpName);
ioEvolver.getMainLoopSet().push_back(lStatsCalcOpML);
EC::TerminationOp::Handle lTermOpML = castHandleT<EC::TerminationOp>(lTermOpAlloc->allocate());
lTermOpML->setName(lTermOpName);
ioEvolver.getMainLoopSet().push_back(lTermOpML);
EC::MilestoneWriteOp::Handle lMsWriteOpML =
castHandleT<EC::MilestoneWriteOp>(lMsWriteOpAlloc->allocate());
lMsWriteOpML->setName(lMsWriteOpName);
ioEvolver.getMainLoopSet().push_back(lMsWriteOpML);
Beagle_StackTraceEndM();
}
/*!
* \brief Configure master-slave cruncher evolutionary algorithm in evolver.
* \param ioEvolver Evolver modified by setting the algorithm.
* \param ioSystem Evolutionary system.
*
*/
void Distrib::Master::AlgoSequential::configure(Evolver& ioEvolver, System& ioSystem)
{
Beagle_StackTraceBeginM();
// Get reference to the factory
const Factory& lFactory = ioSystem.getFactory();
// Get name and allocator of used operators
std::string lEvalOpName = "DBMS-DistribEvalOp";
Distrib::Master::DistribEvalOp::Alloc::Handle lEvalOpAlloc =
castHandleT<Distrib::Master::DistribEvalOp::Alloc>(lFactory.getAllocator(lEvalOpName));
std::string lSelectOpName = lFactory.getConceptTypeName("SelectionOp");
SelectionOp::Alloc::Handle lSelectOpAlloc =
castHandleT<SelectionOp::Alloc>(lFactory.getAllocator(lSelectOpName));
std::string lInitOpName = lFactory.getConceptTypeName("InitializationOp");
InitializationOp::Alloc::Handle lInitOpAlloc =
castHandleT<InitializationOp::Alloc>(lFactory.getAllocator(lInitOpName));
std::string lCxOpName = lFactory.getConceptTypeName("CrossoverOp");
CrossoverOp::Alloc::Handle lCxOpAlloc =
castHandleT<CrossoverOp::Alloc>(lFactory.getAllocator(lCxOpName));
std::string lMutOpName = lFactory.getConceptTypeName("MutationOp");
MutationOp::Alloc::Handle lMutOpAlloc =
castHandleT<MutationOp::Alloc>(lFactory.getAllocator(lMutOpName));
std::string lMigOpName = lFactory.getConceptTypeName("MigrationOp");
MigrationOp::Alloc::Handle lMigOpAlloc =
castHandleT<MigrationOp::Alloc>(lFactory.getAllocator(lMigOpName));
std::string lStatsCalcOpName = lFactory.getConceptTypeName("StatsCalculateOp");
StatsCalculateOp::Alloc::Handle lStatsCalcOpAlloc =
castHandleT<StatsCalculateOp::Alloc>(lFactory.getAllocator(lStatsCalcOpName));
std::string lTermOpName = lFactory.getConceptTypeName("TerminationOp");
TerminationOp::Alloc::Handle lTermOpAlloc =
castHandleT<TerminationOp::Alloc>(lFactory.getAllocator(lTermOpName));
std::string lITEOpName = "IfThenElseOp";
IfThenElseOp::Alloc::Handle lITEOpAlloc =
castHandleT<IfThenElseOp::Alloc>(lFactory.getAllocator(lITEOpName));
std::string lMsWriteOpName = "DBMS-MilestoneWriteOp";
Distrib::Master::MilestoneWriteOp::Alloc::Handle lMsWriteOpAlloc =
castHandleT<MilestoneWriteOp::Alloc>(lFactory.getAllocator(lMsWriteOpName));
std::string lBSBeginOpName = "DBMS-BootStrapBeginOp";
BootStrapBeginOp::Alloc::Handle lBSBeginOpAlloc =
castHandleT<BootStrapBeginOp::Alloc>(lFactory.getAllocator(lBSBeginOpName));
std::string lBSEndOpName = "DBMS-BootStrapEndOp";
BootStrapEndOp::Alloc::Handle lBSEndOpAlloc =
castHandleT<BootStrapEndOp::Alloc>(lFactory.getAllocator(lBSEndOpName));
std::string lMLBeginOpName = "DBMS-MainLoopBeginOp";
MainLoopBeginOp::Alloc::Handle lMLBeginOpAlloc =
castHandleT<MainLoopBeginOp::Alloc>(lFactory.getAllocator(lMLBeginOpName));
std::string lMLEndOpName = "DBMS-MainLoopEndOp";
MainLoopEndOp::Alloc::Handle lMLEndOpAlloc =
castHandleT<MainLoopEndOp::Alloc>(lFactory.getAllocator(lMLEndOpName));
// Clear bootstrap and mainloop sets
ioEvolver.getBootStrapSet().clear();
ioEvolver.getMainLoopSet().clear();
// Set the boostrap operator set
BootStrapBeginOp::Handle lBSBeginOpBS = castHandleT<BootStrapBeginOp>(lBSBeginOpAlloc->allocate());
lBSBeginOpBS->setName(lBSBeginOpName);
ioEvolver.getBootStrapSet().push_back(lBSBeginOpBS);
IfThenElseOp::Handle lITEOp = castHandleT<IfThenElseOp>(lITEOpAlloc->allocate());
lITEOp->setName(lITEOpName);
ioEvolver.getBootStrapSet().push_back(lITEOp);
lITEOp->setConditionTag("db.restart");
lITEOp->setConditionValue("1");
InitializationOp::Handle lInitOpBS = castHandleT<InitializationOp>(lInitOpAlloc->allocate());
lInitOpBS->setName(lInitOpName);
lITEOp->insertNegativeOp(lInitOpBS);
EvaluationOp::Handle lEvalOpBS = castHandleT<EvaluationOp>(lEvalOpAlloc->allocate());
lEvalOpBS->setName(lEvalOpName);
lITEOp->insertNegativeOp(lEvalOpBS);
MigrationOp::Handle lMigOpBS = castHandleT<MigrationOp>(lMigOpAlloc->allocate());
lMigOpBS->setName(lMigOpName);
lITEOp->insertNegativeOp(lMigOpBS);
StatsCalculateOp::Handle lStatsCalcOpBS =
castHandleT<StatsCalculateOp>(lStatsCalcOpAlloc->allocate());
lStatsCalcOpBS->setName(lStatsCalcOpName);
lITEOp->insertNegativeOp(lStatsCalcOpBS);
TerminationOp::Handle lTermOpBS = castHandleT<TerminationOp>(lTermOpAlloc->allocate());
lTermOpBS->setName(lTermOpName);
lITEOp->insertNegativeOp(lTermOpBS);
MilestoneWriteOp::Handle lMsWriteOpBS = castHandleT<MilestoneWriteOp>(lMsWriteOpAlloc->allocate());
lMsWriteOpBS->setName(lMsWriteOpName);
lITEOp->insertNegativeOp(lMsWriteOpBS);
BootStrapEndOp::Handle lBSEndOpBS = castHandleT<BootStrapEndOp>(lBSEndOpAlloc->allocate());
lBSEndOpBS->setName(lBSEndOpName);
ioEvolver.getBootStrapSet().push_back(lBSEndOpBS);
// Set the mainloop operator set
MainLoopBeginOp::Handle lMLBeginOpML = castHandleT<MainLoopBeginOp>(lMLBeginOpAlloc->allocate());
lMLBeginOpML->setName(lMLBeginOpName);
ioEvolver.getMainLoopSet().push_back(lMLBeginOpML);
SelectionOp::Handle lSelectOpML = castHandleT<SelectionOp>(lSelectOpAlloc->allocate());
lSelectOpML->setName(lSelectOpName);
ioEvolver.getMainLoopSet().push_back(lSelectOpML);
CrossoverOp::Handle lCxOpML = castHandleT<CrossoverOp>(lCxOpAlloc->allocate());
lCxOpML->setName(lCxOpName);
ioEvolver.getMainLoopSet().push_back(lCxOpML);
MutationOp::Handle lMutOpML = castHandleT<MutationOp>(lMutOpAlloc->allocate());
lMutOpML->setName(lMutOpName);
ioEvolver.getMainLoopSet().push_back(lMutOpML);
EvaluationOp::Handle lEvalOpML = castHandleT<EvaluationOp>(lEvalOpAlloc->allocate());
lEvalOpML->setName(lEvalOpName);
ioEvolver.getMainLoopSet().push_back(lEvalOpML);
MigrationOp::Handle lMigOpML = castHandleT<MigrationOp>(lMigOpAlloc->allocate());
lMigOpML->setName(lMigOpName);
ioEvolver.getMainLoopSet().push_back(lMigOpML);
StatsCalculateOp::Handle lStatsCalcOpML =
castHandleT<StatsCalculateOp>(lStatsCalcOpAlloc->allocate());
lStatsCalcOpML->setName(lStatsCalcOpName);
ioEvolver.getMainLoopSet().push_back(lStatsCalcOpML);
TerminationOp::Handle lTermOpML = castHandleT<TerminationOp>(lTermOpAlloc->allocate());
lTermOpML->setName(lTermOpName);
ioEvolver.getMainLoopSet().push_back(lTermOpML);
MilestoneWriteOp::Handle lMsWriteOpML = castHandleT<MilestoneWriteOp>(lMsWriteOpAlloc->allocate());
lMsWriteOpML->setName(lMsWriteOpName);
ioEvolver.getMainLoopSet().push_back(lMsWriteOpML);
MainLoopEndOp::Handle lMLEndOpML = castHandleT<MainLoopEndOp>(lMLEndOpAlloc->allocate());
lMLEndOpML->setName(lMLEndOpName);
ioEvolver.getMainLoopSet().push_back(lMLEndOpML);
Beagle_StackTraceEndM();
}
/*!
* \brief Configure steady-state evolutionary algorithm in evolver.
* \param ioEvolver Evolver modified by setting the algorithm.
* \param ioSystem Evolutionary system.
*
*/
void AlgoSteadyState::configure(Evolver& ioEvolver, System& ioSystem)
{
Beagle_StackTraceBeginM();
// Get reference to the factory
const Factory& lFactory = ioSystem.getFactory();
// Get name and allocator of used operators
std::string lEvalOpName = lFactory.getConceptTypeName("EvaluationOp");
EvaluationOp::Alloc::Handle lEvalOpAlloc =
castHandleT<EvaluationOp::Alloc>(lFactory.getAllocator(lEvalOpName));
std::string lSelectOpName = lFactory.getConceptTypeName("SelectionOp");
SelectionOp::Alloc::Handle lSelectOpAlloc =
castHandleT<SelectionOp::Alloc>(lFactory.getAllocator(lSelectOpName));
std::string lInitOpName = lFactory.getConceptTypeName("InitializationOp");
InitializationOp::Alloc::Handle lInitOpAlloc =
castHandleT<InitializationOp::Alloc>(lFactory.getAllocator(lInitOpName));
std::string lCxOpName = lFactory.getConceptTypeName("CrossoverOp");
CrossoverOp::Alloc::Handle lCxOpAlloc =
castHandleT<CrossoverOp::Alloc>(lFactory.getAllocator(lCxOpName));
std::string lMutOpName = lFactory.getConceptTypeName("MutationOp");
MutationOp::Alloc::Handle lMutOpAlloc =
castHandleT<MutationOp::Alloc>(lFactory.getAllocator(lMutOpName));
std::string lMigOpName = lFactory.getConceptTypeName("MigrationOp");
MigrationOp::Alloc::Handle lMigOpAlloc =
castHandleT<MigrationOp::Alloc>(lFactory.getAllocator(lMigOpName));
std::string lStatsCalcOpName = lFactory.getConceptTypeName("StatsCalculateOp");
StatsCalculateOp::Alloc::Handle lStatsCalcOpAlloc =
castHandleT<StatsCalculateOp::Alloc>(lFactory.getAllocator(lStatsCalcOpName));
std::string lTermOpName = lFactory.getConceptTypeName("TerminationOp");
TerminationOp::Alloc::Handle lTermOpAlloc =
castHandleT<TerminationOp::Alloc>(lFactory.getAllocator(lTermOpName));
std::string lMsWriteOpName = "MilestoneWriteOp";
MilestoneWriteOp::Alloc::Handle lMsWriteOpAlloc =
castHandleT<MilestoneWriteOp::Alloc>(lFactory.getAllocator(lMsWriteOpName));
std::string lSSOpName = "SteadyStateOp";
SteadyStateOp::Alloc::Handle lSSOpAlloc =
castHandleT<SteadyStateOp::Alloc>(lFactory.getAllocator(lSSOpName));
// Clear bootstrap and mainloop sets
ioEvolver.getBootStrapSet().clear();
ioEvolver.getMainLoopSet().clear();
// Set the boostrap operator set
InitializationOp::Handle lInitOpBS = castHandleT<InitializationOp>(lInitOpAlloc->allocate());
lInitOpBS->setName(lInitOpName);
ioEvolver.getBootStrapSet().push_back(lInitOpBS);
EvaluationOp::Handle lEvalOpBS = castHandleT<EvaluationOp>(lEvalOpAlloc->allocate());
lEvalOpBS->setName(lEvalOpName);
ioEvolver.getBootStrapSet().push_back(lEvalOpBS);
StatsCalculateOp::Handle lStatsCalcOpBS = castHandleT<StatsCalculateOp>(lStatsCalcOpAlloc->allocate());
lStatsCalcOpBS->setName(lStatsCalcOpName);
ioEvolver.getBootStrapSet().push_back(lStatsCalcOpBS);
TerminationOp::Handle lTermOpBS = castHandleT<TerminationOp>(lTermOpAlloc->allocate());
lTermOpBS->setName(lTermOpName);
ioEvolver.getBootStrapSet().push_back(lTermOpBS);
MilestoneWriteOp::Handle lMsWriteOpBS = castHandleT<MilestoneWriteOp>(lMsWriteOpAlloc->allocate());
lMsWriteOpBS->setName(lMsWriteOpName);
ioEvolver.getBootStrapSet().push_back(lMsWriteOpBS);
// Set the mainloop operator set
SteadyStateOp::Handle lSSOp = castHandleT<SteadyStateOp>(lSSOpAlloc->allocate());
lSSOp->setName(lSSOpName);
// Set crossover branch
BreederNode::Handle lCxBranchNode = new BreederNode;
lSSOp->setRootNode(lCxBranchNode);
lCxBranchNode->setBreederOp(castHandleT<EvaluationOp>(lEvalOpAlloc->allocate()));
lCxBranchNode->getBreederOp()->setName(lEvalOpName);
BreederNode::Handle lCxNode = new BreederNode;
lCxBranchNode->setFirstChild(lCxNode);
lCxNode->setBreederOp(castHandleT<CrossoverOp>(lCxOpAlloc->allocate()));
lCxNode->getBreederOp()->setName(lCxOpName);
BreederNode::Handle lSelectCxNode1 = new BreederNode;
lCxNode->setFirstChild(lSelectCxNode1);
lSelectCxNode1->setBreederOp(castHandleT<SelectionOp>(lSelectOpAlloc->allocate()));
lSelectCxNode1->getBreederOp()->setName(lSelectOpName);
BreederNode::Handle lSelectCxNode2 = new BreederNode;
lSelectCxNode1->setNextSibling(lSelectCxNode2);
lSelectCxNode2->setBreederOp(castHandleT<SelectionOp>(lSelectOpAlloc->allocate()));
lSelectCxNode2->getBreederOp()->setName(lSelectOpName);
// Set mutation branch
BreederNode::Handle lMutBranchNode = new BreederNode;
lCxBranchNode->setNextSibling(lMutBranchNode);
lMutBranchNode->setBreederOp(castHandleT<EvaluationOp>(lEvalOpAlloc->allocate()));
lMutBranchNode->getBreederOp()->setName(lEvalOpName);
BreederNode::Handle lMutNode = new BreederNode;
lMutBranchNode->setFirstChild(lMutNode);
lMutNode->setBreederOp(castHandleT<MutationOp>(lMutOpAlloc->allocate()));
lMutNode->getBreederOp()->setName(lMutOpName);
BreederNode::Handle lSelectMutNode = new BreederNode;
lMutNode->setFirstChild(lSelectMutNode);
lSelectMutNode->setBreederOp(castHandleT<SelectionOp>(lSelectOpAlloc->allocate()));
lSelectMutNode->getBreederOp()->setName(lSelectOpName);
// Set reproduction branch
BreederNode::Handle lReproBranchNode = new BreederNode;
lMutBranchNode->setNextSibling(lReproBranchNode);
lReproBranchNode->setBreederOp(castHandleT<SelectionOp>(lSelectOpAlloc->allocate()));
lReproBranchNode->getBreederOp()->setName(lSelectOpName);
// Set remaining operators of mainloop
MigrationOp::Handle lMigOpML = castHandleT<MigrationOp>(lMigOpAlloc->allocate());
lMigOpML->setName(lMigOpName);
ioEvolver.getMainLoopSet().push_back(lMigOpML);
StatsCalculateOp::Handle lStatsCalcOpML =
castHandleT<StatsCalculateOp>(lStatsCalcOpAlloc->allocate());
lStatsCalcOpML->setName(lStatsCalcOpName);
ioEvolver.getMainLoopSet().push_back(lStatsCalcOpML);
TerminationOp::Handle lTermOpML = castHandleT<TerminationOp>(lTermOpAlloc->allocate());
lTermOpML->setName(lTermOpName);
ioEvolver.getMainLoopSet().push_back(lTermOpML);
MilestoneWriteOp::Handle lMsWriteOpML =
castHandleT<MilestoneWriteOp>(lMsWriteOpAlloc->allocate());
lMsWriteOpML->setName(lMsWriteOpName);
ioEvolver.getMainLoopSet().push_back(lMsWriteOpML);
Beagle_StackTraceEndM("void AlgoSteadyState::configure(Evolver&,System&)");
}