TDataServer.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 TDATASERVER_H
#define TDATASERVER_H

#ifndef ROOT_TCut
#include "TCut.h"
#endif
#ifndef ROOT_TGraph
#include "TGraph.h"
#endif
#ifndef ROOT_TMatrixD
#include "TMatrixD.h"
#endif
#ifndef ROOT_TNtupleD
#include "TNtupleD.h"
#endif

// Uranie
#include "DataServer.h"
#include "TDSNtupleD.h"
#include "TAttribute.h"
#include "TStochAttribut.h"
#include "TDataSpecification.h"
#include "TPatternsEventList.h"
#include "UMessageLogger.h"

#include <iostream>
#include <fstream>
#include <sstream>
#include <map>

using std::cout;
using std::endl;
using std::string;
using std::map;
using std::vector;
using std::ios;

namespace URANIE
{
namespace DataServer
{
class TDataServer: public TNamed
{

  // Attributes
 public:
  enum EOrigin 
  {
    kUnknown, kASCIIFile, kTree, kSQL
  };
  enum ENormalisation 
  {
    kCR, kCentered, kCenteredSum0fSquareOne, kMinusOneOne, kZeroOne
  };
  enum ECAHMethod 
  {
    kWard, kWardExact, kCentroid, kAverage, kSingle, kComplete
  };

  TObjArray *_drawingGarbageCollector;

  //---------------------------------------------
  TDataServer();
  TDataServer(const char *name, const char* title);
  TDataServer(const TDataServer &tds);
  virtual ~TDataServer();
  
  //---------------------------------------------

    Bool_t fileDataRead(const char* name, Bool_t bSave = kTRUE, Bool_t bDontAddAttribute = kFALSE, Option_t *option="");


    Bool_t fileDataReadCSV(const char* name, string delimiter = ",", Bool_t bSave = kTRUE, Bool_t bDontAddAttribute = kFALSE, Option_t *option="");

#ifdef WITH_JSONCPP
    Bool_t fileDataReadJSon(const char* name, Bool_t bSave = kTRUE);
#endif
    

  Bool_t ntupleDataRead(const char* file, const char *tree, const char* svar =
                        "*", const char *cut = "");
  /*
    This method takes a tree and investigate its content to rebuild a TDS from it.
    TDataSpecification and TDSNtupleD are rebuilt completly deleting all possible previous information
    \param tt: the tree to be read
   */
  Bool_t loadTree(TTree* tt);

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

  void exportData(const char *filename, const char *varexp = "*",
                  const char *select = "", Option_t *option = "");


  void exportDataCSV(const char *filename, const char *varexp = "*",
                  const char *select = "", string delimiter = ",", Option_t *option = "");



  void exportDataHeader(const char *filename, const char *varexp = "*",
      const char *select = "", Option_t *option = "");


  void exportDataNeMo(const char *filename, const char *varexpinput,
                      const char *varexpoutput, const char *select = "");


  void exportDataContext(const char *filename, const char *varexp = "*",
                         const char *select = "");

#ifdef WITH_JSONCPP
  void exportDataJSon(const char *filename, const char *varexp = "*",
            const char *select = "", Option_t *option = "");
#endif


  void saveTuple(Option_t* option);


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


    static string checkAttributes(TDataServer *tds, string varexp, map<string, vector<int> > &mAttributeElements);
    

  void addAttribute(TString name, Double_t dmin, Double_t dmax);


    void addAttributeUsingData(TString name, double *arr, int size);
    

  void addAttributeByNameTitle(TString name, TString title);


  void addAttribute(const char *name);


    void addAttribute(TString name, TString formula, TString title = "",TString unit = "", bool update=true);

  void fillOthersAttributes(bool update=kFALSE);

  void addAttribute(URANIE::DataServer::TAttribute *att);
  

  void delAttribute(TString name);


  void merge(TDataServer *tds, const char* varexpinput="*", bool bwithFriend=kFALSE);

  void normalize(const char* varexp = "", const char* suffix = "_CR",
                 ENormalisation method = kCR, bool global=true);


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

  void setSelect(TString str)
  {
    if( str.EqualTo(TString(_ccut.GetTitle())) )
      return;
    _ccut = TCut(str);
    cleanStatAndQuantiles();
  }
  
  /*
    The cut is tested and if it differs from the previous one (currently used) the quantiles and statistical caracteristic 
    of the attributes are cleared.
    \param cut (TCut): A TCut to reject event
   */
  void setCut(TCut cut)
  {
    string thecut = "!("+string(cut.GetTitle())+")";
    if( string(_ccut.GetTitle())==thecut )
      return;
    _ccut = !cut;
    cleanStatAndQuantiles();
  }
    
  /*
    The cut is tested and if it differs from the previous one (currently used) the quantiles and statistical caracteristic 
    of the attributes are cleared.
    \param cut (TCut): A TCut to reject event
   */
  void setCut(const char * str)
  {
    string thecut = "!("+string(str)+")";
    if( string(_ccut.GetTitle())==thecut )
      return;
    _ccut = !TCut(str);
    cleanStatAndQuantiles();
  }


