TreeFiller/src/FillMitTree.cc

// $Id: FillMitTree.cc,v 1.31 2009/03/06 14:40:11 bendavid Exp $

#include "MitProd/TreeFiller/interface/FillMitTree.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ParameterSet/interface/ParameterSet.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/FillerVertexes.h"
#include "MitProd/TreeFiller/interface/FillerBeamSpot.h"
#include "MitProd/TreeFiller/interface/FillerTracks.h"
#include "MitProd/TreeFiller/interface/FillerBasicClusters.h"
#include "MitProd/TreeFiller/interface/FillerSuperClusters.h"
#include "MitProd/TreeFiller/interface/FillerCaloTowers.h"
#include "MitProd/TreeFiller/interface/FillerMuons.h"
#include "MitProd/TreeFiller/interface/FillerElectrons.h"
#include "MitProd/TreeFiller/interface/FillerGenJets.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"
#include "MitProd/TreeFiller/interface/FillerPATMuons.h"
#include "MitProd/TreeFiller/interface/FillerPATElectrons.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.
}

//--------------------------------------------------------------------------------------------------
bool FillMitTree::addActiveFiller(BaseFiller *bf)
{
  // Check if filler is active and add it to list of fillers. Otherwise delete it.

  if (bf->Active()) {
    fillers_.push_back(bf);
    return 1;
  }

  delete bf;
  bf = 0;
  return 0;
}

//--------------------------------------------------------------------------------------------------
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. " 
      << "Do you have the TreeServie define in your config?" << "\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. " 
        << "Do you have the ObjectService defined in your config?" << "\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 according to given order ("fillerOrder").

  std::vector<std::string> pars(cfg.getParameterNames());
  if (cfg.exists("fillerOrder"))
    pars=cfg.getUntrackedParameter<vector<string> >("fillerOrder");

  // loop over psets
  for (unsigned int i = 0; i<pars.size(); ++i) {

    const string name(pars.at(i));
    if (!cfg.existsAs<ParameterSet>(name,0))
      continue;

    ParameterSet next(cfg.getUntrackedParameter<ParameterSet>(name));
    if (!next.exists("fillerType")) {
      edm::LogError("FillMitTree") << "Can not determine fillerType for pset named "
                                   << name << std::endl;
      continue;
    }

    string ftype(next.getUntrackedParameter<string>("fillerType"));

    if (ftype.compare("FillerMetaInfos")==0) {
      FillerMetaInfos *fillerMetaInfos = new FillerMetaInfos(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerMetaInfos);
      continue;
    }
    if (ftype.compare("FillerMCParticles")==0) {
      FillerMCParticles *fillerMCParticles = new FillerMCParticles(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerMCParticles);
      continue;
    }
    if (ftype.compare("FillerBeamSpot")==0) {
      FillerBeamSpot *fillerBeamSpot = new FillerBeamSpot(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerBeamSpot);
      continue;
    }
    if (ftype.compare("FillerVertexes")==0) {
      FillerVertexes *fillerVertexes = new FillerVertexes(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerVertexes);
      continue;
    }  

    if (ftype.compare("FillerCaloTowers")==0) {
      FillerCaloTowers *fillerCaloTowers = new FillerCaloTowers(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerCaloTowers);
      continue;
    }  

    if (ftype.compare("FillerGenJets")==0) {
      FillerGenJets *fillerGenJets = new FillerGenJets(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerGenJets);
      continue;
    }  

    if (ftype.compare("FillerCaloJets")==0) {
      FillerCaloJets *fillerCaloJets = new FillerCaloJets(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerCaloJets);
      continue;
    }  

    if (ftype.compare("FillerCaloMet")==0) {
      FillerCaloMet *fillerCaloMet = new FillerCaloMet(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerCaloMet);
      continue;
    }  

    if (ftype.compare("FillerBasicClusters")==0) {
      FillerBasicClusters *fillerBasicClusters = 
        new FillerBasicClusters(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerBasicClusters);
      continue;
    }  

    if (ftype.compare("FillerSuperClusters")==0) {
      FillerSuperClusters *fillerSuperClusters =  
        new FillerSuperClusters(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerSuperClusters);
      continue;
    }  

    if (ftype.compare("FillerTracks")==0) {
      FillerTracks *fillerTracks = new FillerTracks(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerTracks);
      continue;
    }  

    if (ftype.compare("FillerMuons")==0) {
      FillerMuons *fillerMuons = new FillerMuons(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerMuons);
      continue;
    }  

    if (ftype.compare("FillerElectrons")==0) {
      FillerElectrons *fillerElectrons = new FillerElectrons(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerElectrons);
      continue;
    }  

    if (ftype.compare("FillerConversionElectrons")==0) {
      FillerConversionElectrons *fillerConversionElectrons = 
        new FillerConversionElectrons(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerConversionElectrons);
      continue;
    }  

    if (ftype.compare("FillerConversions")==0) {
      FillerConversions *fillerConversions = new FillerConversions(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerConversions);
      continue;
    }  

    if (ftype.compare("FillerPhotons")==0) { 
      FillerPhotons *fillerPhotons = new FillerPhotons(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerPhotons);
      continue;
    }  

    if (ftype.compare("FillerStableParts")==0) {
      FillerStableParts *fillerStableParts = new FillerStableParts(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerStableParts);
      continue;
    }  

    if (ftype.compare("FillerDecayParts")==0) {
      FillerDecayParts *fillerDecayParts = new FillerDecayParts(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerDecayParts);
      continue;
    }  

    edm::LogError("FillMitTree") 
      << "Unknown fillerType " << ftype << " for pset named " << name << std::endl;
    throw edm::Exception(edm::errors::Configuration, "FillMitTree::configure\n")
      << "Unknown fillerType " << ftype << " for pset named " << name << std::endl;
  }

  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.32
