CMS 3D CMS Logo
RegressionEnergyPatElectronProducer.cc
Go to the documentation of this file.
1 #include "EgammaAnalysis/ElectronTools/plugins/RegressionEnergyPatElectronProducer.h"
2 
3 #include "FWCore/Framework/interface/Frameworkfwd.h"
4 #include "FWCore/Framework/interface/MakerMacros.h"
5 #include "FWCore/MessageLogger/interface/MessageLogger.h"
6 #include "FWCore/ParameterSet/interface/ParameterSet.h"
7 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
8 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
9 #include "FWCore/Framework/interface/ESHandle.h"
10 #include "FWCore/Utilities/interface/EDMException.h"
11 #include "Geometry/CaloEventSetup/interface/CaloTopologyRecord.h"
12 #include "Geometry/Records/interface/CaloGeometryRecord.h"
13 #include "EgammaAnalysis/ElectronTools/interface/SuperClusterHelper.h"
14 
15 #include <iostream>
16 
17 RegressionEnergyPatElectronProducer::RegressionEnergyPatElectronProducer( const edm::ParameterSet & cfg )
18 {
19 
20  inputGsfElectronsToken_ = mayConsume<reco::GsfElectronCollection>(cfg.getParameter<edm::InputTag>("inputElectronsTag"));
21  inputPatElectronsToken_ = mayConsume<pat::ElectronCollection>(cfg.getParameter<edm::InputTag>("inputElectronsTag"));
22  inputCollectionType_ = cfg.getParameter<uint32_t>("inputCollectionType");
23  rhoInputToken_ = consumes<double>(cfg.getParameter<edm::InputTag>("rhoCollection"));
24  verticesInputToken_ = consumes<reco::VertexCollection>(cfg.getParameter<edm::InputTag>("vertexCollection"));
25  energyRegressionType_ = cfg.getParameter<uint32_t>("energyRegressionType");
26  regressionInputFile_ = cfg.getParameter<std::string>("regressionInputFile");
27  recHitCollectionEBToken_ = mayConsume<EcalRecHitCollection>(cfg.getParameter<edm::InputTag>("recHitCollectionEB"));
28  recHitCollectionEEToken_ = mayConsume<EcalRecHitCollection>(cfg.getParameter<edm::InputTag>("recHitCollectionEE"));
29  nameEnergyReg_ = cfg.getParameter<std::string>("nameEnergyReg");
30  nameEnergyErrorReg_ = cfg.getParameter<std::string>("nameEnergyErrorReg");
31  debug_ = cfg.getUntrackedParameter<bool>("debug");
32  useReducedRecHits_ = cfg.getParameter<bool>("useRecHitCollections");
33  produceValueMaps_ = cfg.getParameter<bool>("produceValueMaps");
34 
35  // if Gsf Electrons; useReducedRecHits should be used)
36  if(inputCollectionType_ == 0 && !useReducedRecHits_) {
37  throw cms::Exception("InconsistentParameters") << " *** Inconsistent configuration : if you read GsfElectrons, you should set useRecHitCollections to true and provide the correcte values to recHitCollectionEB and recHitCollectionEE (most probably reducedEcalRecHitsEB and reducedEcalRecHitsEE )" << std::endl;
38  }
39 
40  if(inputCollectionType_ == 0 && !produceValueMaps_) {
41  std::cout << " You are running on GsfElectrons and the producer is not configured to produce ValueMaps with the results. In that case, it does not nothing !! " << std::endl;
42  }
43 
44  if (inputCollectionType_ == 0) {
45  // do nothing
46  } else if (inputCollectionType_ == 1) {
47  produces<pat::ElectronCollection>();
48  } else {
49  throw cms::Exception("InconsistentParameters") << " inputCollectionType should be either 0 (GsfElectrons) or 1 (pat::Electrons) " << std::endl;
50  }
51 
52 
53  //set regression type
54  ElectronEnergyRegressionEvaluate::ElectronEnergyRegressionType type = ElectronEnergyRegressionEvaluate::kNoTrkVar;
55  if (energyRegressionType_ == 1) type = ElectronEnergyRegressionEvaluate::kNoTrkVar;
56  else if (energyRegressionType_ == 2) type = ElectronEnergyRegressionEvaluate::kWithSubCluVar;
57  else if (energyRegressionType_ == 3) type = ElectronEnergyRegressionEvaluate::kWithTrkVar;
58 
59  //load weights and initialize
60  regressionEvaluator_ = new ElectronEnergyRegressionEvaluate();
61  regressionEvaluator_->initialize(regressionInputFile_,type);
62 
63  if(produceValueMaps_) {
64  produces<edm::ValueMap<double> >(nameEnergyReg_);
65  produces<edm::ValueMap<double> >(nameEnergyErrorReg_);
66  }
67 
68 
69  //****************************************************************************************
70  //set up regression calculator
71  //****************************************************************************************
72 
73  geomInitialized_ = false;
74 
75  std::cout << " Finished initialization " << std::endl;
76 
77 }
78 
79 RegressionEnergyPatElectronProducer::~RegressionEnergyPatElectronProducer()
80 {
81  delete regressionEvaluator_;
82 
83 }
84 
85 void RegressionEnergyPatElectronProducer::produce( edm::Event & event, const edm::EventSetup & setup )
86 {
87 
88  assert(regressionEvaluator_->isInitialized());
89  if (!geomInitialized_) {
90  edm::ESHandle<CaloTopology> theCaloTopology;
91  setup.get<CaloTopologyRecord>().get(theCaloTopology);
92  ecalTopology_ = & (*theCaloTopology);
93 
94  edm::ESHandle<CaloGeometry> theCaloGeometry;
95  setup.get<CaloGeometryRecord>().get(theCaloGeometry);
96  caloGeometry_ = & (*theCaloGeometry);
97  geomInitialized_ = true;
98  }
99 
100 
101  //**************************************************************************
102  //Get Number of Vertices
103  //**************************************************************************
104  edm::Handle<reco::VertexCollection> hVertexProduct;
105  event.getByToken(verticesInputToken_,hVertexProduct);
106  const reco::VertexCollection inVertices = *(hVertexProduct.product());
107 
108  // loop through all vertices
109  Int_t nvertices = 0;
110  for (reco::VertexCollection::const_iterator inV = inVertices.begin();
111  inV != inVertices.end(); ++inV) {
112 
113  //pass these vertex cuts
114  if (inV->ndof() >= 4
115  && inV->position().Rho() <= 2.0
116  && fabs(inV->z()) <= 24.0
117  ) {
118  nvertices++;
119  }
120  }
121 
122  //**************************************************************************
123  //Get Rho
124  //**************************************************************************
125  double rho = 0;
126  edm::Handle<double> hRhoKt6PFJets;
127  event.getByToken(rhoInputToken_, hRhoKt6PFJets);
128  rho = (*hRhoKt6PFJets);
129 
130  //*************************************************************************
131  // Get the RecHits
132  //************************************************************************
133 
134  edm::Handle< EcalRecHitCollection > pEBRecHits;
135  edm::Handle< EcalRecHitCollection > pEERecHits;
136  if (useReducedRecHits_) {
137  event.getByToken( recHitCollectionEBToken_, pEBRecHits );
138  event.getByToken( recHitCollectionEEToken_, pEERecHits );
139  }
140 
141  edm::Handle<reco::GsfElectronCollection> gsfCollectionH ;
142  edm::Handle<pat::ElectronCollection> patCollectionH;
143  if ( inputCollectionType_ == 0 ) {
144  event.getByToken ( inputGsfElectronsToken_,gsfCollectionH ) ;
145  nElectrons_ = gsfCollectionH->size();
146  }
147  if ( inputCollectionType_ == 1 ) {
148  event.getByToken ( inputPatElectronsToken_,patCollectionH ) ;
149  nElectrons_ = patCollectionH->size();
150  }
151 
152  // prepare the two even if only one is used
153  std::unique_ptr<pat::ElectronCollection> patElectrons( new pat::ElectronCollection ) ;
154 
155  // Fillers for ValueMaps:
156  std::unique_ptr<edm::ValueMap<double> > regrEnergyMap(new edm::ValueMap<double>() );
157  edm::ValueMap<double>::Filler energyFiller(*regrEnergyMap);
158 
159  std::unique_ptr<edm::ValueMap<double> > regrEnergyErrorMap(new edm::ValueMap<double>() );
160  edm::ValueMap<double>::Filler energyErrorFiller(*regrEnergyErrorMap);
161 
162 
163  // Reserve the vectors with outputs
164  std::vector<double> energyValues;
165  std::vector<double> energyErrorValues;
166  energyValues.reserve(nElectrons_);
167  energyErrorValues.reserve(nElectrons_);
168 
169 
170  for(unsigned iele=0; iele < nElectrons_ ; ++iele) {
171 
172  const reco::GsfElectron * ele = ( inputCollectionType_ == 0 ) ? &(*gsfCollectionH)[iele] : &(*patCollectionH)[iele] ;
173  if (debug_) {
174  std::cout << "***********************************************************************\n";
175  std::cout << "Run Lumi Event: " << event.id().run() << " " << event.luminosityBlock() << " " << event.id().event() << "\n";
176  std::cout << "Pat Electron : " << ele->pt() << " " << ele->eta() << " " << ele->phi() << "\n";
177  }
178 
179  pat::Electron * myPatElectron = (inputCollectionType_ == 0 ) ? nullptr : new pat::Electron((*patCollectionH)[iele]);
180  // Get RecHit Collection
181  const EcalRecHitCollection * recHits=nullptr;
182  if (useReducedRecHits_) {
183  if(ele->isEB()) {
184  recHits = pEBRecHits.product();
185  } else
186  recHits = pEERecHits.product();
187  } else {
188  recHits = (*patCollectionH)[iele].recHits();
189  }
190 
191  SuperClusterHelper * mySCHelper = nullptr ;
192  if ( inputCollectionType_ == 0 ) {
193  mySCHelper = new SuperClusterHelper(&(*ele),recHits,ecalTopology_,caloGeometry_);
194  } else if ( inputCollectionType_ == 1) {
195  mySCHelper = new SuperClusterHelper( &(*patCollectionH)[iele], recHits,ecalTopology_,caloGeometry_);
196  }
197 
198  // apply regression energy
199  Double_t FinalMomentum = 0;
200  Double_t FinalMomentumError = 0;
201  Double_t RegressionMomentum = 0;
202  Double_t RegressionMomentumError = 0;
203 
204  if (energyRegressionType_ == 1) {
205 
206  RegressionMomentum = regressionEvaluator_->regressionValueNoTrkVar( mySCHelper->rawEnergy(),
207  mySCHelper->eta(),
208  mySCHelper->phi(),
209  mySCHelper->r9(),
210  mySCHelper->etaWidth(),
211  mySCHelper->phiWidth(),
212  mySCHelper->clustersSize(),
213  mySCHelper->hadronicOverEm(),
214  rho,
215  nvertices,
216  mySCHelper->seedEta(),
217  mySCHelper->seedPhi(),
218  mySCHelper->seedEnergy(),
219  mySCHelper->e3x3(),
220  mySCHelper->e5x5(),
221  mySCHelper->sigmaIetaIeta(),
222  mySCHelper->spp(),
223  mySCHelper->sep(),
224  mySCHelper->eMax(),
225  mySCHelper->e2nd(),
226  mySCHelper->eTop(),
227  mySCHelper->eBottom(),
228  mySCHelper->eLeft(),
229  mySCHelper->eRight(),
230  mySCHelper->e2x5Max(),
231  mySCHelper->e2x5Top(),
232  mySCHelper->e2x5Bottom(),
233  mySCHelper->e2x5Left(),
234  mySCHelper->e2x5Right(),
235  mySCHelper->ietaSeed(),
236  mySCHelper->iphiSeed(),
237  mySCHelper->etaCrySeed(),
238  mySCHelper->phiCrySeed(),
239  mySCHelper->preshowerEnergyOverRaw(),
240  debug_);
241  RegressionMomentumError = regressionEvaluator_->regressionUncertaintyNoTrkVar(
242  mySCHelper->rawEnergy(),
243  mySCHelper->eta(),
244  mySCHelper->phi(),
245  mySCHelper->r9(),
246  mySCHelper->etaWidth(),
247  mySCHelper->phiWidth(),
248  mySCHelper->clustersSize(),
249  mySCHelper->hadronicOverEm(),
250  rho,
251  nvertices,
252  mySCHelper->seedEta(),
253  mySCHelper->seedPhi(),
254  mySCHelper->seedEnergy(),
255  mySCHelper->e3x3(),
256  mySCHelper->e5x5(),
257  mySCHelper->sigmaIetaIeta(),
258  mySCHelper->spp(),
259  mySCHelper->sep(),
260  mySCHelper->eMax(),
261  mySCHelper->e2nd(),
262  mySCHelper->eTop(),
263  mySCHelper->eBottom(),
264  mySCHelper->eLeft(),
265  mySCHelper->eRight(),
266  mySCHelper->e2x5Max(),
267  mySCHelper->e2x5Top(),
268  mySCHelper->e2x5Bottom(),
269  mySCHelper->e2x5Left(),
270  mySCHelper->e2x5Right(),
271  mySCHelper->ietaSeed(),
272  mySCHelper->iphiSeed(),
273  mySCHelper->etaCrySeed(),
274  mySCHelper->phiCrySeed(),
275  mySCHelper->preshowerEnergyOverRaw(),
276  debug_);
277 
278  // PAT method
279  if(inputCollectionType_ == 1) {
280  myPatElectron->setEcalRegressionEnergy(RegressionMomentum, RegressionMomentumError);
281  }
282  energyValues.push_back(RegressionMomentum);
283  energyErrorValues.push_back(RegressionMomentumError);
284 
285 
286  } else if (energyRegressionType_ == 2) {// ECAL regression with subcluster information
287  RegressionMomentum = regressionEvaluator_->regressionValueWithSubClusters(
288  mySCHelper->rawEnergy(),
289  mySCHelper->eta(),
290  mySCHelper->phi(),
291  mySCHelper->r9(),
292  mySCHelper->etaWidth(),
293  mySCHelper->phiWidth(),
294  mySCHelper->clustersSize(),
295  mySCHelper->hadronicOverEm(),
296  rho,
297  nvertices,
298  mySCHelper->seedEta(),
299  mySCHelper->seedPhi(),
300  mySCHelper->seedEnergy(),
301  mySCHelper->e3x3(),
302  mySCHelper->e5x5(),
303  mySCHelper->sigmaIetaIeta(),
304  mySCHelper->spp(),
305  mySCHelper->sep(),
306  mySCHelper->eMax(),
307  mySCHelper->e2nd(),
308  mySCHelper->eTop(),
309  mySCHelper->eBottom(),
310  mySCHelper->eLeft(),
311  mySCHelper->eRight(),
312  mySCHelper->e2x5Max(),
313  mySCHelper->e2x5Top(),
314  mySCHelper->e2x5Bottom(),
315  mySCHelper->e2x5Left(),
316  mySCHelper->e2x5Right(),
317  mySCHelper->ietaSeed(),
318  mySCHelper->iphiSeed(),
319  mySCHelper->etaCrySeed(),
320  mySCHelper->phiCrySeed(),
321  mySCHelper->preshowerEnergyOverRaw(),
322  ele->ecalDrivenSeed(),
323  ele->isEBEtaGap(),
324  ele->isEBPhiGap(),
325  ele->isEEDeeGap(),
326  mySCHelper->eSubClusters(),
327  mySCHelper->subClusterEnergy(1),
328  mySCHelper->subClusterEta(1),
329  mySCHelper->subClusterPhi(1),
330  mySCHelper->subClusterEmax(1),
331  mySCHelper->subClusterE3x3(1),
332  mySCHelper->subClusterEnergy(2),
333  mySCHelper->subClusterEta(2),
334  mySCHelper->subClusterPhi(2),
335  mySCHelper->subClusterEmax(2),
336  mySCHelper->subClusterE3x3(2),
337  mySCHelper->subClusterEnergy(3),
338  mySCHelper->subClusterEta(3),
339  mySCHelper->subClusterPhi(3),
340  mySCHelper->subClusterEmax(3),
341  mySCHelper->subClusterE3x3(3),
342  mySCHelper->nPreshowerClusters(),
343  mySCHelper->eESClusters(),
344  mySCHelper->esClusterEnergy(0),
345  mySCHelper->esClusterEta(0),
346  mySCHelper->esClusterPhi(0),
347  mySCHelper->esClusterEnergy(1),
348  mySCHelper->esClusterEta(1),
349  mySCHelper->esClusterPhi(1),
350  mySCHelper->esClusterEnergy(2),
351  mySCHelper->esClusterEta(2),
352  mySCHelper->esClusterPhi(2),
353  ele->isEB(),
354  debug_);
355  RegressionMomentumError = regressionEvaluator_->regressionUncertaintyWithSubClusters(
356  mySCHelper->rawEnergy(),
357  mySCHelper->eta(),
358  mySCHelper->phi(),
359  mySCHelper->r9(),
360  mySCHelper->etaWidth(),
361  mySCHelper->phiWidth(),
362  mySCHelper->clustersSize(),
363  mySCHelper->hadronicOverEm(),
364  rho,
365  nvertices,
366  mySCHelper->seedEta(),
367  mySCHelper->seedPhi(),
368  mySCHelper->seedEnergy(),
369  mySCHelper->e3x3(),
370  mySCHelper->e5x5(),
371  mySCHelper->sigmaIetaIeta(),
372  mySCHelper->spp(),
373  mySCHelper->sep(),
374  mySCHelper->eMax(),
375  mySCHelper->e2nd(),
376  mySCHelper->eTop(),
377  mySCHelper->eBottom(),
378  mySCHelper->eLeft(),
379  mySCHelper->eRight(),
380  mySCHelper->e2x5Max(),
381  mySCHelper->e2x5Top(),
382  mySCHelper->e2x5Bottom(),
383  mySCHelper->e2x5Left(),
384  mySCHelper->e2x5Right(),
385  mySCHelper->ietaSeed(),
386  mySCHelper->iphiSeed(),
387  mySCHelper->etaCrySeed(),
388  mySCHelper->phiCrySeed(),
389  mySCHelper->preshowerEnergyOverRaw(),
390  ele->ecalDrivenSeed(),
391  ele->isEBEtaGap(),
392  ele->isEBPhiGap(),
393  ele->isEEDeeGap(),
394  mySCHelper->eSubClusters(),
395  mySCHelper->subClusterEnergy(1),
396  mySCHelper->subClusterEta(1),
397  mySCHelper->subClusterPhi(1),
398  mySCHelper->subClusterEmax(1),
399  mySCHelper->subClusterE3x3(1),
400  mySCHelper->subClusterEnergy(2),
401  mySCHelper->subClusterEta(2),
402  mySCHelper->subClusterPhi(2),
403  mySCHelper->subClusterEmax(2),
404  mySCHelper->subClusterE3x3(2),
405  mySCHelper->subClusterEnergy(3),
406  mySCHelper->subClusterEta(3),
407  mySCHelper->subClusterPhi(3),
408  mySCHelper->subClusterEmax(3),
409  mySCHelper->subClusterE3x3(3),
410  mySCHelper->nPreshowerClusters(),
411  mySCHelper->eESClusters(),
412  mySCHelper->esClusterEnergy(0),
413  mySCHelper->esClusterEta(0),
414  mySCHelper->esClusterPhi(0),
415  mySCHelper->esClusterEnergy(1),
416  mySCHelper->esClusterEta(1),
417  mySCHelper->esClusterPhi(1),
418  mySCHelper->esClusterEnergy(2),
419  mySCHelper->esClusterEta(2),
420  mySCHelper->esClusterPhi(2),
421  ele->isEB(),
422  debug_);
423 
424  // PAT method
425  if(inputCollectionType_ == 1) {
426  myPatElectron->setEcalRegressionEnergy(RegressionMomentum, RegressionMomentumError);
427  }
428  energyValues.push_back(RegressionMomentum);
429  energyErrorValues.push_back(RegressionMomentumError);
430 
431 
432  }
433 
434  else if (energyRegressionType_ == 3) {
435  RegressionMomentum = regressionEvaluator_->regressionValueWithTrkVar(ele->p(),
436  mySCHelper->rawEnergy(),
437  mySCHelper->eta(),
438  mySCHelper->phi(),
439  mySCHelper->etaWidth(),
440  mySCHelper->phiWidth(),
441  mySCHelper->clustersSize(),
442  mySCHelper->hadronicOverEm(),
443  mySCHelper->r9(),
444  rho,
445  nvertices,
446  mySCHelper->seedEta(),
447  mySCHelper->seedPhi(),
448  mySCHelper->seedEnergy(),
449  mySCHelper->e3x3(),
450  mySCHelper->e5x5(),
451  mySCHelper->sigmaIetaIeta(),
452  mySCHelper->spp(),
453  mySCHelper->sep(),
454  mySCHelper->eMax(),
455  mySCHelper->e2nd(),
456  mySCHelper->eTop(),
457  mySCHelper->eBottom(),
458  mySCHelper->eLeft(),
459  mySCHelper->eRight(),
460  mySCHelper->e2x5Max(),
461  mySCHelper->e2x5Top(),
462  mySCHelper->e2x5Bottom(),
463  mySCHelper->e2x5Left(),
464  mySCHelper->e2x5Right(),
465  ele->pt(),
466  ele->trackMomentumAtVtx().R(),
467  ele->fbrem(),
468  ele->charge(),
469  ele->eSuperClusterOverP(),
470  mySCHelper->ietaSeed(),
471  mySCHelper->iphiSeed(),
472  mySCHelper->etaCrySeed(),
473  mySCHelper->phiCrySeed(),
474  mySCHelper->preshowerEnergy(),
475  debug_);
476  RegressionMomentumError = regressionEvaluator_->regressionUncertaintyWithTrkVar(
477  ele->p(),
478  mySCHelper->rawEnergy(),
479  mySCHelper->eta(),
480  mySCHelper->phi(),
481  mySCHelper->etaWidth(),
482  mySCHelper->phiWidth(),
483  mySCHelper->clustersSize(),
484  mySCHelper->hadronicOverEm(),
485  mySCHelper->r9(),
486  rho,
487  nvertices,
488  mySCHelper->seedEta(),
489  mySCHelper->seedPhi(),
490  mySCHelper->seedEnergy(),
491  mySCHelper->e3x3(),
492  mySCHelper->e5x5(),
493  mySCHelper->sigmaIetaIeta(),
494  mySCHelper->spp(),
495  mySCHelper->sep(),
496  mySCHelper->eMax(),
497  mySCHelper->e2nd(),
498  mySCHelper->eTop(),
499  mySCHelper->eBottom(),
500  mySCHelper->eLeft(),
501  mySCHelper->eRight(),
502  mySCHelper->e2x5Max(),
503  mySCHelper->e2x5Top(),
504  mySCHelper->e2x5Bottom(),
505  mySCHelper->e2x5Left(),
506  mySCHelper->e2x5Right(),
507  ele->pt(),
508  ele->trackMomentumAtVtx().R(),
509  ele->fbrem(),
510  ele->charge(),
511  ele->eSuperClusterOverP(),
512  mySCHelper->ietaSeed(),
513  mySCHelper->iphiSeed(),
514  mySCHelper->etaCrySeed(),
515  mySCHelper->phiCrySeed(),
516  mySCHelper->preshowerEnergy(),
517  debug_);
518  FinalMomentum = RegressionMomentum;
519  FinalMomentumError = RegressionMomentumError;
520  const math::XYZTLorentzVector& oldMomentum = ele->p4();
521  math::XYZTLorentzVector newMomentum = math::XYZTLorentzVector
522  ( oldMomentum.x()*FinalMomentum/oldMomentum.t(),
523  oldMomentum.y()*FinalMomentum/oldMomentum.t(),
524  oldMomentum.z()*FinalMomentum/oldMomentum.t(),
525  FinalMomentum ) ;
526 
527  myPatElectron->correctEcalEnergy(RegressionMomentum, RegressionMomentumError);
528  myPatElectron->correctMomentum(newMomentum,ele->trackMomentumError(),FinalMomentumError);
529 
530  energyValues.push_back(RegressionMomentum);
531  energyErrorValues.push_back(RegressionMomentumError);
532  } else {
533  std::cout << "Error: RegressionType = " << energyRegressionType_ << " is not supported.\n";
534  }
535 
536  if(inputCollectionType_ == 1) {
537  patElectrons->push_back(*myPatElectron);
538  }
539  if (myPatElectron) delete myPatElectron;
540  if (mySCHelper) delete mySCHelper;
541  } // loop on electrons
542 
543  // Write the new collection in the event (AOD case)
544  if(inputCollectionType_ == 1) {
545  event.put(std::move(patElectrons));
546  }
547 
548  // now AOD case: write ValueMaps
549  if (produceValueMaps_) {
550 
551  if ( inputCollectionType_ ==0 ) {
552  energyFiller.insert( gsfCollectionH, energyValues.begin(), energyValues.end() );
553  energyErrorFiller.insert( gsfCollectionH, energyErrorValues.begin(), energyErrorValues.end() );
554  } else if ( inputCollectionType_ ==1 ) {
555  energyFiller.insert( patCollectionH, energyValues.begin(), energyValues.end() );
556  energyErrorFiller.insert( patCollectionH, energyErrorValues.begin(), energyErrorValues.end() );
557  }
558 
559  energyFiller.fill();
560  energyErrorFiller.fill();
561  event.put(std::move(regrEnergyMap),nameEnergyReg_);
562  event.put(std::move(regrEnergyErrorMap),nameEnergyErrorReg_);
563  }
564 
565 }
566 
567 
568 #include "FWCore/Framework/interface/MakerMacros.h"
569 #include "FWCore/Framework/interface/ESProducer.h"
570 #include "FWCore/Framework/interface/ModuleFactory.h"
571 DEFINE_FWK_MODULE(RegressionEnergyPatElectronProducer);
type
type
Definition: HCALResponse.h:21
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
reco::GsfElectron::correctEcalEnergy
void correctEcalEnergy(float newEnergy, float newEnergyError)
Definition: GsfElectron.h:853
reco::GsfElectron::trackMomentumError
float trackMomentumError() const
Definition: GsfElectron.h:836
reco::LeafCandidate::eta
double eta() const final
momentum pseudorapidity
Definition: LeafCandidate.h:137
electronProducer_cfi.patElectrons
patElectrons
Definition: electronProducer_cfi.py:3
SuperClusterHelper::eESClusters
float eESClusters() const
Definition: SuperClusterHelper.h:71
SuperClusterHelper::e2x5Max
float e2x5Max() const
Definition: SuperClusterHelper.h:38
reco::GsfElectron::isEBEtaGap
bool isEBEtaGap() const
Definition: GsfElectron.h:357
reco::GsfElectron::p4
const LorentzVector & p4(P4Kind kind) const
Definition: GsfElectron.cc:225
reco::GsfElectron::eSuperClusterOverP
float eSuperClusterOverP() const
Definition: GsfElectron.h:245
SuperClusterHelper::esClusterEnergy
float esClusterEnergy(unsigned i) const
Definition: SuperClusterHelper.cc:160
SuperClusterHelper::sigmaIetaIeta
float sigmaIetaIeta() const
Definition: SuperClusterHelper.h:27
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:17
SuperClusterHelper::subClusterE3x3
float subClusterE3x3(unsigned i) const
Definition: SuperClusterHelper.cc:156
reco::GsfElectron::correctMomentum
void correctMomentum(const LorentzVector &p4, float trackMomentumError, float p4Error)
Definition: GsfElectron.h:858
reco::GsfElectron::trackMomentumAtVtx
math::XYZVectorF trackMomentumAtVtx() const
Definition: GsfElectron.h:291
edm::helper::Filler::insert
void insert(const H &h, I begin, I end)
Definition: ValueMap.h:53
GeneralSetup.setup
def setup(process, global_tag, zero_tesla=False)
Definition: GeneralSetup.py:2
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:131
reco::VertexCollection
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
reco::LeafCandidate::charge
int charge() const final
electric charge
Definition: LeafCandidate.h:91
ElectronEnergyRegressionEvaluate::regressionValueWithTrkVar
double regressionValueWithTrkVar(double electronP, double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double pt, double GsfTrackPIn, double fbrem, double Charge, double EoP, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:1271
reco::GsfElectron::fbrem
float fbrem() const
Definition: GsfElectron.h:761
SuperClusterHelper::eSubClusters
float eSubClusters() const
Definition: SuperClusterHelper.h:64
ElectronEnergyRegressionEvaluate::regressionUncertaintyNoTrkVar
double regressionUncertaintyNoTrkVar(double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:769
nullptr
#define nullptr
RegressionEnergyPatElectronProducer::recHitCollectionEBToken_
edm::EDGetTokenT< EcalRecHitCollection > recHitCollectionEBToken_
Definition: RegressionEnergyPatElectronProducer.h:34
SuperClusterHelper::e2x5Right
float e2x5Right() const
Definition: SuperClusterHelper.h:42
ElectronEnergyRegressionEvaluate::regressionValueWithSubClusters
double regressionValueWithSubClusters(double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, double isEcalDriven, double isEtaGap, double isPhiGap, double isDeeGap, double ESubs, double ESub1, double EtaSub1, double PhiSub1, double EMaxSub1, double E3x3Sub1, double ESub2, double EtaSub2, double PhiSub2, double EMaxSub2, double E3x3Sub2, double ESub3, double EtaSub3, double PhiSub3, double EMaxSub3, double E3x3Sub3, double NPshwClusters, double EPshwSubs, double EPshwSub1, double EtaPshwSub1, double PhiPshwSub1, double EPshwSub2, double EtaPshwSub2, double PhiPshwSub2, double EPshwSub3, double EtaPshwSub3, double PhiPshwSub3, bool isEB, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:3145
reco::GsfElectron::isEEDeeGap
bool isEEDeeGap() const
Definition: GsfElectron.h:360
RegressionEnergyPatElectronProducer::recHitCollectionEEToken_
edm::EDGetTokenT< EcalRecHitCollection > recHitCollectionEEToken_
Definition: RegressionEnergyPatElectronProducer.h:35
SuperClusterHelper::eBottom
float eBottom() const
Definition: SuperClusterHelper.h:35
reco::GsfElectron::isEB
bool isEB() const
Definition: GsfElectron.h:352
SuperClusterHelper::e2x5Bottom
float e2x5Bottom() const
Definition: SuperClusterHelper.h:40
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29
SuperClusterHelper::esClusterEta
float esClusterEta(unsigned i) const
Definition: SuperClusterHelper.cc:164
SuperClusterHelper::etaWidth
float etaWidth() const
Definition: SuperClusterHelper.h:23
SuperClusterHelper::rawEnergy
float rawEnergy() const
Definition: SuperClusterHelper.h:20
SuperClusterHelper::subClusterEnergy
float subClusterEnergy(unsigned i) const
Definition: SuperClusterHelper.cc:140
pat::ElectronCollection
std::vector< Electron > ElectronCollection
Definition: Electron.h:37
RegressionEnergyPatElectronProducer::verticesInputToken_
edm::EDGetTokenT< reco::VertexCollection > verticesInputToken_
Definition: RegressionEnergyPatElectronProducer.h:33
ElectronEnergyRegressionEvaluate::regressionValueNoTrkVar
double regressionValueNoTrkVar(double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:605
SuperClusterHelper::eLeft
float eLeft() const
Definition: SuperClusterHelper.h:36
SuperClusterHelper::preshowerEnergyOverRaw
float preshowerEnergyOverRaw() const
Definition: SuperClusterHelper.h:29
ElectronEnergyRegressionEvaluate::initialize
void initialize(std::string weightsFile, ElectronEnergyRegressionEvaluate::ElectronEnergyRegressionType type)
Definition: ElectronEnergyRegressionEvaluate.cc:29
SuperClusterHelper::eRight
float eRight() const
Definition: SuperClusterHelper.h:37
SuperClusterHelper::e2x5Top
float e2x5Top() const
Definition: SuperClusterHelper.h:39
SuperClusterHelper::preshowerEnergy
float preshowerEnergy() const
Definition: SuperClusterHelper.h:28
SuperClusterHelper::hadronicOverEm
float hadronicOverEm() const
Definition: SuperClusterHelper.h:26
SuperClusterHelper::phiWidth
float phiWidth() const
Definition: SuperClusterHelper.h:24
SuperClusterHelper::subClusterEmax
float subClusterEmax(unsigned i) const
Definition: SuperClusterHelper.cc:152
reco::LeafCandidate::p
double p() const final
magnitude of momentum vector
Definition: LeafCandidate.h:108
RegressionEnergyPatElectronProducer::regressionEvaluator_
ElectronEnergyRegressionEvaluate * regressionEvaluator_
Definition: RegressionEnergyPatElectronProducer.h:49
SuperClusterHelper::esClusterPhi
float esClusterPhi(unsigned i) const
Definition: SuperClusterHelper.cc:168
SuperClusterHelper::subClusterPhi
float subClusterPhi(unsigned i) const
Definition: SuperClusterHelper.cc:148
edm::Handle::product
T const * product() const
Definition: Handle.h:81
ElectronEnergyRegressionEvaluate::regressionUncertaintyWithTrkVar
double regressionUncertaintyWithTrkVar(double electronP, double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double pt, double GsfTrackPIn, double fbrem, double Charge, double EoP, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:1444
SuperClusterHelper::seedEta
float seedEta() const
Definition: SuperClusterHelper.h:47
pat::Electron
Analysis-level electron class.
Definition: Electron.h:52
RegressionEnergyPatElectronProducer::inputGsfElectronsToken_
edm::EDGetTokenT< reco::GsfElectronCollection > inputGsfElectronsToken_
Definition: RegressionEnergyPatElectronProducer.h:30
edm::EventSetup::get
T get() const
Definition: EventSetup.h:68
reco::GsfElectron::isEBPhiGap
bool isEBPhiGap() const
Definition: GsfElectron.h:358
SuperClusterHelper::nPreshowerClusters
float nPreshowerClusters() const
Definition: SuperClusterHelper.h:70
RegressionEnergyPatElectronProducer::produce
void produce(edm::Event &, const edm::EventSetup &) override
Definition: RegressionEnergyPatElectronProducer.cc:85
SuperClusterHelper::seedPhi
float seedPhi() const
Definition: SuperClusterHelper.h:48
gather_cfg.cout
cout
Definition: gather_cfg.py:144
SuperClusterHelper::clustersSize
float clustersSize() const
Definition: SuperClusterHelper.h:25
SuperClusterHelper::subClusterEta
float subClusterEta(unsigned i) const
Definition: SuperClusterHelper.cc:144
SuperClusterHelper::seedEnergy
float seedEnergy() const
Definition: SuperClusterHelper.h:49
ElectronEnergyRegressionEvaluate::regressionUncertaintyWithSubClusters
double regressionUncertaintyWithSubClusters(double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, double isEcalDriven, double isEtaGap, double isPhiGap, double isDeeGap, double ESubs, double ESub1, double EtaSub1, double PhiSub1, double EMaxSub1, double E3x3Sub1, double ESub2, double EtaSub2, double PhiSub2, double EMaxSub2, double E3x3Sub2, double ESub3, double EtaSub3, double PhiSub3, double EMaxSub3, double E3x3Sub3, double NPshwClusters, double EPshwSubs, double EPshwSub1, double EtaPshwSub1, double PhiPshwSub1, double EPshwSub2, double EtaPshwSub2, double PhiPshwSub2, double EPshwSub3, double EtaPshwSub3, double PhiPshwSub3, bool isEB, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:3401
reco::LeafCandidate::phi
double phi() const final
momentum azimuthal angle
Definition: LeafCandidate.h:133
SuperClusterHelper::e2x5Left
float e2x5Left() const
Definition: SuperClusterHelper.h:41
pat::Electron::setEcalRegressionEnergy
void setEcalRegressionEnergy(double val, double err)
set regression1
Definition: Electron.h:241
eostools.move
def move(src, dest)
Definition: eostools.py:511
RegressionEnergyPatElectronProducer::inputPatElectronsToken_
edm::EDGetTokenT< pat::ElectronCollection > inputPatElectronsToken_
Definition: RegressionEnergyPatElectronProducer.h:31
event
Definition: event.py:1
reco::GsfElectron::ecalDrivenSeed
bool ecalDrivenSeed() const
Definition: GsfElectron.h:188
Generated for CMSSW Reference Manual by doxygen 1.8.11