TAttribute.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 TAttribute_H
#define TAttribute_H
#include "TString.h"
#include <string>
 
//ROOT
#include "TEventList.h"
#include "TList.h"
#include "TROOT.h"
#include "TSystem.h"
 
#include "DataServer.h"
 
//URANIE
//#include "UExceptions.h"
 
//STL
#include <vector>
#include <map>
#include <list>
#include <iostream>
using std::vector;
using std::string;
using std::map;
using std::cout;
using std::endl;
using std::list;
 
//URANIE
 
//#include "UExceptions.h"
 
#define DLE_MAX 1.42387e+64
 
namespace URANIE
{
namespace DataServer
{
 
typedef struct STRUCT
{
 
    enum EFileType
    {
        kUnknown,
        kKey,
        kFlag,
        kNewKey,
        kNewLine,
        kNewRow,
        kNewColumn,     
        kXMLAttribute,
        kXMLField,
        kFMU,
        kNewTDS
    };
    TString _sFile; 
    TString _sKey;  
    TString _sFormat; 
    EFileType _sFileType; 
    TEventList * _sEventList; 
} TAttributeFileKey;
 
class TAttribute: public TNamed
{
public:
    enum EOrigin
    {
        kInternal, kIterator, kConstant, kAttribute, kDeleted
    };
    enum EAttribute
    {
        kInput, kOutput
    };
    enum EType
    {
        kDefault, kReal, kVector, kString, kCategory, kInconnu
    };
    // Attributes
protected:
    //---------------------------------------------
    TString _sunity;        
    TString _snote;         
    Bool_t _blog;         
    Int_t _nshare; 
    TAttribute *_attSon;      
    Int_t _nlevel;                     
    Bool_t _haveSon; 
 
    //---------------------------------------------
    TString _sFormatSubstitute;   
 
    list<TEventList *> _nfields; 
 
    list<TAttributeFileKey *> _KeyList; 
 
    //---------------------------------------------
    Double_t upperBound;   
    Bool_t _bHaveUpperBound;  
 
    Double_t lowerBound;   
    Bool_t _bHaveLowerBound;  
 
    Double_t _defaultValue;       
    Bool_t _bHaveDefaultValue;    
 
    vector<double> _defaultVector;       
    Bool_t _bHaveDefaultVector;    
 
    string _defaultString;       
    Bool_t _bHaveDefaultString;    
    
    Double_t _stepValue;          
    Bool_t _bHaveStepValue;       
 
    //---------------------------------------------
    vector<Double_t> _vminimum;         
    vector<Double_t> _vmaximum;         
    vector<Double_t> _vmean;            
    vector<Double_t> _vstd;             
 
    vector<Double_t> *_vbuffer;        
    vector<map<double,double>* > _vquantile;         
  
    EOrigin _norigin; 
    EAttribute _nAttribute; 
    EType _nType; 
 
    TString _slurmValue;
 
public:
    //---------------------------------------------
 
    TAttribute();
    TAttribute(const char* name, const char* title);
 
 
    TAttribute(TString name);
 
    TAttribute(TString name, EType type);
 
    TAttribute(TString name,TString value, EType type);
 
    TAttribute(TString name, Double_t lower, Double_t upper);
    TAttribute(const TAttribute &attr);
 
    TAttribute *Clone(const char *newname) const;
    virtual ~TAttribute();
 
 
    //---------------------------------------------
 
    void checkSizeBeforePush(const char* type, int iel, Double_t val);
  
 
    Double_t checkSizeBeforeGet(const char* type, int iel=0);
  
 
    void setQuantile(double prob, double quantile, int iel=0);
    void getQuantilesSize(int &nb, int iel=0);
 
    void getQuantiles(double* prob, double* quantile, int iel=0);
 
    void getQuantile(double &prob, double &quantile, int iel=0);
 
    void getQuantileVector(double &prob, vector<double> &quantile);
     
