TreeMod/src/AnaFwkMod.cc

// $Id: AnaFwkMod.cc,v 1.24 2013/08/27 14:13:15 bendavid Exp $

#include "MitAna/TreeMod/interface/AnaFwkMod.h"
#include "MitAna/DataUtil/interface/Debug.h"
#include "MitAna/DataTree/interface/Names.h"
#include "MitAna/DataTree/interface/PileupInfo.h"
#include <TFile.h>
#include <TH1D.h>
#include <TH3D.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),
  fPileupInfoName("PileupInfo"),
  fDoPUInfo(kFALSE),
  hNPU(0),
  hNPU50ns(0),
  hNPUTrue(0),
  fMCEventInfo(0),
  fMCEventInfoName(Names::gkMCEvtInfoBrn),
  hDTotalMCWeight(0),
  hNPURunABObs(0),
  hNPURunCObs(0),
  hNPURunDObs(0),
  hNPURunABTrue(0),
  hNPURunCTrue(0),
  hNPURunDTrue(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 (GetEventHeader()->IsMC()) {
    LoadBranch(fPileupInfoName);  
    Double_t npu[4] = {0.,0.,0.,0.};
    for (UInt_t i=0; i<fPileupInfo->GetEntries(); ++i) {
      const PileupInfo *puinfo = fPileupInfo->At(i);
      if (puinfo->GetBunchCrossing()==0) npu[0]= puinfo->GetPU_NumInteractions();
      else if (puinfo->GetBunchCrossing()==-1) npu[1] = puinfo->GetPU_NumInteractions();
      else if (puinfo->GetBunchCrossing()==1) npu[2] = puinfo->GetPU_NumInteractions();
      if (puinfo->GetBunchCrossing()==0) npu[3]= puinfo->GetPU_NumMean();
    }
    
    LoadBranch(fMCEventInfoName);
    double mcweight = fMCEventInfo->Weight();
    
    hNPU->Fill(npu[0],mcweight);
    hNPU50ns->Fill(npu[0],npu[1],npu[2],mcweight);
    hNPUTrue->Fill(npu[3],mcweight);
    
    UInt_t run = GetEventHeader()->RunNum();
    
    //Josh: fill pileup histograms for 2012 run-dependent Monte Carlo which currently has one of three run numbers
    //More generic solution to be implemented depending on future run/lumi dependent Monte Carlo production strategy
    if (run==194533) {
      hNPURunABObs->Fill(npu[0],mcweight); 
      hNPURunABTrue->Fill(npu[3],mcweight); 
    }
    else if (run==200519) {
      hNPURunCObs->Fill(npu[0],mcweight); 
      hNPURunCTrue->Fill(npu[3],mcweight);       
    }
    else if (run==206859) {
      hNPURunDObs->Fill(npu[0],mcweight); 
      hNPURunDTrue->Fill(npu[3],mcweight);       
    }    
    
    hDTotalMCWeight->Fill(0., mcweight);

  }


  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;
  }
  
  ReqBranch(fPileupInfoName, fPileupInfo);
  ReqBranch(fMCEventInfoName, fMCEventInfo);
  
  hNPU = new TH1D("hNPU", "hNPU", 201, -0.5, 200.5);
  AddOutput(hNPU);  
  
  hNPU50ns = new TH3D("hNPU50ns", "hNPU50ns", 201, -0.5, 200.5, 201, -0.5, 200.5, 201, -0.5, 200.5);
  AddOutput(hNPU50ns);  
  
  hNPUTrue = new TH1D("hNPUTrue", "hNPUTrue", 2000, 0.0, 200.0);
  AddOutput(hNPUTrue);  
  
  hDTotalMCWeight = new TH1D("hDTotalMCWeight","hDTotalMCWeight",1,-0.5,0.5);
  AddOutput(hDTotalMCWeight);
  
  hNPURunABObs = new TH1D("hNPURunABObs","hNPURunABObs",201, -0.5, 200.5);
  AddOutput(hNPURunABObs);  

  hNPURunCObs = new TH1D("hNPURunCObs","hNPURunCObs",201, -0.5, 200.5);
  AddOutput(hNPURunCObs);    
  
  hNPURunDObs = new TH1D("hNPURunDObs","hNPURunDObs",201, -0.5, 200.5);
  AddOutput(hNPURunDObs);    
  
  hNPURunABTrue = new TH1D("hNPURunABTrue","hNPURunABTrue",2000, 0.0, 200.0);
  AddOutput(hNPURunABTrue);  

  hNPURunCTrue = new TH1D("hNPURunCTrue","hNPURunCTrue",2000, 0.0, 200.0);
  AddOutput(hNPURunCTrue);    
  
  hNPURunDTrue = new TH1D("hNPURunDTrue","hNPURunDTrue",2000, 0.0, 200.0);
  AddOutput(hNPURunDTrue);      
  
}

