TreeFiller/src/FillMitTree.cc

// $Id: FillMitTree.cc,v 1.10 2008/07/07 13:29:05 bendavid 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/FillerTracks.h"
#include "MitProd/TreeFiller/interface/FillerGsfTracks.h"
#include "MitProd/TreeFiller/interface/FillerMuons.h"
#include "MitProd/TreeFiller/interface/FillerElectrons.h"
#include "MitProd/TreeFiller/interface/FillerElectrons.h"
#include "MitProd/TreeFiller/interface/FillerCaloJets.h"
#include "MitProd/TreeFiller/interface/FillerCaloMet.h"
#include "MitProd/TreeFiller/interface/FillerConversions.h"
#include "MitProd/TreeFiller/interface/FillerConversionElectrons.h"
#include "MitProd/TreeFiller/interface/FillerPhotons.h"
#include "MitProd/TreeFiller/interface/FillerGenParts.h"
#include "MitProd/TreeFiller/interface/FillerSimParticles.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;
    fillerMetaInfos = 0;
  }

  FillerGenParts *fillerGenParts = new FillerGenParts(cfg,defactive_);
  const GenParticleMap* genParticleMap = 0;
  if (fillerGenParts->Active()) {
    fillers_.push_back(fillerGenParts);
    genParticleMap = fillerGenParts->GetGenParticleMap();
  }
  else {
    delete fillerGenParts;  
    fillerGenParts = 0;
  }

  FillerSimParticles *fillerSimParticles = new FillerSimParticles(cfg,defactive_,genParticleMap);
  const SimParticleMap *simParticleMap = 0;
  if (fillerSimParticles->Active()) {
    fillers_.push_back(fillerSimParticles);
    simParticleMap = fillerSimParticles->GetSimParticleMap();
  }
  else {
    delete fillerSimParticles;  
    fillerSimParticles = 0;
  }

  FillerCaloJets *fillerCaloJets = new FillerCaloJets(cfg,"CaloJets",defactive_);
  if (fillerCaloJets->Active()) {
    fillers_.push_back(fillerCaloJets);
  }
  else {
    delete fillerCaloJets;
    fillerCaloJets = 0;
  }

  FillerCaloMet *fillerCaloMet = new FillerCaloMet(cfg,"CaloMet",defactive_);
  if (fillerCaloMet->Active()) {
    fillers_.push_back(fillerCaloMet);
  }
  else {
    delete fillerCaloMet;
    fillerCaloMet = 0;
  }

  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;
    fillerGeneralTracks = 0;
  }

  FillerTracks *fillerStandaloneMuonTracks = 
    new FillerTracks(cfg,"StandaloneMuonTracks",defactive_);
  const TrackMap *standaloneMuonTrackMap=0;
  if (fillerStandaloneMuonTracks->Active()) {
    fillers_.push_back(fillerStandaloneMuonTracks);
    standaloneMuonTrackMap = fillerStandaloneMuonTracks->GetTrackMap();
  }
  else {
    delete fillerStandaloneMuonTracks;
    fillerStandaloneMuonTracks = 0;
  }

  FillerTracks *fillerStandaloneMuonTracksVtx = 
    new FillerTracks(cfg,"StandaloneMuonTracksWVtxConstraint",defactive_);
  const TrackMap *standaloneMuonTrackVtxMap=0;
  if (fillerStandaloneMuonTracksVtx->Active()) {
    fillers_.push_back(fillerStandaloneMuonTracksVtx);
    standaloneMuonTrackVtxMap = fillerStandaloneMuonTracksVtx->GetTrackMap();
  }
  else {
    delete fillerStandaloneMuonTracksVtx;
    fillerStandaloneMuonTracksVtx = 0;
  }

  FillerTracks *fillerGlobalMuonTracks = new FillerTracks(cfg,"GlobalMuonTracks",defactive_);
  const TrackMap *globalMuonTrackMap=0;
  if (fillerGlobalMuonTracks->Active()) {
    fillers_.push_back(fillerGlobalMuonTracks);
    globalMuonTrackMap = fillerGlobalMuonTracks->GetTrackMap();
  }
  else {
    delete fillerGlobalMuonTracks;  
    fillerGlobalMuonTracks = 0;
  }
    
  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;
    fillerConversionInOutTracks = 0;
  }

  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;
    fillerConversionOutInTracks = 0;
  }

  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;
    fillerGsfTracks = 0;
  }

  FillerMuons *fillerMuons = 
    new FillerMuons(cfg,defactive_,globalMuonTrackMap,standaloneMuonTrackMap, 
                    standaloneMuonTrackVtxMap,generalTrackMap);
  if (fillerMuons->Active())
    fillers_.push_back(fillerMuons);
  else {
    delete fillerMuons;
    fillerMuons = 0;
  }

  FillerElectrons *fillerElectrons = 
    new FillerElectrons(cfg,defactive_,gsfTrackMap,generalTrackMap);
  if (fillerElectrons->Active())
    fillers_.push_back(fillerElectrons);
  else {
    delete fillerElectrons;
      fillerElectrons = 0;
  }

  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;
    fillerConversionElectrons = 0;
  }

  FillerConversions *fillerConversions = new FillerConversions(cfg, defactive_, convElectronMap);
  const ConversionMap *conversionMap=0;
  if (fillerConversions->Active()) {
    fillers_.push_back(fillerConversions);
    conversionMap = fillerConversions->GetConversionMap();
  }
  else {
    delete fillerConversions;
    fillerConversions = 0;
  }

  FillerPhotons *fillerPhotons = new FillerPhotons(cfg, defactive_, conversionMap);
  if (fillerPhotons->Active())
    fillers_.push_back(fillerPhotons);
  else {
    delete fillerPhotons;
    fillerPhotons = 0;
  }

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