ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitProd/TreeFiller/src/FillMitTree.cc

Comparing UserCode/MitProd/TreeFiller/src/FillMitTree.cc (file contents):
Revision 1.1 by paus, Wed Jun 18 13:23:22 2008 UTC vs.
Revision 1.32 by loizides, Tue Mar 10 15:56:01 2009 UTC

#	Line 1 | Line 1
1		// $Id$
2
3	+	#include "MitProd/TreeFiller/interface/FillMitTree.h"
4		#include "FWCore/MessageLogger/interface/MessageLogger.h"
5	<	#include "FWCore/Framework/interface/ESHandle.h"
5	<	#include "DataFormats/Common/interface/Handle.h"
5	>	#include "FWCore/ParameterSet/interface/ParameterSet.h"
6		#include "FWCore/ServiceRegistry/interface/Service.h"
7	<
8	<	#include "MitProd/TreeFiller/interface/FillerGlobalMuons.h"
9	<	#include "MitProd/TreeFiller/interface/FillMitTree.h"
7	>	#include "MitProd/TreeService/interface/TreeService.h"
8	>	#include "MitProd/ObjectService/interface/ObjectService.h"
9	>	#include "MitProd/TreeFiller/interface/AssociationMaps.h"
10	>	#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
11	>	#include "MitProd/TreeFiller/interface/FillerVertexes.h"
12	>	#include "MitProd/TreeFiller/interface/FillerBeamSpot.h"
13	>	#include "MitProd/TreeFiller/interface/FillerTracks.h"
14	>	#include "MitProd/TreeFiller/interface/FillerBasicClusters.h"
15	>	#include "MitProd/TreeFiller/interface/FillerSuperClusters.h"
16	>	#include "MitProd/TreeFiller/interface/FillerCaloTowers.h"
17	>	#include "MitProd/TreeFiller/interface/FillerMuons.h"
18	>	#include "MitProd/TreeFiller/interface/FillerElectrons.h"
19	>	#include "MitProd/TreeFiller/interface/FillerGenJets.h"
20	>	#include "MitProd/TreeFiller/interface/FillerCaloJets.h"
21	>	#include "MitProd/TreeFiller/interface/FillerCaloMet.h"
22	>	#include "MitProd/TreeFiller/interface/FillerConversions.h"
23	>	#include "MitProd/TreeFiller/interface/FillerConversionElectrons.h"
24	>	#include "MitProd/TreeFiller/interface/FillerPhotons.h"
25	>	#include "MitProd/TreeFiller/interface/FillerMCParticles.h"
26	>	#include "MitProd/TreeFiller/interface/FillerDecayParts.h"
27	>	#include "MitProd/TreeFiller/interface/FillerStableParts.h"
28	>	#include "MitProd/TreeFiller/interface/FillerPATMuons.h"
29	>	#include "MitProd/TreeFiller/interface/FillerPATElectrons.h"
30
31		using namespace std;
32		using namespace edm;
33		using namespace mithep;
34
35	<	//-------------------------------------------------------------------------------------------------
35	>	mithep::ObjectService *mithep::FillMitTree::os_ = 0;
36	>
37	>	//--------------------------------------------------------------------------------------------------
38		FillMitTree::FillMitTree(const edm::ParameterSet &cfg) :
39	<	fillerGlobalMuons_(0)
39	>	defactive_(cfg.getUntrackedParameter<bool>("defactive",1))
40		{
41	<	// initialize fillers
42	<	fillerGlobalMuons_ = new FillerGlobalMuons(cfg);
43	<	if (fillerGlobalMuons_->Active())
44	<	fillers_.push_back(fillerGlobalMuons_);
41	>	// Constructor.
42	>
43	>	if (!configure(cfg)) {
44	>	throw edm::Exception(edm::errors::Configuration, "FillMitTree::FillMitTree()\n")
45	>	<< "Could not configure fillers." << "\n";
46	>	}
47		}
48
49	<	//-------------------------------------------------------------------------------------------------
49	>	//--------------------------------------------------------------------------------------------------
50		FillMitTree::~FillMitTree()
51		{
52	<	// We own the fillers so we have to delete them
29	<	delete fillerGlobalMuons_;
52	>	// Destructor: nothing to be done here.
53		}
54
55	<	//-------------------------------------------------------------------------------------------------
56	<	void FillMitTree::beginJob(edm::EventSetup const &event)
55	>	//--------------------------------------------------------------------------------------------------
56	>	bool FillMitTree::addActiveFiller(BaseFiller *bf)
57		{
58	<	Service<TreeService> ts;
36	<	TreeWriter *tws = ts->get();
37	<	if (! tws) {
38	<	throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
39	<	<< "Could not get pointer to Tree with name " << tws->GetName() << "\n";
40	<	return;
41	<	}
58	>	// Check if filler is active and add it to list of fillers. Otherwise delete it.
59
60	<	// Loop over the various components and book the branches
61	<	for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
62	<	(*iF)->BookDataBlock(tws);
60	>	if (bf->Active()) {
61	>	fillers_.push_back(bf);
62	>	return 1;
63		}
64	<	return;
64	>
65	>	delete bf;
66	>	bf = 0;
67	>	return 0;
68		}
69
70	<	//-------------------------------------------------------------------------------------------------
70	>	//--------------------------------------------------------------------------------------------------
71		void FillMitTree::analyze(const edm::Event      &event,
72		const edm::EventSetup &setup)
73		{
74	<	// First step: Loop over the data fillers of the various components
74	>	// Access and copy event content.
75	>
76	>	// first step: Loop over the data fillers of the various components
77		for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
78		(*iF)->FillDataBlock(event,setup);
79		}
80
81	<	// Second step: Loop over the link resolution of the various components
81	>	// second step: Loop over the link resolution of the various components
82		for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
83		(*iF)->ResolveLinks(event,setup);
84		}
85		}
86
87	<	//-------------------------------------------------------------------------------------------------
87	>	//--------------------------------------------------------------------------------------------------
88	>	void FillMitTree::beginJob(const edm::EventSetup &event)
89	>	{
90	>	// Access the tree and book branches.
91	>
92	>	Service<TreeService> ts;
93	>	TreeWriter *tws = ts->get();
94	>	if (! tws) {
95	>	throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
96	>	<< "Could not get pointer to tree. "
97	>	<< "Do you have the TreeServie define in your config?" << "\n";
98	>	return;
99	>	}
100	>
101	>	if (os_==0) {
102	>	Service<ObjectService> os;
103	>	if (!os.isAvailable()) {
104	>	throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
105	>	<< "Could not get object service. "
106	>	<< "Do you have the ObjectService defined in your config?" << "\n";
107	>	return;
108	>	}
109	>	os_ = &(*os);
110	>	}
111	>
112	>	// loop over the various components and book the branches
113	>	for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
114	>	edm::LogInfo("FillMitTree::beginJob") << "Booking for " << (*iF)->Name() << endl;
115	>	(*iF)->BookDataBlock(*tws);
116	>	}
117	>	}
118	>
119	>	//--------------------------------------------------------------------------------------------------
120	>	bool FillMitTree::configure(const edm::ParameterSet &cfg)
121	>	{
122	>	// Configure our fillers according to given order ("fillerOrder").
123	>
124	>	std::vector<std::string> pars(cfg.getParameterNames());
125	>	if (cfg.exists("fillerOrder"))
126	>	pars=cfg.getUntrackedParameter<vector<string> >("fillerOrder");
127	>
128	>	// loop over psets
129	>	for (unsigned int i = 0; i<pars.size(); ++i) {
130	>
131	>	const string name(pars.at(i));
132	>	if (!cfg.existsAs<ParameterSet>(name,0))
133	>	continue;
134	>
135	>	ParameterSet next(cfg.getUntrackedParameter<ParameterSet>(name));
136	>	if (!next.exists("fillerType")) {
137	>	edm::LogError("FillMitTree") << "Can not determine fillerType for pset named "
138	>	<< name << std::endl;
139	>	continue;
140	>	}
141	>
142	>	string ftype(next.getUntrackedParameter<string>("fillerType"));
143	>
144	>	if (ftype.compare("FillerMetaInfos")==0) {
145	>	FillerMetaInfos *fillerMetaInfos = new FillerMetaInfos(cfg, name.c_str(), defactive_);
146	>	addActiveFiller(fillerMetaInfos);
147	>	continue;
148	>	}
149	>	if (ftype.compare("FillerMCParticles")==0) {
150	>	FillerMCParticles *fillerMCParticles = new FillerMCParticles(cfg, name.c_str(), defactive_);
151	>	addActiveFiller(fillerMCParticles);
152	>	continue;
153	>	}
154	>	if (ftype.compare("FillerBeamSpot")==0) {
155	>	FillerBeamSpot *fillerBeamSpot = new FillerBeamSpot(cfg, name.c_str(), defactive_);
156	>	addActiveFiller(fillerBeamSpot);
157	>	continue;
158	>	}
159	>	if (ftype.compare("FillerVertexes")==0) {
160	>	FillerVertexes *fillerVertexes = new FillerVertexes(cfg, name.c_str(), defactive_);
161	>	addActiveFiller(fillerVertexes);
162	>	continue;
163	>	}
164	>
165	>	if (ftype.compare("FillerCaloTowers")==0) {
166	>	FillerCaloTowers *fillerCaloTowers = new FillerCaloTowers(cfg, name.c_str(), defactive_);
167	>	addActiveFiller(fillerCaloTowers);
168	>	continue;
169	>	}
170	>
171	>	if (ftype.compare("FillerGenJets")==0) {
172	>	FillerGenJets *fillerGenJets = new FillerGenJets(cfg, name.c_str(), defactive_);
173	>	addActiveFiller(fillerGenJets);
174	>	continue;
175	>	}
176	>
177	>	if (ftype.compare("FillerCaloJets")==0) {
178	>	FillerCaloJets *fillerCaloJets = new FillerCaloJets(cfg, name.c_str(), defactive_);
179	>	addActiveFiller(fillerCaloJets);
180	>	continue;
181	>	}
182	>
183	>	if (ftype.compare("FillerCaloMet")==0) {
184	>	FillerCaloMet *fillerCaloMet = new FillerCaloMet(cfg, name.c_str(), defactive_);
185	>	addActiveFiller(fillerCaloMet);
186	>	continue;
187	>	}
188	>
189	>	if (ftype.compare("FillerBasicClusters")==0) {
190	>	FillerBasicClusters *fillerBasicClusters =
191	>	new FillerBasicClusters(cfg, name.c_str(), defactive_);
192	>	addActiveFiller(fillerBasicClusters);
193	>	continue;
194	>	}
195	>
196	>	if (ftype.compare("FillerSuperClusters")==0) {
197	>	FillerSuperClusters *fillerSuperClusters =
198	>	new FillerSuperClusters(cfg, name.c_str(), defactive_);
199	>	addActiveFiller(fillerSuperClusters);
200	>	continue;
201	>	}
202	>
203	>	if (ftype.compare("FillerTracks")==0) {
204	>	FillerTracks *fillerTracks = new FillerTracks(cfg, name.c_str(), defactive_);
205	>	addActiveFiller(fillerTracks);
206	>	continue;
207	>	}
208	>
209	>	if (ftype.compare("FillerMuons")==0) {
210	>	FillerMuons *fillerMuons = new FillerMuons(cfg, name.c_str(), defactive_);
211	>	addActiveFiller(fillerMuons);
212	>	continue;
213	>	}
214	>
215	>	if (ftype.compare("FillerElectrons")==0) {
216	>	FillerElectrons *fillerElectrons = new FillerElectrons(cfg, name.c_str(), defactive_);
217	>	addActiveFiller(fillerElectrons);
218	>	continue;
219	>	}
220	>
221	>	if (ftype.compare("FillerConversionElectrons")==0) {
222	>	FillerConversionElectrons *fillerConversionElectrons =
223	>	new FillerConversionElectrons(cfg, name.c_str(), defactive_);
224	>	addActiveFiller(fillerConversionElectrons);
225	>	continue;
226	>	}
227	>
228	>	if (ftype.compare("FillerConversions")==0) {
229	>	FillerConversions *fillerConversions = new FillerConversions(cfg, name.c_str(), defactive_);
230	>	addActiveFiller(fillerConversions);
231	>	continue;
232	>	}
233	>
234	>	if (ftype.compare("FillerPhotons")==0) {
235	>	FillerPhotons *fillerPhotons = new FillerPhotons(cfg, name.c_str(), defactive_);
236	>	addActiveFiller(fillerPhotons);
237	>	continue;
238	>	}
239	>
240	>	if (ftype.compare("FillerStableParts")==0) {
241	>	FillerStableParts *fillerStableParts = new FillerStableParts(cfg, name.c_str(), defactive_);
242	>	addActiveFiller(fillerStableParts);
243	>	continue;
244	>	}
245	>
246	>	if (ftype.compare("FillerDecayParts")==0) {
247	>	FillerDecayParts *fillerDecayParts = new FillerDecayParts(cfg, name.c_str(), defactive_);
248	>	addActiveFiller(fillerDecayParts);
249	>	continue;
250	>	}
251	>
252	>	edm::LogError("FillMitTree")
253	>	<< "Unknown fillerType " << ftype << " for pset named " << name << std::endl;
254	>	throw edm::Exception(edm::errors::Configuration, "FillMitTree::configure\n")
255	>	<< "Unknown fillerType " << ftype << " for pset named " << name << std::endl;
256	>	}
257	>
258	>	return 1;
259	>	}
260	>
261	>	//--------------------------------------------------------------------------------------------------
262		void FillMitTree::endJob()
263		{
264	+	// Delete fillers.
265	+
266	+	for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
267	+	delete *iF;
268	+	}
269	+
270		edm::LogInfo("FillMitTree::endJob") << "Ending Job" << endl;
271		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines