ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitProd/TreeFiller/src/FillMitTree.cc
(Generate patch)

Comparing UserCode/MitProd/TreeFiller/src/FillMitTree.cc (file contents):
Revision 1.4 by loizides, Fri Jun 20 17:52:57 2008 UTC vs.
Revision 1.32 by loizides, Tue Mar 10 15:56:01 2009 UTC

# Line 2 | Line 2
2  
3   #include "MitProd/TreeFiller/interface/FillMitTree.h"
4   #include "FWCore/MessageLogger/interface/MessageLogger.h"
5 + #include "FWCore/ParameterSet/interface/ParameterSet.h"
6   #include "FWCore/ServiceRegistry/interface/Service.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/FillerGlobalMuons.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 < //-------------------------------------------------------------------------------------------------
36 < FillMitTree::FillMitTree(const edm::ParameterSet &cfg)
35 > mithep::ObjectService *mithep::FillMitTree::os_ = 0;
36 >
37 > //--------------------------------------------------------------------------------------------------
38 > FillMitTree::FillMitTree(const edm::ParameterSet &cfg) :
39 >  defactive_(cfg.getUntrackedParameter<bool>("defactive",1))
40   {
41 <  // Constructor: initialize fillers
41 >  // Constructor.
42  
43    if (!configure(cfg)) {
44      throw edm::Exception(edm::errors::Configuration, "FillMitTree::FillMitTree()\n")
# Line 22 | Line 46 | FillMitTree::FillMitTree(const edm::Para
46    }
47   }
48  
49 < //-------------------------------------------------------------------------------------------------
49 > //--------------------------------------------------------------------------------------------------
50   FillMitTree::~FillMitTree()
51   {
52    // Destructor: nothing to be done here.
53   }
54  
55 < //-------------------------------------------------------------------------------------------------
55 > //--------------------------------------------------------------------------------------------------
56 > 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   void FillMitTree::analyze(const edm::Event      &event,
72                            const edm::EventSetup &setup)
73   {
74    // Access and copy event content.
75  
76 <  // First step: Loop over the data fillers of the various components
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.
# Line 54 | Line 93 | void FillMitTree::beginJob(const edm::Ev
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." << "\n";
96 >      << "Could not get pointer to tree. "
97 >      << "Do you have the TreeServie define in your config?" << "\n";
98      return;
99    }
100  
101 <  // Loop over the various components and book the branches
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 < //-------------------------------------------------------------------------------------------------
119 > //--------------------------------------------------------------------------------------------------
120   bool FillMitTree::configure(const edm::ParameterSet &cfg)
121   {
122 <  // Configure our fillers.
122 >  // Configure our fillers according to given order ("fillerOrder").
123  
124 <
125 <  FillerMetaInfos *fillerMetaInfos = new FillerMetaInfos(cfg);
126 <  if (fillerMetaInfos->Active())
127 <    fillers_.push_back(fillerMetaInfos);
128 <  else
129 <    delete fillerMetaInfos;
130 <
131 <  FillerGlobalMuons *fillerGlobalMuons = new FillerGlobalMuons(cfg);
132 <  if (fillerGlobalMuons->Active())
133 <    fillers_.push_back(fillerGlobalMuons);
134 <  else
135 <    delete fillerGlobalMuons;
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 < //-------------------------------------------------------------------------------------------------
261 > //--------------------------------------------------------------------------------------------------
262   void FillMitTree::endJob()
263   {
264    // Delete fillers.

Diff Legend

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