evorobotexperiment.h

/********************************************************************************
 *  FARSA Experiments Library                                                   *
 *  Copyright (C) 2007-2012                                                     *
 *  Stefano Nolfi <stefano.nolfi@istc.cnr.it>                                   *
 *  Onofrio Gigliotta <onofrio.gigliotta@istc.cnr.it>                           *
 *  Gianluca Massera <emmegian@yahoo.it>                                        *
 *  Tomassino Ferrauto <tomassino.ferrauto@istc.cnr.it>                         *
 *                                                                              *
 *  This program is free software; you can redistribute it and/or modify        *
 *  it under the terms of the GNU General Public License as published by        *
 *  the Free Software Foundation; either version 2 of the License, or           *
 *  (at your option) any later version.                                         *
 *                                                                              *
 *  This program is distributed in the hope that it will be useful,             *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of              *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               *
 *  GNU General Public License for more details.                                *
 *                                                                              *
 *  You should have received a copy of the GNU General Public License           *
 *  along with this program; if not, write to the Free Software                 *
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

#ifndef EVOROBOTEXPERIMENT_H
#define EVOROBOTEXPERIMENT_H

#include "resourcesuser.h"
#include "evonet.h"
#include "neuroninterfaces.h"
#include "robots.h"
#include "world.h"
#include "physphere.h"
#include "phybox.h"
#include "phycylinder.h"
#include "configurationparameters.h"
#include "parametersettable.h"
#include "arena.h"
#include "logger.h"
#include "simpletimer.h"
#include "randomgenerator.h"

#include <QCoreApplication>
#include <QVector>
#include <QMap>
#include <QString>

namespace farsa {

class Evoga;

class FARSA_EXPERIMENTS_TEMPLATE WObjectsList : public QVector<WObject*>, public Resource
{
public:
    WObjectsList() :
        QVector<WObject*>()
    {
    }

    WObjectsList(int size) :
        QVector<WObject*>(size)
    {
    }

    WObjectsList(int size, WObject* const & value) :
        QVector<WObject*>(size, value)
    {
    }

    WObjectsList(const QVector<WObject*>& other) :
        QVector<WObject*>(other)
    {
    }
};

class FARSA_EXPERIMENTS_API EvoRobotExperiment : public QObject, public ParameterSettableWithConfigureFunction, public ConcurrentResourcesUser
{
    Q_OBJECT
public:
    EvoRobotExperiment();
    virtual ~EvoRobotExperiment();

    void setEvoga( Evoga* ga );
    Evoga* getEvoga();
    bool inBatchRunning();
    int getNAgents();
    bool selectAgent( int agentId );
    void enableAgent( int agentId );
    void disableAgent( int agentId );
    bool agentEnabled( int agentId );
    Evonet* getNeuralNetwork( int agentId=0 );
    virtual void setNetParameters(float *genes);
    virtual void setNetParameters(int *genes);
    virtual void initGeneration(int generation);
    virtual void initIndividual(int individual);
    virtual void initTrial(int trial);
    virtual void initStep( int step );
    double getFitness();
    double getError();
    void stopTrial();
    void skipTrial();
    void restartTrial();
    void endIndividualLife();
    virtual void afterSensorsUpdate();
    virtual void beforeMotorsUpdate();
    virtual void beforeWorldAdvance();
    virtual void endStep( int step ) = 0;
    virtual void endTrial(int trial);
    virtual void endIndividual(int individual);
    virtual void endGeneration(int generation);
    void doAllTrialsForIndividual(int individual);

    int getGenomeLength();
    Sensor* getSensor( QString sensorName, int agentId=0 );
    Motor* getMotor( QString motorName, int agentId=0 );

    Arena* getArena() {
        return arena;
    }

    virtual void setTestingAgentAndSeed( int idindividual, int nreplica );

    enum Phases {
        INTEST,
        INEVOLUTION,
        NONE
    };
    Phases getActivityPhase() {
        return gaPhase;
    };
    void setActivityPhase( Phases newPhase ) {
        gaPhase = newPhase;
    };

    virtual void configure(ConfigurationParameters& params, QString prefix);

    virtual void save(ConfigurationParameters& params, QString prefix);

    static void describe( QString type );

    virtual void postConfigureInitialization();

    int getNTrials() const
    {
        return ntrials;
    }
    void setNTrials( int new_ntrials ) {
        ntrials = new_ntrials;
    }

    int getNSteps() const
    {
        return nsteps;
    }
    void setNSteps( int new_nsteps ) {
        nsteps = new_nsteps;
    }

    int getCurStep() const
    {
        return nstep;
    }

    int getCurTrial() const
    {
        return ntrial;
    }

    void newGASeed(int seed);

    QVector<int*> m_weightIndividual;

public slots:
    void setStepDelay( int delay );

    int getStepDelay();

    float getWorldTimeStep() const;

protected:
    int ntrials;            
    int nsteps;         
    int nstep;          
    int ntrial;         

    void recreateWorld();
    bool recreateRobot( int agentId = 0 );
    void recreateAllRobots();
    void recreateArena();
    void recreateNeuralNetwork( int agentId = 0 );
    void recreateAllNeuralNetworks();

    RandomGenerator* getRNG();

    double trialFitnessValue;
    double totalFitnessValue;
    double trialErrorValue;
    double totalErrorValue;

    //--- it's not anymore const, because createNeuralNetwork may modify some [NET]
    //    parameters; in particual nSensors, nHiddens and nMotors
    ConfigurationParameters* savedConfigurationParameters;
    const QString* savedPrefix;

private:
    void doTrial();
    void doStep();

    void setWorldTimestep( float timestep );

    class EmbodiedAgent {
    public:
        EmbodiedAgent( int id, QString agentPath, EvoRobotExperiment* exp );
        ~EmbodiedAgent();
        void configure();
        void recreateRobot();
        void recreateNeuralNetwork();
        void disable();
        void enable();
        int id;
        bool enabled;
        QString agentPath;
        QString resourcePrefix;
        Evonet* evonet;
        EvonetIterator* neuronsIterator;
        Robot* robot;
        QVector<Sensor*> sensors;
        QVector<Motor*> motors;
        QMap<QString, Sensor*> sensorsMap;
        QMap<QString, Motor*> motorsMap;
        EvoRobotExperiment* exp;
    };

    Evoga* ga;
    World* world;
    float timestep;
    QList<EmbodiedAgent*> eagents;
    int agentIdSelected;
    Phases gaPhase;
    bool stopCurrentTrial;
    bool skipCurrentTrial;
    bool restartCurrentTrial;
    bool endCurrentIndividualLife;
    bool batchRunning;
    Arena* arena;
    int stepDelay;
    bool sameRandomSequence;
    RandomGenerator* randomGeneratorInUse;
    RandomGenerator localRNG;
};

} // end namespace farsa

#endif