TreeMod/src/AnaFwkMod.cc

// $Id: AnaFwkMod.cc,v 1.14 2009/06/28 08:02:05 loizides Exp $

#include "MitAna/TreeMod/interface/AnaFwkMod.h"
#include "MitAna/DataUtil/interface/Debug.h"
#include "MitAna/DataTree/interface/Names.h"
#include <TFile.h>
#include <TH1D.h>
#include <TStopwatch.h>
#include <TTree.h>

using namespace mithep;

ClassImp(mithep::AnaFwkMod)

//--------------------------------------------------------------------------------------------------
AnaFwkMod::AnaFwkMod(const char *name, const char *title) : 
  BaseMod(name,title),
  fAllHeadTreeName(Names::gkAllEvtTreeName),
  fAllHeadBrName(Names::gkAllEvtHeaderBrn),
  fSkipNEvents(0),
  fPrintScale(1),
  fSWtotal(0),
  fSWevent(0),
  fAllHeaders(0,Names::gkSkimmedHeaders),
  fAllHeadTree(0),
  fAllEventHeader(0),
  fReload(kFALSE),
  fCurEnt(-2),
  fNEventsSkimmed(0),
  fNEventsSkipped(0)
{
  // Constructor.
}

//--------------------------------------------------------------------------------------------------
void AnaFwkMod::BeginRun()
{
  // Get HLT tree and set branches if new file was opened. Read next entry in HLT key
  // depending on entry in RunInfo.

  if (fReload) {
    // reset to be (re-)loaded variables
    fReload         = 0;
    fAllHeadTree    = 0;
    fAllEventHeader = 0;
    fCurEnt         = 0;

    // get current file
    TFile *file = GetCurrentFile();
    if (!file) 
      return;

    // get all event header tree
    fAllHeadTree = dynamic_cast<TTree*>(file->Get(fAllHeadTreeName));
    if (!fAllHeadTree) {
      SendError(kWarning, "BeginRun",
                "Cannot find tree '%s' in file '%s'", 
                fAllHeadTreeName.Data(),file->GetName());
      return;
    }

    // get all event header branch
    if (fAllHeadTree->GetBranch(fAllHeadBrName)) {
      fAllHeadTree->SetBranchAddress(fAllHeadBrName, &fAllEventHeader);
    } else {
      SendError(kWarning, "BeginRun",
                "Cannot find branch '%s' in tree '%s'", 
                fAllHeadBrName.Data(), fAllHeadTreeName.Data());
      return;
    }
  }
}

//--------------------------------------------------------------------------------------------------
void AnaFwkMod::CopyAllEventHeaders()
{
  // Deal with the headers from all events if needed.

  fAllHeaders.Reset();

  const EventHeader *curev = GetEventHeader();
  if (!curev) {
    SendError(kWarning, "CopyAllEventHeaders", "Cannot obtain current event");
    return;
  }

  if (fAllHeadTree) {
    const Int_t nemax = fAllHeadTree->GetEntries();
    if (fCurEnt == nemax) {
      SendError(kAbortEvent, "CopyAllEventHeaders", 
                "End of all events tree reached (%d=%d)", fCurEnt, nemax);
      return;
    }
    fAllHeadTree->GetEntry(fCurEnt++);
    while(fCurEnt<=nemax && fAllEventHeader->Skimmed()) {
      EventHeader *eh = fAllHeaders.AddNew();
      eh->SetRunNum(fAllEventHeader->RunNum());
      eh->SetEvtNum(fAllEventHeader->EvtNum());
      eh->SetLumiSec(fAllEventHeader->LumiSec());
      eh->SetRunEntry(fAllEventHeader->RunEntry());
      eh->SetSkimmed(fAllEventHeader->Skimmed());
      fAllHeadTree->GetEntry(fCurEnt++);
    }
    if ((fAllEventHeader->RunNum()!=curev->RunNum())   ||
        (fAllEventHeader->EvtNum()!=curev->EvtNum())   ||
        (fAllEventHeader->LumiSec()!=curev->LumiSec()) ||
        (fAllEventHeader->RunEntry()!=curev->RunEntry())) {
      SendError(kWarning, "CopyAllEventHeaders", 
                "Event header information for entry %d inconsistent: "
                "%d==%d, %d==%d, %d==%d, %d==%d",
                fCurEnt,
                fAllEventHeader->RunNum(),   curev->RunNum(), 
                fAllEventHeader->EvtNum(),   curev->EvtNum(),
                fAllEventHeader->LumiSec(),  curev->LumiSec(),
                fAllEventHeader->RunEntry(), curev->RunEntry());
      return;
    }

    // read-ahead to check if more events are coming
    if (fCurEnt<nemax) { 
      Int_t testEnt = fCurEnt;
      fAllHeadTree->GetEntry(testEnt++);
      while(testEnt<=nemax && fAllEventHeader->Skimmed())
        fAllHeadTree->GetEntry(testEnt++);
      if (testEnt==nemax+1) { // need to add remaining skimmed events
        fAllHeadTree->GetEntry(fCurEnt++);
        while(fCurEnt<=nemax) {
          EventHeader *eh = fAllHeaders.AddNew();
          eh->SetRunNum(fAllEventHeader->RunNum());
          eh->SetEvtNum(fAllEventHeader->EvtNum());
          eh->SetLumiSec(fAllEventHeader->LumiSec());
          eh->SetRunEntry(fAllEventHeader->RunEntry());
          eh->SetSkimmed(fAllEventHeader->Skimmed());
          fAllHeadTree->GetEntry(fCurEnt++);
        }
        if (fCurEnt != nemax+1) {
          SendError(kAbortEvent, "CopyAllEventHeaders", 
                    "End of all events tree unexpectedly not reached (%d!=%d)", fCurEnt, nemax);
          return;
        }
      }
    }
  }
}

