D:/Radagast_D/Projekt/ECF_trunk/ECF/State.cpp

#include "ECF.h"
#include <fstream>
#include <iomanip>
#include <time.h>


State::State()
{
    this->population_ = static_cast<PopulationP> (new Population);
    this->crossover_ = static_cast<CrossoverP> (new Crossover);
    this->mutation_ = static_cast<MutationP> (new Mutation);

    XMLNode::setGlobalOptions(XMLNode::char_encoding_legacy);   // XML encoding

    bInitialized_ = false;
    bAlgorithmSet_ = false;
    bGenotypeSet_ = false;
    bEvaluatorSet_ = false;
    bLoadMilestone_ = false;
    bBatchMode_ = false;
    bBatchStart_ = false;
    bBatchSingleMilestone_ = false;
    bBatchWriteStats_ = false;

    // register existing components:
    // algorithms
    AlgorithmP alg = static_cast<AlgorithmP> (new SteadyStateTournament);
    this->mAlgorithms_[alg->getName()] = alg;
    alg = static_cast<AlgorithmP> (new RouletteWheel);
    this->mAlgorithms_[alg->getName()] = alg;
    alg = static_cast<AlgorithmP> (new ParticleSwarmOptimization);
    this->mAlgorithms_[alg->getName()] = alg;
    alg = static_cast<AlgorithmP> (new Elimination);
    this->mAlgorithms_[alg->getName()] = alg;

#ifdef _MPI
    // paralel algorithms
    alg = static_cast<AlgorithmP> (new AlgSGenGpea);
    this->mAlgorithms_[alg->getName()] = alg;
    alg = static_cast<AlgorithmP> (new AlgAEliGpea);
    this->mAlgorithms_[alg->getName()] = alg;
    alg = static_cast<AlgorithmP> (new AlgAEliGpea2);
    this->mAlgorithms_[alg->getName()] = alg;
#endif

    // genotypes
    GenotypeP gen = static_cast<GenotypeP> (new BitString::BitString);
    this->mGenotypes_[gen->getName()] = gen;
    gen = static_cast<GenotypeP> (new Binary::Binary);
    this->mGenotypes_[gen->getName()] = gen;
    gen = static_cast<GenotypeP> (new Tree::Tree);
    this->mGenotypes_[gen->getName()] = gen;
    gen = static_cast<GenotypeP> (new Permutation::Permutation);
    this->mGenotypes_[gen->getName()] = gen;
    gen = static_cast<GenotypeP> (new FloatingPoint::FloatingPoint);
    this->mGenotypes_[gen->getName()] = gen;

    // termination operators
    OperatorP op = static_cast<OperatorP> (new TermStagnationOp);
    this->allTerminationOps_.push_back(op);
    op = static_cast<OperatorP> (new TermMaxGenOp);
    this->allTerminationOps_.push_back(op);
    op = static_cast<OperatorP> (new TermFitnessValOp);
    this->allTerminationOps_.push_back(op);
    op = static_cast<OperatorP> (new TermMaxTimeOp);
    this->allTerminationOps_.push_back(op);

    setRandomizer(static_cast<RandomizerP> (new SimpleRandomizer));
    this->registry_ = static_cast<RegistryP> (new Registry);
    this->logger_ = static_cast<LoggerP> (new Logger);
    this->statistic_ = static_cast<StatCalcP> (new StatCalc);
    this->comm_ = static_cast<CommunicatorP> (new Comm::Communicator);
    this->migration_ = static_cast<MigrationP> (new Migration);
}


