HafHistogram/src/HTuple.cc


/** \class HTuple  Ganzhur/HafHistogram/src/HTuple.cc
 *
 * 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
 *
 * \author Marcel Kunze,        Ruhr-University Bochum, Germany 
 * \author Serguei Ganjour,     CEA-Saclay/IRFU, FR
 *
 * \version $Id: HTuple.cc,v 1.3 2009/11/19 09:40:31 ganzhur Exp $
 *
 */

#include "TTree.h"
#include "TBranch.h"
#include "TString.h"

#include "UserCode/HafHistogram/interface/HTuple.h"

using namespace std;

ClassImp(HTuple)

HTuple::HTuple() 
{ 
    fMap   = new THashList(); 
}

// Constructor to create a tuple with name and title:
HTuple::HTuple(const char* name,const char* title) : 
TNamed(name,title)
{
    fMap  = new THashList(); 
    fTree = new TTree(name,title);
}

// Destructor:
HTuple::~HTuple() 
{
    delete fTree;
    delete fMap;
}

// 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.


// ===== = Bool type ======
// Make/fill Column with a single value
void HTuple::Column(const char* label,
                        Bool_t value,
                        Bool_t defval,
                        const char* block) 
{   
    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 BoolColumn(label,value,defval,fTree);
        fMap->Add(colp);
    }
    
}

// Make/fill Column-array. Length is fixed at creation time.
void HTuple::Column(const char* label,
                        const HTAbsValVector<Bool_t> &vector,
                        Bool_t defval,
                        const char* block)
{   
    HColumn* colp = (HColumn*) fMap->FindObject(label);
    if(colp) {
        // Column exists,fill corresponding memory location with value:
        colp->SetValue(&vector);
        colp->SetUseDefValue(kFALSE);
    }
    else {
        // Create a new Column:
        colp = new BoolArrColumn(label,vector,defval,fTree);
        fMap->Add(colp);
    }
    
}

// Make/fill Column-array. Length is variable and is taken from 
// another Column.
void HTuple::Column(const char* label,
                        const HTAbsValVector<Bool_t> &vector,
                        const char* ilab,
                        Bool_t defval,
                        const char* block) 
{ 
    HColumn* colp = (HColumn*) fMap->FindObject(label);
    if(colp) {
        // Column exists,fill corresponding memory location with value:
        colp->SetValue(&vector,(HColumn*)fMap->FindObject(ilab));
        colp->SetUseDefValue(kFALSE);
    }
    else {
        // Create a new branch:
        HColumn* indexPtr = (HColumn*) fMap->FindObject(ilab);
        colp = new BoolDynArrColumn(label,vector,defval,indexPtr,fTree);
        fMap->Add(colp);
    }
    
}


// ===== = Int type ======
// Make/fill Column with a single value
void HTuple::Column(const char* label,
                        Int_t value,
                        Int_t defval,
                        const char* block,
                        const HTRange<Int_t> &range)
{
    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 IntColumn(label,value,defval,fTree);
        fMap->Add(colp);
    }
    
}

// Make/fill Column-array. Length is fixed at creation time.
void HTuple::Column(const char* label,
                        const HTAbsValVector<Int_t> &vector,
                        Int_t defval,
                        const char* block,
                        const HTRange<Int_t> &range)
{
    HColumn* colp = (HColumn*) fMap->FindObject(label);
    if(colp) {
        // Column exists,fill corresponding memory location with value:
        colp->SetValue(&vector);
        colp->SetUseDefValue(kFALSE);
    }
    else {
        // Create a new Column:
        colp = new IntArrColumn(label,vector,defval,fTree);
        fMap->Add(colp);
    }
    
}

// Make/fill Column-array. Length is variable and is taken from 
// another Column.
void HTuple::Column(const char* label,
                        const HTAbsValVector<Int_t> &vector,
                        const char* ilab,
                        Int_t defval,
                        const char* block,
                        const HTRange<Int_t> &range)
{
    HColumn* colp = (HColumn*) fMap->FindObject(label);
    if(colp) {
        // Column exists,fill corresponding memory location with value:
        colp->SetValue(&vector,(HColumn*)fMap->FindObject(ilab));
        colp->SetUseDefValue(kFALSE);
    }
    else {
        // Create a new branch:
        HColumn* indexPtr = (HColumn*) fMap->FindObject(ilab);
        colp = new IntDynArrColumn(label,vector,defval,indexPtr,fTree);
        fMap->Add(colp);
    }
    
}


