TreeFiller/src/FillMitTree.cc

// $Id: FillMitTree.cc,v 1.7 2008/07/01 21:11:47 loizides Exp $

#include "MitProd/TreeFiller/interface/FillMitTree.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "MitProd/TreeService/interface/TreeService.h"
#include "MitProd/TreeFiller/interface/AssociationMaps.h"
#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
#include "MitProd/TreeFiller/interface/FillerSimParticles.h"
#include "MitProd/TreeFiller/interface/FillerTracks.h"
#include "MitProd/TreeFiller/interface/FillerGsfTracks.h"
#include "MitProd/TreeFiller/interface/FillerMuons.h"
#include "MitProd/TreeFiller/interface/FillerElectrons.h"
#include "MitProd/TreeFiller/interface/FillerConversionElectrons.h"
#include "MitProd/TreeFiller/interface/FillerConversions.h"
#include "MitProd/TreeFiller/interface/FillerPhotons.h"
#include "MitProd/TreeFiller/interface/FillerGenParts.h"

using namespace std;
using namespace edm;
using namespace mithep;

//-------------------------------------------------------------------------------------------------
FillMitTree::FillMitTree(const edm::ParameterSet &cfg) :
  defactive_(cfg.getUntrackedParameter<bool>("defactive",1))
{
  // Constructor.
    
  if (!configure(cfg)) {
    throw edm::Exception(edm::errors::Configuration, "FillMitTree::FillMitTree()\n")
      << "Could not configure fillers." << "\n";
  }
}

//-------------------------------------------------------------------------------------------------
FillMitTree::~FillMitTree()
{
  // Destructor: nothing to be done here.
}

//-------------------------------------------------------------------------------------------------
void FillMitTree::analyze(const edm::Event      &event, 
                          const edm::EventSetup &setup)
{
  // Access and copy event content.

  // First step: Loop over the data fillers of the various components
  for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
    (*iF)->FillDataBlock(event,setup);
  }

  // Second step: Loop over the link resolution of the various components
  for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
    (*iF)->ResolveLinks(event,setup);
  }
}

//-------------------------------------------------------------------------------------------------
void FillMitTree::beginJob(const edm::EventSetup &event)
{
  // Access the tree and book branches.

  Service<TreeService> ts;
  TreeWriter *tws = ts->get();
  if (! tws) {
    throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
      << "Could not get pointer to tree." << "\n";
    return;
  }
  
  // Loop over the various components and book the branches
  for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
    (*iF)->BookDataBlock(*tws);
  }
}