void State::registerParameters()
{
    // State parameters
    registry_->registerEntry("milestone.interval", (voidP) (new uint(0)), ECF::UINT);
    registry_->registerEntry("milestone.filename", (voidP) (new std::string("milestone.txt")), ECF::STRING);
    registry_->registerEntry("batch.repeats", (voidP) (new uint(0)), ECF::UINT);
    registry_->registerEntry("batch.singlemilestone", (voidP) (new uint(0)), ECF::UINT);
    registry_->registerEntry("batch.statsfile", (voidP) (new std::string("")), ECF::STRING);

    // milestone data
    registry_->registerEntry("milestone.generation_", (voidP) (new uint(0)), ECF::UINT);
    registry_->registerEntry("milestone.elapsedtime_", (voidP) (new uint(0)), ECF::UINT);
    registry_->registerEntry("batch.remaining_", (voidP) (new uint(0)), ECF::UINT);
    registry_->registerEntry("batch.logfile_", (voidP) (new std::string("")), ECF::STRING);

    // call registerParameters() methods:
    alg_iter itAlg;
    for(itAlg = mAlgorithms_.begin(); itAlg != mAlgorithms_.end(); itAlg++)
        itAlg->second->registerParameters(state_);

    // register common implicit parallel parameters (Algorithm base class)
    mAlgorithms_.begin()->second->registerParallelParameters(state_);

    for(uint i = 0; i < allTerminationOps_.size(); i++)
        allTerminationOps_[i]->registerParameters(state_);

    // user-defined operators
    for(uint i = 0; i < allUserOps_.size(); i++)
        allUserOps_[i]->registerParameters(state_);

    mutation_->registerParameters(state_);
    crossover_->registerParameters(state_);
    randomizer_->registerParameters(state_);
    population_->registerParameters(state_);
    logger_->registerParameters(state_);
    migration_->registerParameters(state_);
    evalOp_->registerParameters(state_);
}


void State::readParameters()
{
    // milestone saving data
    if(registry_->isModified("milestone.filename"))
        bSaveMilestone_ = true;
    else
        bSaveMilestone_ = false;

    voidP sptr = registry_->getEntry("milestone.interval");
    milestoneInterval_ = *((uint*) sptr.get());

    sptr = registry_->getEntry("milestone.filename");
    milestoneFilename_ = *((std::string*) sptr.get());

    // milestone loading data
    if(registry_->isModified("milestone.generation_"))
        bLoadMilestone_ = true;
    else
        bLoadMilestone_ = false;

    sptr = registry_->getEntry("milestone.generation_");
    milestoneGeneration_ = *((uint*) sptr.get());

    sptr = registry_->getEntry("milestone.elapsedtime_");
    milestoneElapsedTime_ = *((uint*) sptr.get());

    // batch running data
    sptr = registry_->getEntry("batch.repeats");
    batchRepeats_ = *((uint*) sptr.get());

    sptr = registry_->getEntry("batch.remaining_");
    batchRemaining_ = *((uint*) sptr.get());

    sptr = registry_->getEntry("batch.statsfile");
    batchStatsFile_ = *((std::string*) sptr.get());

    sptr = registry_->getEntry("batch.logfile_");
    batchLogFile_ = *((std::string*) sptr.get());

    sptr = registry_->getEntry("batch.singlemilestone");
    bBatchSingleMilestone_ = *((uint*) sptr.get()) % 2 ? true:false;

    if(registry_->isModified("batch.repeats") && batchRepeats_ > 1)
        bBatchStart_ = true;
    else
        bBatchStart_ = false;
}


