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