// ===== = Float type ======
// Make/fill Column with a single value
void HTuple::Column(const char* label,
                        Float_t value,
                        Float_t defval,
                        const char* block,
                        const HTRange<Float_t> &range) 
{
    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 FloatColumn(label,value,defval,fTree);
        fMap->Add(colp);
    }
    
    
}

// Make/fill Column-array. Length is fixed at creation time.
void HTuple::Column(const char* label,
                        const TVector &vector,
                        Float_t defval,
                        const char* block,
                        const HTRange<Float_t> &range)
{
    HColumn* colp = (HColumn*) fMap->FindObject(label);
    if(colp) {
        // Column exists,fill corresponding memory location with value:
        colp->SetValue(&vector);
        colp->SetUseDefValue(0);
    }
    else {
        // Create a new Column:
        colp = new FloatArrColumn(label,vector,defval,fTree);
        fMap->Add(colp);
    }
    
    
}

// Make/fill Column-array. Length is variable and is taken from 
// another Column.
void HTuple::Column(const char* label,
                        const TVector &vector,
                        const char *ilab,
                        Float_t defval,
                        const char* block,
                        const HTRange<Float_t> &range)
{   
    HColumn* colp = (HColumn*) fMap->FindObject(label);
    if(colp) {
        // Column exists,fill corresponding memory location with value:
        colp->SetValue(&vector,(HColumn*)fMap->FindObject(ilab));
        colp->SetUseDefValue(0);
    }
    else {
        // Create a new branch:
        HColumn* indexPtr = (HColumn*) fMap->FindObject(ilab);
        colp = new FloatDynArrColumn(label,vector,defval,indexPtr,fTree);
        fMap->Add(colp);
    }
    
}

// Make/fill Column-array. Length is fixed at creation time.
void HTuple::Column(const char* label,
                        const HTAbsValVector<Float_t> &vector,
                        Float_t defval,
                        const char* block,
                        const HTRange<Float_t> &range) 
{
    HColumn* colp = (HColumn*) fMap->FindObject(label);
    if(colp) {
        // Column exists,fill corresponding memory location with value:
        colp->SetValue(&vector);
        colp->SetUseDefValue(kFALSE);
    }
    else {
        // Create a new Column:
        colp = new FloatArrColumn(label,vector,defval,fTree);
        fMap->Add(colp);
    }
    
    
}

// Make/fill Column-array. Length is variable and is taken from 
// another Column.
void HTuple::Column(const char* label,
                        const HTAbsValVector<Float_t> &vector,
                        const char *ilab,
                        Float_t defval,
                        const char* block,
                        const HTRange<Float_t> &range) 
{
    HColumn* colp = (HColumn*) fMap->FindObject(label);
    if(colp) {
        // Column exists,fill corresponding memory location with value:
        colp->SetValue(&vector,(HColumn*)fMap->FindObject(ilab));
        colp->SetUseDefValue(kFALSE);
    }
    else {
        // Create a new branch:
        HColumn* indexPtr = (HColumn*) fMap->FindObject(ilab);
        colp = new FloatDynArrColumn(label,vector,defval,indexPtr,fTree);
        fMap->Add(colp);
    }
    
}

// ===== = Double type ======
// Make/fill Column with a single value
void HTuple::Column(const char* label,
                        Double_t value,
                        Double_t defval,
                        const char* block,
                        const HTRange<Double_t> &range) 
{
    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 DoubleColumn(label,value,defval,fTree);
        fMap->Add(colp);
    }
    
    
}

// Make/fill Column-array. Length is fixed at creation time.
void HTuple::Column(const char* label,
                        const HTAbsValVector<Double_t> &vector,
                        Double_t defval,
                        const char* block,
                        const HTRange<Double_t> &range)
{ 
    HColumn* colp = (HColumn*) fMap->FindObject(label);
    if(colp) {
        // Column exists,fill corresponding memory location with value:
        colp->SetValue(&vector);
        colp->SetUseDefValue(kFALSE);
    }
    else {
        // Create a new Column:
        colp = new DoubleArrColumn(label,vector,defval,fTree);
        fMap->Add(colp);
    }
    
    
}