bool State::parseConfig(std::string filename) 
{
    std::ifstream fin(filename.c_str());
    if (!fin) {
        throw std::string("Error opening file " + filename);
    }
    std::cout << "Parsing configuration file: " << filename << std::endl;

    std::string xmlFile, temp;
    while (!fin.eof())
        getline(fin, temp), xmlFile += "\n" + temp;

    XMLResults results;
    xConfig_ = XMLNode::parseString(xmlFile.c_str(), "ECF", &results);
    if (results.error != eXMLErrorNone) {
        std::cerr << "Configuration file: " << XMLNode::getError(results.error);
        std::cerr << " (line " << results.nLine << ", col " << results.nColumn << ")" << std::endl;
        throw("");
    }

    if (xConfig_.isEmpty())
        return false;

    int n = xConfig_.nChildNode();
    for (int i = 0; i < n; ++i) {
        XMLNode     child = xConfig_.getChildNode(i);
        std::string name  = child.getName();
        bool        ok    = true;

        if (name == NODE_REGISTRY) 
            ok &= registry_->readEntries(child);
        else if (name == NODE_ALGORITHM)
            ok &= parseAlgorithmNode(child);
        else if (name == NODE_GENOTYPE)
            ok &= parseGenotypeNode(child);
        else if (name == NODE_POPULATION)
            continue;
        else 
            std::cerr << "Unknown node: " << name << std::endl;

        if (!ok)
            throw "";
    }

    return true;
}


bool State::parseAlgorithmNode(XMLNode node) 
{
    int n = node.nChildNode();
    if (n > 1)
        std::cerr << "Warning: multiple Algorithm nodes found! (using the first one)" << std::endl;

    XMLNode child = node.getChildNode(0);
    alg_iter alg = mAlgorithms_.find(child.getName());
    if (alg == mAlgorithms_.end()) {
        throw std::string("Error: unknown Algorithm : ") + child.getName();
    }

    algorithm_ = alg->second;
    bAlgorithmSet_ = true;

    if (! registry_->readEntries(child, child.getName()))
        return false;

    return true;
}


bool State::parseGenotypeNode(XMLNode node) 
{
    int n = node.nChildNode();
    for (int i = 0; i < n; ++i) {
        XMLNode child = node.getChildNode(i);
        gen_iter gen = mGenotypes_.find(child.getName());
        if (gen == mGenotypes_.end()) {
            throw std::string("Error: unknown Genotype : ") + child.getName();
        }

        uint genotypeId = (uint) genotype_.size();
        gen->second->setGenotypeId(genotypeId);
        gen->second->registerParameters(state_);
        setGenotype(gen->second);

        if (! registry_->readEntries(child, child.getName(), genotypeId))
            return false;
    }

    return true;
}


bool State::initializeComponents(int argc, char **argv)
{
    try {
        bTerminate_ = false;
        generationNo_ = 0;

        logger_->initialize(state_);
        randomizer_->initialize(state_);

        // initialize single instance of active genotypes
        for(uint i = 0; i < genotype_.size(); i++) {
            GenotypeP copy = (GenotypeP) genotype_[i]->copy();
            bInitialized_ &= copy->initialize(state_);
        }
        if(!bInitialized_) {
            throw "Error: Genotype initialization failed!";
        }

        // MPI communicator
        bInitialized_ &= comm_->initialize(state_, argc, argv);

        // damo algoritmu pointer na operator evaluacije i pointere na repozitorij krizanja i mutacije
        algorithm_->evalOp_ = this->evalOp_;
        algorithm_->crossover_ = crossover_;
        algorithm_->mutation_ = mutation_;
        algorithm_->initialize(state_); 

        population_->initialize(state_);
        algorithm_->initializeParallel(state_); // provjera impl. paralelizacije (nakon population_->initialize zbog podjele procesa po demovima)

        mutation_->initialize(state_);
        crossover_->initialize(state_);
        migration_->initialize(state_);

        // initialize termination ops
        activeTerminationOps_.clear();
        for(uint i = 0; i < allTerminationOps_.size(); i++)
            if(allTerminationOps_[i]->initialize(state_))
                activeTerminationOps_.push_back(allTerminationOps_[i]);
        // if no term operators are configured, activate default (the first)
        if(activeTerminationOps_.size() == 0)
            activeTerminationOps_.push_back(allTerminationOps_[0]);

        // initialize user ops
        activeUserOps_.clear();
        for(uint i = 0; i < allUserOps_.size(); i++)
            if(allUserOps_[i]->initialize(state_))
                activeUserOps_.push_back(allUserOps_[i]);

        // evaluation op. initializes last
        if(!evalOp_->initialize(state_))
            throw "Error: Evaluation operator initialization failed!";

        // generate one individual and fitness object
        individual_ = (IndividualP) (new Individual(state_));
        fitness_ = evalOp_->evaluate(individual_);

    } // try

    catch(std::string& msg) {
        std::cerr << msg << std::endl;
        bInitialized_ = false;
    }
    catch(const char* msg) {
        std::cerr << msg << std::endl;
        bInitialized_ = false;
    }
    catch(...) {
        std::cerr << "Unknown error in initialization!" << std::endl;
        bInitialized_ = false;
    }

    return bInitialized_;
}


bool State::runBatch()
{
    bBatchStart_ = false;
    bBatchMode_ = true;

    bool bUseLog = registry_->isModified("log.filename");

    if(!bLoadMilestone_)
        batchRemaining_ = batchRepeats_;
    uint numerals = 1 + (uint) (log((double) batchRepeats_) / log((double) 10.));

    // get logfile name and extension
    std::string logFileName = *(std::string*) registry_->getEntry("log.filename").get();
    std::string logFileExt = "";
    if(bLoadMilestone_)
        logFileName = batchLogFile_;
    else
        batchLogFile_ = logFileName;

    if(logFileName.find(".") != std::string::npos) {
        logFileExt = logFileName.substr(logFileName.find("."));
        logFileName = logFileName.substr(0, logFileName.find("."));
    }

    // get milestone name and extension
    std::string milestoneName = *(std::string*) registry_->getEntry("milestone.filename").get();
    std::string milestoneExt = "";
    if(milestoneName.find(".") != std::string::npos) {
        milestoneExt = milestoneName.substr(milestoneName.find("."));
        milestoneName = milestoneName.substr(0, milestoneName.find("."));
    }

    // (re)open stats file
    std::ofstream statsFile;
    if(registry_->isModified("batch.statsfile")) {
        if(bLoadMilestone_)
            statsFile.open(batchStatsFile_.c_str(), std::ios_base::app);
        else {
            statsFile.open(batchStatsFile_.c_str());
            statsFile << "runId\tfit_min\tfit_max\tfit_avg\tfit_std\n";
        }
        if(!statsFile) {
            logger_->log(1, "Error: can't open batch statsfile (" + batchStatsFile_ + ")!");
            return false;
        }
        statsFile.close();
        bBatchWriteStats_ = true;
    }

    uint runId = batchRepeats_ - batchRemaining_ + 1;

    for(; runId <= batchRepeats_; runId++) {
        // set current logfile
        if(bUseLog) {
            std::stringstream ss;
            ss << std::setw(numerals) << std::setfill('0') << runId;
            std::string currentLogName = logFileName + "_" + ss.str() + logFileExt;
            registry_->modifyEntry("log.filename", (voidP) new std::string(currentLogName));
        }

        // set current milestone
        if(!bBatchSingleMilestone_) {
            std::stringstream ss;
            ss << std::setw(numerals) << std::setfill('0') << runId;
            milestoneFilename_ = milestoneName + "_" + ss.str() + milestoneExt;
        }

        // run
        batchRemaining_--;
        bInitialized_ = true;
        initializeComponents(argc_, argv_);
        logger_->log(1, "Running in batch mode: run " + uint2str(runId) + "/" + uint2str(batchRepeats_));
        run();

        // write stats (PECF: only master process)
        if(comm_->getCommGlobalRank() == 0) {
            if(bBatchWriteStats_) {
                statsFile.open(batchStatsFile_.c_str(), std::ios_base::app);
                std::vector<double> stats = population_->stats_->getStats();
                statsFile << runId << '\t';
                statsFile << stats[0] << '\t' << stats[1] << '\t' << stats[2] << '\t' << stats[3] << '\n';
                statsFile.close();
            }
        }
    }

    // ugly workabout for MPI_Finalize, which may only be called once
    bBatchMode_ = false;
    comm_->finalize();

    std::cout << "Batch mode end (" << batchRepeats_ << " runs concluded)." << std::endl;

    if(statsFile)
        statsFile.close();
    return true;
}


