TCirce.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 TCIRCE_H
#define TCIRCE_H

#include "TUncertModeler.h"

#include <iostream>
#include <fstream>

using std::cout;
using std::endl;

// ROOT
#include "Rtypes.h"
#include "TVectorD.h"
#include "TSystem.h"

// Uranie
#include "UncertModeler.h"
#define CIRCE_DIFF_ATTRIBUTE "__circe__diff__"
#define CIRCE_RESIDU_ATTRIBUTE "__circe__residual__"
#define CIRCE_BLOC_NAME "__circe__bloc__"

namespace URANIE
{
namespace UncertModeler
{
class TCirce: public TUncertModeler
{

    // Attributes
public:
    enum ECirceMethod
    {
        kBiais, kBiaisBloc, kBiaisBlocCInitAlea, kBiaisBlocBootstrap, kUnknown
    };
protected:
    Int_t _nSeed;                          
    Double_t _dTol;    
    Double_t _dLikelihood;         
    TVectorD _vecBiais;                           
    TMatrixD _matC;                          
    TMatrixD _matCorrelation;               
    Int_t _nPatterns;                             
    Int_t _nParameters;                           
    TString _sCirceInputFile;                     
    ECirceMethod _nCirceMethod; 

    Int_t _nInitCAlea;              

    TList * _listOfTDS;                  
    TList * _listOfInformations;          
    TList * _listOfBloc; 
    TList * _listOfSensitivity;           

    TVectorD _vecDiff;                          
    TVectorD _vecYStarVariance;         
    TMatrixD _matSensibility;                     
    TMatrixD _matInitialC;                        
    TVectorD _vecInitialB;                        

    TMatrixD _matVarianceMu;                      
    TMatrixD _matVarianceSigma;                   


    // Methods
public:
    //---------------------------------------------
    TCirce(URANIE::DataServer::TDataServer *tds, const char *systar,
            const char *syhat, const char *ssensi, const char *sexpuncert = "",
            Option_t * option = "");
    virtual ~TCirce();

    //---------------------------------------------
    void setTolerance(Double_t dtol);
    Double_t getTolerance()
    {
        return _dTol;
    }
    void setNCMatrix(Int_t n)
    {
        _nInitCAlea = n;
    }
    Int_t getNCMatrix()
    {
        return _nInitCAlea;
    }
    Int_t getNTDS();
    Double_t getLikelihood()
    {
        return _dLikelihood;
    }
    Int_t getNPatterns()
    {
        return _nPatterns;
    }
    Int_t getNParameters()
    {
        return _nParameters;
    }
    TMatrixD getMatrixVarianceMu()
    {
        return _matVarianceMu;
    }
    TMatrixD getMatrixVarianceSigma()
    {
        return _matVarianceSigma;
    }

    //---------------------------------------------
    void setCMatrixInitial(TMatrixD mat);
    TMatrixD getCMatrixInitial()
    {
        return _matInitialC;
    }
    TMatrixD getCMatrix()
    {
        return _matC;
    }
    void setBVectorInitial(TVectorD vec);
    TVectorD getBVectorInitial()
    {
        return _vecInitialB;
    }
    TVectorD getBVector()
    {
        return _vecBiais;
    }

    //---------------------------------------------
    void init(Option_t * option = "");
    void estimate(Option_t * option = "");
    void terminate(Option_t * option = "");
    void printResults(Option_t * option = "");
    void addData(URANIE::DataServer::TDataServer *tds, const char *systar,
            const char *syhat, const char *ssensi, const char *sexpuncert = "");

    //---------------------------------------------
    void setInputFile(const char * sfile);
    const char * getInputFile()
    {
        return _sCirceInputFile.Data();
    }
    void readInputFile(const char * sfile = "", ECirceMethod nCirceMethod =
            kBiaisBloc);

    //---------------------------------------------
    void addBloc(URANIE::DataServer::TDataServer *tds, const char *sbloc,
            const char* sname = "");
    TMatrixD initCMatrix(Int_t nrows, Double_t dMulti);

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

    void setSeed(Int_t ind = 0);
    Int_t getSeed()
    {
        return _nSeed;
    }

    //---------------------------------------------
    virtual void printLog(Option_t *option = "");

    ClassDef(URANIE::UncertModeler::TCirce, ID_UNCERTMODELER)
    //The description
};

} // End Of namespace UncertModeler
} // End Of namespace URANIE

#endif
//  End Of File TCirce.h