TreeFiller/src/FillMitTree.cc

// $Id: FillMitTree.cc,v 1.13 2008/07/28 23:13:44 paus 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/FillerMCParticles.h"
#include "MitProd/TreeFiller/interface/FillerDecayParts.h"
#include "MitProd/TreeFiller/interface/FillerStableParts.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;
  }

  FillerMCParticles *fillerMCParticles = new FillerMCParticles(cfg,"MCParticles",defactive_);
  const GenParticleMap* genParticleMap = 0;
  const SimParticleMap *simParticleMap = 0;
  if (fillerMCParticles->Active()) {
    fillers_.push_back(fillerMCParticles);
    genParticleMap = fillerMCParticles->GetGenParticleMap();
    simParticleMap = fillerMCParticles->GetSimParticleMap();
  }
  else {
    delete fillerMCParticles;  
    fillerMCParticles = 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;
  }

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