HafHistogram/interface/HTuple.h

#ifndef HTUPLE_H
#define HTUPLE_H

/** \class HTuple  Ganzhur/HafHistogram/interface/HTuple.h
 *
 * Description:
 * Analysis code of the CMS experiment;
 * Original version is a part of HAF package developed for CMS: UserCode/HAF  
 * Nested class hierarchy to hold information about HTuple columns.
 * 
 * Root 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()". 
 * 
 *
 * \author Marcel Kunze,        Ruhr-University Bochum, Germany 
 * \author Serguei Ganjour,     CEA-Saclay/IRFU, FR
 *
 * \version $Id: HTuple.h,v 1.4 2010/03/05 10:24:31 musella Exp $
 *
 */

#include <iostream>
#include "UserCode/HafHistogram/interface/HColumn.h"
#include "THashList.h"

class TTree;
class TBranch;

class HTuple : public TNamed {
    
public:
    
    HTuple();
    
    // Constructor to create a ROOT tuple with name and title:
    HTuple(const char*, const char*);
    
    // Destructor:
    virtual ~HTuple();
    
    // 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 = 0);
    // Make/fill Column-array. Length is fixed at creation time.
    virtual void Column(const char* label, 
        const HTAbsValVector<Bool_t> &vector, 
        Bool_t defval = kFALSE,
        const char* block = 0);
    // Make/fill Column-array. Length is variable and is taken from 
    // another Column.
    virtual void Column(const char* label, 
        const HTAbsValVector<Bool_t> &vector, 
        const char* ilab,
        Bool_t defval = kFALSE,
        const char* block = 0);
    
    
    // ====== Int type ======
    // Make/fill Column with a single value
    void Column(const char* label, 
        Int_t value, 
        Int_t defval = 0,
        const char* block = 0,
        const HTRange<Int_t>& range = HTRange<Int_t>());
    // Make/fill Column-array. Length is fixed at creation time.
    virtual void Column(const char* label, 
        const HTAbsValVector<Int_t> &vector, 
        Int_t defval = 0,
        const char* block = 0,
        const HTRange<Int_t>& range = HTRange<Int_t>());
    // Make/fill Column-array. Length is variable and is taken from 
    // another Column.
    virtual void Column(const char* label, 
        const HTAbsValVector<Int_t> &vector, 
        const char* ilab,
        Int_t defval = 0,
        const char* block = 0,
        const HTRange<Int_t> &range = HTRange<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 = 0,
        const HTRange<Float_t> &range = HTRange<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 = 0,
        const HTRange<Float_t> &range = HTRange<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 = 0,
        const HTRange<Float_t> &range = HTRange<Float_t>());
    // Make/fill Column-array. Length is fixed at creation time.
    virtual void Column(const char* label, 
        const HTAbsValVector<Float_t> &vector, 
        Float_t defval = 0.0f,
        const char* block = 0,
        const HTRange<Float_t> &range = HTRange<Float_t>());
    // Make/fill Column-array. Length is variable and is taken from 
    // another Column.
    virtual void Column(const char* label, 
        const HTAbsValVector<Float_t> &vector, 
        const char* ilab,
        Float_t defval = 0.0f,
        const char* block = 0,
        const HTRange<Float_t> &range = HTRange<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 = 0,
        const HTRange<Double_t> &range = HTRange<Double_t>());
    // Make/fill Column-array. Length is fixed at creation time.
    virtual void Column(const char *label, 
                      const HTAbsValVector<Double_t> &vector, 
                      Double_t defval = 0.0,
                      const char* block = 0,
                      const HTRange<Double_t> &range = HTRange<Double_t>());
    // Make/fill Column-array. Length is variable and is taken from 
    // another Column.
    virtual void Column(const char* label, 
        const HTAbsValVector<Double_t> &vector, 
        const char* ilab,
        Double_t defval = 0.0,
        const char* block = 0,
        const HTRange<Double_t> &range = HTRange<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 = 0,
        const char* block = 0);
    void Column(const char* label,
        const char* value);

    // ====== Generic Object ======
    // Make/fill Column with a single value
    template <class T>
    void ObjColumn(const char* label,
                T & value,
                T & defval,
                const char* block=0) 
            {   
                    HColumn* colp = (HColumn*) fMap->FindObject(label);
                    if(colp) {
                            // Column exists,fill corresponding memory location with value:
                            colp->SetValue(&value);
                            colp->SetUseDefValue(0);
                    }
                    else {
                            // Create a new Column:
                            colp = new ClassColumn<T>(label,value,defval,fTree);
                            fMap->Add(colp);
                    }
            }
    // Make/fill Column-array
    template <class T>
    void ClnColumn(const char* label,
                   const HTAbsValVector<T> &v,
                   const char* ilab,
                   T & defval,
                   const char* block=0)
            {   
                    HColumn* colp = (HColumn*) fMap->FindObject(label);
                    if(colp) {
                            // Column exists,fill corresponding memory location with value:
                            colp->SetValue(&v,(HColumn*)fMap->FindObject(ilab));
                            colp->SetUseDefValue(kFALSE);
                    }
                    else {
                            // Create a new Column:
                            colp = new ClonesColumn<T>(label,v,defval,(HColumn*)fMap->FindObject(ilab),fTree);
                            fMap->Add(colp);
                    }
            }
    
    void Column(const char* label, TVector3 value, TVector3 defval=TVector3(0,0,0), const char* block=0) 
            { ObjColumn( label, value, defval, block);   }
    void Column(const char* label, const HTAbsValVector<TVector3> &v, const char* ilab, TVector3 defval=TVector3(0,0,0), const char* block=0) 
            { ClnColumn( label, v, ilab, defval, block); }
    void Column(const char* label, TLorentzVector value, TLorentzVector defval=TLorentzVector(0,0,0), const char* block=0) 
            { ObjColumn( label, value, defval, block);   }
    void Column(const char* label, const HTAbsValVector<TLorentzVector> &v, const char* ilab, TLorentzVector defval=TLorentzVector(0,0,0), 
                const char* block=0) 
            { ClnColumn( label, v, ilab, defval, block); }

    // 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(ostream &) const;
    
    HTuple& operator=(const HTuple &v) { return *this; }
    
private:
    
    // Data members of HTuple:
    THashList* fMap; //!Do not stream
    TTree* fTree; //!Do not stream
public:
    ClassDef(HTuple,1) // NTuple
};