// Make/fill Column-array. Length is variable and is taken from 
// another Column.
void HTuple::Column(const char* label,
                        const HTAbsValVector<Double_t> &vector,
                        const char *ilab,
                        Double_t defval,
                        const char* block,
                        const HTRange<Double_t> &range)
{
    HColumn* colp = (HColumn*) fMap->FindObject(label);
    if(colp) {
        // Column exists,fill corresponding memory location with value:
        colp->SetValue(&vector,(HColumn*)fMap->FindObject(ilab));
        colp->SetUseDefValue(kFALSE);
    }
    else {
        // Create a new branch:
        HColumn* indexPtr = (HColumn*) fMap->FindObject(ilab);
        colp = new DoubleDynArrColumn(label,vector,defval,indexPtr,fTree);
        fMap->Add(colp);
    }
    
}

// ===== = string Columns ======
// Can actually be variable length in ROOT,N is ignored:
void HTuple::Column(const char* label,
                        const char* value,
                        Int_t N,
                        const char* defval,
                        const char* block)
{
    HColumn* colp = (HColumn*) fMap->FindObject(label);
    if(colp) {
        // Branch exists,fill corresponding memory location with value:
        Column(label,value);
    }
    else {
        // Create a new branch:
        colp = new StringColumn(label,value,defval,fTree);
        fMap->Add(colp);
    }
    
}

void HTuple::Column(const char* label,const char* value)
{    
    HColumn* colp = (HColumn*) fMap->FindObject(label);
    if(colp) {
        colp->SetValue(value);
        colp->SetUseDefValue(0);
    }
    else {
        cerr << "HTuple::Column: Column "<< label << " does not exist" << endl;
    }
    
}


// Dump all the data into the ntuple and then clear
void HTuple::DumpData()
{    
    for (Int_t i=0;i<fMap->GetSize();i++)
    {
        HColumn *col = (HColumn*) fMap->At(i);
        if(col->GetUseDefValue()) col->SetDefValue();
        col->SetUseDefValue(1);
    }
    fTree->Fill(); 
    
}

// Set all the data to their default values:
void HTuple::ClearData() 
{   
    for (Int_t i=0;i<fMap->GetSize();i++)
    {
        HColumn *col = (HColumn*) fMap->At(i);
        col->SetDefValue();
        col->SetUseDefValue(1);
    }
    return; 
    
}

// Return title of ntuple:
const char* HTuple::Title() const 
{
    return fTree->GetTitle();
}

// number of Columns
Int_t HTuple::NColumns() const 
{
    return fMap->GetSize();    
}

// Return label for a particular Column with index i:
const char* HTuple::Label(Int_t i) const 
{
    TString str;
    if(i >= 0 && i < fMap->GetSize()) str = ((HColumn*)fMap->At(i))->GetLabel();
    else str = "unknown Column index";
    return str.Data();
    
}

