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

#include "ECF_base.h"
#include <string.h>


Population::Population()
{
    hof_ = static_cast<HallOfFameP> (new HallOfFame);
    stats_ = static_cast<StatCalcP> (new StatCalc);
}


void Population::registerParameters(StateP state)
{
    int *sizep = new int(100);
    state->getRegistry()->registerEntry("population.size", (voidP) sizep, ECF::UINT);
    int *demep = new int(1);
    state->getRegistry()->registerEntry("population.demes", (voidP) demep, ECF::UINT);

    stats_->registerParameters(state);
}


#ifndef _MPI    // slijedna verzija

bool Population::initialize(StateP state)
{
    state_ = state;
    this->clear();

    voidP sptr = state->getRegistry()->getEntry("population.size");
    nIndividuals_ = *((uint*) sptr.get());
    sptr = state->getRegistry()->getEntry("population.demes");
    nDemes_ = *((uint*) sptr.get());

    for(uint i = 0; i < nDemes_; i++){
        this->push_back(static_cast<DemeP> (new Deme));
        this->back()->getSize() = nIndividuals_;
        this->back()->initialize(state);
    }

    hof_->initialize(state);

    stats_->initialize(state);

    return true;
}


void Population::read(XMLNode &xPopulation)
{
    XMLNode xHof = xPopulation.getChildNode(0);
    this->hof_->read(xHof);

    for(uint i = 0; i < this->size(); i++) {
        XMLNode xDeme = xPopulation.getChildNode(i + 1);
        this->at(i)->read(xDeme);
    }
}


void Population::write(XMLNode &xPopulation)
{
    xPopulation = XMLNode::createXMLTopNode(NODE_POPULATION);
    xPopulation.addAttribute("size", uint2str(nDemes_).c_str());    // number of demes

    XMLNode xHoF;
    hof_->write(xHoF);
    xPopulation.addChild(xHoF);

    for(uint iDeme = 0; iDeme < nDemes_; iDeme++) {
        XMLNode xDeme;
        this->at(iDeme)->write(xDeme);
        xPopulation.addChild(xDeme);
    }
}


void Population::updateDemeStats()
{   
    std::vector<IndividualP> pool;
    pool.push_back(this->at(0)->at(0));
    stats_->operate(pool);  // initialize

    // gather statistics
    for(uint iDeme = 0; iDeme < this->size(); iDeme++) {
        DemeP deme = this->at(iDeme);
        deme->stats_->operate(*(deme));
        state_->getLogger()->log(3, "Deme: " + uint2str(iDeme));
        deme->stats_->log();
        this->stats_->update(deme->stats_->getStats());
    }
    if(this->nDemes_ > 1) {
        state_->getLogger()->log(3, "Population:");
        stats_->log();
    }

    // gather HoF
    pool.clear();
    for(uint iDeme = 0; iDeme < this->size(); iDeme++) {
        this->at(iDeme)->hof_->operate(*(this->at(iDeme)));
        std::vector<IndividualP> bestOfDeme = this->at(iDeme)->hof_->getBest();
        for(uint i = 0; i < bestOfDeme.size(); i++)
            pool.push_back(bestOfDeme[i]);
        hof_->operate(pool);
    }
}


#else   // _MPI - paralelna verzija

bool Population::initialize(StateP state)
{
    state_ = state;
    voidP sptr = state->getRegistry()->getEntry("population.size");
    nIndividuals_ = *((uint*) sptr.get());
    sptr = state->getRegistry()->getEntry("population.demes");
    nDemes_ = *((uint*) sptr.get());

    hof_ = static_cast<HallOfFameP> (new HallOfFame);
    hof_->initialize(state);

    stats_ = static_cast<StatCalcP> (new StatCalc);
    stats_->initialize(state);

    // single deme:
    if(nDemes_ == 1) {
        this->push_back(static_cast<DemeP> (new Deme));
        this->back()->getSize() = nIndividuals_;
        this->back()->initialize(state);
        myDemeIndex_ = 0;
        return true;
    }

    // multiple demes:
    myDemeIndex_ = state->getCommunicator()->createDemeCommunicator(nDemes_);
    this->push_back(static_cast<DemeP> (new Deme));
    this->back()->getSize() = nIndividuals_;
    this->back()->initialize(state);

    return true;
}


