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