TBaseModel.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 TBASEMODEL_H
#define TBASEMODEL_H
 
#define DEFAULTTOLERANCE 0.0001
 
// ROOT
#include "TNamed.h"
 
// URANIE
#include "XMLProblem.h"
#include "UExceptions.h"
 
namespace URANIE
{
  namespace XMLProblem
  {
    class TBaseModel: public TNamed
    {
    public:
      enum ELanguage
      {
        kEMPTY, kC, kCXX, kPMML, kPYTHON, kFORTRAN
      };
      enum ENorm
      {
        kNO, kCR, kMinusOneOne, kZeroOne
      };
 
    private:
      TString _sinput;
      TString _shidden;
      TString _soutput;
 
      ELanguage _nlanguage;
      ENorm _nNormType;                   
 
      TString _sfileNameExport;
      TString _sfunctionNameExport;
 
      Int_t _niteration;
      Int_t _ninitialization;
 
      Double_t _dlearn;
      Double_t _dtolerance;
      Int_t _nseed;
    public:
      TBaseModel();
      TBaseModel(TString sinput, TString soutput);
      TBaseModel(TString sname, TString sinput, TString shidden, TString soutput);
      virtual ~TBaseModel();
 
      //---------------------------------------------
      void setName(TString str)
      {
        SetName(str);
      }
      void setInput(TString str)
      {
        _sinput = str;
      }
      TString getInput()
      {
        return _sinput;
      }
      void setHidden(TString str)
      {
        _shidden = str;
      }
      TString getHidden()
      {
        return _shidden;
      }
      void setOutput(TString str)
      {
        _soutput = str;
      }
      TString getOutput()
      {
        return _soutput;
      }
      void setLanguage(ELanguage val)
      {
        _nlanguage = val;
      }
      ELanguage getLanguage()
      {
        return _nlanguage;
      }
      void setNormalization(ENorm n)
      {
        _nNormType = n;
      }
 
      ENorm getNormalization()
      {
        return _nNormType;
      }
      void setFileNameExport(TString str)
      {
        _sfileNameExport = str;
      }
      TString getFileNameExport()
      {
        return _sfileNameExport;
      }
      void setFunctionNameExport(TString str)
      {
        _sfunctionNameExport = str;
      }
      TString getFunctionNameExport()
      {
        return _sfunctionNameExport;
      }
      void setNIteration(Int_t n)
      {
        try {
          if (n < 0) {
              throw URANIE::Exceptions::UErrorExceptions(__FILE__, __LINE__,
                                                         Form("TBaseModel::setNIteration Error\n The number of iteration must be positive [%d].", n));
            }
        } catch (URANIE::Exceptions::UErrorExceptions& ue)
        {
          ue.printMessage();
          throw ue;
        }
        _niteration = n;
      }
      Int_t getNIteration()
      {
        return _niteration;
      }
      void setNInitialization(Int_t n)
      {
        try {
          if (n < 0) {
              throw URANIE::Exceptions::UErrorExceptions(__FILE__, __LINE__,
                                                         Form("TBaseModel::setNInitialization Error\n The number of initialization must be positive [%d].", n));
            }
        } catch (URANIE::Exceptions::UErrorExceptions& ue)
        {
          ue.printMessage();
          throw ue;
        }
        _ninitialization = n;
      }
      Int_t getNInitialization()
      {
        return _ninitialization;
      }
      void setLearn(Double_t dval)
      {
        try {
          if ( ( dval < 0 ) || ( dval > 1.0 ) )  {
              throw URANIE::Exceptions::UErrorExceptions(__FILE__, __LINE__,
                                                         Form("TBaseModel::setLearn Error\n The proportion must be in [0.0, 1.0], and we set to [%f].", dval));
            }
        } catch (URANIE::Exceptions::UErrorExceptions& ue)
        {
          ue.printMessage();
          throw ue;
        }
        _dlearn = dval;
      }
      Double_t getLearn()
      {
        return _dlearn;
      }
      void setTolerance(Double_t dval)
      {
        try {
          if ( dval < 0 )  {
              throw URANIE::Exceptions::UErrorExceptions(__FILE__, __LINE__,
                                                         Form("TBaseModel::setTolerance Error\n The tolerance must be possitive [%f].", dval));
            }
        } catch (URANIE::Exceptions::UErrorExceptions& ue)
        {
          ue.printMessage();
          throw ue;
        }
        _dtolerance = dval;
      }
      Double_t getTolerance()
      {
        return _dtolerance;
      }
 
      void setSeed(Int_t n)
      {
        try {
          if ( n < 0 )  {
              throw URANIE::Exceptions::UErrorExceptions(__FILE__, __LINE__,
                                                         Form("TBaseModel::setSeed Error\n The seed must be possitive [%d].", n));
            }
        } catch (URANIE::Exceptions::UErrorExceptions& ue)
        {
          ue.printMessage();
          throw ue;
        }
        _nseed = n;
      }
      Int_t getSeed()
      {
        return _nseed;
      }
 
      //---------------------------------------------
      void initExport();
 
      //---------------------------------------------
      void printLog(Option_t *option = "");
 
      ClassDef(URANIE::XMLProblem::TBaseModel, ID_XMLPROBLEM)
      //Classe de
    };
 
  } // Fin du namespace XMLProblem
} // Fin du namespace URANIE
#endif