TreeFiller/src/FillMitTree.cc

// $Id: FillMitTree.cc,v 1.6 2008/07/01 14:38:33 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) :
  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;

  FillerGenParts *fillerGenParts = new FillerGenParts(cfg,defactive_);
  if (fillerGenParts->Active())
    fillers_.push_back(fillerGenParts);
  else 
    delete fillerGenParts;  
    
  FillerSimParticles *fillerSimParticles = new FillerSimParticles(cfg,defactive_);
  const SimParticleMap* simParticleMap=0;
  if (fillerSimParticles->Active()) {
    fillers_.push_back(fillerSimParticles);
    simParticleMap = fillerSimParticles->GetSimParticleMap();
  }
  else 
    delete fillerSimParticles;  
  
  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;
    
  FillerTracks *fillerStandaloneMuonTracks = new FillerTracks(cfg,"StandaloneMuonTracks",defactive_);
  const TrackMap* standaloneMuonTrackMap=0;
  if (fillerStandaloneMuonTracks->Active()) {
    fillers_.push_back(fillerStandaloneMuonTracks);
    standaloneMuonTrackMap = fillerStandaloneMuonTracks->GetTrackMap();
  }
  else 
    delete fillerStandaloneMuonTracks;

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