// Print info about ntuple:
void HTuple::PrintOn(ostream & o)  const 
{  
    cout << "HTuple: ntuple " << Title() << " has " << NColumns() 
        << " Columns." << endl;
    cout << "Complete printout follows: " << endl;
    fTree->Print(); 
}
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
2			/** \class HTuple Ganzhur/HafHistogram/src/HTuple.cc
3			*
4			* Description:
5			* Analysis code of the CMS experiment;
6			* Original version is a part of HAF package developed for CMS: UserCode/HAF
7			* Nested class hierarchy to hold information about HTuple columns
8			*
9			* \author Marcel Kunze, Ruhr-University Bochum, Germany
10			* \author Serguei Ganjour, CEA-Saclay/IRFU, FR
11			*
12			* \version $Id: HTuple.cc,v 1.3 2009/11/19 09:40:31 ganzhur Exp $
13			*
14			*/
15
16			#include "TTree.h"
17			#include "TBranch.h"
18			#include "TString.h"
19
20			#include "UserCode/HafHistogram/interface/HTuple.h"
21
22			using namespace std;
23
24			ClassImp(HTuple)
25
26			HTuple::HTuple()
27			{
28			fMap = new THashList();
29			}
30
31			// Constructor to create a tuple with name and title:
32			HTuple::HTuple(const char* name,const char* title) :
33			TNamed(name,title)
34			{
35			fMap = new THashList();
36			fTree = new TTree(name,title);
37			}
38
39			// Destructor:
40			HTuple::~HTuple()
41			{
42			delete fTree;
43			delete fMap;
44			}
45
46			// Column booking/filling. All these have the same name - Column(...)
47
48			// Specify the data for a Column. The string is to the key to
49			// the Column,so it must be unique.
50
51
52			// ===== = Bool type ======
53			// Make/fill Column with a single value
54			void HTuple::Column(const char* label,
55			Bool_t value,
56			Bool_t defval,
57			const char* block)
58			{
59			HColumn* colp = (HColumn*) fMap->FindObject(label);
60			if(colp) {
61			// Column exists,fill corresponding memory location with value:
62			colp->SetValue(&value);
63			colp->SetUseDefValue(0);
64			}
65			else {
66			// Create a new Column:
67			colp = new BoolColumn(label,value,defval,fTree);
68			fMap->Add(colp);
69			}
70
71			}
72
73			// Make/fill Column-array. Length is fixed at creation time.
74			void HTuple::Column(const char* label,
75			const HTAbsValVector<Bool_t> &vector,
76			Bool_t defval,
77			const char* block)
78			{
79			HColumn* colp = (HColumn*) fMap->FindObject(label);
80			if(colp) {
81			// Column exists,fill corresponding memory location with value:
82			colp->SetValue(&vector);
83			colp->SetUseDefValue(kFALSE);
84			}
85			else {
86			// Create a new Column:
87			colp = new BoolArrColumn(label,vector,defval,fTree);
88			fMap->Add(colp);
89			}
90
91			}
92
93			// Make/fill Column-array. Length is variable and is taken from
94			// another Column.
95			void HTuple::Column(const char* label,
96			const HTAbsValVector<Bool_t> &vector,
97			const char* ilab,
98			Bool_t defval,
99			const char* block)
100			{
101			HColumn* colp = (HColumn*) fMap->FindObject(label);
102			if(colp) {
103			// Column exists,fill corresponding memory location with value:
104			colp->SetValue(&vector,(HColumn*)fMap->FindObject(ilab));
105			colp->SetUseDefValue(kFALSE);
106			}
107			else {
108			// Create a new branch:
109			HColumn* indexPtr = (HColumn*) fMap->FindObject(ilab);
110			colp = new BoolDynArrColumn(label,vector,defval,indexPtr,fTree);
111			fMap->Add(colp);
112			}
113
114			}
115
116
117			// ===== = Int type ======
118			// Make/fill Column with a single value
119			void HTuple::Column(const char* label,
120			Int_t value,
121			Int_t defval,
122			const char* block,
123			const HTRange<Int_t> &range)
124			{
125			HColumn* colp = (HColumn*) fMap->FindObject(label);
126			if(colp) {
127			// Column exists,fill corresponding memory location with value:
128			colp->SetValue(&value);
129			colp->SetUseDefValue(0);
130			}
131			else {
132			// Create a new Column:
133			colp = new IntColumn(label,value,defval,fTree);
134			fMap->Add(colp);
135			}
136
137			}
138
139			// Make/fill Column-array. Length is fixed at creation time.
140			void HTuple::Column(const char* label,
141			const HTAbsValVector<Int_t> &vector,
142			Int_t defval,
143			const char* block,
144			const HTRange<Int_t> &range)
145			{
146			HColumn* colp = (HColumn*) fMap->FindObject(label);
147			if(colp) {
148			// Column exists,fill corresponding memory location with value:
149			colp->SetValue(&vector);
150			colp->SetUseDefValue(kFALSE);
151			}
152			else {
153			// Create a new Column:
154			colp = new IntArrColumn(label,vector,defval,fTree);
155			fMap->Add(colp);
156			}
157
158			}
159
160			// Make/fill Column-array. Length is variable and is taken from
161			// another Column.
162			void HTuple::Column(const char* label,
163			const HTAbsValVector<Int_t> &vector,
164			const char* ilab,
165			Int_t defval,
166			const char* block,
167			const HTRange<Int_t> &range)
168			{
169			HColumn* colp = (HColumn*) fMap->FindObject(label);
170			if(colp) {
171			// Column exists,fill corresponding memory location with value:
172			colp->SetValue(&vector,(HColumn*)fMap->FindObject(ilab));
173			colp->SetUseDefValue(kFALSE);
174			}
175			else {
176			// Create a new branch:
177			HColumn* indexPtr = (HColumn*) fMap->FindObject(ilab);
178			colp = new IntDynArrColumn(label,vector,defval,indexPtr,fTree);
179			fMap->Add(colp);
180			}
181
182			}
183
184
185			// ===== = Float type ======
186			// Make/fill Column with a single value
187			void HTuple::Column(const char* label,
188			Float_t value,
189			Float_t defval,
190			const char* block,
191			const HTRange<Float_t> &range)
192			{
193			HColumn* colp = (HColumn*) fMap->FindObject(label);
194			if(colp) {
195			// Column exists,fill corresponding memory location with value:
196			colp->SetValue(&value);
197			colp->SetUseDefValue(0);
198			}
199			else {
200			// Create a new Column:
201			colp = new FloatColumn(label,value,defval,fTree);
202			fMap->Add(colp);
203			}
204
205
206			}
207
208			// Make/fill Column-array. Length is fixed at creation time.
209			void HTuple::Column(const char* label,
210			const TVector &vector,
211			Float_t defval,
212			const char* block,
213			const HTRange<Float_t> &range)
214			{
215			HColumn* colp = (HColumn*) fMap->FindObject(label);
216			if(colp) {
217			// Column exists,fill corresponding memory location with value:
218			colp->SetValue(&vector);
219			colp->SetUseDefValue(0);
220			}
221			else {
222			// Create a new Column:
223			colp = new FloatArrColumn(label,vector,defval,fTree);
224			fMap->Add(colp);
225			}
226
227
228			}
229
230			// Make/fill Column-array. Length is variable and is taken from
231			// another Column.
232			void HTuple::Column(const char* label,
233			const TVector &vector,
234			const char *ilab,
235			Float_t defval,
236			const char* block,
237			const HTRange<Float_t> &range)
238			{
239			HColumn* colp = (HColumn*) fMap->FindObject(label);
240			if(colp) {
241			// Column exists,fill corresponding memory location with value:
242			colp->SetValue(&vector,(HColumn*)fMap->FindObject(ilab));
243			colp->SetUseDefValue(0);
244			}
245			else {
246			// Create a new branch:
247			HColumn* indexPtr = (HColumn*) fMap->FindObject(ilab);
248			colp = new FloatDynArrColumn(label,vector,defval,indexPtr,fTree);
249			fMap->Add(colp);
250			}
251
252			}
253
254			// Make/fill Column-array. Length is fixed at creation time.
255			void HTuple::Column(const char* label,
256			const HTAbsValVector<Float_t> &vector,
257			Float_t defval,
258			const char* block,
259			const HTRange<Float_t> &range)
260			{
261			HColumn* colp = (HColumn*) fMap->FindObject(label);
262			if(colp) {
263			// Column exists,fill corresponding memory location with value:
264			colp->SetValue(&vector);
265			colp->SetUseDefValue(kFALSE);
266			}
267			else {
268			// Create a new Column:
269			colp = new FloatArrColumn(label,vector,defval,fTree);
270			fMap->Add(colp);
271			}
272
273
274			}
275
276			// Make/fill Column-array. Length is variable and is taken from
277			// another Column.
278			void HTuple::Column(const char* label,
279			const HTAbsValVector<Float_t> &vector,
280			const char *ilab,
281			Float_t defval,
282			const char* block,
283			const HTRange<Float_t> &range)
284			{
285			HColumn* colp = (HColumn*) fMap->FindObject(label);
286			if(colp) {
287			// Column exists,fill corresponding memory location with value:
288			colp->SetValue(&vector,(HColumn*)fMap->FindObject(ilab));
289			colp->SetUseDefValue(kFALSE);
290			}
291			else {
292			// Create a new branch:
293			HColumn* indexPtr = (HColumn*) fMap->FindObject(ilab);
294			colp = new FloatDynArrColumn(label,vector,defval,indexPtr,fTree);
295			fMap->Add(colp);
296			}
297
298			}
299
300			// ===== = Double type ======
301			// Make/fill Column with a single value
302			void HTuple::Column(const char* label,
303			Double_t value,
304			Double_t defval,
305			const char* block,
306			const HTRange<Double_t> &range)
307			{
308			HColumn* colp = (HColumn*) fMap->FindObject(label);
309			if(colp) {
310			// Column exists,fill corresponding memory location with value:
311			colp->SetValue(&value);
312			colp->SetUseDefValue(0);
313			}
314			else {
315			// Create a new Column:
316			colp = new DoubleColumn(label,value,defval,fTree);
317			fMap->Add(colp);
318			}
319
320
321			}
322
323			// Make/fill Column-array. Length is fixed at creation time.
324			void HTuple::Column(const char* label,
325			const HTAbsValVector<Double_t> &vector,
326			Double_t defval,
327			const char* block,
328			const HTRange<Double_t> &range)
329			{
330			HColumn* colp = (HColumn*) fMap->FindObject(label);
331			if(colp) {
332			// Column exists,fill corresponding memory location with value:
333			colp->SetValue(&vector);
334			colp->SetUseDefValue(kFALSE);
335			}
336			else {
337			// Create a new Column:
338			colp = new DoubleArrColumn(label,vector,defval,fTree);
339			fMap->Add(colp);
340			}
341
342
343			}
344
345			// Make/fill Column-array. Length is variable and is taken from
346			// another Column.
347			void HTuple::Column(const char* label,
348			const HTAbsValVector<Double_t> &vector,
349			const char *ilab,
350			Double_t defval,
351			const char* block,
352			const HTRange<Double_t> &range)
353			{
354			HColumn* colp = (HColumn*) fMap->FindObject(label);
355			if(colp) {
356			// Column exists,fill corresponding memory location with value:
357			colp->SetValue(&vector,(HColumn*)fMap->FindObject(ilab));
358			colp->SetUseDefValue(kFALSE);
359			}
360			else {
361			// Create a new branch:
362			HColumn* indexPtr = (HColumn*) fMap->FindObject(ilab);
363			colp = new DoubleDynArrColumn(label,vector,defval,indexPtr,fTree);
364			fMap->Add(colp);
365			}
366
367			}
368
369			// ===== = string Columns ======
370			// Can actually be variable length in ROOT,N is ignored:
371			void HTuple::Column(const char* label,
372			const char* value,
373			Int_t N,
374			const char* defval,
375			const char* block)
376			{
377			HColumn* colp = (HColumn*) fMap->FindObject(label);
378			if(colp) {
379			// Branch exists,fill corresponding memory location with value:
380			Column(label,value);
381			}
382			else {
383			// Create a new branch:
384			colp = new StringColumn(label,value,defval,fTree);
385			fMap->Add(colp);
386			}
387
388			}
389
390			void HTuple::Column(const char* label,const char* value)
391			{
392			HColumn* colp = (HColumn*) fMap->FindObject(label);
393			if(colp) {
394			colp->SetValue(value);
395			colp->SetUseDefValue(0);
396			}
397			else {
398			cerr << "HTuple::Column: Column "<< label << " does not exist" << endl;
399			}
400
401			}
402
403
404			// Dump all the data into the ntuple and then clear
405			void HTuple::DumpData()
406			{
407			for (Int_t i=0;i<fMap->GetSize();i++)
408			{
409			HColumn col = (HColumn) fMap->At(i);
410			if(col->GetUseDefValue()) col->SetDefValue();
411			col->SetUseDefValue(1);
412			}
413			fTree->Fill();
414
415			}
416
417			// Set all the data to their default values:
418			void HTuple::ClearData()
419			{
420			for (Int_t i=0;i<fMap->GetSize();i++)
421			{
422			HColumn col = (HColumn) fMap->At(i);
423			col->SetDefValue();
424			col->SetUseDefValue(1);
425			}
426			return;
427
428			}
429
430			// Return title of ntuple:
431			const char* HTuple::Title() const
432			{
433			return fTree->GetTitle();
434			}
435
436			// number of Columns
437			Int_t HTuple::NColumns() const
438			{
439			return fMap->GetSize();
440			}
441
442			// Return label for a particular Column with index i:
443			const char* HTuple::Label(Int_t i) const
444			{
445			TString str;
446			if(i >= 0 && i < fMap->GetSize()) str = ((HColumn*)fMap->At(i))->GetLabel();
447			else str = "unknown Column index";
448			return str.Data();
449
450			}
451
452			// Print info about ntuple:
453			void HTuple::PrintOn(ostream & o) const
454			{
455			cout << "HTuple: ntuple " << Title() << " has " << NColumns()
456			<< " Columns." << endl;
457			cout << "Complete printout follows: " << endl;
458			fTree->Print();
459			}