GwollumOptions.h

Go to the documentation of this file.

 
#ifndef __GwollumOptions__
#define __GwollumOptions__
 
#include "IO.h"
#include "Monitor.h"
#include <TFile.h>
#include <TChain.h>
#include <H5Cpp.h>
 
using namespace std;
 
class GwollumOption{
 
public:
  GwollumOption(const string aTag, const string aKey, const int aDefaultValue, const unsigned int aSize=0);
   
  GwollumOption(const string aTag, const string aKey, const unsigned int aDefaultValue, const unsigned int aSize=0);
 
  GwollumOption(const string aTag, const string aKey, const double aDefaultValue, const unsigned int aSize=0);
 
  GwollumOption(const string aTag, const string aKey, const string aDefaultValue, const unsigned int aSize=0);
 
  virtual ~GwollumOption(void);
 
  inline bool IsProvided(void){ return provided; };
 
  inline string GetTag(void){ return tag; };
 
  inline string GetKey(void){ return key; };
 
  inline char GetType(void){ return valtype; };
 
  inline unsigned int GetSize(void){ return osize; };
 
  inline unsigned int GetNumberOfValues(void){ return ivec.size()+uvec.size()+dvec.size()+svec.size(); };
 
  inline bool GetValueI(int &aValue, const unsigned int aValIndex){
    if(aValIndex<ivec.size()){
      aValue = ivec[aValIndex];
      return true;
    }
    return false;
  };
 
  inline int GetValueI(const unsigned int aValIndex=0){
    if(aValIndex<ivec.size()) return ivec[aValIndex];
    return idef;
  };
 
  inline vector<int> GetValuesI(void){
    return ivec;
  };
 
  inline int GetDefaultI(void){ return idef; };
 
  inline void Add(const int aValue){
    if((valtype=='i')&&(osize==0)){
      ivec.push_back(aValue);
      provided = true;
    }
  };
 
  inline void Set(const unsigned int aValIndex, const int aValue){
    if(valtype!='i') return;
    if(aValIndex<ivec.size()){
      ivec[aValIndex] = aValue;
      provided = true;
    }
  };
 
  inline bool GetValueU(unsigned int &aValue, const unsigned int aValIndex){
    if(aValIndex<uvec.size()){
      aValue = uvec[aValIndex];
      return true;
    }
    return false;
  };
 
  inline unsigned int GetValueU(const unsigned int aValIndex=0){
    if(aValIndex<uvec.size()) return uvec[aValIndex];
    return udef;
  };
 
  inline vector<unsigned int> GetValuesU(void){
    return uvec;
  };
 
  inline unsigned int GetDefaultU(void){ return udef; };
 
  inline void Add(const unsigned int aValue){
    if((valtype=='u')&&(osize==0)){
      uvec.push_back(aValue);
      provided = true;
    }
  };
 
  inline void Set(const unsigned int aValIndex, const unsigned int aValue){
    if(valtype!='u') return;
    if(aValIndex<uvec.size()){
      uvec[aValIndex] = aValue;
      provided = true;
    }
  };
 
  inline bool GetValueD(double &aValue, const unsigned int aValIndex){
    if(aValIndex<dvec.size()){
      aValue = dvec[aValIndex];
      return true;
    }
    return false;
  };
 
  inline double GetValueD(const unsigned int aValIndex=0){
    if(aValIndex<dvec.size()) return dvec[aValIndex];
    return ddef;
  };
 
  inline vector<double> GetValuesD(void){
    return dvec;
  };
 
  inline double GetDefaultD(void){ return ddef; };
 
  inline void Add(const double aValue){
    if((valtype=='d')&&(osize==0)){
      dvec.push_back(aValue);
      provided = true;
    }
  };
 
  inline void Set(const unsigned int aValIndex, const double aValue){
    if(valtype!='d') return;
    if(aValIndex<dvec.size()){
      dvec[aValIndex] = aValue;
      provided = true;
    }      
  };
 
  inline bool GetValueS(string &aValue, const unsigned int aValIndex){
    if(aValIndex<svec.size()){
      aValue = svec[aValIndex];
      return true;
    }
    return false;
  };
 
  inline string GetValueS(const unsigned int aValIndex=0){
    if(aValIndex<svec.size()) return svec[aValIndex];
    return sdef;
  };
 
  inline vector<string> GetValuesS(void){
    return svec;
  };
 
  inline string GetDefaultS(void){ return sdef; };
 
  inline void Add(const string aValue){
    if((valtype=='s')&&(osize==0)){
      svec.push_back(aValue);
      provided = true;
    }
  };
 
  inline void Set(const unsigned int aValIndex, const string aValue){
    if(valtype!='s') return;
    if(aValIndex<svec.size()){
      svec[aValIndex] = aValue;
      provided = true;
    }
  };
  
  string GetOptionName(const unsigned int aValIndex);
 
  void Reset(void);
 
  void SetDefault(void);
 
private:
 
  bool provided;            
  string tag;               
  string key;               
  char valtype;             
  unsigned int osize;       
  int idef;                 
  unsigned int udef;        
  double ddef;              
  string sdef;              
  vector<int> ivec;         
  vector<unsigned int> uvec;
  vector<double> dvec;      
  vector<string> svec;      
};
 
 
class GwollumOptions{
 
 public:
  
  GwollumOptions(void);
 
  virtual ~GwollumOptions(void);
 
  void Copy(GwollumOptions *aG);
 
  inline void Reset(void){ options.clear(); OptTree->Reset(); };
 
