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