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 "TCode.h"
 
// Vizir
#define MAXNBGENERATIONS 5
#include "vizir.h"
 
 
 
namespace URANIE
{
namespace Optimizer
{
class TVizir: public TNamed
{
public:
    Double_t survie, zygotie, mutation, precision;
    Int_t intern, param, contrainte, cost, hide;
    Int_t population, duree;
    TMethodCall *fDecode, *fSoft, *fHard;
    TMatrixD minmax;
 
    Bool_t _blog;                              
    URANIE::DataServer::TDataServer *_tds;      
    URANIE::Launcher::TCode *_code;
    TString _sdirectory;                        
    vzr_t *vizir;        
 
 
protected:
    void rearangeInput(TList *, TString &);
    void createTuple(TString &);
private:
 
public:
    TString _sdraw;                      
    TString _sopt;                       
    TString _scut;                       
    Int_t _nNbGenerationToDraw; 
 
    //       TVizir();
    TVizir(URANIE::DataServer::TDataServer *tds, int npop);
    virtual ~TVizir();
    // parametrage
    //      void init(URANIE::DataServer::TDataServer *tds, int npop);
 
    //---------------------------------------------
 
    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 = "");
    // TString str, TString select ="", TString opt="");
 
    //---------------------------------------------
    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();
 
    //---------------------------------------------
    void setLog()
    {
        _blog = kTRUE;
    }
    void unsetLog()
    {
        _blog = kFALSE;
    }
    void changeLog()
    {
        _blog = _blog ? kFALSE : kTRUE;
    }
    Bool_t getLog()
    {
        return _blog;
    }
    virtual void printLog(Option_t *option = "");
 
    ClassDef(URANIE::Optimizer::TVizir, ID_OPTIMIZER)
    //Classe de
};
 
} // Fin du namespace Optimizer
} // Fin du namespace URANIE
 
#endif