//--------------------------------------------------------------------------------------------------
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.25
Committed:	Fri Sep 13 10:16:35 2013 UTC (11 years, 7 months ago) by bendavid
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_032, HEAD
Changes since 1.24:	+50 -6 lines
Log Message:	Add pileup histograms for run-dependent Monte Carlo
#	User	Rev	Content
1	bendavid	1.25	// $Id: AnaFwkMod.cc,v 1.24 2013/08/27 14:13:15 bendavid 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	bendavid	1.16	#include "MitAna/DataTree/interface/PileupInfo.h"
7	loizides	1.4	#include <TFile.h>
8	loizides	1.1	#include <TH1D.h>
9	bendavid	1.16	#include <TH3D.h>
10	loizides	1.1	#include <TStopwatch.h>
11	loizides	1.4	#include <TTree.h>
12	loizides	1.1
13			using namespace mithep;
14
15			ClassImp(mithep::AnaFwkMod)
16
17			//--------------------------------------------------------------------------------------------------
18			AnaFwkMod::AnaFwkMod(const char name, const char title) :
19			BaseMod(name,title),
20	loizides	1.6	fAllHeadTreeName(Names::gkAllEvtTreeName),
21			fAllHeadBrName(Names::gkAllEvtHeaderBrn),
22	loizides	1.8	fSkipNEvents(0),
23	loizides	1.13	fPrintScale(1),
24	loizides	1.1	fSWtotal(0),
25	loizides	1.4	fSWevent(0),
26	loizides	1.6	fAllHeaders(0,Names::gkSkimmedHeaders),
27	loizides	1.4	fAllHeadTree(0),
28			fAllEventHeader(0),
29			fReload(kFALSE),
30	loizides	1.6	fCurEnt(-2),
31	loizides	1.8	fNEventsSkimmed(0),
32	bendavid	1.16	fNEventsSkipped(0),
33			fPileupInfoName("PileupInfo"),
34			fDoPUInfo(kFALSE),
35			hNPU(0),
36	ceballos	1.19	hNPU50ns(0),
37	bendavid	1.23	hNPUTrue(0),
38			fMCEventInfo(0),
39			fMCEventInfoName(Names::gkMCEvtInfoBrn),
40	bendavid	1.25	hDTotalMCWeight(0),
41			hNPURunABObs(0),
42			hNPURunCObs(0),
43			hNPURunDObs(0),
44			hNPURunABTrue(0),
45			hNPURunCTrue(0),
46			hNPURunDTrue(0)
47	loizides	1.1	{
48			// Constructor.
49			}
50
51			//--------------------------------------------------------------------------------------------------
52	loizides	1.4	void AnaFwkMod::BeginRun()
53			{
54			// Get HLT tree and set branches if new file was opened. Read next entry in HLT key
55			// depending on entry in RunInfo.
56
57			if (fReload) {
58			// reset to be (re-)loaded variables
59			fReload = 0;
60			fAllHeadTree = 0;
61			fAllEventHeader = 0;
62			fCurEnt = 0;
63
64			// get current file
65			TFile *file = GetCurrentFile();
66			if (!file)
67			return;
68
69	loizides	1.10	// get all event header tree
70	loizides	1.4	fAllHeadTree = dynamic_cast<TTree*>(file->Get(fAllHeadTreeName));
71			if (!fAllHeadTree) {
72	loizides	1.6	SendError(kWarning, "BeginRun",
73	loizides	1.9	"Cannot find tree '%s' in file '%s'",
74	loizides	1.6	fAllHeadTreeName.Data(),file->GetName());
75	loizides	1.4	return;
76			}
77
78	loizides	1.10	// get all event header branch
79			if (fAllHeadTree->GetBranch(fAllHeadBrName)) {
80			fAllHeadTree->SetBranchAddress(fAllHeadBrName, &fAllEventHeader);
81			} else {
82			SendError(kWarning, "BeginRun",
83			"Cannot find branch '%s' in tree '%s'",
84			fAllHeadBrName.Data(), fAllHeadTreeName.Data());
85			return;
86			}
87	loizides	1.4	}
88			}
89
90			//--------------------------------------------------------------------------------------------------
91			void AnaFwkMod::CopyAllEventHeaders()
92			{
93			// Deal with the headers from all events if needed.
94
95			fAllHeaders.Reset();
96
97			const EventHeader *curev = GetEventHeader();
98			if (!curev) {
99	loizides	1.9	SendError(kWarning, "CopyAllEventHeaders", "Cannot obtain current event");
100	loizides	1.4	return;
101			}
102
103			if (fAllHeadTree) {
104	loizides	1.6	const Int_t nemax = fAllHeadTree->GetEntries();
105			if (fCurEnt == nemax) {
106			SendError(kAbortEvent, "CopyAllEventHeaders",
107			"End of all events tree reached (%d=%d)", fCurEnt, nemax);
108			return;
109			}
110	loizides	1.4	fAllHeadTree->GetEntry(fCurEnt++);
111	paus	1.17	while (fCurEnt <= nemax && fAllEventHeader->Skimmed()) {
112	loizides	1.4	EventHeader *eh = fAllHeaders.AddNew();
113	paus	1.17	eh->SetRunNum (fAllEventHeader->RunNum());
114			eh->SetEvtNum (fAllEventHeader->EvtNum());
115			eh->SetLumiSec (fAllEventHeader->LumiSec());
116	loizides	1.5	eh->SetRunEntry(fAllEventHeader->RunEntry());
117	paus	1.17	eh->SetSkimmed (fAllEventHeader->Skimmed());
118	loizides	1.4	fAllHeadTree->GetEntry(fCurEnt++);
119			}
120	paus	1.17	if ((fAllEventHeader->RunNum() != curev->RunNum()) \|\|
121			(fAllEventHeader->EvtNum() != curev->EvtNum()) \|\|
122			(fAllEventHeader->LumiSec() != curev->LumiSec()) \|\|
123			(fAllEventHeader->RunEntry() != curev->RunEntry())) {
124	loizides	1.4	SendError(kWarning, "CopyAllEventHeaders",
125	loizides	1.6	"Event header information for entry %d inconsistent: "
126			"%d==%d, %d==%d, %d==%d, %d==%d",
127			fCurEnt,
128	loizides	1.4	fAllEventHeader->RunNum(), curev->RunNum(),
129			fAllEventHeader->EvtNum(), curev->EvtNum(),
130			fAllEventHeader->LumiSec(), curev->LumiSec(),
131			fAllEventHeader->RunEntry(), curev->RunEntry());
132			return;
133			}
134	loizides	1.6
135			// read-ahead to check if more events are coming
136			if (fCurEnt<nemax) {
137			Int_t testEnt = fCurEnt;
138			fAllHeadTree->GetEntry(testEnt++);
139	paus	1.17	while (testEnt<=nemax && fAllEventHeader->Skimmed())
140	loizides	1.6	fAllHeadTree->GetEntry(testEnt++);
141	loizides	1.7	if (testEnt==nemax+1) { // need to add remaining skimmed events
142	loizides	1.6	fAllHeadTree->GetEntry(fCurEnt++);
143	loizides	1.7	while(fCurEnt<=nemax) {
144	loizides	1.6	EventHeader *eh = fAllHeaders.AddNew();
145	paus	1.17	eh->SetRunNum (fAllEventHeader->RunNum());
146			eh->SetEvtNum (fAllEventHeader->EvtNum());
147			eh->SetLumiSec (fAllEventHeader->LumiSec());
148	loizides	1.6	eh->SetRunEntry(fAllEventHeader->RunEntry());
149	paus	1.17	eh->SetSkimmed (fAllEventHeader->Skimmed());
150	loizides	1.6	fAllHeadTree->GetEntry(fCurEnt++);
151			}
152	loizides	1.7	if (fCurEnt != nemax+1) {
153	loizides	1.6	SendError(kAbortEvent, "CopyAllEventHeaders",
154			"End of all events tree unexpectedly not reached (%d!=%d)", fCurEnt, nemax);
155			return;
156			}
157			}
158			}
159	loizides	1.4	}
160			}
161
162			//--------------------------------------------------------------------------------------------------
163			Bool_t AnaFwkMod::Notify()
164			{
165			// Make sure to get the new "AllEvents" tree when the file changes.
166
167			fReload = kTRUE;
168			return kTRUE;
169			}
170
171			//--------------------------------------------------------------------------------------------------
172	loizides	1.1	void AnaFwkMod::Process()
173			{
174	loizides	1.8	// Do event skipping and counting and print out timing information.
175	loizides	1.1
176	loizides	1.8	// counting processed events
177			IncNEventsProcessed();
178	loizides	1.4
179	loizides	1.6	// get skimmed event headers
180			CopyAllEventHeaders();
181			fNEventsSkimmed += fAllHeaders.GetEntries();
182	loizides	1.4
183	loizides	1.8	// check if events should be skipped
184			if (fNEventsSkipped<fSkipNEvents) {
185			++fNEventsSkipped;
186			MDB(kAnalysis, 3) {
187	bendavid	1.15	Info("Process", "Skipping (aborting) %d out of %lld first events.",
188	loizides	1.9	fNEventsSkipped, fSkipNEvents);
189	loizides	1.8	}
190			AbortEvent();
191			return;
192			}
193	loizides	1.1
194			// check if printout should be done
195	loizides	1.14	Bool_t doPrint = 0;
196			UInt_t nProcessed = fPrintScale;
197	loizides	1.1
198			MDB(kAnalysis, 4) {
199	loizides	1.12	if (GetNEventsProcessed() % (fPrintScale) == 0)
200	loizides	1.1	doPrint = 1;
201			} else {
202			MDB(kAnalysis, 3) {
203	loizides	1.12	if (GetNEventsProcessed() % (fPrintScale*10) == 0)
204	loizides	1.1	doPrint = 1;
205	loizides	1.14	nProcessed = fPrintScale*10;
206	loizides	1.1	} else {
207			MDB(kAnalysis, 2) {
208	loizides	1.12	if (GetNEventsProcessed() % (fPrintScale*100) == 0)
209	loizides	1.1	doPrint = 1;
210	loizides	1.14	nProcessed = fPrintScale*100;
211	loizides	1.1	} else {
212			MDB(kAnalysis, 1) {
213	loizides	1.12	if (GetNEventsProcessed() % (fPrintScale*1000) == 0)
214	loizides	1.1	doPrint = 1;
215	loizides	1.14	nProcessed = fPrintScale*1000;
216	loizides	1.1	}
217			}
218			}
219			}
220
221	bendavid	1.16	if (GetEventHeader()->IsMC()) {
222			LoadBranch(fPileupInfoName);
223	ceballos	1.21	Double_t npu[4] = {0.,0.,0.,0.};
224	bendavid	1.16	for (UInt_t i=0; i<fPileupInfo->GetEntries(); ++i) {
225			const PileupInfo *puinfo = fPileupInfo->At(i);
226			if (puinfo->GetBunchCrossing()==0) npu[0]= puinfo->GetPU_NumInteractions();
227			else if (puinfo->GetBunchCrossing()==-1) npu[1] = puinfo->GetPU_NumInteractions();
228			else if (puinfo->GetBunchCrossing()==1) npu[2] = puinfo->GetPU_NumInteractions();
229	ceballos	1.19	if (puinfo->GetBunchCrossing()==0) npu[3]= puinfo->GetPU_NumMean();
230	bendavid	1.16	}
231	bendavid	1.23
232			LoadBranch(fMCEventInfoName);
233	bendavid	1.25	double mcweight = fMCEventInfo->Weight();
234
235			hNPU->Fill(npu[0],mcweight);
236			hNPU50ns->Fill(npu[0],npu[1],npu[2],mcweight);
237			hNPUTrue->Fill(npu[3],mcweight);
238
239			UInt_t run = GetEventHeader()->RunNum();
240
241			//Josh: fill pileup histograms for 2012 run-dependent Monte Carlo which currently has one of three run numbers
242			//More generic solution to be implemented depending on future run/lumi dependent Monte Carlo production strategy
243			if (run==194533) {
244			hNPURunABObs->Fill(npu[0],mcweight);
245			hNPURunABTrue->Fill(npu[3],mcweight);
246			}
247			else if (run==200519) {
248			hNPURunCObs->Fill(npu[0],mcweight);
249			hNPURunCTrue->Fill(npu[3],mcweight);
250			}
251			else if (run==206859) {
252			hNPURunDObs->Fill(npu[0],mcweight);
253			hNPURunDTrue->Fill(npu[3],mcweight);
254			}
255
256			hDTotalMCWeight->Fill(0., mcweight);
257	bendavid	1.23
258	bendavid	1.16	}
259
260
261	loizides	1.1	if (doPrint) {
262			fSWevent->Stop();
263	loizides	1.9	Info("Process",
264			"Events %d -> %.2gs real, %.2gs cpu (%.2g real, %.2g cpu per event)",
265			GetNEventsProcessed(), fSWevent->RealTime(), fSWevent->CpuTime(),
266	loizides	1.14	fSWevent->RealTime()/nProcessed,
267			fSWevent->CpuTime()/nProcessed);
268	loizides	1.1	fSWevent->Start();
269	bendavid	1.16	}
270
271
272	loizides	1.1	}
273
274			//--------------------------------------------------------------------------------------------------
275			void AnaFwkMod::SlaveBegin()
276			{
277			// Book our histogram and start the stop watches.
278
279			fSWtotal = new TStopwatch;
280			fSWevent = new TStopwatch;
281	loizides	1.4
282			if (!PublishObj(&fAllHeaders)) {
283			SendError(kAbortAnalysis, "SlaveBegin",
284			"Could not publish all event headers with name %s.", fAllHeaders.GetName());
285			return;
286			}
287	bendavid	1.16
288			ReqBranch(fPileupInfoName, fPileupInfo);
289	bendavid	1.24	ReqBranch(fMCEventInfoName, fMCEventInfo);
290	bendavid	1.16
291	bendavid	1.18	hNPU = new TH1D("hNPU", "hNPU", 201, -0.5, 200.5);
292	bendavid	1.16	AddOutput(hNPU);
293
294	bendavid	1.18	hNPU50ns = new TH3D("hNPU50ns", "hNPU50ns", 201, -0.5, 200.5, 201, -0.5, 200.5, 201, -0.5, 200.5);
295	bendavid	1.16	AddOutput(hNPU50ns);
296
297	ceballos	1.22	hNPUTrue = new TH1D("hNPUTrue", "hNPUTrue", 2000, 0.0, 200.0);
298	ceballos	1.19	AddOutput(hNPUTrue);
299
300	bendavid	1.23	hDTotalMCWeight = new TH1D("hDTotalMCWeight","hDTotalMCWeight",1,-0.5,0.5);
301			AddOutput(hDTotalMCWeight);
302
303	bendavid	1.25	hNPURunABObs = new TH1D("hNPURunABObs","hNPURunABObs",201, -0.5, 200.5);
304			AddOutput(hNPURunABObs);
305
306			hNPURunCObs = new TH1D("hNPURunCObs","hNPURunCObs",201, -0.5, 200.5);
307			AddOutput(hNPURunCObs);
308
309			hNPURunDObs = new TH1D("hNPURunDObs","hNPURunDObs",201, -0.5, 200.5);
310			AddOutput(hNPURunDObs);
311
312			hNPURunABTrue = new TH1D("hNPURunABTrue","hNPURunABTrue",2000, 0.0, 200.0);
313			AddOutput(hNPURunABTrue);
314
315			hNPURunCTrue = new TH1D("hNPURunCTrue","hNPURunCTrue",2000, 0.0, 200.0);
316			AddOutput(hNPURunCTrue);
317
318			hNPURunDTrue = new TH1D("hNPURunDTrue","hNPURunDTrue",2000, 0.0, 200.0);
319			AddOutput(hNPURunDTrue);
320
321	loizides	1.1	}
322
323			//--------------------------------------------------------------------------------------------------
324			void AnaFwkMod::SlaveTerminate()
325			{
326			// Fill event histogram and printout timing information.
327
328	loizides	1.4	RetractObj(fAllHeaders.GetName());
329
330	loizides	1.3	SaveNEventsProcessed();
331	loizides	1.6	TH1D *hDAllEvents = new TH1D("hDAllEvents","Sum of processed and skimmed events",1,-0.5,0.5);
332			hDAllEvents->Fill(0.0,fNEventsSkimmed+GetNEventsProcessed());
333			hDAllEvents->SetEntries(fNEventsSkimmed+GetNEventsProcessed());
334			AddOutput(hDAllEvents);
335	loizides	1.1
336	loizides	1.8	TH1D *hDSkippedEvents = new TH1D("hDSkippedEvents","Number of skipped events",1,-0.5,0.5);
337			hDSkippedEvents->Fill(0.0,fNEventsSkipped);
338			hDSkippedEvents->SetEntries(fNEventsSkipped);
339			AddOutput(hDSkippedEvents);
340
341	loizides	1.1	fSWtotal->Stop();
342			fSWevent->Stop();
343
344			MDB(kAnalysis, 1)
345	loizides	1.9	Info("SlaveTerminate",
346			"Events %d -> %.2gs real, %.2gs cpu (%.2gs real, %.2gs cpu per event)",
347			GetNEventsProcessed(), fSWtotal->RealTime(), fSWtotal->CpuTime(),
348			fSWtotal->RealTime()/GetNEventsProcessed(),
349			fSWtotal->CpuTime()/GetNEventsProcessed());
350	loizides	1.1
351			delete fSWtotal;
352			delete fSWevent;
353			}