TCalibration.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/>.
// TCalibration
// $Id$
// $Author$
// $Date$
// $Revision$
// $State$

#ifndef TCALIBRATION_H
#define TCALIBRATION_H

// Root
#include "TMatrixD.h"

#include <iostream>
#include <sstream>
using std::cout;
using std::endl;

// Uranie
#include "TDataServer.h"
#include "TDSNtupleD.h"
#include "TRun.h"
#include "UExceptions.h"
#include "Calibration.h"
#include "TDistanceFunction.h"
#include "TCode.h"

namespace URANIE {
namespace Calibration {
class TCalibration: public TNamed {

   
    //---------------------------------------------
public:
    
    enum ELauncher
    {
        kCode, kFunction, kRun, kUnknown
    };

    URANIE::DataServer::TDataServer *_tdsPar;         
    URANIE::DataServer::TDataServer *_tdsObs;         
    URANIE::DataServer::TDataServer *_tdsEval;        
    
    ELauncher _nLauncher;                             
    TString _sFunctionName;                           
    TString _sEI;                                     
    TString _sEO;                                     
    URANIE::Launcher::TCode *_code;                   
    URANIE::Relauncher::TRun *_run;                   
    void (*_pFunction)(double *, double *);           
    vector<URANIE::DataServer::TStochasticAttribute*>  _vatt; 

protected:

    URANIE::Calibration::TDistanceFunction *_dFunc;   
    URANIE::DataServer::TDSNtupleD         *_evTuple; 

    TList *_listOfParameters;                         

    TCanvas *_canvas;                                 
    TObjArray *_drawingGarbageCollector;              
    
    int _nSam;                                        
    int _nObs;                                        
    int _nIterMax;                                    
    int _nPar;                                        
    int _nVar;                                        
    
    int   _nSeed;                                     
    TString _sMethodName;                             
    TString _referenceName;                           
    TString _outputName;                              
    vector<string> _vrefName;                         
    vector<string> _voutName;                         
    TString _weightName;                              
    TMatrixD _mObsCovMat;                             
    
    bool   _buseMatrix;                               
    bool   _bsaveAll;                                 
    bool   _bdontKeepAgreement;                       
    bool   _buseMode;                                 
    Bool_t _blog;                                     

    
public:
    //---------------------------------------------

    TCalibration(URANIE::DataServer::TDataServer *tds, URANIE::Relauncher::TRun *run, int ns=1, Option_t * option = "");
    
    TCalibration(URANIE::DataServer::TDataServer *tds, void (*fcn)(Double_t*,Double_t*), const char *varexpinput, const char *varexpoutput, int ns = 1, Option_t * option = "");

    TCalibration(URANIE::DataServer::TDataServer *tds, const char *fcn, const char *varexpinput, const char *varexpoutput, int ns = 1, Option_t * option = "");

    TCalibration(URANIE::DataServer::TDataServer *tds, URANIE::Launcher::TCode *fcode, int ns = 1, const char *option = "");
    
    virtual ~TCalibration();

    //---------------------------------------------
    Int_t getID()
    {
        return ID_CALIBRATION;
    }

    void setSeed(UInt_t nval)
    {
        _nSeed = nval;
    }

    UInt_t getSeed()
    {
        return _nSeed;
    }

    const char * getMethodName()
    {
        return _sMethodName.Data();
    }

    void setObservationCovarianceMatrix(TMatrixD &mat);

    URANIE::Calibration::TDistanceFunction *getDistanceFunction() { return _dFunc; }   
    
    Int_t getNPar() {
        return _nPar;
    }

    URANIE::DataServer::TDataServer *getEvaluationTDS() {
        return _tdsEval;
    }
    
    
    //---------------------------------------------

    virtual void setDistanceAndReference(const char *funcName, URANIE::DataServer::TDataServer *tdsRef, const char *input, const char *reference, const char *weight="");

    virtual void setDistanceAndReference(URANIE::Calibration::TDistanceFunction *distFunc, URANIE::DataServer::TDataServer *tdsRef, const char *input, const char *reference, const char *weight="");
    
    //---------------------------------------------

    /* 
     * \brief common method to estimate the parameters once all variables are set
     * \param option : see parseOption
     */
    void estimateParameters(Option_t *option="");

    /* 
     * \brief common method to estimate the residue on the observed dataserver given a specific set of parameter values
     * \param resName: the name of the parameters to be stored
     * \param n_theta: the number of parameters
     * \param theta: the values of the parameters
     */
    void estimateCustomResidues(string resName, int n_theta, double *theta);

    
    /* 
     * \warning Should only be used by user if one wants to provide its own DistanceFunction
     */
    void checkReference(URANIE::DataServer::TDataServer *tdsRef, const char *input, const char *output, const char *weight);    
    

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

    virtual void drawParameters(TString sTitre, const char *variable = "*", const char *select = "1>0", Option_t * option = "");// { UNUSED(sTitre, variable, select, option); cout<<"The method drawParameters is not relevant (and so not implemented) for the class "<<this->ClassName()<<endl; }

    void drawResidues(TString sTitre, const char *variable = "*", const char *select="1>0", Option_t * option = "");

    //---------------------------------------------
    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 = "");

    
protected:
    //---------------------------------------------

    void setMethodName(const char *str)
    {
        _sMethodName = TString(str);
    }
    

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

    virtual void computeParameters(Option_t *option="")=0;
    virtual void checktdsParContent()=0;
    
    void checkCanvasCreation(bool newcan);

    void initInputs();

    void initResults(vector<string> *ParsedLines);

    void computeAPosterioriForDistribution();

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

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

    ClassDef(URANIE::Calibration::TCalibration, ID_CALIBRATION)

};

} // Fin du namespace Calibration
} // Fin du namespace URANIE

#endif