ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitAna/DataUtil/src/TreeWriter.cc

Comparing UserCode/MitAna/DataUtil/src/TreeWriter.cc (file contents):
Revision 1.8 by loizides, Tue Jul 1 14:36:52 2008 UTC vs.
Revision 1.11 by loizides, Sat Sep 27 06:14:05 2008 UTC

#	Line 1 | Line 1
1		// $Id$
2
3		#include "MitAna/DataUtil/interface/TreeWriter.h"
4	–
4		#include <Riostream.h>
5		#include <TObject.h>
6		#include <TSystem.h>
7		#include <TProcessID.h>
8	<
8	>	#include <TBranchRef.h>
9		#include "MitAna/DataUtil/interface/Debug.h"
10
11		using namespace mithep;
#	Line 62 | Line 61 | void TreeWriter::AddBranch(const char *n
61		}
62
63
64	<	//__________________________________________________________________________________________________
64	>	//--------------------------------------------------------------------------------------------------
65		void TreeWriter::AddBranch(const char *name, void *obj, Int_t bsize, Int_t level)
66		{
67		// Add branch with name "name" into tree with name "tname" and set its address
#	Line 71 | Line 70 | void TreeWriter::AddBranch(const char *n
70		AddBranch(name, CName(obj), obj, bsize, level);
71		}
72
73	<	//__________________________________________________________________________________________________
73	>	//--------------------------------------------------------------------------------------------------
74		void TreeWriter::AddBranch(const char *name, const char *cname,
75		void *obj, Int_t bsize)
76		{
#	Line 83 | Line 82 | void TreeWriter::AddBranch(const char *n
82		b->SetCompressionLevel(GetCompressLevel());
83		}
84
85	<	//__________________________________________________________________________________________________
85	>	//--------------------------------------------------------------------------------------------------
86		void TreeWriter::AddBranch(const char *name, void *obj, Int_t bsize)
87		{
88		// Add branch with name "name" into tree with name "tname" and set its address
#	Line 92 | Line 91 | void TreeWriter::AddBranch(const char *n
91		AddBranch(name, CName(obj), obj, bsize);
92		}
93
94	<	//__________________________________________________________________________________________________
94	>	//--------------------------------------------------------------------------------------------------
95		void TreeWriter::AddBranch(const char *name, const char *cname,
96		void *obj)
97		{
#	Line 104 | Line 103 | void TreeWriter::AddBranch(const char *n
103		b->SetCompressionLevel(GetCompressLevel());
104		}
105
106	<	//__________________________________________________________________________________________________
106	>	//--------------------------------------------------------------------------------------------------
107		void TreeWriter::AddBranch(const char *name, void *obj)
108		{
109		// Add branch with name "name" into tree with name "tname" and set its address
#	Line 113 | Line 112 | void TreeWriter::AddBranch(const char *n
112		AddBranch(name, CName(obj), obj);
113		}
114
115	<	//__________________________________________________________________________________________________
115	>	//--------------------------------------------------------------------------------------------------
116		void TreeWriter::AddBranchToTree(const char *tname, const char *name, const char *cname,
117		void *obj, Int_t bsize, Int_t level)
118		{
#	Line 125 | Line 124 | void TreeWriter::AddBranchToTree(const c
124		b->SetCompressionLevel(GetCompressLevel());
125		}
126
127	<	//__________________________________________________________________________________________________
127	>	//--------------------------------------------------------------------------------------------------
128		void TreeWriter::AddBranchToTree(const char *tname, const char *name, void *obj,
129		Int_t bsize, Int_t level)
130		{
#	Line 135 | Line 134 | void TreeWriter::AddBranchToTree(const c
134		AddBranchToTree(tname, name, CName(obj), obj, bsize, level);
135		}
136
137	<	//__________________________________________________________________________________________________
137	>	//--------------------------------------------------------------------------------------------------
138		void TreeWriter::AddBranchToTree(const char *tname, const char *name, const char *cname,
139		void *obj, Int_t bsize)
140		{
#	Line 147 | Line 146 | void TreeWriter::AddBranchToTree(const c
146		b->SetCompressionLevel(GetCompressLevel());
147		}
148
149	<	//__________________________________________________________________________________________________
149	>	//--------------------------------------------------------------------------------------------------
150		void TreeWriter::AddBranchToTree(const char *tname, const char *name, void *obj,
151		Int_t bsize)
152		{
#	Line 157 | Line 156 | void TreeWriter::AddBranchToTree(const c
156		AddBranchToTree(tname, name, CName(obj), obj, bsize);
157		}
158
159	<	//__________________________________________________________________________________________________
159	>	//--------------------------------------------------------------------------------------------------
160		void TreeWriter::AddBranchToTree(const char *tname, const char *name, const char *cname,
161		void *obj)
162		{
#	Line 169 | Line 168 | void TreeWriter::AddBranchToTree(const c
168		b->SetCompressionLevel(GetCompressLevel());
169		}
170
171	<	//__________________________________________________________________________________________________
171	>	//--------------------------------------------------------------------------------------------------
172		void TreeWriter::AddBranchToTree(const char *tname, const char *name, void *obj)
173		{
174		// Add branch with name "name" into tree with name "tname" and set its address
#	Line 178 | Line 177 | void TreeWriter::AddBranchToTree(const c
177		AddBranchToTree(tname, name, CName(obj), obj);
178		}
179
180	<	//__________________________________________________________________________________________________
180	>	//--------------------------------------------------------------------------------------------------
181		MyTree *TreeWriter::AddOrGetMyTree(const char *tn)
182		{
183		// Add new tree if not present in array of trees or return
#	Line 197 | Line 196 | MyTree *TreeWriter::AddOrGetMyTree(const
196		return tree;
197		}
198
199	<	//__________________________________________________________________________________________________
199	>	//--------------------------------------------------------------------------------------------------
200		Bool_t TreeWriter::BeginEvent(Bool_t doreset)
201		{
202		// Prepare for the next event. If doreset or fDoObjNumReset is kTRUE
#	Line 214 | Line 213 | Bool_t TreeWriter::BeginEvent(Bool_t dor
213		return kTRUE;
214		}
215
216	<	//__________________________________________________________________________________________________
216	>	//--------------------------------------------------------------------------------------------------
217		void TreeWriter::CloseFile()
218		{
219		// Write tree(s) and close file.
#	Line 230 | Line 229 | void TreeWriter::CloseFile()
229		for (Int_t i=0;i<fTrees.GetEntries();++i) {
230		MyTree *mt = static_cast<MyTree*>(fTrees.At(i));
231		mt->Write(mt->GetName(),TObject::kOverwrite);
232	<	mt->Reset();
232	>	// Backup and restore list of branch pointers from TRefTable (needed for autoloading)
233	>	if (mt->GetBranchRef()) {
234	>	TObjArray *parents = mt->GetBranchRef()->GetRefTable()->GetParents();
235	>	TObjArray parentsBak(*parents);
236	>	mt->Reset();
237	>	for (Int_t j=0; j<parentsBak.GetEntries(); ++j)
238	>	parents->Add(parentsBak.At(j));
239	>	}
240	>	else
241	>	mt->Reset();
242		mt->SetDirectory(0);
243		}
244
#	Line 242 | Line 250 | void TreeWriter::CloseFile()
250		fFileNumber++;
251		}
252
253	<	//__________________________________________________________________________________________________
253	>	//--------------------------------------------------------------------------------------------------
254		const char *TreeWriter::CName(void *obj) const
255		{
256		// Dereference void* pointer into TObject* pointer
#	Line 254 | Line 262 | const char *TreeWriter::CName(void *obj)
262		return tobj->ClassName();
263		}
264
265	<	//__________________________________________________________________________________________________
265	>	//--------------------------------------------------------------------------------------------------
266		Bool_t TreeWriter::EndEvent(Bool_t doreset)
267		{
268		// Store the event in the tree. If doreset or fDoObjNumReset is kTRUE
#	Line 281 | Line 289 | Bool_t TreeWriter::EndEvent(Bool_t dores
289		if (fEvtObjNum<0) {
290		Error("EndEvent", "Object counter is zero. Did you call BeginEvent(kTRUE)?");
291		} else {
292	<	// Reset the TRef table. keep it from growing with each event (see doc)
292	>	// Reset the TRef table. Keep it from growing with each event (see doc)
293		TProcessID::SetObjectCount(fEvtObjNum);
294		}
295		}
#	Line 289 | Line 297 | Bool_t TreeWriter::EndEvent(Bool_t dores
297		return (r >= 0);
298		}
299
300	<	//-------------------------------------------------------------------------------------------------
300	>	//--------------------------------------------------------------------------------------------------
301		Long64_t TreeWriter::GetEntries(const char *tn) const
302		{
303		// Return entries of tree with given name. If no tree is given, return sum of entries
#	Line 313 | Line 321 | Long64_t TreeWriter::GetEntries(const ch
321		return ret;
322		}
323
324	<	//-------------------------------------------------------------------------------------------------
324	>	//--------------------------------------------------------------------------------------------------
325		MyTree *mithep::TreeWriter::GetMyTree(const char *tn)
326		{
327		// Return MyTree with given name from array.
#	Line 333 | Line 341 | MyTree *mithep::TreeWriter::GetMyTree(co
341		return 0;
342		}
343
344	<	//-------------------------------------------------------------------------------------------------
344	>	//--------------------------------------------------------------------------------------------------
345		const TTree *mithep::TreeWriter::GetTree(const char *tn) const
346		{
347		// Return TTree with given name from array.
#	Line 353 | Line 361 | const TTree *mithep::TreeWriter::GetTree
361		return 0;
362		}
363
364	<	//-------------------------------------------------------------------------------------------------
364	>	//--------------------------------------------------------------------------------------------------
365		TTree *mithep::TreeWriter::GetTree(const char *tn)
366		{
367		// Return TTree with given name from array.
#	Line 373 | Line 381 | TTree *mithep::TreeWriter::GetTree(const
381		return 0;
382		}
383
384	<	//__________________________________________________________________________________________________
384	>	//--------------------------------------------------------------------------------------------------
385		Bool_t TreeWriter::IsFull() const
386		{
387		// Check if the maximum file size has been reached.
#	Line 389 | Line 397 | Bool_t TreeWriter::IsFull() const
397		return (GetFileSize() + avgSize + fkMinFreeSpace) > fMaxSize;
398		}
399
400	<	//__________________________________________________________________________________________________
400	>	//--------------------------------------------------------------------------------------------------
401		void TreeWriter::OpenFile()
402		{
403		// Open the file and attach the tree.
#	Line 420 | Line 428 | void TreeWriter::OpenFile()
428		fIsInit = kTRUE;
429		}
430
431	<	//__________________________________________________________________________________________________
431	>	//--------------------------------------------------------------------------------------------------
432		void TreeWriter::Print(Option_t *option) const
433		{
434		// Print the contents of the tree writer.
#	Line 442 | Line 450 | void TreeWriter::Print(Option_t *option)
450		<< (GetEntries() == 1 ? " event" : " events") << endl;
451		}
452
453	<	//-------------------------------------------------------------------------------------------------
453	>	//--------------------------------------------------------------------------------------------------
454		void TreeWriter::SetAutoFill(const char *tn, Bool_t b)
455		{
456		// Set auto-fill mode of tree with given name.
#	Line 457 | Line 465 | void TreeWriter::SetAutoFill(const char
465		mt->SetAutoFill(b);
466		}
467
468	<
461	<	//-------------------------------------------------------------------------------------------------
468	>	//--------------------------------------------------------------------------------------------------
469		void TreeWriter::SetMaxSize(Long64_t s)
470		{
471		// Set maximum file size. Check if this exceeds the ROOT file size and if,
#	Line 474 | Line 481 | void TreeWriter::SetMaxSize(Long64_t s)
481		fMaxSize=s;
482		}
483
484	<	//__________________________________________________________________________________________________
484	>	//--------------------------------------------------------------------------------------------------
485		void TreeWriter::StoreObject(const TObject *obj)
486		{
487		// Store object next to tree in file. Used to store the

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines