TOptimizer.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 TOPTIMIZER_H
#define TOPTIMIZER_H

#include <iostream>

//ROOT
#include "Rtypes.h"
#include "TNamed.h"
#include "TMethodCall.h"

// Uranie
#include "Optimizer.h"
#include "TLauncherEnv.h"
#include "TCode.h"
#include "TDataServer.h"
#include "TObjective.h"
#include "TObjectiveUncertainty.h"

namespace URANIE
{
namespace Optimizer
{

class TOptimizer: public URANIE::Launcher::TLauncherEnv
{
public:
    enum EOptimType
    {
        kMinimizeCode, kMinimizeFunction, kSumOfSquare
    };
    enum EOptimMethod
    {
        kMigrad, kSimplex, kCombined, kScan
    };

private:
    Bool_t _bsave;        
    Bool_t _bclean;    
    Int_t _nPrintLevel; 
    URANIE::DataServer::TDataServer *_tds;      
    Int_t _nMaxIterations;                  
    Int_t _nMaxFunctionCalls;      
    Double_t _dTolerance;                      
    vector<TObjective *> _objectives;           
    TMethodCall *_fMethodCall; 
#ifdef ROOT5
    void *_fMethod;                    
#else
    void (*_fMethod)(Double_t*, Double_t*);                    
#endif
    TString _sFunctionName;              
    EOptimType _optimProblem;                   
    EOptimMethod _optimMethod;                  
    TString _sInput;                       
    TString _sOutput; 
    TString _sCost; 
public:
    //---------------------------------------------
    TOptimizer(URANIE::DataServer::TDataServer *tds,
            URANIE::Launcher::TCode *code);
#ifdef ROOT5
    TOptimizer(URANIE::DataServer::TDataServer *tds, void* fcn, TString sinput =
            "", TString soutput = "");
#else
    TOptimizer(URANIE::DataServer::TDataServer *tds, void (*fcn)(Double_t*, Double_t*),
               TString sinput, TString soutput);
#endif
    TOptimizer(URANIE::DataServer::TDataServer *tds, const char* fcn, TString sinput =
               "", TString soutput = "");
    virtual ~TOptimizer();

    //---------------------------------------------
    void setTolerance(Double_t dtol)
    {
        _dTolerance = dtol;
    }
    Double_t getTolerance()
    {
        return _dTolerance;
    }
    void setMaxIterations(Int_t nmax)
    {
        _nMaxIterations = nmax;
    }
    Int_t getMaxIterations()
    {
        return _nMaxIterations;
    }
    void setMaxFunctionCalls(Int_t nmax)
    {
        _nMaxFunctionCalls = nmax;
    }
    Int_t getMaxFunctionCalls()
    {
        return _nMaxFunctionCalls;
    }

    //---------------------------------------------
    void setMethod(EOptimMethod method = kMigrad)
    {
        _optimMethod = method;
    }
    EOptimMethod getMethod()
    {
        return _optimMethod;
    }
    EOptimType getOptimType()
    {
        return _optimProblem;
    }
    void setPrintLevel(int level)
    {
        _nPrintLevel = level;
    }
    int getPrintLevel() const
    {
        return _nPrintLevel;
    }

    //---------------------------------------------
    virtual void init(Option_t *option = "");
    virtual void optimize(Option_t *option = "");
    virtual void terminate(Option_t *option = "");
    virtual void clean(Option_t *option = "");

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

    void addObjective(TString name, URANIE::DataServer::TDataServer *tds,
            TString ystar, URANIE::Launcher::TOutputFile *outfile, TString yhat,
            Double_t weight = 1.0);

    void addObjective(TString name, URANIE::DataServer::TDataServer *tds,
            TString ystar, TString sigma,
            URANIE::Launcher::TOutputFile *outfile, TString yhat,
            Double_t alpha = 1.0);
    void unactiveObjective(TString name);
    void activeObjective(TString name);
    void invertObjectives();
    vector< URANIE::Optimizer::TObjective * > getObjectives()
    {
        return _objectives;
    }

    void addOutputVariable(TString soutput);
    void selectCost(TString scost);
    TString getSelectedCost()
    {
        return _sCost;
    }

    //---------------------------------------------
    void fixParameter(TString name);

    void unfixParameter(TString name);

    void invertParameters();

    //---------------------------------------------
    void printState(Option_t *option = "");

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

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

} // Fin du namespace Optimizer
} // Fin du namespace URANIE
#endif