TreeFiller/src/FillMitTree.cc

// $Id: FillMitTree.cc,v 1.15 2008/07/30 08:39:50 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/ObjectService/interface/ObjectService.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;

mithep::ObjectService *mithep::FillMitTree::os_ = 0;

//--------------------------------------------------------------------------------------------------
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;
  }

  if (os_==0) { 
    Service<ObjectService> os;
    if (!os.isAvailable()) {
      throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
        << "Could not get object service." << "\n";
      return;
    }
    os_ = &(*os);
  }

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