ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitProd/TreeFiller/src/FillMitTree.cc

Comparing UserCode/MitProd/TreeFiller/src/FillMitTree.cc (file contents):
Revision 1.7 by loizides, Tue Jul 1 21:11:47 2008 UTC vs.
Revision 1.12 by bendavid, Fri Jul 25 11:33:58 2008 UTC

#	Line 6 | Line 6
6		#include "MitProd/TreeService/interface/TreeService.h"
7		#include "MitProd/TreeFiller/interface/AssociationMaps.h"
8		#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
9	–	#include "MitProd/TreeFiller/interface/FillerSimParticles.h"
9		#include "MitProd/TreeFiller/interface/FillerTracks.h"
10		#include "MitProd/TreeFiller/interface/FillerGsfTracks.h"
11		#include "MitProd/TreeFiller/interface/FillerMuons.h"
12		#include "MitProd/TreeFiller/interface/FillerElectrons.h"
13	<	//#include "MitProd/TreeFiller/interface/FillerConvElectrons.h"
14	<	//#include "MitProd/TreeFiller/interface/FillerPhotons.h"
15	<	#include "MitProd/TreeFiller/interface/FillerGenParts.h"
13	>	#include "MitProd/TreeFiller/interface/FillerElectrons.h"
14	>	#include "MitProd/TreeFiller/interface/FillerCaloJets.h"
15	>	#include "MitProd/TreeFiller/interface/FillerCaloMet.h"
16	>	#include "MitProd/TreeFiller/interface/FillerConversions.h"
17	>	#include "MitProd/TreeFiller/interface/FillerConversionElectrons.h"
18	>	#include "MitProd/TreeFiller/interface/FillerPhotons.h"
19	>	#include "MitProd/TreeFiller/interface/FillerMCParticles.h"
20
21		using namespace std;
22		using namespace edm;
23		using namespace mithep;
24
25	<	//-------------------------------------------------------------------------------------------------
25	>	//--------------------------------------------------------------------------------------------------
26		FillMitTree::FillMitTree(const edm::ParameterSet &cfg) :
27		defactive_(cfg.getUntrackedParameter<bool>("defactive",1))
28		{
#	Line 31 | Line 34 | FillMitTree::FillMitTree(const edm::Para
34		}
35		}
36
37	<	//-------------------------------------------------------------------------------------------------
37	>	//--------------------------------------------------------------------------------------------------
38		FillMitTree::~FillMitTree()
39		{
40		// Destructor: nothing to be done here.
41		}
42
43	<	//-------------------------------------------------------------------------------------------------
43	>	//--------------------------------------------------------------------------------------------------
44		void FillMitTree::analyze(const edm::Event      &event,
45		const edm::EventSetup &setup)
46		{
#	Line 54 | Line 57 | void FillMitTree::analyze(const edm::Eve
57		}
58		}
59
60	<	//-------------------------------------------------------------------------------------------------
60	>	//--------------------------------------------------------------------------------------------------
61		void FillMitTree::beginJob(const edm::EventSetup &event)
62		{
63		// Access the tree and book branches.
#	Line 73 | Line 76 | void FillMitTree::beginJob(const edm::Ev
76		}
77		}
78
79	<	//-------------------------------------------------------------------------------------------------
79	>	//--------------------------------------------------------------------------------------------------
80		bool FillMitTree::configure(const edm::ParameterSet &cfg)
81		{
82		// Configure our fillers.
#	Line 81 | Line 84 | bool FillMitTree::configure(const edm::P
84		FillerMetaInfos *fillerMetaInfos = new FillerMetaInfos(cfg);
85		if (fillerMetaInfos->Active())
86		fillers_.push_back(fillerMetaInfos);
87	<	else
87	>	else {
88		delete fillerMetaInfos;
89	+	fillerMetaInfos = 0;
90	+	}
91
92	<	FillerGenParts *fillerGenParts = new FillerGenParts(cfg,defactive_);
93	<	if (fillerGenParts->Active())
94	<	fillers_.push_back(fillerGenParts);
95	<	else
96	<	delete fillerGenParts;
97	<
98	<	FillerSimParticles *fillerSimParticles = new FillerSimParticles(cfg,defactive_);
94	<	const SimParticleMap* simParticleMap=0;
95	<	if (fillerSimParticles->Active()) {
96	<	fillers_.push_back(fillerSimParticles);
97	<	simParticleMap = fillerSimParticles->GetSimParticleMap();
92	>	FillerMCParticles *fillerMCParticles = new FillerMCParticles(cfg,"MCParticles",defactive_);
93	>	const GenParticleMap* genParticleMap = 0;
94	>	const SimParticleMap *simParticleMap = 0;
95	>	if (fillerMCParticles->Active()) {
96	>	fillers_.push_back(fillerMCParticles);
97	>	genParticleMap = fillerMCParticles->GetGenParticleMap();
98	>	simParticleMap = fillerMCParticles->GetSimParticleMap();
99		}
100	<	else
101	<	delete fillerSimParticles;
102	<
103	<	FillerTracks *fillerGeneralTracks = new FillerTracks(cfg,"GeneralTracks",defactive_,simParticleMap);
104	<	const TrackMap* generalTrackMap=0;
100	>	else {
101	>	delete fillerMCParticles;
102	>	fillerMCParticles = 0;
103	>	}
104	>
105	>	FillerCaloJets *fillerCaloJets = new FillerCaloJets(cfg,"CaloJets",defactive_);
106	>	if (fillerCaloJets->Active()) {
107	>	fillers_.push_back(fillerCaloJets);
108	>	}
109	>	else {
110	>	delete fillerCaloJets;
111	>	fillerCaloJets = 0;
112	>	}
113	>
114	>	FillerCaloMet *fillerCaloMet = new FillerCaloMet(cfg,"CaloMet",defactive_);
115	>	if (fillerCaloMet->Active()) {
116	>	fillers_.push_back(fillerCaloMet);
117	>	}
118	>	else {
119	>	delete fillerCaloMet;
120	>	fillerCaloMet = 0;
121	>	}
122	>
123	>	FillerTracks *fillerGeneralTracks =
124	>	new FillerTracks(cfg,"GeneralTracks",defactive_,simParticleMap);
125	>	const TrackMap *generalTrackMap=0;
126		if (fillerGeneralTracks->Active()) {
127		fillers_.push_back(fillerGeneralTracks);
128		generalTrackMap = fillerGeneralTracks->GetTrackMap();
129		}
130	<	else
130	>	else {
131		delete fillerGeneralTracks;
132	<
133	<	FillerTracks *fillerStandaloneMuonTracks = new FillerTracks(cfg,"StandaloneMuonTracks",defactive_);
134	<	const TrackMap* standaloneMuonTrackMap=0;
132	>	fillerGeneralTracks = 0;
133	>	}
134	>
135	>	FillerTracks *fillerStandaloneMuonTracks =
136	>	new FillerTracks(cfg,"StandaloneMuonTracks",defactive_);
137	>	const TrackMap *standaloneMuonTrackMap=0;
138		if (fillerStandaloneMuonTracks->Active()) {
139		fillers_.push_back(fillerStandaloneMuonTracks);
140		standaloneMuonTrackMap = fillerStandaloneMuonTracks->GetTrackMap();
141		}
142	<	else
142	>	else {
143		delete fillerStandaloneMuonTracks;
144	+	fillerStandaloneMuonTracks = 0;
145	+	}
146
147		FillerTracks *fillerStandaloneMuonTracksVtx =
148		new FillerTracks(cfg,"StandaloneMuonTracksWVtxConstraint",defactive_);
149	<	const TrackMap* standaloneMuonTrackVtxMap=0;
149	>	const TrackMap *standaloneMuonTrackVtxMap=0;
150		if (fillerStandaloneMuonTracksVtx->Active()) {
151		fillers_.push_back(fillerStandaloneMuonTracksVtx);
152		standaloneMuonTrackVtxMap = fillerStandaloneMuonTracksVtx->GetTrackMap();
153		}
154	<	else
154	>	else {
155		delete fillerStandaloneMuonTracksVtx;
156	<
156	>	fillerStandaloneMuonTracksVtx = 0;
157	>	}
158	>
159		FillerTracks *fillerGlobalMuonTracks = new FillerTracks(cfg,"GlobalMuonTracks",defactive_);
160	<	const TrackMap* globalMuonTrackMap=0;
160	>	const TrackMap *globalMuonTrackMap=0;
161		if (fillerGlobalMuonTracks->Active()) {
162		fillers_.push_back(fillerGlobalMuonTracks);
163		globalMuonTrackMap = fillerGlobalMuonTracks->GetTrackMap();
164		}
165	<	else
165	>	else {
166		delete fillerGlobalMuonTracks;
167	+	fillerGlobalMuonTracks = 0;
168	+	}
169
170		FillerTracks *fillerConversionInOutTracks =
171		new FillerTracks(cfg,"ConversionInOutTracks",defactive_,simParticleMap);
172	<	const TrackMap* conversionInOutTrackMap=0;
173	<	const TrackCol* conversionInOutTracks=0;
172	>	const TrackMap *conversionInOutTrackMap=0;
173	>	const TrackCol *conversionInOutTracks=0;
174		if (fillerConversionInOutTracks->Active()) {
175		fillers_.push_back(fillerConversionInOutTracks);
176		conversionInOutTrackMap = fillerConversionInOutTracks->GetTrackMap();
177		conversionInOutTracks = fillerConversionInOutTracks->GetTrackCol();
178		}
179	<	else
179	>	else {
180		delete fillerConversionInOutTracks;
181	<
181	>	fillerConversionInOutTracks = 0;
182	>	}
183	>
184		FillerTracks *fillerConversionOutInTracks =
185		new FillerTracks(cfg,"ConversionOutInTracks",defactive_,simParticleMap);
186	<	const TrackMap* conversionOutInTrackMap=0;
187	<	const TrackCol* conversionOutInTracks=0;
186	>	const TrackMap *conversionOutInTrackMap=0;
187	>	const TrackCol *conversionOutInTracks=0;
188		if (fillerConversionOutInTracks->Active()) {
189		fillers_.push_back(fillerConversionOutInTracks);
190		conversionOutInTrackMap = fillerConversionOutInTracks->GetTrackMap();
191		conversionOutInTracks = fillerConversionOutInTracks->GetTrackCol();
192		}
193	<	else
193	>	else {
194		delete fillerConversionOutInTracks;
195	<
196	<	FillerGsfTracks *fillerGsfTracks = new FillerGsfTracks(cfg,"GsfTracks",defactive_,simParticleMap);
197	<	const GsfTrackMap* gsfTrackMap=0;
195	>	fillerConversionOutInTracks = 0;
196	>	}
197	>
198	>	FillerGsfTracks *fillerGsfTracks =
199	>	new FillerGsfTracks(cfg,"GsfTracks",defactive_,simParticleMap);
200	>	const GsfTrackMap *gsfTrackMap=0;
201		if (fillerGsfTracks->Active()) {
202		fillers_.push_back(fillerGsfTracks);
203		gsfTrackMap = (GsfTrackMap*)fillerGsfTracks->GetTrackMap();
204		}
205	<	else
205	>	else {
206		delete fillerGsfTracks;
207	<
207	>	fillerGsfTracks = 0;
208	>	}
209	>
210		FillerMuons *fillerMuons =
211		new FillerMuons(cfg,defactive_,globalMuonTrackMap,standaloneMuonTrackMap,
212		standaloneMuonTrackVtxMap,generalTrackMap);
213		if (fillerMuons->Active())
214		fillers_.push_back(fillerMuons);
215	<	else
215	>	else {
216		delete fillerMuons;
217	<
218	<	FillerElectrons *fillerElectrons = new FillerElectrons(cfg,defactive_,gsfTrackMap,generalTrackMap);
217	>	fillerMuons = 0;
218	>	}
219	>
220	>	FillerElectrons *fillerElectrons =
221	>	new FillerElectrons(cfg,defactive_,gsfTrackMap,generalTrackMap);
222		if (fillerElectrons->Active())
223		fillers_.push_back(fillerElectrons);
224	<	else
224	>	else {
225		delete fillerElectrons;
226	<
227	<	#if 0
187	<	FillerConversionElectrons *fillerConversionElectrons =
188	<	new FillerConversionElectrons(cfg,defactive_,conversionInOutTracks,conversionOutInTracks,
189	<	conversionInOutTrackMap,conversionOutInTrackMap);
226	>	fillerElectrons = 0;
227	>	}
228
229	<	const ConversionElectronMap* convElectronMap=0;
229	>	FillerConversionElectrons *fillerConversionElectrons =
230	>	new FillerConversionElectrons(cfg, defactive_, conversionInOutTracks, conversionOutInTracks,
231	>	conversionInOutTrackMap, conversionOutInTrackMap);
232	>	const ConversionElectronMap *convElectronMap=0;
233		if (fillerConversionElectrons->Active()) {
234		fillers_.push_back(fillerConversionElectrons);
235		convElectronMap = fillerConversionElectrons->GetConversionElectronMap();
236		}
237	<	else
237	>	else {
238		delete fillerConversionElectrons;
239	<
240	<	FillerPhotons *fillerPhotons = new FillerPhotons(cfg,defactive_,convElectronMap);
239	>	fillerConversionElectrons = 0;
240	>	}
241	>
242	>	FillerConversions *fillerConversions = new FillerConversions(cfg, defactive_, convElectronMap);
243	>	const ConversionMap *conversionMap=0;
244	>	if (fillerConversions->Active()) {
245	>	fillers_.push_back(fillerConversions);
246	>	conversionMap = fillerConversions->GetConversionMap();
247	>	}
248	>	else {
249	>	delete fillerConversions;
250	>	fillerConversions = 0;
251	>	}
252	>
253	>	FillerPhotons *fillerPhotons = new FillerPhotons(cfg, defactive_, conversionMap);
254		if (fillerPhotons->Active())
255		fillers_.push_back(fillerPhotons);
256	<	else
256	>	else {
257		delete fillerPhotons;
258	<	#endif
258	>	fillerPhotons = 0;
259	>	}
260
261		return 1;
262		}
263
264	<	//-------------------------------------------------------------------------------------------------
264	>	//--------------------------------------------------------------------------------------------------
265		void FillMitTree::endJob()
266		{
267		// Delete fillers.

Diff Legend

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