RhoTuple.h

Go to the documentation of this file.

#ifndef RHOTUPLE_H
#define RHOTUPLE_H
//                                                                      //
// RhoTuple                                                             //
//                                                                      //
// Nested class hierarchy to hold information about RhoTuple columns.   //
//                                                                      //
// Author List:                                                         //
// Marcel Kunze,  RUB, Mar. 99                                          //
// Apr.2001 (MK), Faster implementation based on THashList              //
// Copyright (C) 1999-2001, Ruhr-University Bochum.                     //
// Ralf Kliemt, HIM/GSI Feb.2013 (Cleanup & Restructuring)              //
//                                                                      //

// Rho implementation of a Tuple.
//
// The member function "Column" provides the data for a Column of the ntuple.
// The string is the label of the Column as well as being a unique identifier
// of the Column. The second argument provides the data (Float_t or int) for
// one row in the Column. Note that only one line of code is needed to
// define the Column (if it has not been seen previously) and provide the
// data for each "event".
//
// The third argument of "Column()" provides the default value for that
// Column (if it not provided, it defaults to 0.0). On a particular "event",
// if no call is made to "Column" for a particular Column, that Column's
// default value is used when filling the ntuple. Therefore, the default
// value should be set to an "unphysical" number.
//
// At the end of an "event", a call should be made to either "dumpData()" or
// "clearData()". "dumpData()" dumps all the data it has stored internally
// into the ntuple and then calls "clearData()".
// "clearData()" sets all the internal Column values to their defaults,
// without changing the ntuple. Therefore, if you want to keep the data
// that is presently in an NTuple, call "dumpData()"; else, call
// "clearData()".

#include <iosfwd>
#include "RhoColumn.h"
#include "THashList.h"

class TTree;
class TBranch;
class TFile;

class RhoTuple : public TNamed {

 public:
  RhoTuple();

  // Constructor to create a ROOT tuple with name and title:
  RhoTuple(const char *, const char *);

  // Destructor:
  virtual ~RhoTuple();

  // Column booking/filling. All these have the same name - Column(...)
  // Specify the data for a Column. The string is to the key to
  // the Column, so it must be unique. If an existing Column with the given
  // label is not found, a new one is created. The third, optional, argument
  // is the value to use if this Column is not otherwise filled in for a
  // given row of the tuple.

  // ====== Bool type ======
  // Make/fill Column with a single value
  void Column(const char *label, Bool_t value, Bool_t defval = 0, const char *block = nullptr);
  // Make/fill Column-array. Length is fixed at creation time.
  virtual void Column(const char *label, const RhoHTAbsValVector<Bool_t> &vector, Bool_t defval = kFALSE, const char *block = nullptr);
  // Make/fill Column-array. Length is variable and is taken from
  // another Column.
  virtual void Column(const char *label, const RhoHTAbsValVector<Bool_t> &vector, const char *ilab, Bool_t defval = kFALSE, const char *block = nullptr);

  // ====== Int type ======
  // Make/fill Column with a single value
  void Column(const char *label, Int_t value, Int_t defval = 0, const char *block = nullptr, const RhoHTRange<Int_t> &range = RhoHTRange<Int_t>());
  // Make/fill Column-array. Length is fixed at creation time.
  virtual void
  Column(const char *label, const RhoHTAbsValVector<Int_t> &vector, Int_t defval = 0, const char *block = nullptr, const RhoHTRange<Int_t> &range = RhoHTRange<Int_t>());
  // Make/fill Column-array. Length is variable and is taken from
  // another Column.
  virtual void Column(const char *label, const RhoHTAbsValVector<Int_t> &vector, const char *ilab, Int_t defval = 0, const char *block = nullptr,
                      const RhoHTRange<Int_t> &range = RhoHTRange<Int_t>());

  // ====== Float type ======
  // Make/fill Column with a single value
  void Column(const char *label, Float_t value, Float_t defval = 0.0f, const char *block = nullptr, const RhoHTRange<Float_t> &range = RhoHTRange<Float_t>());
  // Make/fill Column-array. Length is fixed at creation time.
  void Column(const char *label, const TVector &vec, Float_t defval = 0.0f, const char *block = nullptr, const RhoHTRange<Float_t> &range = RhoHTRange<Float_t>());
  // Make/fill Column-array. Length is variable and is taken from
  // another Column.
  void
  Column(const char *label, const TVector &vec, const char *ilab, Float_t defval = 0.0f, const char *block = nullptr, const RhoHTRange<Float_t> &range = RhoHTRange<Float_t>());
  // Make/fill Column-array. Length is fixed at creation time.
  virtual void
  Column(const char *label, const RhoHTAbsValVector<Float_t> &vector, Float_t defval = 0.0f, const char *block = nullptr, const RhoHTRange<Float_t> &range = RhoHTRange<Float_t>());
  // Make/fill Column-array. Length is variable and is taken from
  // another Column.
  virtual void Column(const char *label, const RhoHTAbsValVector<Float_t> &vector, const char *ilab, Float_t defval = 0.0f, const char *block = nullptr,
                      const RhoHTRange<Float_t> &range = RhoHTRange<Float_t>());

  // ====== Double type ======
  // Make/fill Column with a single value
  void Column(const char *label, Double_t value, Double_t defval = 0.0, const char *block = nullptr, const RhoHTRange<Double_t> &range = RhoHTRange<Double_t>());
  // Make/fill Column-array. Length is fixed at creation time.
  virtual void Column(const char *label, const RhoHTAbsValVector<Double_t> &vector, Double_t defval = 0.0, const char *block = nullptr,
                      const RhoHTRange<Double_t> &range = RhoHTRange<Double_t>());
  // Make/fill Column-array. Length is variable and is taken from
  // another Column.
  virtual void Column(const char *label, const RhoHTAbsValVector<Double_t> &vector, const char *ilab, Double_t defval = 0.0, const char *block = nullptr,
                      const RhoHTRange<Double_t> &range = RhoHTRange<Double_t>());

  // ====== fixed-length string Columns ======
  // ROOT ntuples allow variable length strings, thus N is ignored
  void Column(const char *label, const char *value, Int_t N, const char *defval = nullptr, const char *block = nullptr);
  void Column(const char *label, const char *value);

  // Dump all the data into the ntuple and then clear:
  void DumpData();

  // Set all the data to their default values:
  void ClearData();

  // Return the title of the ntuple:
  const char *Title() const;

  // Number of Columns:
  Int_t NColumns() const;

  // Label for a particular Column
  const char *Label(Int_t) const;

  // Print info about ntuple:
  virtual void PrintOn(std::ostream &) const;

  RhoTuple &operator=(const RhoTuple &) { return *this; }

  void WriteToFile(TString fname = "ntpdata.root", TString opt = "RECREATE");
  void AddToFile(TString fname = "ntpdata.root");

  TTree *GetInternalTree() { return fTree; }

 private:
  // Data members of TTuple:
  THashList *fMap; 
  TTree *fTree;    
 public:
  ClassDef(RhoTuple, 1) // NTuple
};

#endif