TFCNCode.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 TFCNCODE_H
#define TFCNCODE_H
 
#include "TH1.h"
#include "TF1.h"
#include "TFile.h"
#include "TPad.h"
#include "TRandom3.h"
#include "TVirtualFitter.h"
#include "TStyle.h"
#include "Minuit2/FCNBase.h"
//#include "TFitterMinuit.h"
#include "TSystem.h"
 
#include <vector>
#include <iostream>
 
// URANIE
#include "Optimizer.h"
#include "TCode.h"
#include "TDataServer.h"
 
namespace URANIE
{
namespace Optimizer
{
class TFCNCode: public ROOT::Minuit2::FCNBase
{
 
public:
    TFCNCode() :
            _ninput(0), _noutput(0), _soutput(""), _tds(NULL), _code(NULL)
    {
    }
    TFCNCode(URANIE::DataServer::TDataServer *tds,
            URANIE::Launcher::TCode *code, TString scost) :
             _sCost(scost), _tds(tds), _code(code)
    {
        init();
    }
 
    ~TFCNCode()
    {
        _dinputValue = NULL;
        delete[] _dinputValue;
        _doutputValue = NULL;
        delete[] _doutputValue;
 
    }
 
    void init();
 
    double operator()(const vector<double> & par) const
    {
        Int_t niter = _tds->getTuple()->GetEntries();
        double fval = 0.1;
        if (_code->getLog())
            cout << "iter[" << niter << "]" << endl;
        if (_code != NULL)
        {
            _dinputValue[0] = 1.0 + niter;
            // Remark: If we want to save all computations, we need a constant Bool_t _bSave,
            // and call the the method _code->init() at each new computation.
            _code->init();
            // Pretraitment of the data
            for (int i = 0; i < _ninput; i++)
            {
                _dinputValue[1 + i] = par[i];
                if (_code->getLog())
                    cout << "**** input i[" << i << "] val["
                            << _dinputValue[1 + i] << "]" << endl;
            }
            int ind = 1;
            _code->preTraitment(ind, _dinputValue);
            // Lancement du code
            _code->run();
            // Post-traitment of the data
            ind = 0;
            _code->postTraitment(ind, _doutputValue);
            if (_code->getLog())
            {
                cout << endl << "*************************************" << endl
                        << " *** TFCNCode operator () _nCost[" << _nCost << "]"
                        << endl;
                for (Int_t ii = 0; ii <= _nCost; ii++)
                    cout << " ** ii(" << ii << "/" << _nCost << ") val("
                            << _doutputValue[ii] << ")" << endl;
                cout << " *** End Of TFCNCode operator ()" << endl
                        << "*************************************" << endl;
            }
            fval = _doutputValue[_nCost];
            if (_code->getLog())
                cout << " *** output _nCost[" << _nCost << "] val[" << fval
                        << "]" << endl;
 
            //Fill the output values in the input vector
            // +1 because the first value is the index
            for (int i = 1; i <= _noutput; i++)
                _dinputValue[_ninput + i] = _doutputValue[i];
            _tds->getTuple()->Fill(_dinputValue);
 
            // Visualisation
            if (niter % 10)
            {
                //          _ntd->Draw("val:x", "", "lp");
                _tds->draw(
                        Form("%s:%s", _sCost.Data(), _tds->getIteratorName()),
                        "", "lp");
                gPad->Modified();
                gPad->Update();
                // save the TNtuple in a TFile
//          TString srootfile = _code->getWorkingDirectory(); // getReferenceDirectory();
//          srootfile += "/UranieResults/uranielauncher.root";
//          TFile rootfile(srootfile, "recreate");
//          _tds->getTuple()->Write();
//          rootfile.Close();
            }
        }
 
        return fval;
    }
 
    double Up() const
    {
        return 1.;
    }
 
    void clean();
 
private:
    int _ninput;
    double * _dinputValue;
    int _noutput;
    TString _soutput;                         
    double * _doutputValue;                    
    TString _sCost; 
    Int_t _nCost; 
    URANIE::DataServer::TDataServer *_tds;     
    URANIE::Launcher::TCode *_code;    
 
    ClassDef(URANIE::Optimizer::TFCNCode, ID_OPTIMIZER)
    //Classe de
 
};
} // Fin du namespace Optimizer
} // Fin du namespace URANIE
#endif