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.6 by loizides, Tue Jun 24 14:05:03 2008 UTC vs.
Revision 1.16 by loizides, Mon Mar 23 22:15:11 2009 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 28 | Line 27 | TreeWriter::TreeWriter(const char *tname
27		fEvtObjNum(-1),
28		fIsInit(kFALSE),
29		fDoObjNumReset(doreset),
30	+	fDoBranchRef(0),
31		fFile(0),
32		fTrees(0)
33		{
#	Line 41 | Line 41 | TreeWriter::~TreeWriter()
41		{
42		// Destructor.
43
44	<	if (fIsInit) {
45	<	CloseFile();
46	<	}
47	<
48	<	TDirectory::TContext context(0);
49	<	fTrees.Clear();
44	>	Terminate();
45		}
46
47		//__________________________________________________________________________________________________
#	Line 56 | Line 51 | void TreeWriter::AddBranch(const char *n
51		// Add branch with name "name" into tree with name "tname" and set its address
52		// to object pointer for class name "cname" using a given buffer size and splitlevel.
53
54	<	MyTree *t = AddOrGetMyTree(GetName());
55	<	t->Bronch(name, cname, obj, bsize, level);
54	>	MyTree  *t = AddOrGetMyTree(GetName());
55	>	TBranch *b = t->Bronch(name, cname, obj, bsize, level);
56	>	b->SetCompressionLevel(GetCompressLevel());
57		}
58
59	<
64	<	//__________________________________________________________________________________________________
59	>	//--------------------------------------------------------------------------------------------------
60		void TreeWriter::AddBranch(const char *name, void *obj, Int_t bsize, Int_t level)
61		{
62		// Add branch with name "name" into tree with name "tname" and set its address
#	Line 70 | Line 65 | void TreeWriter::AddBranch(const char *n
65		AddBranch(name, CName(obj), obj, bsize, level);
66		}
67
68	<	//__________________________________________________________________________________________________
68	>	//--------------------------------------------------------------------------------------------------
69		void TreeWriter::AddBranch(const char *name, const char *cname,
70		void *obj, Int_t bsize)
71		{
72		// Add branch with name "name" into tree with name "tname" and set its address
73		// to object pointer for class name "cname" using a given buffer size and default splitlevel.
74
75	<	MyTree *t = AddOrGetMyTree(GetName());
76	<	t->Bronch(name, cname, obj, bsize, fDefSL);
75	>	MyTree  *t = AddOrGetMyTree(GetName());
76	>	TBranch *b = t->Bronch(name, cname, obj, bsize, fDefSL);
77	>	b->SetCompressionLevel(GetCompressLevel());
78		}
79
80	<	//__________________________________________________________________________________________________
80	>	//--------------------------------------------------------------------------------------------------
81		void TreeWriter::AddBranch(const char *name, void *obj, Int_t bsize)
82		{
83		// Add branch with name "name" into tree with name "tname" and set its address
#	Line 90 | Line 86 | void TreeWriter::AddBranch(const char *n
86		AddBranch(name, CName(obj), obj, bsize);
87		}
88
89	<	//__________________________________________________________________________________________________
89	>	//--------------------------------------------------------------------------------------------------
90		void TreeWriter::AddBranch(const char *name, const char *cname,
91		void *obj)
92		{
93		// Add branch with name "name" into tree with name "tname" and set its address
94		// to object pointer for class name "cname" using a default buffer size and splitlevel.
95
96	<	MyTree *t = AddOrGetMyTree(GetName());
97	<	t->Bronch(name, cname, obj, fDefBrSize, fDefSL);
96	>	MyTree  *t = AddOrGetMyTree(GetName());
97	>	TBranch *b = t->Bronch(name, cname, obj, fDefBrSize, fDefSL);
98	>	b->SetCompressionLevel(GetCompressLevel());
99		}
100
101	<	//__________________________________________________________________________________________________
101	>	//--------------------------------------------------------------------------------------------------
102		void TreeWriter::AddBranch(const char *name, void *obj)
103		{
104		// Add branch with name "name" into tree with name "tname" and set its address
#	Line 110 | Line 107 | void TreeWriter::AddBranch(const char *n
107		AddBranch(name, CName(obj), obj);
108		}
109
110	<	//__________________________________________________________________________________________________
110	>	//--------------------------------------------------------------------------------------------------
111		void TreeWriter::AddBranchToTree(const char *tname, const char *name, const char *cname,
112		void *obj, Int_t bsize, Int_t level)
113		{
114		// Add branch with name "name" into tree with name "tname" and set its address
115		// to object pointer for class name "cname" using a given buffer size and splitlevel.
116
117	<	MyTree *t = AddOrGetMyTree(tname);
118	<	t->Bronch(name, cname, obj, bsize, level);
117	>	MyTree  *t = AddOrGetMyTree(tname);
118	>	TBranch *b = t->Bronch(name, cname, obj, bsize, level);
119	>	b->SetCompressionLevel(GetCompressLevel());
120		}
121
122	<	//__________________________________________________________________________________________________
122	>	//--------------------------------------------------------------------------------------------------
123		void TreeWriter::AddBranchToTree(const char *tname, const char *name, void *obj,
124		Int_t bsize, Int_t level)
125		{
#	Line 131 | Line 129 | void TreeWriter::AddBranchToTree(const c
129		AddBranchToTree(tname, name, CName(obj), obj, bsize, level);
130		}
131
132	<	//__________________________________________________________________________________________________
132	>	//--------------------------------------------------------------------------------------------------
133		void TreeWriter::AddBranchToTree(const char *tname, const char *name, const char *cname,
134		void *obj, Int_t bsize)
135		{
136		// Add branch with name "name" into tree with name "tname" and set its address
137		// to object pointer for class name "cname" using a given buffer size and default splitlevel.
138
139	<	MyTree *t = AddOrGetMyTree(tname);
140	<	t->Bronch(name, cname, obj, bsize, fDefSL);
139	>	MyTree  *t = AddOrGetMyTree(tname);
140	>	TBranch *b = t->Bronch(name, cname, obj, bsize, fDefSL);
141	>	b->SetCompressionLevel(GetCompressLevel());
142		}
143
144	<	//__________________________________________________________________________________________________
144	>	//--------------------------------------------------------------------------------------------------
145		void TreeWriter::AddBranchToTree(const char *tname, const char *name, void *obj,
146		Int_t bsize)
147		{
#	Line 152 | Line 151 | void TreeWriter::AddBranchToTree(const c
151		AddBranchToTree(tname, name, CName(obj), obj, bsize);
152		}
153
154	<	//__________________________________________________________________________________________________
154	>	//--------------------------------------------------------------------------------------------------
155		void TreeWriter::AddBranchToTree(const char *tname, const char *name, const char *cname,
156		void *obj)
157		{
158		// Add branch with name "name" into tree with name "tname" and set its address
159		// to object pointer for class name "cname" using a default buffer size and splitlevel.
160
161	<	MyTree *t = AddOrGetMyTree(tname);
162	<	t->Bronch(name, cname, obj, fDefBrSize, fDefSL);
161	>	MyTree  *t = AddOrGetMyTree(tname);
162	>	TBranch *b = t->Bronch(name, cname, obj, fDefBrSize, fDefSL);
163	>	b->SetCompressionLevel(GetCompressLevel());
164		}
165
166	<	//__________________________________________________________________________________________________
166	>	//--------------------------------------------------------------------------------------------------
167		void TreeWriter::AddBranchToTree(const char *tname, const char *name, void *obj)
168		{
169		// Add branch with name "name" into tree with name "tname" and set its address
#	Line 172 | Line 172 | void TreeWriter::AddBranchToTree(const c
172		AddBranchToTree(tname, name, CName(obj), obj);
173		}
174
175	<	//__________________________________________________________________________________________________
175	>	//--------------------------------------------------------------------------------------------------
176	>	void TreeWriter::AddTree(const char *tname)
177	>	{
178	>	// Add tree with name "name" into tree with name "tname".
179	>
180	>	AddOrGetMyTree(tname);
181	>	}
182	>
183	>	//--------------------------------------------------------------------------------------------------
184		MyTree *TreeWriter::AddOrGetMyTree(const char *tn)
185		{
186		// Add new tree if not present in array of trees or return
187		// present tree.
188
189	<	MyTree *tree = dynamic_cast<MyTree*>(fTrees.FindObject(tn));
189	>	MyTree *tree = GetMyTree(tn);
190		if (tree)
191		return tree;
192
193		TDirectory::TContext context(fFile);
194		tree = new MyTree(tn, tn);
195		tree->SetDirectory(fFile);
196	+	if (fDoBranchRef)
197	+	tree->BranchRef();
198		fTrees.AddLast(tree);
199		return tree;
200		}
201
202	<	//__________________________________________________________________________________________________
202	>	//--------------------------------------------------------------------------------------------------
203		Bool_t TreeWriter::BeginEvent(Bool_t doreset)
204		{
205		// Prepare for the next event. If doreset or fDoObjNumReset is kTRUE
#	Line 206 | Line 216 | Bool_t TreeWriter::BeginEvent(Bool_t dor
216		return kTRUE;
217		}
218
219	<	//__________________________________________________________________________________________________
219	>	//--------------------------------------------------------------------------------------------------
220		void TreeWriter::CloseFile()
221		{
222		// Write tree(s) and close file.
#	Line 222 | Line 232 | void TreeWriter::CloseFile()
232		for (Int_t i=0;i<fTrees.GetEntries();++i) {
233		MyTree *mt = static_cast<MyTree*>(fTrees.At(i));
234		mt->Write(mt->GetName(),TObject::kOverwrite);
235	<	mt->Reset();
235	>
236	>	// backup and restore list of branch pointers from TRefTable (needed for autoloading)
237	>	if (mt->GetBranchRef()) {
238	>	TObjArray *parents = mt->GetBranchRef()->GetRefTable()->GetParents();
239	>	TObjArray parentsBak(*parents);
240	>	mt->Reset();
241	>	for (Int_t j=0; j<parentsBak.GetEntries(); ++j)
242	>	parents->Add(parentsBak.At(j));
243	>	}
244	>	else
245	>	mt->Reset();
246		mt->SetDirectory(0);
247		}
248
#	Line 234 | Line 254 | void TreeWriter::CloseFile()
254		fFileNumber++;
255		}
256
257	<	//__________________________________________________________________________________________________
257	>	//--------------------------------------------------------------------------------------------------
258		const char *TreeWriter::CName(void *obj) const
259		{
260		// Dereference void* pointer into TObject* pointer
261
262	<	TObject *tobj = dynamic_cast<TObject*>(*(TObject**)obj);
262	>	TObject **sobj = static_cast<TObject**>(obj);
263	>	TObject *tobj = dynamic_cast<TObject*>(*sobj);
264		if (tobj==0) {
265	<	Fatal("ClassName", "Given void* ptr can not be dereferenced into TObject*");
265	>	Fatal("CName", "Given void* ptr cannot be dereferenced into TObject*");
266		}
267		return tobj->ClassName();
268		}
269
270	<	//__________________________________________________________________________________________________
270	>	//--------------------------------------------------------------------------------------------------
271	>	void TreeWriter::DoBranchRef(const char *tn)
272	>	{
273	>	// Fill BranchRef for given tree.
274	>
275	>	if (fTrees.GetEntries()==0) {
276	>	Error("DoBranchRef", "Tree with name %s not found!", tn);
277	>	return;
278	>	}
279	>
280	>	MyTree *mt = GetMyTree(tn);
281	>	if (!mt)
282	>	return;
283	>
284	>	mt->BranchRef();
285	>	}
286	>
287	>	//--------------------------------------------------------------------------------------------------
288		Bool_t TreeWriter::EndEvent(Bool_t doreset)
289		{
290		// Store the event in the tree. If doreset or fDoObjNumReset is kTRUE
#	Line 273 | Line 311 | Bool_t TreeWriter::EndEvent(Bool_t dores
311		if (fEvtObjNum<0) {
312		Error("EndEvent", "Object counter is zero. Did you call BeginEvent(kTRUE)?");
313		} else {
314	<	// Reset the TRef table. keep it from growing with each event (see doc)
314	>	// Reset the TRef table. Keep it from growing with each event (see doc)
315		TProcessID::SetObjectCount(fEvtObjNum);
316		}
317		}
#	Line 281 | Line 319 | Bool_t TreeWriter::EndEvent(Bool_t dores
319		return (r >= 0);
320		}
321
322	<	//-------------------------------------------------------------------------------------------------
322	>	//--------------------------------------------------------------------------------------------------
323		Long64_t TreeWriter::GetEntries(const char *tn) const
324		{
325		// Return entries of tree with given name. If no tree is given, return sum of entries
#	Line 305 | Line 343 | Long64_t TreeWriter::GetEntries(const ch
343		return ret;
344		}
345
346	<	//-------------------------------------------------------------------------------------------------
346	>	//--------------------------------------------------------------------------------------------------
347		MyTree *mithep::TreeWriter::GetMyTree(const char *tn)
348		{
349		// Return MyTree with given name from array.
#	Line 325 | Line 363 | MyTree *mithep::TreeWriter::GetMyTree(co
363		return 0;
364		}
365
366	<	//-------------------------------------------------------------------------------------------------
366	>	//--------------------------------------------------------------------------------------------------
367		const TTree *mithep::TreeWriter::GetTree(const char *tn) const
368		{
369		// Return TTree with given name from array.
#	Line 345 | Line 383 | const TTree *mithep::TreeWriter::GetTree
383		return 0;
384		}
385
386	<	//-------------------------------------------------------------------------------------------------
386	>	//--------------------------------------------------------------------------------------------------
387		TTree *mithep::TreeWriter::GetTree(const char *tn)
388		{
389		// Return TTree with given name from array.
#	Line 365 | Line 403 | TTree *mithep::TreeWriter::GetTree(const
403		return 0;
404		}
405
406	<	//__________________________________________________________________________________________________
406	>	//--------------------------------------------------------------------------------------------------
407		Bool_t TreeWriter::IsFull() const
408		{
409		// Check if the maximum file size has been reached.
#	Line 381 | Line 419 | Bool_t TreeWriter::IsFull() const
419		return (GetFileSize() + avgSize + fkMinFreeSpace) > fMaxSize;
420		}
421
422	<	//__________________________________________________________________________________________________
422	>	//--------------------------------------------------------------------------------------------------
423		void TreeWriter::OpenFile()
424		{
425		// Open the file and attach the tree.
#	Line 412 | Line 450 | void TreeWriter::OpenFile()
450		fIsInit = kTRUE;
451		}
452
453	<	//__________________________________________________________________________________________________
453	>	//--------------------------------------------------------------------------------------------------
454		void TreeWriter::Print(Option_t *option) const
455		{
456		// Print the contents of the tree writer.
#	Line 434 | Line 472 | void TreeWriter::Print(Option_t *option)
472		<< (GetEntries() == 1 ? " event" : " events") << endl;
473		}
474
475	<	//-------------------------------------------------------------------------------------------------
475	>	//--------------------------------------------------------------------------------------------------
476		void TreeWriter::SetAutoFill(const char *tn, Bool_t b)
477		{
478		// Set auto-fill mode of tree with given name.
#	Line 449 | Line 487 | void TreeWriter::SetAutoFill(const char
487		mt->SetAutoFill(b);
488		}
489
490	<
453	<	//-------------------------------------------------------------------------------------------------
490	>	//--------------------------------------------------------------------------------------------------
491		void TreeWriter::SetMaxSize(Long64_t s)
492		{
493		// Set maximum file size. Check if this exceeds the ROOT file size and if,
#	Line 466 | Line 503 | void TreeWriter::SetMaxSize(Long64_t s)
503		fMaxSize=s;
504		}
505
506	<	//__________________________________________________________________________________________________
506	>	//--------------------------------------------------------------------------------------------------
507		void TreeWriter::StoreObject(const TObject *obj)
508		{
509		// Store object next to tree in file. Used to store the
#	Line 484 | Line 521 | void TreeWriter::StoreObject(const TObje
521
522		fFile->WriteTObject(obj,obj->GetName(),"WriteDelete");
523		}
524	+
525	+	//__________________________________________________________________________________________________
526	+	void TreeWriter::Terminate()
527	+	{
528	+	// Terminate tree file writing.
529	+
530	+	if (fIsInit) {
531	+	CloseFile();
532	+	}
533	+
534	+	TDirectory::TContext context(0);
535	+	fTrees.Clear();
536	+	}

Diff Legend

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