bool State::initialize(int argc, char **argv)
{
    this->state_ = this->getState(); // obtain a sptr to this
    genotype_.clear();
    mutation_->operators.clear();
    crossover_->operators.clear();

    bInitialized_ = true;
    argc_ = argc;
    argv_ = argv;

    try {

        std::cout << "-- ECF, version " << ECF_VERSION << " --" << std::endl;

        if(!bEvaluatorSet_) {
            throw "Error: no EvaluateOp defined!";
        }

        // parse arguments: currently only the configuration file's name
        std::string config_file;
        if (argc > 1)
            config_file = argv[1];

        registerParameters();

        if (config_file != "") {
            bInitialized_ = parseConfig(config_file);
        }
        else {
            std::cout << "Warning: no configuration file given." << std::endl;
            std::cout << "Example usage: <ECF_binary> <parameter_file>" << std::endl;
        }

        // use the default algorithm
        if (!bAlgorithmSet_)
            algorithm_ = mAlgorithms_.find("SteadyStateTournament")->second;

        if(!bGenotypeSet_) {
            throw "Error: no Genotype defined!";
        }

        readParameters();

        if(bBatchStart_)
            return true;

        initializeComponents(argc, argv);

        if(bLoadMilestone_)
            loadMilestone();

    } // try

    catch(std::string& msg) {
        std::cerr << msg << std::endl;
        bInitialized_ = false;
    }
    catch(const char* msg) {
        std::cerr << msg << std::endl;
        bInitialized_ = false;
    }
    catch(...) {
        std::cerr << "Unknown error in initialization!" << std::endl;
        bInitialized_ = false;
    }

    return bInitialized_;
}


bool State::isImplicitParallel()
{   return algorithm_->isImplicitParallel();    }


bool State::isAlgorithmParallel()
{   return algorithm_->isParallel();    }


void State::write(XMLNode& xState)
{
    registry_->modifyEntry("milestone.generation_", (voidP) (new uint(getGenerationNo())));
    registry_->modifyEntry("milestone.elapsedtime_", (voidP) (new time_t(elapsedTime_)));
    registry_->modifyEntry("batch.remaining_", (voidP) (new uint(batchRemaining_)));
    if(registry_->isModified("log.filename"))
        registry_->modifyEntry("batch.logfile_", (voidP) (new std::string(batchLogFile_)));
}


void State::saveMilestone()
{
    XMLNode xMainNode = XMLNode::createXMLTopNode("ECF");
    xMainNode.addAttribute("milestone", ctime(&currentTime_));

    XMLNode xMilestone;
    this->write(xMilestone);
    xMainNode.addChild(xMilestone);

    XMLNode xNode = this->xConfig_.getChildNode(NODE_ALGORITHM);
    xNode = xNode.deepCopy();
    xMainNode.addChild(xNode);
    xNode = this->xConfig_.getChildNode(NODE_GENOTYPE);
    xNode = xNode.deepCopy();
    xMainNode.addChild(xNode);

    this->registry_->write(xNode);
    xMainNode.addChild(xNode);

    // save population
    XMLNode xPopulation;
    population_->write(xPopulation);
    xMainNode.addChild(xPopulation);

#ifdef _MPI
    if(comm_->getCommGlobalRank() != 0)
        return;
#endif

    xMainNode.writeToFile(milestoneFilename_.c_str());
}


void State::loadMilestone()
{
    XMLNode xPopulation = xConfig_.getChildNode("Population");
    population_->read(xPopulation);

    generationNo_ = milestoneGeneration_;
}



//
// setting components
//