// prikupi hof i statistiku svih demova
void Population::updateDemeStats()
{
    // every process 'processes' its local deme
    state_->getLogger()->log(3, "Deme: " + uint2str(getDemeId()));
    this->at(0)->hof_->operate(*(getLocalDeme()));

    std::vector<IndividualP> bestPool = this->at(0)->hof_->getBest();
    hof_->operate(bestPool);

    stats_->operate(*(getLocalDeme()));
    stats_->log();

    if(nDemes_ > 1) {       // vise demova - svaki lokalni proces 0 dodje ovdje
        // globalni proces 0 prima hof-ove i statistiku od ostalih deme mastera
        if(state_->getCommunicator()->getCommGlobalRank() == 0) {

            std::vector<IndividualP> bestPool, received;
            bestPool = this->at(0)->hof_->getBest();    // uzmi moj hof za pocetak

            for(uint iDeme = 1; iDeme < nDemes_; iDeme++) { // dodaj ostale
                received = state_->getCommunicator()->recvIndividualsGlobal();
                for(uint ind = 0; ind < received.size(); ind++)
                    bestPool.push_back(received[ind]);
            }

            hof_->operate(bestPool);    // konacno, odredi globalni hof

            // gather statistics
            std::vector<double> statValues;
            for(uint iDeme = 1; iDeme < nDemes_; iDeme++) {
                statValues = state_->getCommunicator()->recvValuesGlobal();
                stats_->update(statValues);
            }
            state_->getLogger()->log(3, "Population: ");
            stats_->log();
        }
        else {  // saljem globalnom 0
            // send HoF
            std::vector<IndividualP> myBest = this->at(0)->hof_->getBest();
            state_->getCommunicator()->sendIndividualsGlobal(myBest, 0);
            // send stats
            std::vector<double> myStats = stats_->getStats();
            state_->getCommunicator()->sendValuesGlobal(myStats, 0);
        }
    }
}


void Population::write(XMLNode &xPopulation)
{
    CommunicatorP comm = state_->getCommunicator();

    // only deme masters continue
    if(comm->getCommRank() != 0)
        return;

    xPopulation = XMLNode::createXMLTopNode(NODE_POPULATION);
    xPopulation.addAttribute("size", uint2str(nDemes_).c_str());

    XMLNode xHoF;
    hof_->write(xHoF);
    xPopulation.addChild(xHoF);

    // write local deme
    XMLNode xDeme;
    this->at(0)->write(xDeme);
    xPopulation.addChild(xDeme);

    // collect remote demes
    if(comm->getCommGlobalRank() == 0) {
        for(uint iDeme = 1; iDeme < nDemes_; iDeme++) {
            XMLNode xDeme;
            voidP msg = comm->recvDataGlobal();
            xDeme = XMLNode::parseString((char*) msg.get(), "Deme");
            xPopulation.addChild(xDeme);
        }
    }
    else {
        char* message = xDeme.createXMLString();
        comm->sendDataGlobal((voidP) message, (uint) strlen(message), 0);
    }
}


void Population::read(XMLNode &xPopulation)
{
    CommunicatorP comm = state_->getCommunicator();

    // only deme masters continue
    if(comm->getCommRank() != 0)
        return;

    XMLNode xHof = xPopulation.getChildNode(0);
    this->hof_->read(xHof);

    // read the designated deme
    XMLNode xDeme = xPopulation.getChildNode(getDemeId() + 1);
    getLocalDeme()->read(xDeme);
}


#endif  // _MPI