TreeFiller/src/FillMitTree.cc

// $Id: FillMitTree.cc,v 1.5 2008/06/24 14:25:46 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/FillerSimParticles.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/FillerConvElectrons.h"
//#include "MitProd/TreeFiller/interface/FillerPhotons.h"
#include "MitProd/TreeFiller/interface/FillerGenParts.h"

using namespace std;
using namespace edm;
using namespace mithep;

//-------------------------------------------------------------------------------------------------
FillMitTree::FillMitTree(const edm::ParameterSet &cfg)
{
  // 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;

  FillerGenParts *fillerGenParts = new FillerGenParts(cfg);
  if (fillerGenParts->Active())
    fillers_.push_back(fillerGenParts);
  else 
    delete fillerGenParts;  
    
  FillerSimParticles *fillerSimParticles = new FillerSimParticles(cfg);
  const SimParticleMap* simParticleMap=0;
  if (fillerSimParticles->Active()) {
    fillers_.push_back(fillerSimParticles);
    simParticleMap = fillerSimParticles->GetSimParticleMap();
  }
  else 
    delete fillerSimParticles;  
  
  FillerTracks *fillerGeneralTracks = new FillerTracks(cfg,"GeneralTracks", simParticleMap);
  const TrackMap* generalTrackMap=0;
  if (fillerGeneralTracks->Active()) {
    fillers_.push_back(fillerGeneralTracks);
    generalTrackMap = fillerGeneralTracks->GetTrackMap();
  }
  else 
    delete fillerGeneralTracks;
    
  FillerTracks *fillerStandaloneMuonTracks = new FillerTracks(cfg,"StandaloneMuonTracks");
  const TrackMap* standaloneMuonTrackMap=0;
  if (fillerStandaloneMuonTracks->Active()) {
    fillers_.push_back(fillerStandaloneMuonTracks);
    standaloneMuonTrackMap = fillerStandaloneMuonTracks->GetTrackMap();
  }
  else 
    delete fillerStandaloneMuonTracks;

  FillerTracks *fillerStandaloneMuonTracksVtx = 
    new FillerTracks(cfg,"StandaloneMuonTracksWVtxConstraint");
  const TrackMap* standaloneMuonTrackVtxMap=0;
  if (fillerStandaloneMuonTracksVtx->Active()) {
    fillers_.push_back(fillerStandaloneMuonTracksVtx);
    standaloneMuonTrackVtxMap = fillerStandaloneMuonTracksVtx->GetTrackMap();
  }
  else 
    delete fillerStandaloneMuonTracksVtx;
    
  FillerTracks *fillerGlobalMuonTracks = new FillerTracks(cfg,"GlobalMuonTracks");
  const TrackMap* globalMuonTrackMap=0;
  if (fillerGlobalMuonTracks->Active()) {
    fillers_.push_back(fillerGlobalMuonTracks);
    globalMuonTrackMap = fillerGlobalMuonTracks->GetTrackMap();
  }
  else 
    delete fillerGlobalMuonTracks;  
    
  FillerTracks *fillerConversionInOutTracks = 
    new FillerTracks(cfg,"ConversionInOutTracks", 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;
    
  FillerTracks *fillerConversionOutInTracks = 
    new FillerTracks(cfg,"ConversionOutInTracks", 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;
    
  FillerGsfTracks *fillerGsfTracks = new FillerGsfTracks(cfg,"GsfTracks", simParticleMap);
  const GsfTrackMap* gsfTrackMap=0;
  if (fillerGsfTracks->Active()) {
    fillers_.push_back(fillerGsfTracks);
    gsfTrackMap = (GsfTrackMap*)fillerGsfTracks->GetTrackMap();
  }
  else 
    delete fillerGsfTracks;
    
  FillerMuons *fillerMuons = 
    new FillerMuons(cfg, globalMuonTrackMap, standaloneMuonTrackMap, 
                    standaloneMuonTrackVtxMap, generalTrackMap);
  if (fillerMuons->Active())
    fillers_.push_back(fillerMuons);
  else 
    delete fillerMuons;
    
  FillerElectrons *fillerElectrons = new FillerElectrons(cfg, gsfTrackMap, generalTrackMap);
  if (fillerElectrons->Active())
    fillers_.push_back(fillerElectrons);
  else 
    delete fillerElectrons;
  
#if 0
  FillerConversionElectrons *fillerConversionElectrons = 
    new FillerConversionElectrons(cfg, conversionInOutTracks, conversionOutInTracks, 
                                  conversionInOutTrackMap, conversionOutInTrackMap);

  const ConversionElectronMap* convElectronMap=0;
  if (fillerConversionElectrons->Active()) {
    fillers_.push_back(fillerConversionElectrons);
    convElectronMap = fillerConversionElectrons->GetConversionElectronMap();
  }
  else 
    delete fillerConversionElectrons;
    
  FillerPhotons *fillerPhotons = new FillerPhotons(cfg, convElectronMap);
  if (fillerPhotons->Active())
    fillers_.push_back(fillerPhotons);
  else 
    delete fillerPhotons;
#endif

  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.6
Committed:	Tue Jul 1 14:38:33 2008 UTC (16 years, 10 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.5:	+126 -13 lines
Log Message:	Have most of Josh's fillers.
#	User	Rev	Content
1	loizides	1.6	// $Id: FillMitTree.cc,v 1.5 2008/06/24 14:25:46 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/FillerSimParticles.h"
10			#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			//#include "MitProd/TreeFiller/interface/FillerConvElectrons.h"
15			//#include "MitProd/TreeFiller/interface/FillerPhotons.h"
16	loizides	1.5	#include "MitProd/TreeFiller/interface/FillerGenParts.h"
17	paus	1.1
18			using namespace std;
19			using namespace edm;
20			using namespace mithep;
21
22			//-------------------------------------------------------------------------------------------------
23	loizides	1.2	FillMitTree::FillMitTree(const edm::ParameterSet &cfg)
24	paus	1.1	{
25	loizides	1.6	// Constructor.
26
27	loizides	1.3	if (!configure(cfg)) {
28			throw edm::Exception(edm::errors::Configuration, "FillMitTree::FillMitTree()\n")
29			<< "Could not configure fillers." << "\n";
30			}
31	paus	1.1	}
32
33			//-------------------------------------------------------------------------------------------------
34			FillMitTree::~FillMitTree()
35			{
36	loizides	1.2	// Destructor: nothing to be done here.
37	paus	1.1	}
38
39			//-------------------------------------------------------------------------------------------------
40	loizides	1.3	void FillMitTree::analyze(const edm::Event &event,
41			const edm::EventSetup &setup)
42			{
43			// Access and copy event content.
44
45			// First step: Loop over the data fillers of the various components
46			for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
47			(*iF)->FillDataBlock(event,setup);
48			}
49
50			// Second step: Loop over the link resolution of the various components
51			for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
52			(*iF)->ResolveLinks(event,setup);
53			}
54			}
55
56			//-------------------------------------------------------------------------------------------------
57			void FillMitTree::beginJob(const edm::EventSetup &event)
58	paus	1.1	{
59	loizides	1.2	// Access the tree and book branches.
60
61	paus	1.1	Service<TreeService> ts;
62			TreeWriter *tws = ts->get();
63			if (! tws) {
64			throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
65	loizides	1.2	<< "Could not get pointer to tree." << "\n";
66	paus	1.1	return;
67			}
68	loizides	1.6
69	paus	1.1	// Loop over the various components and book the branches
70			for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
71	loizides	1.4	(iF)->BookDataBlock(tws);
72	paus	1.1	}
73			}
74
75			//-------------------------------------------------------------------------------------------------
76	loizides	1.3	bool FillMitTree::configure(const edm::ParameterSet &cfg)
77	paus	1.1	{
78	loizides	1.3	// Configure our fillers.
79
80			FillerMetaInfos *fillerMetaInfos = new FillerMetaInfos(cfg);
81			if (fillerMetaInfos->Active())
82			fillers_.push_back(fillerMetaInfos);
83			else
84			delete fillerMetaInfos;
85	loizides	1.2
86	loizides	1.5	FillerGenParts *fillerGenParts = new FillerGenParts(cfg);
87			if (fillerGenParts->Active())
88			fillers_.push_back(fillerGenParts);
89			else
90	loizides	1.6	delete fillerGenParts;
91
92			FillerSimParticles *fillerSimParticles = new FillerSimParticles(cfg);
93			const SimParticleMap* simParticleMap=0;
94			if (fillerSimParticles->Active()) {
95			fillers_.push_back(fillerSimParticles);
96			simParticleMap = fillerSimParticles->GetSimParticleMap();
97			}
98			else
99			delete fillerSimParticles;
100
101			FillerTracks *fillerGeneralTracks = new FillerTracks(cfg,"GeneralTracks", simParticleMap);
102			const TrackMap* generalTrackMap=0;
103			if (fillerGeneralTracks->Active()) {
104			fillers_.push_back(fillerGeneralTracks);
105			generalTrackMap = fillerGeneralTracks->GetTrackMap();
106			}
107			else
108			delete fillerGeneralTracks;
109
110			FillerTracks *fillerStandaloneMuonTracks = new FillerTracks(cfg,"StandaloneMuonTracks");
111			const TrackMap* standaloneMuonTrackMap=0;
112			if (fillerStandaloneMuonTracks->Active()) {
113			fillers_.push_back(fillerStandaloneMuonTracks);
114			standaloneMuonTrackMap = fillerStandaloneMuonTracks->GetTrackMap();
115			}
116			else
117			delete fillerStandaloneMuonTracks;
118
119			FillerTracks *fillerStandaloneMuonTracksVtx =
120			new FillerTracks(cfg,"StandaloneMuonTracksWVtxConstraint");
121			const TrackMap* standaloneMuonTrackVtxMap=0;
122			if (fillerStandaloneMuonTracksVtx->Active()) {
123			fillers_.push_back(fillerStandaloneMuonTracksVtx);
124			standaloneMuonTrackVtxMap = fillerStandaloneMuonTracksVtx->GetTrackMap();
125			}
126			else
127			delete fillerStandaloneMuonTracksVtx;
128
129			FillerTracks *fillerGlobalMuonTracks = new FillerTracks(cfg,"GlobalMuonTracks");
130			const TrackMap* globalMuonTrackMap=0;
131			if (fillerGlobalMuonTracks->Active()) {
132			fillers_.push_back(fillerGlobalMuonTracks);
133			globalMuonTrackMap = fillerGlobalMuonTracks->GetTrackMap();
134			}
135			else
136			delete fillerGlobalMuonTracks;
137
138			FillerTracks *fillerConversionInOutTracks =
139			new FillerTracks(cfg,"ConversionInOutTracks", simParticleMap);
140			const TrackMap* conversionInOutTrackMap=0;
141			const TrackCol* conversionInOutTracks=0;
142			if (fillerConversionInOutTracks->Active()) {
143			fillers_.push_back(fillerConversionInOutTracks);
144			conversionInOutTrackMap = fillerConversionInOutTracks->GetTrackMap();
145			conversionInOutTracks = fillerConversionInOutTracks->GetTrackCol();
146			}
147			else
148			delete fillerConversionInOutTracks;
149
150			FillerTracks *fillerConversionOutInTracks =
151			new FillerTracks(cfg,"ConversionOutInTracks", simParticleMap);
152			const TrackMap* conversionOutInTrackMap=0;
153			const TrackCol* conversionOutInTracks=0;
154			if (fillerConversionOutInTracks->Active()) {
155			fillers_.push_back(fillerConversionOutInTracks);
156			conversionOutInTrackMap = fillerConversionOutInTracks->GetTrackMap();
157			conversionOutInTracks = fillerConversionOutInTracks->GetTrackCol();
158			}
159			else
160			delete fillerConversionOutInTracks;
161
162			FillerGsfTracks *fillerGsfTracks = new FillerGsfTracks(cfg,"GsfTracks", simParticleMap);
163			const GsfTrackMap* gsfTrackMap=0;
164			if (fillerGsfTracks->Active()) {
165			fillers_.push_back(fillerGsfTracks);
166			gsfTrackMap = (GsfTrackMap*)fillerGsfTracks->GetTrackMap();
167			}
168			else
169			delete fillerGsfTracks;
170
171			FillerMuons *fillerMuons =
172			new FillerMuons(cfg, globalMuonTrackMap, standaloneMuonTrackMap,
173			standaloneMuonTrackVtxMap, generalTrackMap);
174			if (fillerMuons->Active())
175			fillers_.push_back(fillerMuons);
176			else
177			delete fillerMuons;
178
179			FillerElectrons *fillerElectrons = new FillerElectrons(cfg, gsfTrackMap, generalTrackMap);
180			if (fillerElectrons->Active())
181			fillers_.push_back(fillerElectrons);
182			else
183			delete fillerElectrons;
184
185			#if 0
186			FillerConversionElectrons *fillerConversionElectrons =
187			new FillerConversionElectrons(cfg, conversionInOutTracks, conversionOutInTracks,
188			conversionInOutTrackMap, conversionOutInTrackMap);
189
190			const ConversionElectronMap* convElectronMap=0;
191			if (fillerConversionElectrons->Active()) {
192			fillers_.push_back(fillerConversionElectrons);
193			convElectronMap = fillerConversionElectrons->GetConversionElectronMap();
194			}
195			else
196			delete fillerConversionElectrons;
197
198			FillerPhotons *fillerPhotons = new FillerPhotons(cfg, convElectronMap);
199			if (fillerPhotons->Active())
200			fillers_.push_back(fillerPhotons);
201			else
202			delete fillerPhotons;
203			#endif
204	loizides	1.5
205	loizides	1.3	return 1;
206	paus	1.1	}
207
208			//-------------------------------------------------------------------------------------------------
209			void FillMitTree::endJob()
210			{
211	loizides	1.2	// Delete fillers.
212
213			for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
214			delete *iF;
215			}
216
217	paus	1.1	edm::LogInfo("FillMitTree::endJob") << "Ending Job" << endl;
218			}