TreeFiller/src/FillMitTree.cc

// $Id: FillMitTree.cc,v 1.11 2008/07/07 16:14:01 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/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"

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

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