uint State::setGenotype(GenotypeP genotype)
{
    genotype_.push_back((GenotypeP) genotype->copy());
    uint index = (uint) genotype_.size() - 1;
    genotype_[index]->setGenotypeId(index);
    genotype->setGenotypeId(index);

    genotype_[index]->registerParameters(state_);

    // read genotype's operators and register their parameters
    crossover_->operators.push_back(genotype_[index]->getCrossoverOp());
    for(uint iOp = 0; iOp < crossover_->operators[index].size(); iOp++) {
        crossover_->operators[index][iOp]->myGenotype_ = genotype_[index];
        crossover_->operators[index][iOp]->registerParameters(state_);
    }

    mutation_->operators.push_back(genotype_[index]->getMutationOp());
    for(uint iOp = 0; iOp < mutation_->operators[index].size(); iOp++) {
        mutation_->operators[index][iOp]->myGenotype_ = genotype_[index];
        mutation_->operators[index][iOp]->registerParameters(state_);
    }

    bGenotypeSet_ = true;
    return index;
}


void State::setAlgorithm(AlgorithmP algorithm)
{
    algorithm_ = algorithm;
    bAlgorithmSet_ = true;
}


void State::setEvalOp(EvaluateOpP eval)
{
    evalOp_ = eval;
    bEvaluatorSet_ = true;
}



//
// adding components
//

bool State::addGenotype(GenotypeP gen)
{
    mGenotypes_[gen->getName()] = gen;
    return true;
}


bool State::addAlgorithm(AlgorithmP alg)
{
    mAlgorithms_[alg->getName()] = alg;
    return true;
}

bool State::addOperator(OperatorP op)
{
    allUserOps_.push_back(op);
    return true;
}



//
// run methods
//

#ifndef _MPI

bool State::run()
{
    if(!bInitialized_) {
        std::cerr << "Error: Initialization failed!" << std::endl;
        return false;
    }

    if(bBatchStart_) {
        runBatch();
        return true;
    }

    startTime_ = time(NULL);
    std::string stime = ctime(&startTime_);
    logger_->log(3, "Start time: " + stime);
    // adjust with previous runtime (from milestone)
    startTime_ -= milestoneElapsedTime_;

    // evaluate initial population
    logger_->log(2, "Evaluating initial population...");
    algorithm_->initializePopulation(state_);

    currentTime_ = time(NULL);
    elapsedTime_ = currentTime_ - startTime_;
    logger_->log(2, "Generation: " + uint2str(generationNo_));
    logger_->log(2, "Elapsed time: " + uint2str((uint) elapsedTime_));
    population_->updateDemeStats();

    for(uint i = 0; i < activeTerminationOps_.size(); i++)
        activeTerminationOps_[i]->operate(state_);

    // run the algorithm
    while(bTerminate_ == false) {
        algorithm_->advanceGeneration(state_);
        generationNo_++;

        currentTime_ = time(NULL);
        elapsedTime_ = currentTime_ - startTime_;
        logger_->log(2, "Generation: " + uint2str(generationNo_));
        logger_->log(2, "Elapsed time: " + uint2str((uint) elapsedTime_));

        population_->updateDemeStats();

        // call user-defined operators
        for(uint i = 0; i < activeUserOps_.size(); i++)
            activeUserOps_[i]->operate(state_);

        // termination ops
        for(uint i = 0; i < activeTerminationOps_.size(); i++)
            activeTerminationOps_[i]->operate(state_);

        logger_->saveTo();

        if(bSaveMilestone_ && 
                milestoneInterval_ > 0 && generationNo_ % milestoneInterval_ == 0)
            saveMilestone();

        migration_->operate(state_);
    }

    // output HallOfFame
    XMLNode xHoF;
    population_->hof_->write(xHoF);
    char *out = xHoF.createXMLString(true);
    logger_->log(1, "\nBest of run: \n" + std::string(out));
    freeXMLString(out);

    //population_->stats_->output(1);
    logger_->saveTo(true);
    if(bSaveMilestone_)
        saveMilestone();

    logger_->closeLog();

    return true;
}