    // Calculates with a sampling
    Double_t getMinimum(int iel=0){
        return checkSizeBeforeGet("Minimum", iel);
    }
    Double_t getMinimumSize(){
 
        return _vminimum.size();
    }
    Bool_t hasDefault() {
 
        switch(_nType)
        {
        case kVector :
            return hasDefaultVector();
        case kString :
            return hasDefaultString();
        default :
            return hasDefaultValue();
        }
    }
 
    void setMinimum(Double_t val,int iel=0){
        checkSizeBeforePush("Minimum", iel, val);
    }
 
    Double_t getMaximum(int iel=0){
        return checkSizeBeforeGet("Maximum", iel);
    }
    Double_t getMaximumSize(){
        return _vmaximum.size();
    }
 
    void setMaximum(Double_t val,int iel=0){
        checkSizeBeforePush("Maximum", iel, val);
    }
 
 
    void getStatisticalVector(const char *type, vector<double> &vec);
    
    Double_t getMean(int iel=0)
        {
            return checkSizeBeforeGet("Mean", iel);
        }
    Double_t getMeanSize()
        {
            return _vmean.size();
        }
 
    void setMean(Double_t val,int iel=0);
 
    Double_t getStd(int iel=0)
        {
            return checkSizeBeforeGet("Std", iel);
        }
    Double_t getStdSize()
        {
            return _vstd.size();
        }
 
    void setStd(Double_t val,int iel=0);
    void setSlurmOption(TString value)
        {
            _slurmValue=value;
        }
 
 
    
    //---------------------------------------------
 
    EType getDataType() const
        {
            return _nType;
        }
 
    TString getDataTypeStr();
 
 
    void setTitle(const char* title)
        {
            SetTitle(title);
        }
    void setTitle(TString str)
        {
            SetTitle(str.Data());
        }
 
    TString getTitle()
        {
            return TString(GetTitle());
        }
 
    void setDataType(EType thetype)
        {
            _nType = thetype;
        }
 
    void setDataType(TString name);
 
 
    TString getLegend();
 
 
    TString getUnit()
        {
            return _sunity;
        }
    void setUnit(TString str)
        {
            _sunity = str;
        }
 
    TString getUnity()
        {
            return _sunity;
        }
    void setUnity(TString str)
        {
            _sunity = str;
        }
 
    TString getNote()
        {
            return _snote;
        }
    void setNote(TString str)
        {
            _snote = str;
        }
 
    Bool_t setDefault(TString value);
    TString getDefault(TString format="%e");
    
    Bool_t setDefaultValue(Double_t val);
    Bool_t getDefaultValue(Double_t &val);
    Bool_t hasDefaultValue();
    
    Bool_t setDefaultVector(vector<double> &vec);
    Bool_t getDefaultVector(vector<double> *val);
    Bool_t hasDefaultVector();
    
    Bool_t setDefaultString(TString str);
    Bool_t getDefaultString(string &str);
    Bool_t hasDefaultString();
    
    void setStepValue(Double_t val);
 
    Bool_t getStepValue(Double_t &val);
    TString getSlurmOption()
        {
            return _slurmValue;
        }
    EOrigin getOrigin()
        {
            return _norigin;
        }
    void setOrigin(EOrigin ind)
        {
            _norigin = ind;
        }
 
    Int_t getShare()
        {
            return _nshare;
        }
 
    void setOutput()
        {
            _nAttribute = kOutput;
        }
    void setInput()
        {
            _nAttribute = kInput;
        }
 
    EAttribute getInputOutput()
        {
            return _nAttribute;
        }
 
 
 
    //---------------------------------------------
 
 
    void setFileNameOfKey(TString str);
 
