TGPBuilder.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 TGPBUILDER_H
#define TGPBUILDER_H

#include "TObjArray.h"

#include "TCorrelationFunction.h"
#include "TShareEval.h"
#include "TDataServer.h"       
#include "TAttribute.h"   
#include "TKriging.h"
#include "TOptimShare.h"

#include <vector>

extern "C"
{
int gpMod0(double *Kin, double *yin, int n, double *gamma, double *iL);
int gpModh(double *Hin, double *Kin, double *yin, int n, int p, double *hbeta, double *vbeta, double *gamma, double *iL, double *iR, double *M);
int gpModhBayes(double *BetaPrior, double *QPrior, double *Hin, double *Kin, double *yin, int n, int p, double *BetaPost, double *QPost, double *gamma, double *iL, double *iR, double *M);

int gpLoo0Error(double *Kin, double *yin, int n, double *errorLoo, double *varLoo, double *eqmLoo);
int gpLoohError(double *Hin, double *Kin, double *yin, int n, int p, double *errorLoo, double *varLoo, double *eqmLoo);
int gpLoohBayesError(double *BetaPrior, double *Qprior, double *Hin, double *Kin, double *yin, int n, int p, double *errorLoo, double *varLoo, double *eqmLoo);
}
;

namespace URANIE
{
    namespace Modeler
    {
        class TGPBuilder
        {
        
            // Attributes
        private:
            Bool_t _blog; 

            void LSort(Double_t *costValues, Int_t *minIndexes, Int_t nbthreads, Int_t n);

        public:
            URANIE::DataServer::TDataServer *_tds; 
        
            TString _sInputAttributes;   
            TString _sOutputAttributes;  
            Int_t _nX;  
            Int_t _nY;  
        
            TCorrelationFunction* correlationFunction; 
            Bool_t bHas_corrFunction; 
            Bool_t bVariance_in_factor; 
            Bool_t bHas_measurement_error; 
            
            Int_t _nS;        
            Int_t _nP;        
            Double_t reg;     
            Double_t tolerance;  
            Double_t sigma2;  
            Double_t alpha;   
            std::vector<double> Vmes;   
            std::vector<double> H;      
            std::vector<double> C;      
            std::vector<double> K;      
            std::vector<double> xObs;   
            std::vector<double> yObs;   
            std::vector<double> xNormParams; 

            Double_t  _modlengthMax; 
            Double_t  _modlengthMin; 
            Double_t  _lengthMaxScreeningSF; 
            
            TString trendString;       
//            std::vector<TFormula> trendCoefList;  ///< List of the formulas of the trend coefficients (_nP elements)
            Bool_t bHas_trend;         
            Bool_t bUse_normalisation; 
            
            std::vector<double> BetaPrior; 
            std::vector<double> QPrior;    
            Bool_t bUse_prior;   
            Int_t _nSeed; 

            Int_t _retOptim; 

            Bool_t bIsbuildWithDuplicateKandCandCorrFunc;   
            
            // Operations
        public:
            //---------------------------------------------
            TGPBuilder();
            

            TGPBuilder(URANIE::DataServer::TDataServer *tdsObs,
                       const char *varexpinput,
                       const char *varexpoutput, 
                       TCorrelationFunction* corrFunc, 
                       const char *trend = "",
                       Option_t   *option = "");


            TGPBuilder(URANIE::DataServer::TDataServer *tdsObs,
                       const char *varexpinput,
                       const char *varexpoutput, 
                       const char *corrFunc, 
                       const char *trend = "",
                       Option_t   *option = "");


            TGPBuilder(URANIE::DataServer::TDataServer *tdsModelData);

            TGPBuilder* buildWithDuplicateKandCandCorrFunc();
           
            void initVariables();
            
            void initMatrices();
            
            void createTrend();           

            virtual ~TGPBuilder();            
        
            //---------------------------------------------
            Bool_t hasCorrFunction()
            {
                return bHas_corrFunction;
            }

            Bool_t hasVarianceInFactor()
            {
                return bVariance_in_factor;
            }

            Bool_t hasMeasurementError()
            {
                return bHas_measurement_error;
            }            
            
            Bool_t hasTrend()
            {
                return bHas_trend;
            }
                    
            Bool_t usePrior()
            {
                return bUse_prior;
            }

            int getReturnOptim()
                {
                    return _retOptim;
                }
            
            TCorrelationFunction* getCorrFunction()
            {
                return correlationFunction;
            }
        
