TAnisp.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 TANISP_H
#define TANISP_H
 
#include <vector>
#include <string>
#include "math.h"
 
//ROOT
#include "Rtypes.h"
#include "TLeaf.h"
#include "TCanvas.h"
#include "TH1F.h"
#include "TLegend.h"
 
// uranie
#include "TDataServer.h"
#include "TModeler.h"
#include "TStochAttribut.h"
#include "UExceptions.h"
#include "TLauncherFunction.h"
#include "TCode.h"
#include "TLauncher.h"
#include "TPolynomialChaos.h"
#include "TNisp.h"
 
// anisp
#include "anisp.hpp"
 
using namespace URANIE::DataServer;
using namespace URANIE::Exceptions;
using namespace URANIE::Launcher;
 
namespace URANIE
{
namespace Modeler
{
 
void StepByStepOutput(Double_t * val, vector<Int_t *> indices);
 
void functionLauncher(vector<Double_t *> ptEXp);
 
class TAnisp: public TModeler
{
public:
    enum ANISP_TYPE
    {
        kAnalyticalFunction, kCode
    };
 
    friend void StepByStepOutput(Double_t * val, vector<Int_t *> indices);
 
    friend void functionLauncher(vector<Double_t *> ptEXp);
 
//     public:
//       //! Boolean for edit the log.
//       Bool_t  _blog;
 
private:
    TObjArray *_drawingGarbageCollector;
    Double_t _dTolerance;
    Int_t _nKMin;
    Int_t _nNumberMaxOfSimulations;
    Int_t _nGreaterIndice;
    Int_t _nMaxIndices;
    Int_t _nDegreeMax;
    TString _sRootFilename;
    TString _sLaws;
    Int_t _nIterationNumber;
    TLauncherFunction * _tAnalyticalFunction;
    TCode * _Code;
    TLauncher * _tlauncher;
    ANISP_TYPE _nCible;
    TPolynomialChaos * _tpc;
    TNisp * _nisp;
    TNtupleD * _tErrorIndicator;
    TNtupleD * _tIntegrationIndices;
    /* //! Canvas for graphical outputs */
    /* TCanvas * _myCanvas; */
    Int_t _nNumberOfLaunching;
    Int_t _nNumberOfPoints;
    TString _sinput;
    TString _soutput;
    TDataServer* _tdsAnisp;
#ifdef ROOT5
    void* _analyticalFunction;
#else
    void (*_analyticalFunction)(Double_t*, Double_t*);
#endif
    TString _sFunctionName;
    Int_t _ninputs;
    Int_t _nUranieAnisp;
    TString _sLaunchNumber;
    /* //! Object of type TH1F used for graphical output */
    /* TH1F* _hist1; */
    /* //! Object of type TH1F used for graphical output */
    /* TH1F* _hist2; */
 
public:
#ifdef ROOT5
    TAnisp(TDataServer *tds, void *analyticalFunction, TString sinput = "",
            TString soutput = "", Option_t *option = "");
#else
    TAnisp(TDataServer *tds, void (*analyticalFunction)(Double_t*,Double_t*), 
            const char *fname, TString sinput = "",
            TString soutput = "", Option_t *option = "");
#endif
    TAnisp(TDataServer *tds, const char* analyticalFunction, TString sinput = "",
           TString soutput = "", Option_t *option = "");
 
    TAnisp(TDataServer *tds, TCode* code, Option_t *option = "");
 
    virtual ~TAnisp();
 
    //---------------------------------------------
 
    void exportModelCplusplus(std::ofstream * sourcefile) const;
 
 
    void exportModelFortran(std::ofstream * sourcefile) const
    {
        UNUSED(sourcefile);
        std::cerr
                << "   --- Method TAnisp::exportModelFortran(ofstream * sourcefile) not yet implemented"
                << endl;
    } ;
    
 
    void exportModelPMML(const char* file = "", 
                         const char* name = "",Option_t *option = "") const
    {
        TString soption = option;
        soption.ToLower();
        UNUSED(file,name);
        std::cerr
                << "   --- Method TAnisp::exportModelPMML(ofstream * sourcefile) not yet implemented"
                << endl;
    };
    
 
    void exportModelPython(std::ofstream * sourcefile) const
    {
        UNUSED(sourcefile);
        std::cerr
                << "   --- Method TAnisp::exportModelPython(ofstream * sourcefile) not yet implemented"
                << endl;
    };
 
    //---------------------------------------------
//       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 = "");
 
    //---------------------------------------------
 
 
    void setKMin(Int_t kmin);
 
    Int_t getKMin()
    {
        return _nKMin;
    }
 
 
    void setTolerance(Double_t tol);
 
    Double_t getTolerance()
    {
        return _dTolerance;
    }
 
    void setNumberMaxOfSimulations(Int_t nmos);
 
    Int_t getNumberMaxOfSimulations()
    {
        return _nNumberMaxOfSimulations;
    }
 
    void setGreaterIndice(Int_t greatInd);
 
    Int_t getGreaterIndice()
    {
        return _nGreaterIndice;
    }
 
    void setMaxIndices(Int_t maxInd);
 
    Int_t getMaxIndices()
    {
        return _nMaxIndices;
    }
 
    void setDegreeMax(Int_t degMax);
 
    Int_t getDegreeMax()
    {
        return _nDegreeMax;
    }
 
    Int_t getCible()
    {
        return _nCible;
    }
 
 
    Int_t getIterationNumber()
    {
        return _nIterationNumber;
    }
 
    void setlog(Bool_t blog);
 
    void setRootFilename(TString rootName);
 
    TString getRootFilename()
    {
        return _sRootFilename;
    }
 
    TNtupleD* getErrorIndicator()
    {
        return _tErrorIndicator;
    }
 
    TNtupleD* getIntegrationIndices()
    {
        return _tIntegrationIndices;
    }
 
    TPolynomialChaos getTPolynomialChaos();
 
    TString getVariablesName(TString inputs = "");
 
 
 
    TString getDataAnispFile() const
    {
        return _sRootFilename + "data.dat";
    }
 
    TString getResultFile() const
    {
        return _sRootFilename + TString("res.dat");
    }
 
    TString getStochasticFile() const
    {
        return _sRootFilename + "sto.dat";
    }
 
    TString getErrorIndicatorFile() const
    {
        return _sRootFilename + "error.dat";
    }
 
    TString getIndicesFile() const
    {
        return _sRootFilename + "indices.dat";
    }
 
 
 
 
    void setAllAnispParameters(Double_t tol, Int_t kmin, Int_t nmos,
            Int_t greatInd, Int_t maxInd, Bool_t blog, Int_t degMax,
            TString rootName);
 
    void setAnispParameters(Double_t tol, Int_t kmin, Int_t nmos,
            Int_t greatInd, Int_t maxInd, Bool_t blog);
 
    void setLightAnispParameters(Double_t tol, Int_t kmin, Int_t nmos);
 
 
 
    void runAnisp();
 
    void restartAnisp();
 
 
private:
    void initialize();
 
    void addErrorIndicator(Double_t * errInd)
    {
        _tErrorIndicator->Fill(errInd);
    }
 
    void addIntegrationIndices(Double_t * ind)
    {
        _tIntegrationIndices->Fill(ind);
    }
 
    void launchCalculs(vector<Double_t *> ptExp);
 
    void EndIterationActions(Double_t * errIndicator,
            vector<Double_t *> integrationIndices);
 
    void changeOfVariable(Double_t * x);
 
    void setTPolynomialChaos();
 
    ClassDef(URANIE::Modeler::TAnisp, ID_MODELER)
 
};
//end of the class TAnisp
 
}//end of the namespace Modeler
}     //end of the namespace URANIE
 
R__EXTERN URANIE::Modeler::TAnisp *gUranieTAnisp;
#endif