TPolynomialChaos.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/>.
 
#ifndef TPOLYNOMIALCHAOS_H
#define TPOLYNOMIALCHAOS_H
 
//ROOT
#include "Rtypes.h"
#include "TNamed.h"
 
// uranie
#include "TDataServer.h"
#include "Modeler.h"
 
//nisp
#include "TNisp.h"
#include "nisp_pc.h"
#include "nisp_util.h"
 
#include <ctime>
 
using namespace URANIE::DataServer;
 
namespace URANIE
{
namespace Modeler
{
class TPolynomialChaos: public TNamed
{
 protected:
   URANIE::DataServer::UMessageLogger *_fLogger;   
//-----------------------members of the class
public:
    TNisp * _nisp;
    Int_t _degree;
    PolynomialChaos * _pc;
    Int_t _nx;
    Int_t _np;
    // Number of output
    Int_t _ny;
    Bool_t _bStoreYHat;     
 
    TTree *_degreeResults; 
    double _autoDegreeFactor; 
    int _minAutoDeg; 
    int _maxAutoDeg; 
    int _bestAutoDeg; 
 
    vector<double> *_verrloo; 
    int _degval; 
    double _eqmval; 
      
private:
    TDataSpecification * _listAttOut;
    Bool_t _blog;
//--------------------methodes of the class
public:
 
    TPolynomialChaos(TDataServer *tds, TNisp *nisp, TString soutput = "");
 
    TPolynomialChaos(const char *ct);
 
 
    TPolynomialChaos(const TPolynomialChaos & TPC);
 
    virtual ~TPolynomialChaos();
 
    void setDegree(Int_t degree);
 
 
    void setAutoDegreeFactor(double autodeg);
    
 
    void setAutoDegreeBoundaries(int amin, int amax=-1);
 
    TTree *getAutoDegreeResults()
    {
      return _degreeResults;
    }
    
    int getBestAutoDegree()
    {
      return _bestAutoDeg;
    }
    
 
    void computeOutput(double *input);
 
    Double_t getOutput(TString jname = "");
 
    Double_t getOutput(Int_t j);
 
 
    Double_t getEqmLoo(Int_t rank=0);
    
 
    Double_t getErrLoo(Int_t input, Int_t rank=0);
 
    double factorial(int n);
    
 
    void automatisedDegree(Option_t *option = "");
 
    void computeChaosExpansion(TString type, Option_t * option = "");
 
    Double_t getMean(Int_t j);
 
    Double_t getMean(TString name = "");
 
    Double_t getVariance(Int_t j);
 
    Double_t getVariance(TString name = "");
 
    Double_t getCovariance(Int_t i, Int_t j);
 
    Double_t getCovariance(TString xname, TString yname);
 
    Double_t getCorrelation(Int_t i, Int_t j);
 
    Double_t getCorrelation(TString xname, TString yname);
 
    Double_t getIndexFirstOrder(Int_t i, Int_t j = 0);
 
    Double_t getIndexFirstOrder(TString xname, TString yname = "");
 
    Double_t getIndexTotalOrder(Int_t i, Int_t j = 0);
 
    Double_t getIndexTotalOrder(TString xname, TString yname = "");
 
    Double_t getIndex(TString sinput = "", TString yname = "");
 
    Double_t getIndexInteraction(TString sinput = "", TString yname = "");
 
    Int_t getDimensionInput();
 
    Int_t getDimensionOutput();
 
    Int_t getDimensionExpansion();
 
    Int_t getDegree();
 
    void exportFunction(const char *file = "nisp",
            const char *name = "nisp_fct");
 
    Double_t getCoefficient(Int_t k, TString jname = "");
    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 = "");
private:
 
    void getTarget();
 
    void setGroupAddVar(Int_t i);
 
    void writeCodeCToDenormalizeInput(std::ofstream * sourcefile);
 
    void setGroupEmpty();
public:
 
 
    void setCoefficient(Int_t noutput, Int_t num, Double_t coef);
 
 
    Double_t getCoefficient(Int_t noutput, Int_t num);
 
    //---------------A FAIRE----------juste un lien vers nisp actuellement
    void generateSample(TString type, Int_t np, Int_t order=1);
    Double_t getSample(Int_t k, Int_t j);
    Double_t getSample(Int_t k, TString yname);
    void realisation();
    void getAnova(Int_t nt);
    void getAnovaOrdered(Double_t seuil, Int_t j);
    void getAnovaOrdered(Double_t seuil, TString yname = "");
    void getAnovaOrderedCoefficients(Double_t seuil, Int_t j);
    void getAnovaOrderedCoefficients(Double_t seuil, TString yname = "");
    Double_t getQuantile(Double_t alpha, Int_t j);
    Double_t getQuantile(Double_t alpha, TString yname);
    Double_t getQuantileWilks(Double_t alpha, Double_t beta, Int_t j = 1);
    Double_t getQuantileWilks(Double_t alpha, Double_t beta, TString yname);
    Double_t getInvQuantile(Double_t seuil, Int_t j = 1);
    Double_t getInvQuantile(Double_t seuil, TString yname);
    void readTarget(Char_t *file);
    void setInput(Int_t nt, Double_t dt);
    void propagateInput();
    void propagateInput(Double_t *dt);
    void save(Char_t *file);
    void save(string file);
    void setAnova();
 
    ClassDef(URANIE::Modeler::TPolynomialChaos, ID_MODELER)
 
};
//end of the class TPolynomialChaos
}//end of the namespace Modeler
}      //end of the namespace URANIE
#endif