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"
 
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;   
            Double_t* Vmes;   
            Double_t* H;      
            Double_t* C;      
            Double_t* K;      
            Double_t* xObs;   
            Double_t* yObs;   
            Double_t* xNormParams; 
 
            Double_t  _modlengthMax; 
            Double_t  _modlengthMin; 
            Double_t  _lengthMaxScreeningSF; 
            
            TString trendString;       
            TObjArray* trendCoefList;  
            Bool_t bHas_trend;         
            Bool_t bUse_normalisation; 
            
            Double_t* BetaPrior; 
            Double_t* 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;
            }
        
 
            Double_t* getObsInputs()
            {
                return xObs;
            }
        
            Double_t* getObsOutput()
            {
                return yObs;
            }
 
 
            Double_t* getObsNormParams()
            {
                return xNormParams;
            }
            
            Double_t* getCovarianceMatrix()
            {
                return K;
            }
 
            void setKandCandCorrFunc(Double_t* inK, Double_t* inC, TCorrelationFunction* corrFunc)
            {
               K = inK;
               C = inC;
               correlationFunction = corrFunc;
               bIsbuildWithDuplicateKandCandCorrFunc = kTRUE;
            }
        
            Double_t* getCorrelationMatrix()
            {
                return C;
            }
 
            Double_t* getMeasurementErrorCovMatrix()
            {
                return Vmes;
            }
        
            Double_t* getTrendMatrix()
            {
                return H;
            }
        
            TObjArray* getTrendFormula()
            {
                return trendCoefList;
            }
        
            TString getTrendString()
            {
                return trendString;
            }
            
            Double_t* getTrendPriorMeans()
            {
                return BetaPrior;
            }
        
            Double_t* 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 = "");
        
 
            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