            Int_t getNInputs()
            {
                return _nX;
            }
        
            Int_t getNObs()
            {
                return _nS;
            }
        
            Int_t getNTrendParams()
            {
                return _nP;
            }
        

            std::vector<double> const& getObsInputs()
            {
                return xObs;
            }
        
            std::vector<double> const& getObsOutput()
            {
                return yObs;
            }


            std::vector<double> const& getObsNormParams()
            {
                return xNormParams;
            }
            
            std::vector<double> const& getCovarianceMatrix()
            {
                return K;
            }

            void setCorrFunc(TCorrelationFunction* corrFunc)
            {
                correlationFunction = corrFunc;
                bIsbuildWithDuplicateKandCandCorrFunc = kTRUE;
            }
        
            std::vector<double> const& getCorrelationMatrix()
            {
                return C;
            }

            std::vector<double> const& getMeasurementErrorCovMatrix()
            {
                return Vmes;
            }
        
            std::vector<double> const& getTrendMatrix()
            {
                return H;
            }
        
            /* std::vector<TFormula> const& getTrendFormula()
            {
                return trendCoefList;
            } */
        
            TString getTrendString()
            {
                return trendString;
            }
            
            std::vector<double> const& getTrendPriorMeans()
            {
                return BetaPrior;
            }
        
            std::vector<double> const& getTrendPriorCovMat()
            {
                return QPrior;
            }
        
            Double_t getVariance()
            {
                return sigma2;
            }

            Double_t getTolerance()
            {
                return tolerance;
            }

            Double_t getAlpha()
            {
                return alpha;
            }

            Double_t getRegularisation()
            {
                return reg;
            }
            
            
            Int_t getSeed()
            {
                return _nSeed;
            }

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

            void setLengthRange(double themin, double themax);


            void setLengthMaxScreeningSF(double sf);
            

            void setCorrFunction(TCorrelationFunction* corrFunc);


            void setCorrFunction(const char* corrFuncType);
            

            void setVariance(Double_t var)
            {
                sigma2 = var;
            }


            void setTolerance(Double_t tol)
            {
                tolerance = tol;
            }


            void setRegularisation(Double_t regularisation)
            {
                reg = regularisation;
            }
            

            void setHasMeasurementError(Bool_t has_measurement_error = kTRUE)
            {
                bHas_measurement_error = has_measurement_error;
            }


            void setAlpha(Double_t a)
            {
                alpha = a;
                bHas_measurement_error = kTRUE;
                bVariance_in_factor = kTRUE;
            }
            

            void setMeasurementErrorCovMatrix(Double_t* covMes);


            void setMeasurementErrorVariance(Double_t varMes);
            

             void setTrendString(const char* trend)
             {
                 trendString = TString(trend);
             }
                     

            void setPriorData(Double_t* betaPrior, Double_t* qPrior);
        

            void setUsePrior(Bool_t use_prior = kTRUE);
            
            void computeCovarianceMatrix(bool print = false);
            

            void setSeed(Int_t nSeed = 0);
            
               
            //---------------------------------------------
            

            void updateObservations();
            

            void exportGPData(const char* fileName);

    

            void findOptimalParameters(TString criterion = "ML",
                                       Int_t screeningSize = 100,
                                       TString optimAlgo = "BFGS",
                                       Int_t nbMaxOptimSteps = 1000,
                                       Bool_t reset = kTRUE,
                                       Option_t * option = "");
            void findOptimalParameters(TString criterion,
                                       Int_t screeningSize,
                                       URANIE::Reoptimizer::TOptimSolver *solv,
                                       Int_t nbMaxOptimSteps = 1000,
                                       Bool_t reset = kTRUE,
                                       Option_t * option = "");
        

            URANIE::Modeler::TKriging* buildGP(Bool_t computeLooErrors = kTRUE);

            void cleanAttributeList(TList *inputlist);
        
            //---------------------------------------------
                void setLog()
                {
                    _blog = kTRUE;
                }

                void unsetLog()
                {
                    _blog = kFALSE;
                }

                void changeLog()
                {
                    _blog = !_blog;
                }

                Bool_t getLog()
                {
                    return _blog;
                }

                virtual void printLog(Option_t *option = "");
        
            ClassDef(URANIE::Modeler::TGPBuilder, ID_MODELER)
            //Classe de
        };    
    } // Fin du namespace Modeler
} // Fin du namespace URANIE
#endif