  inline unsigned int GetOptionIndex(const string aTag, const string aKey){
    for(unsigned int o=0; o<options.size(); o++)
      if((!options[o].GetTag().compare(aTag))&&(!options[o].GetKey().compare(aKey))) return o;
    return options.size();
  };
 
  void ResetOption(const string aTag, const string aKey);
 
  void RemoveOption(const string aTag, const string aKey);
 
  bool IsTheSame(GwollumOptions *aG);
 
  void Add(const string aTag, const string aKey, const int aDefaultValue, const unsigned int aSize=0);
 
  void SetOptionValue(const string aTag, const string aKey, const unsigned int aValIndex, const int aValue);
 
  void AddOptionValue(const string aTag, const string aKey, const int aValue);
 
  void Add(const string aTag, const string aKey, const unsigned int aDefaultValue, const unsigned int aSize=0);
 
  void SetOptionValue(const string aTag, const string aKey, const unsigned int aValIndex, const unsigned int aValue);
 
  void AddOptionValue(const string aTag, const string aKey, const unsigned int aValue);
 
  void Add(const string aTag, const string aKey, const double aDefaultValue, const unsigned int aSize=0);
 
  void SetOptionValue(const string aTag, const string aKey, const unsigned int aValIndex, const double aValue);
 
  void AddOptionValue(const string aTag, const string aKey, const double aValue);
 
  void Add(const string aTag, const string aKey, const string aDefaultValue, const unsigned int aSize=0);
 
  void SetOptionValue(const string aTag, const string aKey, const unsigned int aValIndex, const string aValue);
 
  void AddOptionValue(const string aTag, const string aKey, const string aValue);
 
  bool IsProvided(const string aTag, const string aKey);
 
  inline bool Is(const string aTag, const string aKey){
    if(GetOptionIndex(aTag, aKey)==options.size()) return false;
    return true;
  };
 
  void SetDefault(const string aTag, const string aKey);
 
  inline string GetOptionTag(const unsigned int aOptionIndex){
    if(aOptionIndex>=options.size()) return "";
    return options[aOptionIndex].GetTag();
  };
 
  inline char GetOptionType(const unsigned int aOptionIndex){
    if(aOptionIndex>=options.size()) return '0';
    return options[aOptionIndex].GetType();
  };
 
  inline int GetOptionDefaultI(const unsigned int aOptionIndex){
    return options[aOptionIndex].GetDefaultI();
  };
 
  inline unsigned int GetOptionDefaultU(const unsigned int aOptionIndex){
    return options[aOptionIndex].GetDefaultU();
  };
 
  inline double GetOptionDefaultD(const unsigned int aOptionIndex){
    return options[aOptionIndex].GetDefaultD();
  };
 
  inline string GetOptionDefaultS(const unsigned int aOptionIndex){
    return options[aOptionIndex].GetDefaultS();
  };
 
  inline string GetOptionKey(const unsigned int aOptionIndex){
    if(aOptionIndex>=options.size()) return "";
    return options[aOptionIndex].GetKey();
  };
 
  inline unsigned int GetOptionSize(const unsigned int aOptionIndex){
    return options[aOptionIndex].GetSize();
  };
 
  char GetOptionType(const string aTag, const string aKey);
 
  unsigned int GetOptionSize(const string aTag, const string aKey);
 
  unsigned int GetOptionNumberOfValues(const string aTag, const string aKey);
 
  bool GetOptionValueI(int &aValue, const string aTag, const string aKey, const unsigned int aValIndex);
 
  int GetOptionValueI(const string aTag, const string aKey, const unsigned int aValIndex);
 
  vector<int> GetOptionValuesI(const string aTag, const string aKey);
 
  bool GetOptionValueU(unsigned int &aValue, const string aTag, const string aKey, const unsigned int aValIndex);
 
  unsigned int GetOptionValueU(const string aTag, const string aKey, const unsigned int aValIndex);
 
  vector<unsigned int> GetOptionValuesU(const string aTag, const string aKey);
 
  bool GetOptionValueD(double &aValue, const string aTag, const string aKey, const unsigned int aValIndex);
 
  double GetOptionValueD(const string aTag, const string aKey, const unsigned int aValIndex);
 
  vector<double> GetOptionValuesD(const string aTag, const string aKey);
 
  bool GetOptionValueS(string &aValue, const string aTag, const string aKey, const unsigned int aValIndex);
 
  string GetOptionValueS(const string aTag, const string aKey, const unsigned int aValIndex);
 
  vector<string> GetOptionValuesS(const string aTag, const string aKey);
 
  unsigned int ReadTextFile(const string aOptionFile);
 
  void WriteTextFile(const string aFileName);
 
  void WriteH5(H5::H5File* aFile, H5::DataSpace &aDataSpace);
 
  bool ReadTree(const string aRootFileName, const string aTreeName);
 
  bool ReadTree(TTree *aTree);
 
  bool ReadChain(bool &aIsUniform, TChain *aChain);
 
  void FillTree(void);
 
  void WriteTree(const string aTreeName, const string aRootFileName, const string aSubDirectory="");
 
  inline void WriteTree(const string aTreeName){ OptTree->Write(aTreeName.c_str()); };
 
  unsigned int GetOptionsN(void){ return options.size(); };
 
 
 private:
 
  Monitor *mon;                  
  vector<GwollumOption> options; 
  TTree *OptTree;                
  string t_tag;                  
  string t_key;                  
  char t_type;                   
  unsigned int t_size;           
  int t_idef;                    
  unsigned int t_udef;           
  double t_ddef;                 
  string t_sdef;                 
  int t_ival;                    
  unsigned int t_uval;           
  double t_dval;                 
  string t_sval;                 
 
 
  ClassDef(GwollumOptions,0)
};
 
 
#endif