TBestEstimate.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 TBESTESTIMATE_H
#define TBESTESTIMATE_H
 
#include <iostream>
 
//ROOT
#include "Rtypes.h"
#include "TNamed.h"
#include "TMatrixD.h"
 
// Uranie
#include "Optimizer.h"
#include "TDataServer.h"
 
using namespace URANIE::DataServer;
 
namespace URANIE
{
namespace Optimizer
{
class TBestEstimate: public TNamed
{
private:
    // Log
    Bool_t _blog;
 
    // Data sets
    TDataServer *_tdsParam;
    TDataServer *_tdsResp;
    TDataServer *_tdsMeas;
    TDataServer *_tdsOAT;
 
    // matrix dimensions
    Int_t _nParam;
    Int_t _nResp;
    Int_t _nParamTimeSteps;
    Int_t _nRespTimeSteps;
 
    // user provided data
    TMatrixD _a, _m, _r;
    TMatrixD _ca, _cm;
    TMatrixD _car;
    TMatrixD _s;
 
    // Calculated data
    TMatrixD _d;
    TMatrixD _cr, _cd;
    TMatrixD _aBE, _rBE;
    TMatrixD _caBE, _crBE;
    TMatrixD _carBE;
    Double_t _chi2;
 
public:
    //---------------------------------------------
 
    TBestEstimate();
 
 
    TBestEstimate(Int_t nParam, TMatrixD a, Int_t nResp, TMatrixD m, TMatrixD r,
            TMatrixD ca, TMatrixD cm, TMatrixD s, TMatrixD car);
 
 
    TBestEstimate(TDataServer *tdsParam, TDataServer *tdsMeasures,
            TDataServer *tdsResponses, TMatrixD sMatrix, TMatrixD carMatrix);
 
 
    TBestEstimate(TDataServer *tdsParam, TDataServer *tdsMeasures,
            TDataServer *tdsResponses, TDataServer *tdsOATSampling,
            TMatrixD carMatrix);
 
    virtual ~TBestEstimate();
 
    //---------------------------------------------
    void setParameterData(TDataServer *tds);
    TDataServer* getParameterData()
    {
        return _tdsParam;
    }
 
    void setMeasureData(TDataServer *tds);
    TDataServer* getMeasureData()
    {
        return _tdsMeas;
    }
 
    void setResponseData(TDataServer *tds);
    TDataServer* getResponseData()
    {
        return _tdsResp;
    }
 
    void setOATSamplingData(TDataServer *tds);
    TDataServer* getOATSamplingData()
    {
        return _tdsOAT;
    }
 
    void setSensitivityMatrix(TMatrixD matrix);
    TMatrixD getSensitivityMatrix()
    {
        return _s;
    }
 
    void setParameterResponseCovMatrix(TMatrixD matrix);
    TMatrixD getParameterResponseCovMatrix()
    {
        return _car;
    }
 
    TMatrixD getParameterMatrix()
    {
        return _a;
    }
    TMatrixD getMeasureMatrix()
    {
        return _m;
    }
    TMatrixD getResponseMatrix()
    {
        return _r;
    }
    TMatrixD getParameterCovMatrix()
    {
        return _ca;
    }
    TMatrixD getMeasureCovMatrix()
    {
        return _cm;
    }
    TMatrixD getResponsesCovMatrix()
    {
        return _cr;
    }
    TMatrixD getDifferencesCovMatrix()
    {
        return _cd;
    }
 
    TMatrixD getBestEstParameterMatrix()
    {
        return _aBE;
    }
    TMatrixD getBestEstResponseMatrix()
    {
        return _rBE;
    }
    TMatrixD getBestEstParameterCovMatrix()
    {
        return _caBE;
    }
    TMatrixD getBestEstResponsesCovMatrix()
    {
        return _crBE;
    }
    TMatrixD getBestEstParameterResponsesCovMatrix()
    {
        return _carBE;
    }
 
    Double_t getChi2()
    {
        return _chi2;
    }
    Double_t getConsistencyMeasure()
    {
        return _chi2 / (_nResp * _nRespTimeSteps);
    }
    
    Int_t getNInputParameter()
    {
        return _nParam;
    }
    
    Int_t getNResponses()
    {
        return _nResp;   
    }
    
    Int_t getNTimeStepsInputParameter()
    {
        return _nParamTimeSteps;   
    }
    
    Int_t getNTimeStepsResponses()
    {
        return _nRespTimeSteps;   
    }
    
    
 
    //---------------------------------------------
    void buildMatrices();
    void buildSensitivityMatrix();
    void runBestEstimate();
    //---------------------------------------------
 
    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::Optimizer::TBestEstimate, ID_OPTIMIZER)
};
 
} // Fin du namespace Optimizer
} // Fin du namespace URANIE
#endif