  void setCut(TString str)
  {
    string thecut = "!("+string(str)+")";
    if( string(_ccut.GetTitle())==thecut )
      return;
    _ccut = !TCut(str);
    cleanStatAndQuantiles();
  }

  void clearSelect()
  {
    if( string(_ccut.GetTitle())=="" )
      return;
    _ccut = "";
    cleanStatAndQuantiles();
  }

  void clearCut()
  {
    clearSelect();
  }

  /*
    Not to be calles by users
  */
  void cleanStatAndQuantiles()
  {
    if ( gErrorIgnoreLevel < kWarning-1 )
        (*_fLogger) <<  " Selection is changing ==> clearing the TAttribute computed statistics and quantiles" << Endl;
    TList *listOfAtt = getListOfAttributes("*",false);
    TIter next(listOfAtt);
    TAttribute *att;
    while ((att = (TAttribute*) next()))
        att->clearVectors();

    if(listOfAtt!=NULL)
        delete listOfAtt;
  }
  

  void mix();


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

  TMatrixD computeCAH(const char *varexp = "*", ECAHMethod CAHmethod = kWard,
                      const char *selection = "", Option_t *option = "");


  void computeStatistic(const char *varexp = "*", const char *selection = "", Option_t *option = "");


  TMatrixD computeCorrelationMatrix(const char *varexp = "*", const char *selection = "", Option_t *option = "");

  void computeRank(const char *varexp = "*", Option_t *option = "");


  void estimateQuantile(const char *attName, Int_t nProba, Double_t* proba,
                        Double_t* quantile, Double_t confidence = 0.5,
                        Option_t *option = "");

  void estimateQuantile(const char *attName, Double_t proba,
                        Double_t &quantile, Double_t confidence = 0.5,
                        Option_t *option = "");


  void computeQuantile(const char *attName, Double_t proba,
                       Double_t &quantile, Int_t type = 7);

  double computeQuantile(const char *attName, Double_t proba, Int_t type = 7);
    

  void computeQuantile(const char *attName, Int_t nProba, Double_t* proba,
                       Double_t* quantiles, Int_t type = 7);
  //Add by MSA

  void computeQuantileCV(TString yname, Double_t alpha, TString zname,
                         Double_t zapha, Double_t &quantile, Double_t & rho);


  void internalQuantilesComputation(Int_t nData, Int_t nProba, Double_t* data,
                                    Double_t* quantiles, Double_t* proba, Bool_t isSorted = kTRUE,
                                    Int_t* index = 0, Int_t type = 7);


  Int_t computeIndexQuantileWilks(Double_t alpha, Double_t beta, Int_t n);
  

  Double_t computeInverseNormalCDF(Double_t p, Double_t mean = 0.0, Double_t stddev = 1.0);
  
  
  
  //---------------------------------------------

  Int_t scan(const char *varexp = "", const char *selection = "",
             Option_t *option = "");

  Int_t Scan(const char *varexp, const char *selection = "",
             Option_t *option = "")
  {
    return scan(varexp, selection, option);
  }

    void checkCanvasCreation(Option_t *option="");

    void draw(const char* varexp, const char* selection = "", Option_t* option = "", bool internalCall=kFALSE);

  void Draw(const char* varexp, const char* selection = "", Option_t* option =
            "")
  {
    draw(varexp, selection, option);
  }


  void draw(UInt_t nOrder, const char* selection = "", Option_t* option = "");

  void drawHistogram(const char* sVar, const char* selection = "",
                     Option_t* option = "");
  void drawIter(const char* sVar, const char* selection = "",
                Option_t* option = "");

  void drawECDF(const char* varexp, const char* selection = "",
                Option_t* option = "");

    void drawQQPlot(const char* varexp, const char* laws, int nq, Option_t* option = "");

    void drawPPPlot(const char* varexp, const char* laws, int nq, Option_t* option = "");

  void drawCDF(const char* varexp, const char* selection = "",
               Option_t* option = "");

  void drawBoxPlot(const char* varexp, const char* selection = "",
                   Option_t* option = "");

  void startViewer();
  void StartViewer()
  {
    startViewer();
  }


  void drawTufte(const char* varexp, const char* selection = "",
                 Option_t* option = "");
  void drawScatterplot(const char* varexp, const char* selection = "",
                       Option_t* option = "");

  void drawProfile(const char* varexp, const char* selection = "",
                   Option_t* option = "");

  void drawPairs(const char* varexp = "*", const char* selection = "",
                 Option_t* option = "");

  void drawCopulogram(const char* varexp = "*", const char* selection = "",
                 Option_t* option = "");
  /*
    This graph is as \b TParallelCoordonate in ROOT but is called \b cobweb in the uncertainty community (book of Saltelli).
  */
  void drawCobWeb(const char* varexp, const char* selection = "",
                  Option_t* option = "");

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


    void SetName(const char *name);
    void checkName();
    

  void setIterator(TString sname);


    void setTuple(TDSNtupleD *ntd, bool newismain=true, const char* att="*")
  {
    _datatree = ((ntd==NULL) ? NULL : new TDSNtupleD(ntd, att, "", newismain));
  }

  void setTuple(TTree *ntd, bool newismain=true)
  {
    _datatree = ((ntd==NULL)? NULL :new TDSNtupleD(ntd,"*","",newismain));
  }



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

  TList * getListOfAttributes(const char* sListOfAttributes = "*", bool onlyAttribute=true);


    string getStringListOfAttributes(bool onlyNumerical=true, bool onlyAttribute=true);
    

  int getAttributeIndex(TAttribute * att, bool onlyAttribute=false) const;
 

  int getAttributeIndex(TString name, bool onlyAttribute=false) const;


  TAttribute *getAttribute(TString str);



  TAttribute *getAttribute(Int_t ind, bool onlyAttribute=kTRUE);


  Double_t getValue(TString attName, Int_t entry, Int_t ielement=-1);


  vector<double> getVector(TString attName, Int_t entry);

  string getString(TString attName, Int_t entry);


  TMatrixD getMatrix(const char* varexp = "*", const char* selection = "",
                     Option_t* option = "");


  Int_t getNPatterns();
  
  const char *getIteratorName()
  {
    return ((_biteratorNameChanged) ? _siteratorChangedName.Data() : Form("%s__n__iter__", GetName()) );
  }

  void changeIteratorName(const char *name)
  {
    _siteratorChangedName=TString(name);
    _biteratorNameChanged=kTRUE;
  }
  
  char * getDataTreeName();
  char * getDataFileName();
  char * getArchiveFileName();

  EOrigin getOrigin()
  {
    return _norigin;
  }


  Int_t getNAttributes(bool onlyAttribute=true);


  Int_t getNInputAttributes();
  

  Int_t getNOutputAttributes();

  TCut getCut()
  {
    return _ccut;
  }

  TDataSpecification* getDataSpecification()
  {
    return _dataSpecification;
  }


  TDSNtupleD *GetTuple(Option_t *option = "V")
  {
    return getTuple(option);
  }

  TDSNtupleD *getTuple(Option_t *option = "V");
  

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

  void bootstrap(Int_t nsize = -1, Option_t *option = "");

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

  void createTuple(Option_t *option = "");


  void fillAttribute(TString name, TString formula = "", Bool_t update = kTRUE);



  void fillConstantAttribute(TString name, UEntry *ConstUEntry);


  Bool_t isAttribute(TString name) const;

  
  void deleteTuple();  


  Bool_t hasTuple()
  {
    return _datatree != NULL;
  }

   void keepFinalTuple(bool val)
  {
      _bsaveTuple = val;
  }

  //---------------------------------------------
  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 = "");

    static TString getUranieVersion(){ return TString("Uranie v")+TString(URANIE_RELEASE);}
    static Int_t doBanner(){
      string bold_on, bold_off;
#ifndef WIN32
                  bold_on = "\033[1m";
                  bold_off = "\033[0m";
#endif
        cout << "\n" << bold_on << "--- Uranie v" << URANIE_RELEASE
             << " --- Developed with ROOT (" << gROOT->GetVersion() << ")" << bold_off << "\n"
             << "                      Copyright (C) 2013-2024 CEA/DES "  << "\n"
             << "                      Contact: support-uranie@cea.fr "   << "\n"
             << "                      Date: " << URANIE_RELEASE_DATE 
             << "\n\n";
        return 0;
    }

        
    
    static  void findParametersLaw(TString soption, vector<double> &vec, bool blog);
    
    
  ClassDef(URANIE::DataServer::TDataServer, ID_DATASERVER)

    private:
  TDataSpecification* _dataSpecification;      
  TDSNtupleD* _datatree;      
  TCanvas *_canvas;   
  TTree* _friend;      
  Bool_t _blog;          
  Bool_t _bQuantVectPrinted; 
  Bool_t _biteratorNameChanged; 
  Bool_t _bsaveTuple;
  TString _sdatafile;     
  TString _sarchivefile;  
  TString _shortDataTreeName; 
  TString _siteratorChangedName; 
  TCut _ccut;          
  
  void drawLegend(const char* varexp, const char* selection = "",
                  const char * histname = "htemp");


    void drawQQorPPPlot(const char* varexp, const char* laws, int nq, Option_t* option );
    
  EOrigin _norigin; 

  TPatternsEventList *_pelBootstrap;  

  URANIE::DataServer::UMessageLogger *_fLogger;   
  
  //---------------------------------------------
  void drawCDFRaFu(const char* varexp, const char* selection = "",
                   Option_t* option = "");
 

    
};

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