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