    list<URANIE::DataServer::TAttributeFileKey *> getKeyList()
        {
            return _KeyList;
        }
    ;
 
 
    //void      setFieldOfKey(Int_t ind) { _nfield = ind;}
    void setFieldOfKey(Int_t ind);
    void setFieldOfKey(Int_t sIndex, Int_t ind);
 
 
    void setFileKey(TString sfile, TString skey = "",
                    TString sformatToSubstitute = "%e",
                    TAttributeFileKey::EFileType FileType = TAttributeFileKey::kKey);
 
 
    void setFileFlag(TString sfile, TString skey = "", TString sformatToSubstitute = "%e")
        {
            setFileKey(sfile, skey, sformatToSubstitute, TAttributeFileKey::kFlag);
        }
 
 
    void setFileXMLAttribute(TString sfile, TString sXPathAttribute, TString sformatToSubstitute = "%e")
        {
            setFileKey(sfile, sXPathAttribute, sformatToSubstitute, TAttributeFileKey::kXMLAttribute);
        }
 
 
    void setFileXMLField(TString sfile, TString sXPathField, TString sformatToSubstitute = "%e")
        {
            setFileKey(sfile, sXPathField, sformatToSubstitute, TAttributeFileKey::kXMLField);
        }
 
    void setFileFMU(TString sfile, TString sXPathField, TString sformatToSubstitute = "%e")
    {
        setFileKey(sfile, sXPathField, sformatToSubstitute, TAttributeFileKey::kFMU);
    }
 
 
    //---------------------------------------------
 
    const char* getFormatToSubstitute()
        {
            return _sFormatSubstitute.Data();
        }
 
    void setFormatToSubstitute(TString str)
        {
            _sFormatSubstitute = str;
        }
 
 
    //---------------------------------------------
 
    Bool_t isInput()
        {
            return (((_norigin == kAttribute) || (_norigin == kConstant)) && (_nAttribute == kInput));
        }
 
    Bool_t isOutput()
        {
            return ((_norigin == kAttribute)  && (_nAttribute == kOutput));
        }
 
    void addShare()
        {
            _nshare++;
        }
    void delShare()
        {
            _nshare--;
        }
    void initShare()
        {
            _nshare = 1;
        }
 
    void clearVectors();
 
    //---------------------------------------------
 
    /*
      \param val (Double_t) The lower bound value of the attribute
    */
    virtual void setLowerBound(Double_t val, bool internalcall=false);
    /*s
      \return The lower bound value of the attribute
    */
    Double_t getLowerBound()
        {
            return lowerBound;
        }
    /*
      \return If the attribute have a lower bound value return kTRUE else return kFALSE
    */
    Bool_t isLowerBounded()
        {
            return _bHaveLowerBound;
        }
 
    /*
      \param val (Double_t) The upper bound value of the attribute
    */
    virtual void setUpperBound(Double_t val, bool internalcall=false);
    /*
      \return The upper bound value of the attribute
    */
    Double_t getUpperBound()
        {
            return upperBound;
        }
    /*
      \return If the attribute have an upper bound value return kTRUE else return kFALSE
    */
    Bool_t isUpperBounded()
        {
            return _bHaveUpperBound;
        }
 
    /*
      \exception if the lower bound is superior of the upper boun
      \exception if the upper bound is inferior of the lower boun
     
      \param lower (Double_t) The lower bound value of the attribute
      \param upper (Double_t) The upper bound value of the attribute
    */
    virtual void setBounds(Double_t lower, Double_t upper);
    /*
      \return If the attribute have a lower AND an upper bounds return kTRUE else return kFALSE
    */
    Bool_t isBounded()
        {
            return _bHaveLowerBound && _bHaveUpperBound;
        }
 
    //---------------------------------------------
    void setLog()
        {
            _blog = kTRUE;
        }
    void unsetLog()
        {
            _blog = kFALSE;
        }
    void changeLog()
        {
            _blog = _blog ? kFALSE : kTRUE;
        }
    Bool_t getLog()
        {
            return _blog;
        }
    virtual void printLog();
 
public:
 
    //---------------------------------------------
    TAttribute *getSonAttribute();
    void setSonAttribute(TAttribute * tatt);
    void removeSonAttribute();
    Int_t getLevel();
    void setLevel(Int_t nlevel);
    Bool_t haveSon();
    ClassDef(URANIE::DataServer::TAttribute, ID_DATASERVER)
    //Definition of an variable
 
};
 
} // Fin du namespace DataServer
} // Fin du namespace URANIE
 
#endif