#endif
Revision:	1.1
Committed:	Wed Sep 29 15:44:21 2010 UTC (14 years, 7 months ago) by yjlee
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	HafHistogram tool
#	User	Rev	Content
1	yjlee	1.1	#ifndef HTUPLE_H
2			#define HTUPLE_H
3
4			/** \class HTuple Ganzhur/HafHistogram/interface/HTuple.h
5			*
6			* Description:
7			* Analysis code of the CMS experiment;
8			* Original version is a part of HAF package developed for CMS: UserCode/HAF
9			* Nested class hierarchy to hold information about HTuple columns.
10			*
11			* Root implementation of a Tuple.
12			*
13			* The member function "Column" provides the data for a Column of the ntuple.
14			* The string is the label of the Column as well as being a unique identifier
15			* of the Column. The second argument provides the data (Float_t or int) for
16			* one row in the Column. Note that only one line of code is needed to
17			* define the Column (if it has not been seen previously) and provide the
18			* data for each "event".
19			*
20			* The third argument of "Column()" provides the default value for that
21			* Column (if it not provided, it defaults to 0.0). On a particular "event",
22			* if no call is made to "Column" for a particular Column, that Column's
23			* default value is used when filling the ntuple. Therefore, the default
24			* value should be set to an "unphysical" number.
25			*
26			* At the end of an "event", a call should be made to either "dumpData()" or
27			* "clearData()". "dumpData()" dumps all the data it has stored internally
28			* into the ntuple and then calls "clearData()".
29			* "clearData()" sets all the internal Column values to their defaults,
30			* without changing the ntuple. Therefore, if you want to keep the data
31			* that is presently in an NTuple, call "dumpData()"; else, call
32			* "clearData()".
33			*
34			*
35			* \author Marcel Kunze, Ruhr-University Bochum, Germany
36			* \author Serguei Ganjour, CEA-Saclay/IRFU, FR
37			*
38			* \version $Id: HTuple.h,v 1.4 2010/03/05 10:24:31 musella Exp $
39			*
40			*/
41
42			#include <iostream>
43			#include "UserCode/HafHistogram/interface/HColumn.h"
44			#include "THashList.h"
45
46			class TTree;
47			class TBranch;
48
49			class HTuple : public TNamed {
50
51			public:
52
53			HTuple();
54
55			// Constructor to create a ROOT tuple with name and title:
56			HTuple(const char, const char);
57
58			// Destructor:
59			virtual ~HTuple();
60
61			// Column booking/filling. All these have the same name - Column(...)
62			// Specify the data for a Column. The string is to the key to
63			// the Column, so it must be unique. If an existing Column with the given
64			// label is not found, a new one is created. The third, optional, argument
65			// is the value to use if this Column is not otherwise filled in for a
66			// given row of the tuple.
67
68
69			// ====== Bool type ======
70			// Make/fill Column with a single value
71			void Column(const char* label,
72			Bool_t value,
73			Bool_t defval = 0,
74			const char* block = 0);
75			// Make/fill Column-array. Length is fixed at creation time.
76			virtual void Column(const char* label,
77			const HTAbsValVector<Bool_t> &vector,
78			Bool_t defval = kFALSE,
79			const char* block = 0);
80			// Make/fill Column-array. Length is variable and is taken from
81			// another Column.
82			virtual void Column(const char* label,
83			const HTAbsValVector<Bool_t> &vector,
84			const char* ilab,
85			Bool_t defval = kFALSE,
86			const char* block = 0);
87
88
89			// ====== Int type ======
90			// Make/fill Column with a single value
91			void Column(const char* label,
92			Int_t value,
93			Int_t defval = 0,
94			const char* block = 0,
95			const HTRange<Int_t>& range = HTRange<Int_t>());
96			// Make/fill Column-array. Length is fixed at creation time.
97			virtual void Column(const char* label,
98			const HTAbsValVector<Int_t> &vector,
99			Int_t defval = 0,
100			const char* block = 0,
101			const HTRange<Int_t>& range = HTRange<Int_t>());
102			// Make/fill Column-array. Length is variable and is taken from
103			// another Column.
104			virtual void Column(const char* label,
105			const HTAbsValVector<Int_t> &vector,
106			const char* ilab,
107			Int_t defval = 0,
108			const char* block = 0,
109			const HTRange<Int_t> &range = HTRange<Int_t>());
110
111
112			// ====== Float type ======
113			// Make/fill Column with a single value
114			void Column(const char* label,
115			Float_t value,
116			Float_t defval = 0.0f,
117			const char* block = 0,
118			const HTRange<Float_t> &range = HTRange<Float_t>());
119			// Make/fill Column-array. Length is fixed at creation time.
120			void Column(const char* label,
121			const TVector& vec,
122			Float_t defval = 0.0f,
123			const char* block = 0,
124			const HTRange<Float_t> &range = HTRange<Float_t>());
125			// Make/fill Column-array. Length is variable and is taken from
126			// another Column.
127			void Column(const char* label,
128			const TVector& vec,
129			const char* ilab,
130			Float_t defval = 0.0f,
131			const char* block = 0,
132			const HTRange<Float_t> &range = HTRange<Float_t>());
133			// Make/fill Column-array. Length is fixed at creation time.
134			virtual void Column(const char* label,
135			const HTAbsValVector<Float_t> &vector,
136			Float_t defval = 0.0f,
137			const char* block = 0,
138			const HTRange<Float_t> &range = HTRange<Float_t>());
139			// Make/fill Column-array. Length is variable and is taken from
140			// another Column.
141			virtual void Column(const char* label,
142			const HTAbsValVector<Float_t> &vector,
143			const char* ilab,
144			Float_t defval = 0.0f,
145			const char* block = 0,
146			const HTRange<Float_t> &range = HTRange<Float_t>());
147
148
149			// ====== Double type ======
150			// Make/fill Column with a single value
151			void Column(const char* label,
152			Double_t value,
153			Double_t defval = 0.0,
154			const char* block = 0,
155			const HTRange<Double_t> &range = HTRange<Double_t>());
156			// Make/fill Column-array. Length is fixed at creation time.
157			virtual void Column(const char *label,
158			const HTAbsValVector<Double_t> &vector,
159			Double_t defval = 0.0,
160			const char* block = 0,
161			const HTRange<Double_t> &range = HTRange<Double_t>());
162			// Make/fill Column-array. Length is variable and is taken from
163			// another Column.
164			virtual void Column(const char* label,
165			const HTAbsValVector<Double_t> &vector,
166			const char* ilab,
167			Double_t defval = 0.0,
168			const char* block = 0,
169			const HTRange<Double_t> &range = HTRange<Double_t>());
170
171			// ====== fixed-length string Columns ======
172			// ROOT ntuples allow variable length strings, thus N is ignored
173			void Column(const char* label,
174			const char* value,
175			Int_t N,
176			const char* defval = 0,
177			const char* block = 0);
178			void Column(const char* label,
179			const char* value);
180
181			// ====== Generic Object ======
182			// Make/fill Column with a single value
183			template <class T>
184			void ObjColumn(const char* label,
185			T & value,
186			T & defval,
187			const char* block=0)
188			{
189			HColumn* colp = (HColumn*) fMap->FindObject(label);
190			if(colp) {
191			// Column exists,fill corresponding memory location with value:
192			colp->SetValue(&value);
193			colp->SetUseDefValue(0);
194			}
195			else {
196			// Create a new Column:
197			colp = new ClassColumn<T>(label,value,defval,fTree);
198			fMap->Add(colp);
199			}
200			}
201			// Make/fill Column-array
202			template <class T>
203			void ClnColumn(const char* label,
204			const HTAbsValVector<T> &v,
205			const char* ilab,
206			T & defval,
207			const char* block=0)
208			{
209			HColumn* colp = (HColumn*) fMap->FindObject(label);
210			if(colp) {
211			// Column exists,fill corresponding memory location with value:
212			colp->SetValue(&v,(HColumn*)fMap->FindObject(ilab));
213			colp->SetUseDefValue(kFALSE);
214			}
215			else {
216			// Create a new Column:
217			colp = new ClonesColumn<T>(label,v,defval,(HColumn*)fMap->FindObject(ilab),fTree);
218			fMap->Add(colp);
219			}
220			}
221
222			void Column(const char* label, TVector3 value, TVector3 defval=TVector3(0,0,0), const char* block=0)
223			{ ObjColumn( label, value, defval, block); }
224			void Column(const char* label, const HTAbsValVector<TVector3> &v, const char* ilab, TVector3 defval=TVector3(0,0,0), const char* block=0)
225			{ ClnColumn( label, v, ilab, defval, block); }
226			void Column(const char* label, TLorentzVector value, TLorentzVector defval=TLorentzVector(0,0,0), const char* block=0)
227			{ ObjColumn( label, value, defval, block); }
228			void Column(const char* label, const HTAbsValVector<TLorentzVector> &v, const char* ilab, TLorentzVector defval=TLorentzVector(0,0,0),
229			const char* block=0)
230			{ ClnColumn( label, v, ilab, defval, block); }
231
232			// Dump all the data into the ntuple and then clear:
233			void DumpData();
234
235			// Set all the data to their default values:
236			void ClearData();
237
238			// Return the title of the ntuple:
239			const char* Title() const;
240
241			// Number of Columns:
242			Int_t NColumns() const ;
243
244			// Label for a particular Column
245			const char* Label(Int_t) const ;
246
247			// Print info about ntuple:
248			virtual void PrintOn(ostream &) const;
249
250			HTuple& operator=(const HTuple &v) { return *this; }
251
252			private:
253
254			// Data members of HTuple:
255			THashList* fMap; //!Do not stream
256			TTree* fTree; //!Do not stream
257			public:
258			ClassDef(HTuple,1) // NTuple
259			};
260
261
262
263			#endif