//-------------------------------------------------------------------------------------------------
bool FillMitTree::configure(const edm::ParameterSet &cfg)
{
  // Configure our fillers.

  FillerMetaInfos *fillerMetaInfos = new FillerMetaInfos(cfg);
  if (fillerMetaInfos->Active())
    fillers_.push_back(fillerMetaInfos);
  else 
    delete fillerMetaInfos;

  FillerGenParts *fillerGenParts = new FillerGenParts(cfg,defactive_);
  if (fillerGenParts->Active())
    fillers_.push_back(fillerGenParts);
  else 
    delete fillerGenParts;  
    
  FillerSimParticles *fillerSimParticles = new FillerSimParticles(cfg,defactive_);
  const SimParticleMap* simParticleMap=0;
  if (fillerSimParticles->Active()) {
    fillers_.push_back(fillerSimParticles);
    simParticleMap = fillerSimParticles->GetSimParticleMap();
  }
  else 
    delete fillerSimParticles;  
  
  FillerTracks *fillerGeneralTracks = new FillerTracks(cfg,"GeneralTracks",defactive_,simParticleMap);
  const TrackMap* generalTrackMap=0;
  if (fillerGeneralTracks->Active()) {
    fillers_.push_back(fillerGeneralTracks);
    generalTrackMap = fillerGeneralTracks->GetTrackMap();
  }
  else 
    delete fillerGeneralTracks;
    
  FillerTracks *fillerStandaloneMuonTracks = new FillerTracks(cfg,"StandaloneMuonTracks",defactive_);
  const TrackMap* standaloneMuonTrackMap=0;
  if (fillerStandaloneMuonTracks->Active()) {
    fillers_.push_back(fillerStandaloneMuonTracks);
    standaloneMuonTrackMap = fillerStandaloneMuonTracks->GetTrackMap();
  }
  else 
    delete fillerStandaloneMuonTracks;

  FillerTracks *fillerStandaloneMuonTracksVtx = 
    new FillerTracks(cfg,"StandaloneMuonTracksWVtxConstraint",defactive_);
  const TrackMap* standaloneMuonTrackVtxMap=0;
  if (fillerStandaloneMuonTracksVtx->Active()) {
    fillers_.push_back(fillerStandaloneMuonTracksVtx);
    standaloneMuonTrackVtxMap = fillerStandaloneMuonTracksVtx->GetTrackMap();
  }
  else 
    delete fillerStandaloneMuonTracksVtx;
    
  FillerTracks *fillerGlobalMuonTracks = new FillerTracks(cfg,"GlobalMuonTracks",defactive_);
  const TrackMap* globalMuonTrackMap=0;
  if (fillerGlobalMuonTracks->Active()) {
    fillers_.push_back(fillerGlobalMuonTracks);
    globalMuonTrackMap = fillerGlobalMuonTracks->GetTrackMap();
  }
  else 
    delete fillerGlobalMuonTracks;  
    
  FillerTracks *fillerConversionInOutTracks = 
    new FillerTracks(cfg,"ConversionInOutTracks",defactive_,simParticleMap);
  const TrackMap* conversionInOutTrackMap=0;
  const TrackCol* conversionInOutTracks=0;
  if (fillerConversionInOutTracks->Active()) {
    fillers_.push_back(fillerConversionInOutTracks);
    conversionInOutTrackMap = fillerConversionInOutTracks->GetTrackMap();
    conversionInOutTracks = fillerConversionInOutTracks->GetTrackCol();
  }
  else 
    delete fillerConversionInOutTracks;
    
  FillerTracks *fillerConversionOutInTracks = 
    new FillerTracks(cfg,"ConversionOutInTracks",defactive_,simParticleMap);
  const TrackMap* conversionOutInTrackMap=0;
  const TrackCol* conversionOutInTracks=0;
  if (fillerConversionOutInTracks->Active()) {
    fillers_.push_back(fillerConversionOutInTracks);
    conversionOutInTrackMap = fillerConversionOutInTracks->GetTrackMap();
    conversionOutInTracks = fillerConversionOutInTracks->GetTrackCol();
  }
  else 
    delete fillerConversionOutInTracks;
    
  FillerGsfTracks *fillerGsfTracks = new FillerGsfTracks(cfg,"GsfTracks",defactive_,simParticleMap);
  const GsfTrackMap* gsfTrackMap=0;
  if (fillerGsfTracks->Active()) {
    fillers_.push_back(fillerGsfTracks);
    gsfTrackMap = (GsfTrackMap*)fillerGsfTracks->GetTrackMap();
  }
  else 
    delete fillerGsfTracks;
    
  FillerMuons *fillerMuons = 
    new FillerMuons(cfg,defactive_,globalMuonTrackMap,standaloneMuonTrackMap, 
                    standaloneMuonTrackVtxMap,generalTrackMap);
  if (fillerMuons->Active())
    fillers_.push_back(fillerMuons);
  else 
    delete fillerMuons;
    
  FillerElectrons *fillerElectrons = new FillerElectrons(cfg,defactive_,gsfTrackMap,generalTrackMap);
  if (fillerElectrons->Active())
    fillers_.push_back(fillerElectrons);
  else 
    delete fillerElectrons;
  
  FillerConversionElectrons *fillerConversionElectrons = new FillerConversionElectrons(cfg, defactive_, conversionInOutTracks, conversionOutInTracks, conversionInOutTrackMap, conversionOutInTrackMap);
  const ConversionElectronMap* convElectronMap=0;
  if (fillerConversionElectrons->Active()) {
    fillers_.push_back(fillerConversionElectrons);
    convElectronMap = fillerConversionElectrons->GetConversionElectronMap();
  }
  else 
    delete fillerConversionElectrons;
    
  FillerConversions *fillerConversions = new FillerConversions(cfg, defactive_, convElectronMap);
  const ConversionMap* conversionMap=0;
  if (fillerConversions->Active()) {
    fillers_.push_back(fillerConversions);
    conversionMap = fillerConversions->GetConversionMap();
  }
  else 
    delete fillerConversions;
    
  FillerPhotons *fillerPhotons = new FillerPhotons(cfg, defactive_, conversionMap);
  if (fillerPhotons->Active())
    fillers_.push_back(fillerPhotons);
  else
    delete fillerPhotons;


  return 1;
}

