JRootToolkit.hh

Go to the documentation of this file.

#ifndef __JROOT__JROOTTOOLKIT__
#define __JROOT__JROOTTOOLKIT__
 
#include <string>
#include <istream>
#include <ostream>
#include <limits>
#include <cctype>
 
#include "TString.h"
#include "TRegexp.h"
#include "TPRegexp.h"
#include "TFormula.h"
#include "TFile.h"
#include "TStreamerInfo.h"
#include "TList.h"
#include "TIterator.h"
#include "TF1.h"
 
#include "JLang/JType.hh"
#include "JLang/JLangToolkit.hh"
#include "JROOT/JRootFile.hh"
#include "JROOT/JRootDictionary.hh"
#include "JROOT/JRootPrinter.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JROOT {}
namespace JPP { using namespace JROOT; }
 
namespace JROOT {
 
  using JLANG::JType;
 
 
  /**
   * Get ROOT name of given data type.
   *
   * \return            name of object to be read
   */
  template<class T>
  inline const char* getName()
  {
    return getName(JType<T>());
  }
 
 
  /**
   * Get ROOT name of given data type.
   *
   * \param  type       data type
   * \return            name of object to be read
   */
  template<class T>
  inline const char* getName(const JType<T>& type)
  {
    return T::Class_Name();
  }
 
 
  /**
   * Write object to ROOT file.
   *
   * \param  file         ROOT file
   * \param  object       ROOT object
   * \return              ROOT file
   */
  TFile& operator<<(TFile& file, const TObject& object)
  {
    file.WriteTObject(&object);
 
    return file;
  }
  
 
  /**
   * Get ROOT streamer information of class with given name.
   * Note that the class name should include the name space, if any.
   *
   * \param  file         pointer to ROOT file
   * \param  name         class name
   * \return              pointer to TStreamerInfo (NULL in case of error)
   */
  inline const TStreamerInfo* getStreamerInfo(TFile* file, const char* name) 
  {
    if (file != NULL && file->IsOpen()) {
 
      const TString buffer(name);
        
      TIter iter(file->GetStreamerInfoList());
 
      for (const TStreamerInfo* pStreamerInfo; (pStreamerInfo = (TStreamerInfo*) iter.Next()) != NULL; ) {
        if (buffer == TString(pStreamerInfo->GetName())) {
          return pStreamerInfo;
        }
      }
    }
 
    return NULL;
  }
 
 
  /**
   * Get ROOT streamer information of class with given name.
   * Note that the class name should include the name space, if any.
   *
   * \param  file_name    file name
   * \param  name         class name
   * \return              pointer to TStreamerInfo (NULL in case of error)
   */
  inline const TStreamerInfo* getStreamerInfo(const char* file_name, const char* name) 
  {
    JRootInputFile file(file_name);
 
    return getStreamerInfo(file.getFile(), name);
  }
 
 
  /**
   * Get ROOT streamer version of class with given name.
   * Note that the class name should include the name space, if any.
   *
   * \param  file         pointer to ROOT file
   * \param  name         class name
   * \return              streamer version; (-1 in case of error)
   */
  inline int getStreamerVersion(TFile* file, const char* name) 
  {
    const TStreamerInfo* pStreamerInfo = getStreamerInfo(file, name);
    
    if (pStreamerInfo != NULL)
      return pStreamerInfo->GetClassVersion();
    else
      return -1;
  }
 
 
  /**
   * Get ROOT streamer version of class with given name.
   * Note that the class name should include the name space, if any.
   *
   * \param  file_name    file name
   * \param  name         class name
   * \return              streamer version; (-1 in case of error)
   */
  inline int getStreamerVersion(const char* file_name, const char* name) 
  {
    JRootInputFile file(file_name);
    
    return getStreamerVersion(file.getFile(), name);
  }
 
 
/**
   * Match a TString to a TPRegexp, and return the chosen match.
   * If no matches are found corresponding to the indicated index,
   * the original TString is returned.
   *
   * \param  string    string to parse
   * \param  regexp    regular expression
   * \param  i         index of match to return
   * \return           match; (original string in case that matches are not found)
   */
  inline TString parse(TPRegexp& regexp, const TString& string, int i=1) 
  {
    TObjArray* a = regexp.MatchS(string);
    TString    s = string;
    if (a->GetLast() > i-1){
      s = ((TObjString*)a->At(i))->GetName();
    }
 
    return s;
  }
 
 
  /**
   * Auxiliary data structure for a parameter index and its value.
   */
  struct JFitParameter_t {
    /**
     * Default constructor.
     */
    JFitParameter_t() :
      index(0),
      value(0.0)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  index        parameter index
     * \param  value        parameter value
     */
    JFitParameter_t(const Int_t    index,
                    const Double_t value) :
      index(index),
      value(value)
    {}
 
 
    /**
     * Type conversion operator
     *
     *
     * \return              index
     */
    inline operator Int_t() const
    { 
      return index;
    }
 
     
    Int_t    index;
    Double_t value;
  };
  
 
  /**
   * Set fit parameter.
   *
   * \param  f1           fit function
   * \param  parameter    parameter index and value
   */
  inline bool setParameter(TF1& f1, const JFitParameter_t& parameter)
  {
    if (parameter.index >= 0 && parameter.index < f1.GetNpar()) {
 
      f1.SetParameter(parameter.index, parameter.value);
 
      return true;
 
    } else {
 
      return false;
    }
  }
 
 
  /**
   * Fix fit parameter.
   *
   * \param  f1           fit function
   * \param  parameter    parameter index and value
   */
  inline bool fixParameter(TF1& f1, const JFitParameter_t& parameter)
  {
    if (parameter.index >= 0 && parameter.index < f1.GetNpar()) {
 
      f1.FixParameter(parameter.index, parameter.value);
 
      return true;
 
    } else {
 
      return false;
    }
  }
 
 
  /**
   * Release fit parameter.
   *
   * \param  f1           fit function
   * \param  index        parameter index
   */
  inline bool releaseParameter(TF1& f1, const Int_t index)
  {
    if (index >= 0 && index < f1.GetNpar()) {
 
      f1.ReleaseParameter(index);
 
      return true;
 
    } else {
 
      return false;
    }
  }
 
 
  /**
   * Set fit parameter limits.
   *
   * \param  f1           fit function
   * \param  index        parameter index
   * \param  xmin         lower limit
   * \param  xmax         upper limit
   */
  inline bool setParLimits(TF1& f1, const Int_t index, Double_t xmin, Double_t xmax)
  {
    using namespace std;
 
    if (index >= 0 && index < f1.GetNpar()) {
 
      if (xmin == 0.0) { xmin = -numeric_limits<Double_t>::min(); }
      if (xmax == 0.0) { xmax = +numeric_limits<Double_t>::min(); }
 
      f1.SetParLimits(index, xmin, xmax);
 
      return true;
 
    } else {
 
      return false;
    }
  }
 
 
  /**
   * Check if fit parameter is fixed.
   *
   * \param  f1           fit function
   * \param  index        parameter index
   */
  inline bool isParameterFixed(TF1& f1, const Int_t index)
  {
    if (index >= 0 && index < f1.GetNpar()) {
 
      Double_t xmin;
      Double_t xmax;
    
      f1.GetParLimits(index, xmin, xmax);
    
      return (xmin != 0.0 && xmax != 0.0 && xmin >= xmax);
 
    } else {
      
      return false;
    }
  }
 
 
  /**
   * Get result of given textual formula.\n
   * The formula may contain names of data members of the given object.
   * Example:
   * <pre>
   *         getResult("a/b", object, ..);
   * </pre>
   * In this, the corresponding data type should have (at least) data members <tt>a</tt> and <tt>b</tt>.
   *
   * \param  text           text
   * \param  object         object
   * \param  dictionary     dictionary
   * \return                value
   */
  template<class T>
  inline Double_t getResult(const TString&           text,
                            const T&                 object,
                            const JRootDictionary_t& dictionary = JRootDictionary::getInstance())
  {
    using namespace std;
    using namespace JPP;
 
    string buffer = (const char*) text;
 
    for (string::size_type pos = 0; pos != buffer.size(); ) {
 
      if (isalpha(buffer[pos]) || buffer[pos] == '_') {
 
        string::size_type len = 1;
 
        while (pos + len != buffer.size() && (isalnum(buffer[pos+len]) || buffer[pos+len] == '_' || buffer[pos+len] == '.')) {
          ++len;
        }
 
        ostringstream os;
 
        os.precision(10);
 
        JRootPrinter::print(os, object, buffer.substr(pos,len), dictionary);
 
        buffer.replace(pos, len, os.str());
 
        pos += os.str().size();
 
      } else {
 
        pos += 1;
      }
    }
 
    return TFormula("/tmp", buffer.c_str()).Eval(0.0);
  }
}
 
 
/**
 * Read regular expression from input stream
 *
 * \param  in           input stream
 * \param  object       regular expression
 * \return              output stream
 */
std::istream& operator>>(std::istream& in, TRegexp& object)
{
  std::string buffer;
 
  if (in >> buffer) {
    object = TRegexp(buffer.c_str());
  }
 
  return in;
}
 
 
/**
 * Write regular expression to output stream
 *
 * \param  out          output stream
 * \param  object       regular expression
 * \return              output stream
 */
std::ostream& operator<<(std::ostream& out, const TRegexp& object)
{
  return out;
}
 
 
#endif