TVizir.h

Go to the documentation of this file.

// Copyright (C) 2013-2024 CEA/DES
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// $Id$
// $Author$
// $Date$
// $Revision$
// $State$

#ifndef ROOT_TVIZIR
#define ROOT_TVIZIR

// Writes log
#include <iostream>

#include "Rtypes.h"
#include "TNamed.h"
#include "TMethodCall.h"
#include "TMatrixD.h"

// Uranie
#include "Optimizer.h"
#include "TDataServer.h"
#include "UExceptions.h"
#include "TLauncherEnv.h"
#include "TCode.h"

// Vizir
#define MAXNBGENERATIONS 5
#include "vizir.h"



namespace URANIE
{
namespace Optimizer
{

class TVizir: public URANIE::Launcher::TLauncherEnv
{
public:
    Double_t survie, zygotie, mutation, precision;
    Int_t intern, param, contrainte, cost, hide;
    Int_t population, duree;
    TMethodCall *fDecode, *fSoft, *fHard;
    TMatrixD minmax;
    URANIE::Launcher::forkcode *_fjob;

    URANIE::DataServer::TDataServer *_tds;      
    vzr_t *vizir;        


protected:
    void rearangeInput(TList *, TString &);
    void createTuple(TString &);
private:

public:
    TString _sdraw;                      
    TString _sopt;                       
    TString _scut;                       
    Int_t _nNbGenerationToDraw; 

    TVizir(URANIE::DataServer::TDataServer *tds, int npop);
    virtual ~TVizir();
    // parametrage

    //---------------------------------------------

    void setPrecision(double prec)
    {
        precision = prec;
    }
    void setSurvivalRate(double val)
    {
        survie = val;
    }
    void setHomozygoteRate(double val)
    {
        zygotie = val;
    }
    void setMutationRate(double val)
    {
        mutation = val;
    }
    void setMaxEvaluation(int val)
    {
        duree = val;
    }
    void setDecode(const char *, Int_t phys = 0);
    void setCost(const char *, const char*, int hiden = 0, const char *input = "*");
    void setConstraintAndCost(const char *, const char*, int, int hiden = 0,
            const char *input = "*", Bool_t bAddTheAttributes = kTRUE);
    void setCost(URANIE::Launcher::TCode *, int hiden = 0);
    void setConstraintAndCost(URANIE::Launcher::TCode *, int, int hiden = 0);
    void setHardConstraint(const char *);
    Int_t getLastGenerationIndex()
    {
        return vizir1_vzr_generationCount(vizir);
    }

    Int_t getNbGenerationToDraw()
    {
        return _nNbGenerationToDraw;
    }

    void setNbGenerationToDraw(Int_t n);

    void setVarDraw(const char* varexp, const char* selection = "",
            Option_t* option = "");

    //---------------------------------------------
    TMethodCall *copyDecode()
    {
        return (fDecode) ? new TMethodCall(*fDecode) : NULL;
    }
    TMethodCall *copyCost()
    {
        return (fSoft) ? new TMethodCall(*fSoft) : NULL;
    }
    TMethodCall *copyHardConstraint()
    {
        return (fHard) ? new TMethodCall(*fHard) : NULL;
    }
    URANIE::Launcher::TCode *copyCode();

    //---------------------------------------------
    void decode(Double_t*, Double_t*, TMethodCall *);
    int evaluer(Double_t*, Double_t*, TMethodCall*, TMethodCall*, TMethodCall*);
    int evaluer(Double_t*, Double_t*, TMethodCall*, TMethodCall*,
            URANIE::Launcher::TCode*);
    void fitnessChanged();
    void optimize(Option_t *option = "");
    void Results();

    //---------------------------------------------
    virtual void printLog(Option_t *option = "");

    ClassDef(URANIE::Optimizer::TVizir, ID_OPTIMIZER)
    //Classe de
};

} // Fin du namespace Optimizer
} // Fin du namespace URANIE

#endif