TPolynomialRegression.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 TPOLYNOMIALREGRESSION_H
#define TPOLYNOMIALREGRESSION_H

#define MAXLENGTHSTRING 250

//ROOT

// Uranie
#include "TModeler.h"
#include "TDataServer.h"
#include "UMessageLogger.h"
#include "TLinearRegression.h"

namespace URANIE
{
namespace Modeler
{
class TPolynomialRegression: public TModeler
{
public:
    enum ECriteria
    {
        kUnknown, kR2, kR2A, kQ2
    };
protected:
    // the mutable declaration is needed to use the logger in const methods
    URANIE::DataServer::UMessageLogger *_fLogger;   

private:
    ECriteria _nCriteria;                     
    Double_t _dCriteria;                       

    Bool_t _bChangemaxorder; 
    Bool_t _OKcomplete;            
    URANIE::Modeler::TLinearRegression *_theTLR; 
    URANIE::DataServer::TDataServer *_completeDS; 
    TString _sCompleteInputAttributes; 
    TList *_lPropMonoms; 
    TString _sLROption; 
    TObjArray *_drawingGarbageCollector; 
    
public:
    Double_t _dr2a;                                
    Double_t _dq2;                                 
    Double_t _dPress;                              

    TTree* _ntresult;                             
    Char_t _sMonomials[MAXLENGTHSTRING];     
    Int_t _nMonomials;                     
    Int_t _bRetained;        
    Double_t _dValueCriteria; 
    Double_t _dAllCriteria[3]; 

    Int_t _nMinOrder;                   
    Int_t _nMaxOrder;                   
    Int_t _nMaxMonomes; 
    Int_t _nNumber;                          

    Bool_t _bTrace;                    
    TString _sTraceFile;                         
    // Operations
private:
    Bool_t _generateCompletePolynomial();
public:
    //---------------------------------------------

    TPolynomialRegression(URANIE::DataServer::TDataServer *tds,
            TString architecture, Option_t *option = "");

    TPolynomialRegression(URANIE::DataServer::TDataServer *tds,
            const char *varexpinput, const char *varexpoutput,
            Option_t * option = "");
    virtual ~TPolynomialRegression();

    //---------------------------------------------
    Double_t getR2Adjusted()
    {
        return _dr2a;
    }
    Double_t getQ2()
    {
        return _dq2;
    }
    Double_t getPress()
    {
        return _dPress;
    }

    void setMinimalOrder(Int_t iorder)
    {
        if (iorder < 0)
            throw URANIE::Exceptions::UErrorExceptions(__FILE__, __LINE__,
                    "TPolynomialRegression::setMinimalOrder - Error: invalid value for minimal order (Need to be >0)");
        else if (iorder > _nMaxOrder)
            throw URANIE::Exceptions::UErrorExceptions(__FILE__, __LINE__,
                    "TPolynomialRegression::setMinimalOrder - Error: invalid value for minimal order (Need to be lower than maximal order)");
        _nMinOrder = iorder;
    }


    void setMaximalOrder(Int_t iorder)
    {
        if (iorder < 0)
            throw URANIE::Exceptions::UErrorExceptions(__FILE__, __LINE__,
                    "TPolynomialRegression::setMaximalOrder - Error: invalid value for maximal order (Need to be >0)");
        else if (iorder < _nMinOrder)
            throw URANIE::Exceptions::UErrorExceptions(__FILE__, __LINE__,
                    "TPolynomialRegression::setMaximalOrder - Error: invalid value for maximal order (Need to be greater than minimal order)");
        else if (iorder > 2)
            throw URANIE::Exceptions::UErrorExceptions(__FILE__, __LINE__,
                    "TPolynomialRegression::setMaximalOrder - Error: a maximal order greater than 2 is under development");
        _nMaxOrder = iorder;
        _bChangemaxorder = true;
    }

    void setMaxMonomes(Int_t n);
    Int_t getMaxMonomes()
    {
        return _nMaxMonomes;
    }


    void setTrace(TString straceFile = "");
    void unsetTrace()
    {
        _bTrace = kFALSE;
    }
    Bool_t getTrace()
    {
        return _bTrace;
    }
    TString getTraceFile();


    void setCriteria(Double_t dcriteria)
    {
        if (dcriteria < 0.)
            throw URANIE::Exceptions::UErrorExceptions(__FILE__, __LINE__,
                    "TPolynomialRegression::setCriteria - Error: invalid value for criteria (Need to be >0)");
        else if (dcriteria > 1.)
            throw URANIE::Exceptions::UErrorExceptions(__FILE__, __LINE__,
                    "TPolynomialRegression::setCriteria - Error: invalid value for criteria (Need to lower than 1)");
        _dCriteria = dcriteria;
    }

    TTree * getResultsTree()
    {
        return _ntresult;
    }
    //---------------------------------------------
    void estimate(Option_t * option = "");


    void estimateExaustiveResearch(Option_t * option);
    void recursiveSearch(TList * tl, Int_t npos, TString str);


    void fillIndex(TString sinputname, Double_t dval, Int_t bRetained = 0);

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

//     void exportFunction(const char* lang, const char* file = "",
//             const char* name = "");

    void exportModelCplusplus(std::ofstream * sourcefile) const;

    void exportModelFortran(std::ofstream * sourcefile) const;
    

    void exportModelPMML(const char* file = "", 
                         const char* name = "",Option_t *option = "") const
    {
        TString soption = option;
        soption.ToLower();
        UNUSED(file,name);
        std::cerr
                << "   --- Method TPolynomialRegression::exportModelPMML(ofstream * sourcefile) not yet implemented"
                << endl;
    };
    

    void exportModelPython(std::ofstream * sourcefile) const
    {
        UNUSED(sourcefile);
        std::cerr
                << "   --- Method TPolynomialRegression::exportModelPython(ofstream * sourcefile) not yet implemented"
                << endl;
    };
    

    //---------------------------------------------
    virtual void printLog(Option_t *option = "");

    ClassDef(URANIE::Modeler::TPolynomialRegression, ID_MODELER)
    //Classe de
};

} // Fin du namespace Modeler
} // Fin du namespace URANIE
#endif