TSensitivity.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/>.
// TSensitivity jeu sep 14 09:01:14 CEST 2006
// $Id$
// $Author$
// $Date$
// $Revision$
// $State$

#ifndef TSENSITIVITY_H
#define TSENSITIVITY_H

#include "TMethodCall.h"
#include "TTree.h"
#include "TMatrixD.h"
#include "TRandom3.h"
#include "TNamed.h"
#include "TNtupleD.h"
#include "TMath.h"

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

// Uranie
#include "TDataServer.h"
#include "TCode.h"
#include "TRun.h"
#include "UExceptions.h"
#include "Sensitivity.h"
#ifdef WITH_LIBSSH
#include "TCluster.h"
#endif

#define MAXLENGTHSTRING 50

namespace URANIE {
namespace Sensitivity {
class TSensitivity: public TNamed
{

    // Attributes
    //---------------------------------------------
protected:
    Char_t _sOutputAttribute[MAXLENGTHSTRING];  
    Char_t _sInputAttribute[MAXLENGTHSTRING];   
    Char_t _sOrder[MAXLENGTHSTRING];            
    Char_t _sMethod[MAXLENGTHSTRING];           
    Char_t _sAlgorithm[MAXLENGTHSTRING];        
    Double_t _valSobolCrt;                      
    Double_t _valSobolCILower;                  
    Double_t _valSobolCIUpper;                  
    TMatrixD _minputCorr;                       
    Bool_t _bisInputCorrelated;                 
    Bool_t _bgoingThroughError;                 


    //---------------------------------------------
public:
    enum ELauncher
    {
        kCode,kCodeRemote,kFunction, kRun, kUnknown
    };
    
    URANIE::DataServer::TDataServer *_tds;          
    TList *_listOfInputAttributes;               
    TList *_listOfOutputAttributes;              
    TString _sTimeAttribute;            

#ifdef WITH_LIBSSH
    URANIE::Launcher::TCluster* _cluster;
    URANIE::Launcher::TCluster* getCluster(){
        return _cluster;
    };
    
    void addCluster(URANIE::Launcher::TCluster* cluster){
        _cluster =  cluster;
        _cluster->setDataServer(_tds);
    };
#endif

    Int_t _nS; 
    Int_t _nX;               
    UInt_t _nY;               
    UInt_t _nElY;               
    Int_t _nbOut;             
    Int_t _iOut;              
    unsigned int _iy;          
    unsigned int _iely;      

    ELauncher _nLauncher;                           
    TString _sFunctionName;         
    URANIE::Launcher::TCode *_code;                 
    URANIE::Relauncher::TRun *_run;

    TObjArray *_drawingGarbageCollector;         
    Int_t _nSeed;                          

    Bool_t _bChosenOutputs;                    
    Bool_t _blog;                                  
    Bool_t _bquiet;           
    Bool_t _bdrawProgressBar; 
    Bool_t _bnoIntermediateSaved; 

    TString _sIteratorName;        
    TString _sMethodName;         

    TString _sSelectedOutput;           
    TString _sSelectedInput;           

    map<string, unsigned int> _mAttributeSize;  
    map<string, vector<int> > _mAttributeElements;  
    vector<string>            _vOutputNames; 
    
    void setNLauncher(ELauncher codeLauncher){
        _nLauncher = codeLauncher;
    };

    TCanvas *_canvas;                             
    
#ifdef ROOT5
    TMethodCall *fMethodCall; //Pointer to MethodCall in case of interpreted function
    void (*fMethod)(Double_t *x, Double_t *y);
#else
    void (*_pFunction)(double *, double *);
#endif
    TTree* _ntresult;         

    
    // Operations
private:
    void initInputs();
    void initResult();

protected:
    //---------------------------------------------
    void checkCanvasCreation(bool newcan);
    void drawIndexesHistogram(TString sTitre, const char *select = "", Option_t * option = "");
    void drawIndexesPie(TString sTitre, const char *select = "", Option_t * option = "");


    virtual void preTreatment(){}


    virtual void postTreatment(){}


    void setNoIntermediateSaved(Bool_t bbool = kTRUE){
        _bnoIntermediateSaved = bbool;
    }

public:
    //---------------------------------------------
    TSensitivity();
    TSensitivity(URANIE::DataServer::TDataServer *tds, const char *fcn, Int_t ns,
                 const char *varexpinput = "", const char *varexpoutput = "",
                 Option_t * option = "");
#ifdef ROOT5
    TSensitivity(URANIE::DataServer::TDataServer *tds, void *fcn, Int_t ns,
                 const char *varexpinput = "", const char *varexpoutput = "",
                 Option_t * option = "");
#else
    TSensitivity(URANIE::DataServer::TDataServer *tds,
                 void (*fcn)(Double_t*,Double_t*),
                 const char *varexpinput, const char *varexpoutput,
                 Int_t ns, Option_t * option = "");
#endif
    TSensitivity(URANIE::DataServer::TDataServer *tds, const char *varexpinput,
                 const char *varexpoutput, Option_t * option = "");

    TSensitivity(URANIE::DataServer::TDataServer *tds,
                 URANIE::Launcher::TCode *code, Int_t ns, Option_t * option = "");

    TSensitivity(URANIE::DataServer::TDataServer *tds,
                 URANIE::Relauncher::TRun *run, Int_t ns, Option_t * option = "");
    virtual ~TSensitivity();

    //---------------------------------------------
    Int_t getID(){
        return ID_SENSITIVITY;
    }
    virtual TTree * getResultTuple(bool commonresulttuple=true){
        UNUSED(commonresulttuple);
        return _ntresult;
    }

    double getValue(const char * sorder ="", const char * sinputname="", const char * sselect="");

    vector<int>* getAttributeElements(string str){
        return ((_mAttributeElements.count(str)==0)?NULL:&_mAttributeElements[str]);
    }

#ifdef ROOT5
    TMethodCall *GetMethodCall() const{
        return fMethodCall;
    }
    void setFunction(void *fcn, Int_t nx = -1, Int_t ny = 1);
#else
    void setFunction(void (*fct)(Double_t*, Double_t*), Int_t nx = -1, Int_t ny = 1);
#endif
    TString getFunctionName(){
        return _sFunctionName;
    }
    void setSeed(UInt_t nval){
        _nSeed = nval;
    }
    UInt_t getSeed(){
        return _nSeed;
    }
    virtual void setMethodName(const char *str){
        _sMethodName = TString(str);
    }
    const char * getMethodName(){
        return _sMethodName.Data();
    }


    Bool_t getNoIntermediateSaved(){
        return _bnoIntermediateSaved;
    }

    const char * getIteratorName(){
        return _sIteratorName.Data();
    }
    void setSensitivityIteratorName(const char *str){
        _sIteratorName = TString(str);
    }
    void setTimeName(TString sname);
    TString getTimeName() { return _sTimeAttribute;}

    virtual void setDrawProgressBar(Bool_t bbool = kTRUE){
        _bdrawProgressBar = bbool;
    }


    void setUsingErrors(bool thebool){ _bgoingThroughError=thebool;}
    

    Bool_t getDrawProgressBar(){
        return _bdrawProgressBar;
    }
    Bool_t isInputCorrelated() {
        return _bisInputCorrelated;
    }
    TMatrixD getMatrixInputCorrelation() {
        return _minputCorr;
    }

    Int_t getNInput() {
        return _nX;
    }

    Int_t getNOutput() {
        return _nY;
    }

    //---------------------------------------------
    virtual void generateSample(Option_t * option = "") = 0;
    void setInputCorrelationMatrix(TMatrixD Corr);

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

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

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

    void checkOutputRequested(string attlist, bool fromoption=false);

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

    void computeIndexes(Option_t * option = "");

    virtual void evaluateIndexes(Option_t * option = "") = 0;

    void fillIndex(const char * sinputname, const char * sorder,
                   Double_t dval, const char* algo = "",
                   Double_t dvalCILower = -1.0, Double_t dvalCIUpper = -1.0);

    //---------------------------------------------
    virtual void createTuple(Option_t *option = "");
    virtual void drawIndexes(TString sTitre, const char *select = "",
                             Option_t * option = "");


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

    ClassDef(URANIE::Sensitivity::TSensitivity, ID_SENSITIVITY)

};

} // Fin du namespace Sensitivity
} // Fin du namespace URANIE

#ifdef ROOT5
R__EXTERN URANIE::Sensitivity::TSensitivity *gSensitivity;
#endif

#endif