TFCNAnalyticalFunction.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 TFCNANALYTICALFUNCTION_H
#define TFCNANALYTICALFUNCTION_H
 
#include "Minuit2/FCNBase.h"
//#include "TFitterMinuit.h"
#include "TSystem.h"
#include "TPad.h"
#include "TFile.h"
#include "TMethodCall.h"
 
// URANIE
#include "Optimizer.h"
#include "TDataServer.h"
 
namespace URANIE
{
namespace Optimizer
{
class TFCNAnalyticalFunction: public ROOT::Minuit2::FCNBase
{
 
public:
    TFCNAnalyticalFunction() :
            _blog(kFALSE), _ninput(0), _sinput(""), _noutput(0), _soutput(""), _sCost(""),
             _tds(NULL), _fMethod(NULL)
 
    {
    }
    TFCNAnalyticalFunction(URANIE::DataServer::TDataServer *tds, void * fcn,
            TString sinput, TString soutput, TString scost);
    TFCNAnalyticalFunction(URANIE::DataServer::TDataServer *tds,
            TString sfunction, TString sinput, TString soutput);
 
    ~TFCNAnalyticalFunction();
 
    void init();
 
    //---------------------------------------------
 
    TMethodCall *getMethodCall() const
    {
        return _fMethodCall;
    }
 
    double operator()(const vector<double> & par) const
    {
        Int_t niter = _tds->getTuple()->GetEntries();
        if (_blog)
            cout << " ** niter[" << niter << "]" << endl;
        double fval = par[1];
        _dinputValue[0] = 1.0 + niter;
        for (int i = 0; i < _ninput; i++)
        {
            _dinputValue[1 + i] = par[i];
            if (_blog)
                cout << "**** input i[" << i << "] val[" << _dinputValue[1 + i]
                        << "]" << endl;
        }
        _dinputValue[_ninput + 1] = fval;
        if (_fMethod != NULL)
        {
            //int ind = 1;
            (*_fMethod)(&_dinputValue[1], _doutputValue);
            //    fval = _doutputValue[0];
            fval = _doutputValue[_nCost];
            if (_blog)
                cout << "*********** output val[" << fval << "]" << endl;
        }
        //Fill the output values in the input vector
        for (int i = 0; i < _noutput; i++)
            _dinputValue[_ninput + i + 1] = _doutputValue[i];
        //      _dinputValue[_ninput+1] = fval;
        _tds->getTuple()->Fill(_dinputValue);
        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
            TFile *tf = TFile::Open(_tds->getArchiveFileName(), "RECREATE");
            _tds->getTuple()->SetDirectory(0);
            _tds->getTuple()->Write();
            tf->Close();
            _tds->getTuple()->SetDirectory(gDirectory);
        }
        return fval;
    }
 
    double Up() const
    {
        return 1.;
    }
 
    void clean();
 
private:
    Bool_t _blog;                            
    int _ninput;
    TString _sinput;                          
    double * _dinputValue;
    int _noutput;
    TString _soutput;                         
    double * _doutputValue;                       
    TString _sCost; 
    Int_t _nCost; 
    URANIE::DataServer::TDataServer *_tds;              
    void (*_fMethod)(Double_t *gin, Double_t *f); // A pointer for the analytical function
    TMethodCall *_fMethodCall; 
 
    ClassDef(URANIE::Optimizer::TFCNAnalyticalFunction, ID_OPTIMIZER)
    //Classe de
 
};
} // Fin du namespace Optimizer
} // Fin du namespace URANIE
 
R__EXTERN URANIE::Optimizer::TFCNAnalyticalFunction *gTFCNAF;
 
#endif