//-------------------------------------------------------------------------------------------------
void FillMitTree::endJob()
{
  // Delete fillers.

  for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
    delete *iF;
  }

  edm::LogInfo("FillMitTree::endJob") << "Ending Job" << endl;
}
Revision:	1.8
Committed:	Wed Jul 2 19:41:02 2008 UTC (16 years, 10 months ago) by bendavid
Content type:	text/plain
Branch:	MAIN
Changes since 1.7:	+17 -11 lines
Log Message:	added fillers for photons and conversions
#	User	Rev	Content
1	bendavid	1.8	// $Id: FillMitTree.cc,v 1.7 2008/07/01 21:11:47 loizides Exp $
2	paus	1.1
3	loizides	1.3	#include "MitProd/TreeFiller/interface/FillMitTree.h"
4	paus	1.1	#include "FWCore/MessageLogger/interface/MessageLogger.h"
5			#include "FWCore/ServiceRegistry/interface/Service.h"
6	loizides	1.3	#include "MitProd/TreeService/interface/TreeService.h"
7	loizides	1.6	#include "MitProd/TreeFiller/interface/AssociationMaps.h"
8	loizides	1.3	#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
9	loizides	1.6	#include "MitProd/TreeFiller/interface/FillerSimParticles.h"
10			#include "MitProd/TreeFiller/interface/FillerTracks.h"
11			#include "MitProd/TreeFiller/interface/FillerGsfTracks.h"
12			#include "MitProd/TreeFiller/interface/FillerMuons.h"
13			#include "MitProd/TreeFiller/interface/FillerElectrons.h"
14	bendavid	1.8	#include "MitProd/TreeFiller/interface/FillerConversionElectrons.h"
15			#include "MitProd/TreeFiller/interface/FillerConversions.h"
16			#include "MitProd/TreeFiller/interface/FillerPhotons.h"
17	loizides	1.5	#include "MitProd/TreeFiller/interface/FillerGenParts.h"
18	paus	1.1
19			using namespace std;
20			using namespace edm;
21			using namespace mithep;
22
23			//-------------------------------------------------------------------------------------------------
24	loizides	1.7	FillMitTree::FillMitTree(const edm::ParameterSet &cfg) :
25			defactive_(cfg.getUntrackedParameter<bool>("defactive",1))
26	paus	1.1	{
27	loizides	1.6	// Constructor.
28
29	loizides	1.3	if (!configure(cfg)) {
30			throw edm::Exception(edm::errors::Configuration, "FillMitTree::FillMitTree()\n")
31			<< "Could not configure fillers." << "\n";
32			}
33	paus	1.1	}
34
35			//-------------------------------------------------------------------------------------------------
36			FillMitTree::~FillMitTree()
37			{
38	loizides	1.2	// Destructor: nothing to be done here.
39	paus	1.1	}
40
41			//-------------------------------------------------------------------------------------------------
42	loizides	1.3	void FillMitTree::analyze(const edm::Event &event,
43			const edm::EventSetup &setup)
44			{
45			// Access and copy event content.
46
47			// First step: Loop over the data fillers of the various components
48			for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
49			(*iF)->FillDataBlock(event,setup);
50			}
51
52			// Second step: Loop over the link resolution of the various components
53			for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
54			(*iF)->ResolveLinks(event,setup);
55			}
56			}
57
58			//-------------------------------------------------------------------------------------------------
59			void FillMitTree::beginJob(const edm::EventSetup &event)
60	paus	1.1	{
61	loizides	1.2	// Access the tree and book branches.
62
63	paus	1.1	Service<TreeService> ts;
64			TreeWriter *tws = ts->get();
65			if (! tws) {
66			throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
67	loizides	1.2	<< "Could not get pointer to tree." << "\n";
68	paus	1.1	return;
69			}
70	loizides	1.6
71	paus	1.1	// Loop over the various components and book the branches
72			for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
73	loizides	1.4	(iF)->BookDataBlock(tws);
74	paus	1.1	}
75			}
76
77			//-------------------------------------------------------------------------------------------------
78	loizides	1.3	bool FillMitTree::configure(const edm::ParameterSet &cfg)
79	paus	1.1	{
80	loizides	1.3	// Configure our fillers.
81
82			FillerMetaInfos *fillerMetaInfos = new FillerMetaInfos(cfg);
83			if (fillerMetaInfos->Active())
84			fillers_.push_back(fillerMetaInfos);
85			else
86			delete fillerMetaInfos;
87	loizides	1.2
88	loizides	1.7	FillerGenParts *fillerGenParts = new FillerGenParts(cfg,defactive_);
89	loizides	1.5	if (fillerGenParts->Active())
90			fillers_.push_back(fillerGenParts);
91			else
92	loizides	1.6	delete fillerGenParts;
93
94	loizides	1.7	FillerSimParticles *fillerSimParticles = new FillerSimParticles(cfg,defactive_);
95	loizides	1.6	const SimParticleMap* simParticleMap=0;
96			if (fillerSimParticles->Active()) {
97			fillers_.push_back(fillerSimParticles);
98			simParticleMap = fillerSimParticles->GetSimParticleMap();
99			}
100			else
101			delete fillerSimParticles;
102
103	loizides	1.7	FillerTracks *fillerGeneralTracks = new FillerTracks(cfg,"GeneralTracks",defactive_,simParticleMap);
104	loizides	1.6	const TrackMap* generalTrackMap=0;
105			if (fillerGeneralTracks->Active()) {
106			fillers_.push_back(fillerGeneralTracks);
107			generalTrackMap = fillerGeneralTracks->GetTrackMap();
108			}
109			else
110			delete fillerGeneralTracks;
111
112	loizides	1.7	FillerTracks *fillerStandaloneMuonTracks = new FillerTracks(cfg,"StandaloneMuonTracks",defactive_);
113	loizides	1.6	const TrackMap* standaloneMuonTrackMap=0;
114			if (fillerStandaloneMuonTracks->Active()) {
115			fillers_.push_back(fillerStandaloneMuonTracks);
116			standaloneMuonTrackMap = fillerStandaloneMuonTracks->GetTrackMap();
117			}
118			else
119			delete fillerStandaloneMuonTracks;
120
121			FillerTracks *fillerStandaloneMuonTracksVtx =
122	loizides	1.7	new FillerTracks(cfg,"StandaloneMuonTracksWVtxConstraint",defactive_);
123	loizides	1.6	const TrackMap* standaloneMuonTrackVtxMap=0;
124			if (fillerStandaloneMuonTracksVtx->Active()) {
125			fillers_.push_back(fillerStandaloneMuonTracksVtx);
126			standaloneMuonTrackVtxMap = fillerStandaloneMuonTracksVtx->GetTrackMap();
127			}
128			else
129			delete fillerStandaloneMuonTracksVtx;
130
131	loizides	1.7	FillerTracks *fillerGlobalMuonTracks = new FillerTracks(cfg,"GlobalMuonTracks",defactive_);
132	loizides	1.6	const TrackMap* globalMuonTrackMap=0;
133			if (fillerGlobalMuonTracks->Active()) {
134			fillers_.push_back(fillerGlobalMuonTracks);
135			globalMuonTrackMap = fillerGlobalMuonTracks->GetTrackMap();
136			}
137			else
138			delete fillerGlobalMuonTracks;
139
140			FillerTracks *fillerConversionInOutTracks =
141	loizides	1.7	new FillerTracks(cfg,"ConversionInOutTracks",defactive_,simParticleMap);
142	loizides	1.6	const TrackMap* conversionInOutTrackMap=0;
143			const TrackCol* conversionInOutTracks=0;
144			if (fillerConversionInOutTracks->Active()) {
145			fillers_.push_back(fillerConversionInOutTracks);
146			conversionInOutTrackMap = fillerConversionInOutTracks->GetTrackMap();
147			conversionInOutTracks = fillerConversionInOutTracks->GetTrackCol();
148			}
149			else
150			delete fillerConversionInOutTracks;
151
152			FillerTracks *fillerConversionOutInTracks =
153	loizides	1.7	new FillerTracks(cfg,"ConversionOutInTracks",defactive_,simParticleMap);
154	loizides	1.6	const TrackMap* conversionOutInTrackMap=0;
155			const TrackCol* conversionOutInTracks=0;
156			if (fillerConversionOutInTracks->Active()) {
157			fillers_.push_back(fillerConversionOutInTracks);
158			conversionOutInTrackMap = fillerConversionOutInTracks->GetTrackMap();
159			conversionOutInTracks = fillerConversionOutInTracks->GetTrackCol();
160			}
161			else
162			delete fillerConversionOutInTracks;
163
164	loizides	1.7	FillerGsfTracks *fillerGsfTracks = new FillerGsfTracks(cfg,"GsfTracks",defactive_,simParticleMap);
165	loizides	1.6	const GsfTrackMap* gsfTrackMap=0;
166			if (fillerGsfTracks->Active()) {
167			fillers_.push_back(fillerGsfTracks);
168			gsfTrackMap = (GsfTrackMap*)fillerGsfTracks->GetTrackMap();
169			}
170			else
171			delete fillerGsfTracks;
172
173			FillerMuons *fillerMuons =
174	loizides	1.7	new FillerMuons(cfg,defactive_,globalMuonTrackMap,standaloneMuonTrackMap,
175			standaloneMuonTrackVtxMap,generalTrackMap);
176	loizides	1.6	if (fillerMuons->Active())
177			fillers_.push_back(fillerMuons);
178			else
179			delete fillerMuons;
180
181	loizides	1.7	FillerElectrons *fillerElectrons = new FillerElectrons(cfg,defactive_,gsfTrackMap,generalTrackMap);
182	loizides	1.6	if (fillerElectrons->Active())
183			fillers_.push_back(fillerElectrons);
184			else
185			delete fillerElectrons;
186
187	bendavid	1.8	FillerConversionElectrons *fillerConversionElectrons = new FillerConversionElectrons(cfg, defactive_, conversionInOutTracks, conversionOutInTracks, conversionInOutTrackMap, conversionOutInTrackMap);
188	loizides	1.6	const ConversionElectronMap* convElectronMap=0;
189			if (fillerConversionElectrons->Active()) {
190			fillers_.push_back(fillerConversionElectrons);
191			convElectronMap = fillerConversionElectrons->GetConversionElectronMap();
192			}
193			else
194			delete fillerConversionElectrons;
195
196	bendavid	1.8	FillerConversions *fillerConversions = new FillerConversions(cfg, defactive_, convElectronMap);
197			const ConversionMap* conversionMap=0;
198			if (fillerConversions->Active()) {
199			fillers_.push_back(fillerConversions);
200			conversionMap = fillerConversions->GetConversionMap();
201			}
202			else
203			delete fillerConversions;
204
205			FillerPhotons *fillerPhotons = new FillerPhotons(cfg, defactive_, conversionMap);
206	loizides	1.6	if (fillerPhotons->Active())
207			fillers_.push_back(fillerPhotons);
208	bendavid	1.8	else
209	loizides	1.6	delete fillerPhotons;
210	bendavid	1.8
211	loizides	1.5
212	loizides	1.3	return 1;
213	paus	1.1	}
214
215			//-------------------------------------------------------------------------------------------------
216			void FillMitTree::endJob()
217			{
218	loizides	1.2	// Delete fillers.
219
220			for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
221			delete *iF;
222			}
223
224	paus	1.1	edm::LogInfo("FillMitTree::endJob") << "Ending Job" << endl;
225			}