//--------------------------------------------------------------------------------------------------
Bool_t AnaFwkMod::Notify()
{
  // Make sure to get the new "AllEvents" tree when the file changes.

  fReload = kTRUE;
  return kTRUE;
}

//--------------------------------------------------------------------------------------------------
void AnaFwkMod::Process()
{
  // Do event skipping and counting and print out timing information.

  // counting processed events
  IncNEventsProcessed();
  
  // get skimmed event headers
  CopyAllEventHeaders();
  fNEventsSkimmed += fAllHeaders.GetEntries();

  // check if events should be skipped
  if (fNEventsSkipped<fSkipNEvents) {
    ++fNEventsSkipped;
    MDB(kAnalysis, 3) {
      Info("Process", "Skipping (aborting) %d out of %lld first events.",
           fNEventsSkipped, fSkipNEvents);
    }
    AbortEvent();
    return;
  }

  // check if printout should be done
  Bool_t doPrint    = 0;
  UInt_t nProcessed = fPrintScale;

  MDB(kAnalysis, 4) {
    if (GetNEventsProcessed() % (fPrintScale)  == 0) 
      doPrint = 1;
  } else {
    MDB(kAnalysis, 3) {
      if (GetNEventsProcessed() % (fPrintScale*10)  == 0) 
        doPrint = 1;
      nProcessed = fPrintScale*10;
    } else {
      MDB(kAnalysis, 2) {
        if (GetNEventsProcessed() % (fPrintScale*100)  == 0) 
          doPrint = 1;
        nProcessed = fPrintScale*100;
      } else {
        MDB(kAnalysis, 1) {
          if (GetNEventsProcessed() % (fPrintScale*1000) == 0) 
            doPrint = 1;
          nProcessed = fPrintScale*1000;
        } 
      }
    }
  }

  if (doPrint) {
    fSWevent->Stop();
    Info("Process", 
         "Events %d -> %.2gs real, %.2gs cpu (%.2g real, %.2g cpu per event)", 
         GetNEventsProcessed(), fSWevent->RealTime(), fSWevent->CpuTime(),
         fSWevent->RealTime()/nProcessed, 
         fSWevent->CpuTime()/nProcessed);
    fSWevent->Start();
  }  
}

//--------------------------------------------------------------------------------------------------
void AnaFwkMod::SlaveBegin()
{
  // Book our histogram and start the stop watches.

  fSWtotal = new TStopwatch;
  fSWevent = new TStopwatch;

  if (!PublishObj(&fAllHeaders)) {
    SendError(kAbortAnalysis, "SlaveBegin", 
              "Could not publish all event headers with name %s.", fAllHeaders.GetName());
    return;
  }
}