Committed:	Tue Mar 10 15:56:01 2009 UTC (16 years, 1 month ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.31:	+137 -136 lines
Log Message:	Introduced more dynamic filling interface.
#	User	Rev	Content
1	loizides	1.32	// $Id: FillMitTree.cc,v 1.31 2009/03/06 14:40:11 bendavid 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	loizides	1.32	#include "FWCore/ParameterSet/interface/ParameterSet.h"
6	paus	1.1	#include "FWCore/ServiceRegistry/interface/Service.h"
7	loizides	1.3	#include "MitProd/TreeService/interface/TreeService.h"
8	loizides	1.16	#include "MitProd/ObjectService/interface/ObjectService.h"
9	loizides	1.6	#include "MitProd/TreeFiller/interface/AssociationMaps.h"
10	loizides	1.3	#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
11	bendavid	1.24	#include "MitProd/TreeFiller/interface/FillerVertexes.h"
12	bendavid	1.28	#include "MitProd/TreeFiller/interface/FillerBeamSpot.h"
13	loizides	1.6	#include "MitProd/TreeFiller/interface/FillerTracks.h"
14	sixie	1.18	#include "MitProd/TreeFiller/interface/FillerBasicClusters.h"
15			#include "MitProd/TreeFiller/interface/FillerSuperClusters.h"
16	sixie	1.20	#include "MitProd/TreeFiller/interface/FillerCaloTowers.h"
17	loizides	1.6	#include "MitProd/TreeFiller/interface/FillerMuons.h"
18			#include "MitProd/TreeFiller/interface/FillerElectrons.h"
19	sixie	1.22	#include "MitProd/TreeFiller/interface/FillerGenJets.h"
20	loizides	1.11	#include "MitProd/TreeFiller/interface/FillerCaloJets.h"
21			#include "MitProd/TreeFiller/interface/FillerCaloMet.h"
22			#include "MitProd/TreeFiller/interface/FillerConversions.h"
23	bendavid	1.8	#include "MitProd/TreeFiller/interface/FillerConversionElectrons.h"
24			#include "MitProd/TreeFiller/interface/FillerPhotons.h"
25	bendavid	1.12	#include "MitProd/TreeFiller/interface/FillerMCParticles.h"
26	paus	1.13	#include "MitProd/TreeFiller/interface/FillerDecayParts.h"
27			#include "MitProd/TreeFiller/interface/FillerStableParts.h"
28	sixie	1.18	#include "MitProd/TreeFiller/interface/FillerPATMuons.h"
29			#include "MitProd/TreeFiller/interface/FillerPATElectrons.h"
30	loizides	1.21
31	paus	1.1	using namespace std;
32			using namespace edm;
33			using namespace mithep;
34
35	loizides	1.16	mithep::ObjectService *mithep::FillMitTree::os_ = 0;
36
37	loizides	1.9	//--------------------------------------------------------------------------------------------------
38	loizides	1.7	FillMitTree::FillMitTree(const edm::ParameterSet &cfg) :
39			defactive_(cfg.getUntrackedParameter<bool>("defactive",1))
40	paus	1.1	{
41	loizides	1.6	// Constructor.
42	loizides	1.15
43	loizides	1.3	if (!configure(cfg)) {
44			throw edm::Exception(edm::errors::Configuration, "FillMitTree::FillMitTree()\n")
45			<< "Could not configure fillers." << "\n";
46			}
47	paus	1.1	}
48
49	loizides	1.9	//--------------------------------------------------------------------------------------------------
50	paus	1.1	FillMitTree::~FillMitTree()
51			{
52	loizides	1.2	// Destructor: nothing to be done here.
53	paus	1.1	}
54
55	loizides	1.9	//--------------------------------------------------------------------------------------------------
56	loizides	1.17	bool FillMitTree::addActiveFiller(BaseFiller *bf)
57			{
58			// Check if filler is active and add it to list of fillers. Otherwise delete it.
59
60			if (bf->Active()) {
61			fillers_.push_back(bf);
62			return 1;
63			}
64
65			delete bf;
66			bf = 0;
67			return 0;
68			}
69
70			//--------------------------------------------------------------------------------------------------
71	loizides	1.3	void FillMitTree::analyze(const edm::Event &event,
72			const edm::EventSetup &setup)
73			{
74			// Access and copy event content.
75
76	loizides	1.32	// first step: Loop over the data fillers of the various components
77	loizides	1.3	for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
78			(*iF)->FillDataBlock(event,setup);
79			}
80
81	loizides	1.32	// second step: Loop over the link resolution of the various components
82	loizides	1.3	for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
83			(*iF)->ResolveLinks(event,setup);
84			}
85			}
86
87	loizides	1.9	//--------------------------------------------------------------------------------------------------
88	loizides	1.3	void FillMitTree::beginJob(const edm::EventSetup &event)
89	paus	1.1	{
90	loizides	1.2	// Access the tree and book branches.
91
92	paus	1.1	Service<TreeService> ts;
93			TreeWriter *tws = ts->get();
94			if (! tws) {
95			throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
96	loizides	1.17	<< "Could not get pointer to tree. "
97			<< "Do you have the TreeServie define in your config?" << "\n";
98	paus	1.1	return;
99			}
100	loizides	1.16
101			if (os_==0) {
102			Service<ObjectService> os;
103			if (!os.isAvailable()) {
104			throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
105	loizides	1.17	<< "Could not get object service. "
106			<< "Do you have the ObjectService defined in your config?" << "\n";
107	loizides	1.16	return;
108			}
109			os_ = &(*os);
110			}
111
112	loizides	1.32	// loop over the various components and book the branches
113	paus	1.1	for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
114	loizides	1.16	edm::LogInfo("FillMitTree::beginJob") << "Booking for " << (*iF)->Name() << endl;
115	loizides	1.4	(iF)->BookDataBlock(tws);
116	paus	1.1	}
117			}
118
119	loizides	1.9	//--------------------------------------------------------------------------------------------------
120	loizides	1.3	bool FillMitTree::configure(const edm::ParameterSet &cfg)
121	paus	1.1	{
122	loizides	1.32	// Configure our fillers according to given order ("fillerOrder").
123	loizides	1.3
124	loizides	1.32	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	loizides	1.2
142	loizides	1.32	string ftype(next.getUntrackedParameter<string>("fillerType"));
143	loizides	1.11
144	loizides	1.32	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	paus	1.13
258	loizides	1.3	return 1;
259	paus	1.1	}
260
261	loizides	1.9	//--------------------------------------------------------------------------------------------------
262	paus	1.1	void FillMitTree::endJob()
263			{
264	loizides	1.2	// Delete fillers.
265
266			for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
267			delete *iF;
268			}
269
270	paus	1.1	edm::LogInfo("FillMitTree::endJob") << "Ending Job" << endl;
271			}