#else // _MPI

bool State::run()
{
    if(bBatchStart_) {
        runBatch();
        return true;
    }

    // TODO: perform AND_reduce with bInitialized on all processes
    if(!bInitialized_) {
        std::cerr << "Error: Initialization failed!" << std::endl;
        logger_->saveTo();
        if(comm_->isInitialized())
            comm_->finalize();
        return false;
    }

    startTime_ = time(NULL);
    std::string stime = ctime(&startTime_);
    logger_->log(3, "Start time: " + stime);
    // adjust with previous runtime (from milestone)
    startTime_ -= milestoneElapsedTime_;

    // in PECF, every process works with deme '0'
    // 'deme masters' - processes with index 0 in local communicator
    // only deme masters know of whole population
    if(comm_->getCommRank() == 0) {
        logger_->log(2, "Evaluating initial population...");
    }

    // every process participates in the initial population evaluation
    algorithm_->initializePopulation(state_);
    comm_->synchronize();

    currentTime_ = time(NULL);
    elapsedTime_ = currentTime_ - startTime_;

    if(comm_->getCommRank() == 0) {
        // dodatna inicijalizacija za implicitni paralelizam - mozda promijeniti...
        if(isImplicitParallel())
            algorithm_->initializeImplicit(state_);

        logger_->log(2, "Generation: " + uint2str(generationNo_));
        logger_->log(2, "Elapsed time: " + uint2str((uint) elapsedTime_));
        population_->updateDemeStats();
    }

    for(uint i = 0; i < activeTerminationOps_.size(); i++)
        activeTerminationOps_[i]->operate(state_);

    // run the algorithm
    while(bTerminate_ == false) {
        algorithm_->advanceGeneration(state_);

        generationNo_++;
        currentTime_ = time(NULL);
        elapsedTime_ = currentTime_ - startTime_;
        if(comm_->getCommGlobalRank() == 0) {
            logger_->log(2, "Generation: " + uint2str(generationNo_));
            logger_->log(2, "Elapsed time: " + uint2str((uint) elapsedTime_));
        }   

        // deme masters initiate population statistics and HoF update
        if(comm_->getCommRank() == 0) {
            population_->updateDemeStats();

            if(bSaveMilestone_ && milestoneInterval_ > 0 && generationNo_ % milestoneInterval_ == 0)
                saveMilestone();
        }

        // global process 0 checks termination condition and signals deme masters
        if(comm_->getCommGlobalRank() == 0) {
            for(uint i = 0; i < activeTerminationOps_.size(); i++)
                activeTerminationOps_[i]->operate(state_);

            for(uint i = 1; i < population_->getNoDemes(); i++)
                comm_->sendTerminateMessage(comm_->getDemeMaster(i), bTerminate_);
        }
        // deme masters receive info
        else if(comm_->getCommRank() == 0)
            bTerminate_ = comm_->recvTerminateMessage(0);

        // deme masters signal workers of evolution continuation
        algorithm_->bcastTermination(state_);

        // deme masters call migration operator
        if(comm_->getCommRank() == 0) {
            migration_->operate(state_);
        }

        // call user-defined operators
        for(uint i = 0; i < activeUserOps_.size(); i++)
            activeUserOps_[i]->operate(state_);

        logger_->saveTo();
    }

    logger_->setLogFrequency(1);
    if(comm_->getCommGlobalRank() == 0) {
        // output HallOfFame
        XMLNode xHoF;
        population_->hof_->write(xHoF);
        std::string out = xHoF.createXMLString(true);
        logger_->log(1, "\nBest of run: \n" + out);

        logger_->saveTo(true);
    }

    if(comm_->getCommRank() == 0 && bSaveMilestone_)
        saveMilestone();

    logger_->saveTo(true);

    // communicator
    comm_->finalize();

    return true;
}
#endif // _MPI