TDistanceFunction.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 TDISTANCEFUNCTION_H
#define TDISTANCEFUNCTION_H    
 
// Root
#include "TMatrixD.h"
#include "TRandom3.h"
 
#include "Calibration.h"
#include "TStandardEval.h"
#include "TRun.h"
#include "TCode.h"
#include "TLauncher.h"
 
namespace URANIE
{
namespace Calibration
{
 
class TDistanceFunction: public URANIE::Relauncher::TDoubleEval
{
 
 
public:
 
    URANIE::DataServer::TDataServer *_tdsEval;        
    URANIE::DataServer::TDataServer *_tdsObs;         
    URANIE::DataServer::TDSNtupleD  *_allData;         
 
protected:
    //Name of the variables
    vector<string>                   _vrefName;       
    vector<string>                   _voutName;       
    vector<string>                   _vparName;       
 
    //Storing data
    vector<vector<double> >          _yObs;           
    vector<vector<double> >          _yExp;           
    TMatrixD                         _mObsCovMat;     
    TMatrixD                         _myObs;          
    TMatrixD                         _myExp;          
    unsigned int                     _nObs;           
    unsigned int                     _nVar;           
    unsigned int                     _nPar;           
    vector<double>                   _vParValues;
    
    //Weights for events and variables
    vector<double>                   _varWeights;     
    vector<vector<double> >          _obsWeights;     
 
    URANIE::Relauncher::TRun        *_run;
    TString                          _tlcType;
    TString                          _codeLauncherOpt;
    URANIE::Launcher::TCode         *_code;
    TString                         _funcName;
    void (*_pFunction)(double *, double *);           
    TString                         _varexpinput;
    TString                         _varexpoutput;        
        
    // Options
    bool                             _baprioriSet;    
    bool                             _bsaveAll;       
    bool                             _buseMatrix;     
    bool                             _blog;           
    bool                             _dumpAllTds;     
    bool                             _keepParValue;   
    bool                             _bdumpDetails;   
    
    // Iterators
    int                              _icalc;          
    unsigned int                     _ivar, _iobs;
 
    // Attribute
    TList                           *_listOfParameters;
 
    //Random noise
    TRandom3                        *_rand;           
    int                              _nSeed;          
    TMatrixD                         _mSigma;         
    bool                             _boolNoise;      
    
public:
 
    //---------------------------------------------
 
    TDistanceFunction(URANIE::DataServer::TDataServer *tdsEval, URANIE::DataServer::TDataServer *tdsObs, const char *reference, const char *output, const char *weight="");
 
    virtual ~TDistanceFunction();
 
 
    //---------------------------------------------
 
    void fillInOutAtt(URANIE::DataServer::TDataServer *tdsPar);
    void initParameters(URANIE::DataServer::TDataServer *tdsPar, URANIE::Relauncher::TRun *run);
    void initParameters(URANIE::DataServer::TDataServer *tdsPar, const char* funcName, const char *varexpinput, const char *varexpoutput);
    void initParameters(URANIE::DataServer::TDataServer *tdsPar, void (*fcn)(Double_t*,Double_t*), const char *varexpinput, const char *varexpoutput);
    void initParameters(URANIE::DataServer::TDataServer *tdsPar, URANIE::Launcher::TCode *Code);
 
    Int_t eval(Double_t* theta, Double_t* res, int=0);
 
    void runConfiguration(double *theta);
 
    
 
    //---------------------------------------------
 
    vector<vector<double> > getObservationVector() {
        try{
            if( _buseMatrix == true )
                throw URANIE::Exceptions::UErrorExceptions(__FILE__, __LINE__,
                                                           "TDistanceFunction::getObservationVector. This distancefunction is using matrix. Please call getObservationMatrix() instead");
            
        } catch (URANIE::Exceptions::UErrorExceptions& ue)
        {
            ue.printMessage();
            throw ue;
        }
        return _yObs;
    }
 
    TMatrixD getObservationMatrix() {
        try{
            if( _buseMatrix == false )
                throw URANIE::Exceptions::UErrorExceptions(__FILE__, __LINE__,
                                                           "TDistanceFunction::getObservationMatrix. This distancefunction is using vectors. Please call getObservationVector() instead");
            
        } catch (URANIE::Exceptions::UErrorExceptions& ue)
        {
            ue.printMessage();
            throw ue;
        }
        return _myObs;
    }
 
    void setSaveAllEvaluations(bool value)
    {
        _bsaveAll = value;
    }
 
    void changeLauncher(TString tlcName);
 
    void changeCodeLauncherOpt(TString opt){
        _codeLauncherOpt=opt;
    }
 
    void dumpAllDataservers(){
        _dumpAllTds=true;
    }
 
    void keepParametersValue(){
        _keepParValue=true;
    }
 
    void dumpDetails(){
        _bdumpDetails=true;
    }
 
    void addCodeLauncherOpt(TString opt){
        _codeLauncherOpt+=","+opt;
    }
 
    void setUseMatrix(bool value)
    {
        _buseMatrix = value;
        getData(true);
    }
 
    void setVarWeights( int nwei, double *wei);
    void setVarWeights(vector<double> wei);
 
    void setObservationCovarianceMatrix(TMatrixD &mat);
 
    bool getSaveAllEvaluation() {
       return _bsaveAll;
    }
 
    bool getUseMatrix() {
       return _buseMatrix;
    }
    
    void setGaussianRandomNoise(const char *stdname);
    
    void setSeed(UInt_t nval)
    {
        _nSeed = nval;
    }
 
 
 
    
    //---------------------------------------------
    void setLog()
    {
        _blog = kTRUE;
    }
    void unsetLog()
    {
        _blog = kFALSE;
    }
    void changeLog()
    {
        _blog = !_blog;
    }
    Bool_t getLog()
    {
        return _blog;
    }
    virtual void printLog(Option_t *option = "");
    
    
protected:
    //---------------------------------------------
 
    void getData(bool reference=false);  
 
    virtual Int_t localeval(Double_t* res)=0;
 
 
 
    ClassDef(URANIE::Calibration::TDistanceFunction, ID_CALIBRATION)
};
 
} // Fin du namespace Calibration
} // Fin du namespace URANIE
#endif