//--------------------------------------------------------------------------------------------------
void AnaFwkMod::SlaveTerminate()
{
  // Fill event histogram and printout timing information.

  RetractObj(fAllHeaders.GetName());

  SaveNEventsProcessed();
  TH1D *hDAllEvents = new TH1D("hDAllEvents","Sum of processed and skimmed events",1,-0.5,0.5);
  hDAllEvents->Fill(0.0,fNEventsSkimmed+GetNEventsProcessed());
  hDAllEvents->SetEntries(fNEventsSkimmed+GetNEventsProcessed());
  AddOutput(hDAllEvents);

  TH1D *hDSkippedEvents = new TH1D("hDSkippedEvents","Number of skipped events",1,-0.5,0.5);
  hDSkippedEvents->Fill(0.0,fNEventsSkipped);
  hDSkippedEvents->SetEntries(fNEventsSkipped);
  AddOutput(hDSkippedEvents);

  fSWtotal->Stop();
  fSWevent->Stop();

  MDB(kAnalysis, 1)
    Info("SlaveTerminate", 
         "Events %d -> %.2gs real, %.2gs cpu (%.2gs real, %.2gs cpu per event)",
         GetNEventsProcessed(), fSWtotal->RealTime(), fSWtotal->CpuTime(),
         fSWtotal->RealTime()/GetNEventsProcessed(), 
         fSWtotal->CpuTime()/GetNEventsProcessed());

  delete fSWtotal;
  delete fSWevent;
}
Revision:	1.15
Committed:	Fri Mar 11 04:03:54 2011 UTC (14 years, 1 month ago) by bendavid
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_023, Mit_022a, Mit_022, Mit_020d, TMit_020d, Mit_020c, Mit_021, Mit_021pre2, Mit_021pre1, Mit_020b, Mit_020a, Mit_020, Mit_020pre1
Changes since 1.14:	+2 -2 lines
Log Message:	various minor changes to acommodate new root and architecture
#	User	Rev	Content
1	bendavid	1.15	// $Id: AnaFwkMod.cc,v 1.14 2009/06/28 08:02:05 loizides Exp $
2	loizides	1.1
3			#include "MitAna/TreeMod/interface/AnaFwkMod.h"
4			#include "MitAna/DataUtil/interface/Debug.h"
5	loizides	1.6	#include "MitAna/DataTree/interface/Names.h"
6	loizides	1.4	#include <TFile.h>
7	loizides	1.1	#include <TH1D.h>
8			#include <TStopwatch.h>
9	loizides	1.4	#include <TTree.h>
10	loizides	1.1
11			using namespace mithep;
12
13			ClassImp(mithep::AnaFwkMod)
14
15			//--------------------------------------------------------------------------------------------------
16			AnaFwkMod::AnaFwkMod(const char name, const char title) :
17			BaseMod(name,title),
18	loizides	1.6	fAllHeadTreeName(Names::gkAllEvtTreeName),
19			fAllHeadBrName(Names::gkAllEvtHeaderBrn),
20	loizides	1.8	fSkipNEvents(0),
21	loizides	1.13	fPrintScale(1),
22	loizides	1.1	fSWtotal(0),
23	loizides	1.4	fSWevent(0),
24	loizides	1.6	fAllHeaders(0,Names::gkSkimmedHeaders),
25	loizides	1.4	fAllHeadTree(0),
26			fAllEventHeader(0),
27			fReload(kFALSE),
28	loizides	1.6	fCurEnt(-2),
29	loizides	1.8	fNEventsSkimmed(0),
30			fNEventsSkipped(0)
31	loizides	1.1	{
32			// Constructor.
33			}
34
35			//--------------------------------------------------------------------------------------------------
36	loizides	1.4	void AnaFwkMod::BeginRun()
37			{
38			// Get HLT tree and set branches if new file was opened. Read next entry in HLT key
39			// depending on entry in RunInfo.
40
41			if (fReload) {
42			// reset to be (re-)loaded variables
43			fReload = 0;
44			fAllHeadTree = 0;
45			fAllEventHeader = 0;
46			fCurEnt = 0;
47
48			// get current file
49			TFile *file = GetCurrentFile();
50			if (!file)
51			return;
52
53	loizides	1.10	// get all event header tree
54	loizides	1.4	fAllHeadTree = dynamic_cast<TTree*>(file->Get(fAllHeadTreeName));
55			if (!fAllHeadTree) {
56	loizides	1.6	SendError(kWarning, "BeginRun",
57	loizides	1.9	"Cannot find tree '%s' in file '%s'",
58	loizides	1.6	fAllHeadTreeName.Data(),file->GetName());
59	loizides	1.4	return;
60			}
61
62	loizides	1.10	// get all event header branch
63			if (fAllHeadTree->GetBranch(fAllHeadBrName)) {
64			fAllHeadTree->SetBranchAddress(fAllHeadBrName, &fAllEventHeader);
65			} else {
66			SendError(kWarning, "BeginRun",
67			"Cannot find branch '%s' in tree '%s'",
68			fAllHeadBrName.Data(), fAllHeadTreeName.Data());
69			return;
70			}
71	loizides	1.4	}
72			}
73
74			//--------------------------------------------------------------------------------------------------
75			void AnaFwkMod::CopyAllEventHeaders()
76			{
77			// Deal with the headers from all events if needed.
78
79			fAllHeaders.Reset();
80
81			const EventHeader *curev = GetEventHeader();
82			if (!curev) {
83	loizides	1.9	SendError(kWarning, "CopyAllEventHeaders", "Cannot obtain current event");
84	loizides	1.4	return;
85			}
86
87			if (fAllHeadTree) {
88	loizides	1.6	const Int_t nemax = fAllHeadTree->GetEntries();
89			if (fCurEnt == nemax) {
90			SendError(kAbortEvent, "CopyAllEventHeaders",
91			"End of all events tree reached (%d=%d)", fCurEnt, nemax);
92			return;
93			}
94	loizides	1.4	fAllHeadTree->GetEntry(fCurEnt++);
95	loizides	1.7	while(fCurEnt<=nemax && fAllEventHeader->Skimmed()) {
96	loizides	1.4	EventHeader *eh = fAllHeaders.AddNew();
97			eh->SetRunNum(fAllEventHeader->RunNum());
98			eh->SetEvtNum(fAllEventHeader->EvtNum());
99			eh->SetLumiSec(fAllEventHeader->LumiSec());
100	loizides	1.5	eh->SetRunEntry(fAllEventHeader->RunEntry());
101			eh->SetSkimmed(fAllEventHeader->Skimmed());
102	loizides	1.4	fAllHeadTree->GetEntry(fCurEnt++);
103			}
104			if ((fAllEventHeader->RunNum()!=curev->RunNum()) \|\|
105			(fAllEventHeader->EvtNum()!=curev->EvtNum()) \|\|
106			(fAllEventHeader->LumiSec()!=curev->LumiSec()) \|\|
107			(fAllEventHeader->RunEntry()!=curev->RunEntry())) {
108			SendError(kWarning, "CopyAllEventHeaders",
109	loizides	1.6	"Event header information for entry %d inconsistent: "
110			"%d==%d, %d==%d, %d==%d, %d==%d",
111			fCurEnt,
112	loizides	1.4	fAllEventHeader->RunNum(), curev->RunNum(),
113			fAllEventHeader->EvtNum(), curev->EvtNum(),
114			fAllEventHeader->LumiSec(), curev->LumiSec(),
115			fAllEventHeader->RunEntry(), curev->RunEntry());
116			return;
117			}
118	loizides	1.6
119			// read-ahead to check if more events are coming
120			if (fCurEnt<nemax) {
121			Int_t testEnt = fCurEnt;
122			fAllHeadTree->GetEntry(testEnt++);
123	loizides	1.7	while(testEnt<=nemax && fAllEventHeader->Skimmed())
124	loizides	1.6	fAllHeadTree->GetEntry(testEnt++);
125	loizides	1.7	if (testEnt==nemax+1) { // need to add remaining skimmed events
126	loizides	1.6	fAllHeadTree->GetEntry(fCurEnt++);
127	loizides	1.7	while(fCurEnt<=nemax) {
128	loizides	1.6	EventHeader *eh = fAllHeaders.AddNew();
129			eh->SetRunNum(fAllEventHeader->RunNum());
130			eh->SetEvtNum(fAllEventHeader->EvtNum());
131			eh->SetLumiSec(fAllEventHeader->LumiSec());
132			eh->SetRunEntry(fAllEventHeader->RunEntry());
133			eh->SetSkimmed(fAllEventHeader->Skimmed());
134			fAllHeadTree->GetEntry(fCurEnt++);
135			}
136	loizides	1.7	if (fCurEnt != nemax+1) {
137	loizides	1.6	SendError(kAbortEvent, "CopyAllEventHeaders",
138			"End of all events tree unexpectedly not reached (%d!=%d)", fCurEnt, nemax);
139			return;
140			}
141			}
142			}
143	loizides	1.4	}
144			}
145
146			//--------------------------------------------------------------------------------------------------
147			Bool_t AnaFwkMod::Notify()
148			{
149			// Make sure to get the new "AllEvents" tree when the file changes.
150
151			fReload = kTRUE;
152			return kTRUE;
153			}
154
155			//--------------------------------------------------------------------------------------------------
156	loizides	1.1	void AnaFwkMod::Process()
157			{
158	loizides	1.8	// Do event skipping and counting and print out timing information.
159	loizides	1.1
160	loizides	1.8	// counting processed events
161			IncNEventsProcessed();
162	loizides	1.4
163	loizides	1.6	// get skimmed event headers
164			CopyAllEventHeaders();
165			fNEventsSkimmed += fAllHeaders.GetEntries();
166	loizides	1.4
167	loizides	1.8	// check if events should be skipped
168			if (fNEventsSkipped<fSkipNEvents) {
169			++fNEventsSkipped;
170			MDB(kAnalysis, 3) {
171	bendavid	1.15	Info("Process", "Skipping (aborting) %d out of %lld first events.",
172	loizides	1.9	fNEventsSkipped, fSkipNEvents);
173	loizides	1.8	}
174			AbortEvent();
175			return;
176			}
177	loizides	1.1
178			// check if printout should be done
179	loizides	1.14	Bool_t doPrint = 0;
180			UInt_t nProcessed = fPrintScale;
181	loizides	1.1
182			MDB(kAnalysis, 4) {
183	loizides	1.12	if (GetNEventsProcessed() % (fPrintScale) == 0)
184	loizides	1.1	doPrint = 1;
185			} else {
186			MDB(kAnalysis, 3) {
187	loizides	1.12	if (GetNEventsProcessed() % (fPrintScale*10) == 0)
188	loizides	1.1	doPrint = 1;
189	loizides	1.14	nProcessed = fPrintScale*10;
190	loizides	1.1	} else {
191			MDB(kAnalysis, 2) {
192	loizides	1.12	if (GetNEventsProcessed() % (fPrintScale*100) == 0)
193	loizides	1.1	doPrint = 1;
194	loizides	1.14	nProcessed = fPrintScale*100;
195	loizides	1.1	} else {
196			MDB(kAnalysis, 1) {
197	loizides	1.12	if (GetNEventsProcessed() % (fPrintScale*1000) == 0)
198	loizides	1.1	doPrint = 1;
199	loizides	1.14	nProcessed = fPrintScale*1000;
200	loizides	1.1	}
201			}
202			}
203			}
204
205			if (doPrint) {
206			fSWevent->Stop();
207	loizides	1.9	Info("Process",
208			"Events %d -> %.2gs real, %.2gs cpu (%.2g real, %.2g cpu per event)",
209			GetNEventsProcessed(), fSWevent->RealTime(), fSWevent->CpuTime(),
210	loizides	1.14	fSWevent->RealTime()/nProcessed,
211			fSWevent->CpuTime()/nProcessed);
212	loizides	1.1	fSWevent->Start();
213			}
214			}
215
216			//--------------------------------------------------------------------------------------------------
217			void AnaFwkMod::SlaveBegin()
218			{
219			// Book our histogram and start the stop watches.
220
221			fSWtotal = new TStopwatch;
222			fSWevent = new TStopwatch;
223	loizides	1.4
224			if (!PublishObj(&fAllHeaders)) {
225			SendError(kAbortAnalysis, "SlaveBegin",
226			"Could not publish all event headers with name %s.", fAllHeaders.GetName());
227			return;
228			}
229	loizides	1.1	}
230
231			//--------------------------------------------------------------------------------------------------
232			void AnaFwkMod::SlaveTerminate()
233			{
234			// Fill event histogram and printout timing information.
235
236	loizides	1.4	RetractObj(fAllHeaders.GetName());
237
238	loizides	1.3	SaveNEventsProcessed();
239	loizides	1.6	TH1D *hDAllEvents = new TH1D("hDAllEvents","Sum of processed and skimmed events",1,-0.5,0.5);
240			hDAllEvents->Fill(0.0,fNEventsSkimmed+GetNEventsProcessed());
241			hDAllEvents->SetEntries(fNEventsSkimmed+GetNEventsProcessed());
242			AddOutput(hDAllEvents);
243	loizides	1.1
244	loizides	1.8	TH1D *hDSkippedEvents = new TH1D("hDSkippedEvents","Number of skipped events",1,-0.5,0.5);
245			hDSkippedEvents->Fill(0.0,fNEventsSkipped);
246			hDSkippedEvents->SetEntries(fNEventsSkipped);
247			AddOutput(hDSkippedEvents);
248
249	loizides	1.1	fSWtotal->Stop();
250			fSWevent->Stop();
251
252			MDB(kAnalysis, 1)
253	loizides	1.9	Info("SlaveTerminate",
254			"Events %d -> %.2gs real, %.2gs cpu (%.2gs real, %.2gs cpu per event)",
255			GetNEventsProcessed(), fSWtotal->RealTime(), fSWtotal->CpuTime(),
256			fSWtotal->RealTime()/GetNEventsProcessed(),
257			fSWtotal->CpuTime()/GetNEventsProcessed());
258	loizides	1.1
259			delete fSWtotal;
260			delete fSWevent;
261			}