CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Private Attributes
RegressionEnergyPatElectronProducer Class Reference

#include <RegressionEnergyPatElectronProducer.h>

Inheritance diagram for RegressionEnergyPatElectronProducer:
edm::EDProducer edm::ProducerBase edm::ProductRegistryHelper

Public Member Functions

virtual void produce (edm::Event &, const edm::EventSetup &)
 
 RegressionEnergyPatElectronProducer (const edm::ParameterSet &)
 
virtual ~RegressionEnergyPatElectronProducer ()
 
- Public Member Functions inherited from edm::EDProducer
 EDProducer ()
 
virtual ~EDProducer ()
 
- Public Member Functions inherited from edm::ProducerBase
 ProducerBase ()
 
void registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
 
boost::function< void(const
BranchDescription &)> 		registrationCallback () const
 used by the fwk to register list of products More...
 
virtual ~ProducerBase ()
 

Private Attributes

const CaloGeometry * caloGeometry_
 
bool debug_
 
const CaloTopology * ecalTopology_
 
uint32_t energyRegressionType_
 
bool geomInitialized_
 
uint32_t inputCollectionType_
 
edm::InputTag inputElectrons_
 
std::string nameEnergyErrorReg_
 
std::string nameEnergyReg_
 
unsigned nElectrons_
 
bool producePatElectrons_
 
bool produceValueMaps_
 
edm::InputTag recHitCollectionEB_
 
edm::InputTag recHitCollectionEE_
 
ElectronEnergyRegressionEvaluate * regressionEvaluator_
 
std::string regressionInputFile_
 
edm::InputTag rhoInputTag_
 
bool useReducedRecHits_
 
edm::InputTag verticesInputTag_
 

Additional Inherited Members

- Public Types inherited from edm::EDProducer
typedef EDProducer ModuleType
 
typedef WorkerT< EDProducer > WorkerType
 
- Public Types inherited from edm::ProducerBase
typedef
ProductRegistryHelper::TypeLabelList 		TypeLabelList
 
- Static Public Member Functions inherited from edm::EDProducer
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &descriptions)
 
- Protected Member Functions inherited from edm::EDProducer
CurrentProcessingContext const * currentContext () const
 
- Protected Member Functions inherited from edm::ProducerBase
template<class TProducer , class TMethod >
void callWhenNewProductsRegistered (TProducer *iProd, TMethod iMethod)
 

Detailed Description

Definition at line 16 of file RegressionEnergyPatElectronProducer.h.

Constructor & Destructor Documentation

RegressionEnergyPatElectronProducer::RegressionEnergyPatElectronProducer ( const edm::ParameterSet &  cfg)
explicit

Definition at line 26 of file RegressionEnergyPatElectronProducer.cc.

References gather_cfg::cout, edm::hlt::Exception, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), ElectronEnergyRegressionEvaluate::kNoTrkVar, ElectronEnergyRegressionEvaluate::kWithSubCluVar, and ElectronEnergyRegressionEvaluate::kWithTrkVar.

27 {
28 
29  inputElectrons_ = cfg.getParameter<edm::InputTag>("inputElectronsTag");
30  inputCollectionType_ = cfg.getParameter<uint32_t>("inputCollectionType");
31  rhoInputTag_ = cfg.getParameter<edm::InputTag>("rhoCollection");
32  verticesInputTag_ = cfg.getParameter<edm::InputTag>("vertexCollection");
33  energyRegressionType_ = cfg.getParameter<uint32_t>("energyRegressionType");
34  regressionInputFile_ = cfg.getParameter<std::string>("regressionInputFile");
35  recHitCollectionEB_ = cfg.getParameter<edm::InputTag>("recHitCollectionEB");
36  recHitCollectionEE_ = cfg.getParameter<edm::InputTag>("recHitCollectionEE");
37  nameEnergyReg_ = cfg.getParameter<std::string>("nameEnergyReg");
38  nameEnergyErrorReg_ = cfg.getParameter<std::string>("nameEnergyErrorReg");
39  debug_ = cfg.getUntrackedParameter<bool>("debug");
40  useReducedRecHits_ = cfg.getParameter<bool>("useRecHitCollections");
41  produceValueMaps_ = cfg.getParameter<bool>("produceValueMaps");
42 
43  // if Gsf Electrons; useReducedRecHits should be used)
44  if(inputCollectionType_ == 0 && !useReducedRecHits_) {
45  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;
46  }
47 
48  if(inputCollectionType_ == 0 && !produceValueMaps_) {
49  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;
50  }
51 
52  if (inputCollectionType_ == 0) {
53  // do nothing
54  } else if (inputCollectionType_ == 1) {
55  produces<ElectronCollection>();
56  } else {
57  throw cms::Exception("InconsistentParameters") << " inputCollectionType should be either 0 (GsfElectrons) or 1 (pat::Electrons) " << std::endl;
58  }
59 
60 
61  //set regression type
62  ElectronEnergyRegressionEvaluate::ElectronEnergyRegressionType type = ElectronEnergyRegressionEvaluate::kNoTrkVar;
63  if (energyRegressionType_ == 1) type = ElectronEnergyRegressionEvaluate::kNoTrkVar;
64  else if (energyRegressionType_ == 2) type = ElectronEnergyRegressionEvaluate::kWithSubCluVar;
65  else if (energyRegressionType_ == 3) type = ElectronEnergyRegressionEvaluate::kWithTrkVar;
66 
67  //load weights and initialize
68  regressionEvaluator_ = new ElectronEnergyRegressionEvaluate();
69  regressionEvaluator_->initialize(regressionInputFile_.c_str(),type);
70 
71  if(produceValueMaps_) {
72  produces<edm::ValueMap<double> >(nameEnergyReg_);
73  produces<edm::ValueMap<double> >(nameEnergyErrorReg_);
74  }
75 
76 
77  //****************************************************************************************
78  //set up regression calculator
79  //****************************************************************************************
80 
81  geomInitialized_ = false;
82 
83  std::cout << " Finished initialization " << std::endl;
84 
85 }
type
type
Definition: HCALResponse.h:22
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
ElectronEnergyRegressionEvaluate::initialize
void initialize(std::string weightsFile, ElectronEnergyRegressionEvaluate::ElectronEnergyRegressionType type)
Definition: ElectronEnergyRegressionEvaluate.cc:29
RegressionEnergyPatElectronProducer::regressionEvaluator_
ElectronEnergyRegressionEvaluate * regressionEvaluator_
Definition: RegressionEnergyPatElectronProducer.h:45
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
RegressionEnergyPatElectronProducer::~RegressionEnergyPatElectronProducer ( )
virtual

Definition at line 87 of file RegressionEnergyPatElectronProducer.cc.

88 {
89  delete regressionEvaluator_;
90 
91 }
RegressionEnergyPatElectronProducer::regressionEvaluator_
ElectronEnergyRegressionEvaluate * regressionEvaluator_
Definition: RegressionEnergyPatElectronProducer.h:45

Member Function Documentation

void RegressionEnergyPatElectronProducer::produce ( edm::Event &  event,
const edm::EventSetup &  setup 
)
virtual

Implements edm::EDProducer.

Definition at line 93 of file RegressionEnergyPatElectronProducer.cc.

References reco::LeafCandidate::charge(), SuperClusterHelper::clustersSize(), reco::GsfElectron::correctEcalEnergy(), reco::GsfElectron::correctMomentum(), gather_cfg::cout, SuperClusterHelper::e2nd(), SuperClusterHelper::e2x5Bottom(), SuperClusterHelper::e2x5Left(), SuperClusterHelper::e2x5Max(), SuperClusterHelper::e2x5Right(), SuperClusterHelper::e2x5Top(), SuperClusterHelper::e3x3(), SuperClusterHelper::e5x5(), SuperClusterHelper::eBottom(), reco::GsfElectron::ecalDrivenSeed(), SuperClusterHelper::eESClusters(), SuperClusterHelper::eLeft(), SuperClusterHelper::eMax(), SuperClusterHelper::eRight(), SuperClusterHelper::esClusterEnergy(), SuperClusterHelper::esClusterEta(), SuperClusterHelper::esClusterPhi(), SuperClusterHelper::eSubClusters(), reco::GsfElectron::eSuperClusterOverP(), SuperClusterHelper::eta(), reco::LeafCandidate::eta(), SuperClusterHelper::etaCrySeed(), SuperClusterHelper::etaWidth(), SuperClusterHelper::eTop(), reco::GsfElectron::fbrem(), edm::helper::Filler< Map >::fill(), edm::EventSetup::get(), SuperClusterHelper::hadronicOverEm(), SuperClusterHelper::ietaSeed(), edm::helper::Filler< Map >::insert(), SuperClusterHelper::iphiSeed(), reco::GsfElectron::isEB(), reco::GsfElectron::isEBEtaGap(), reco::GsfElectron::isEBPhiGap(), reco::GsfElectron::isEEDeeGap(), SuperClusterHelper::nPreshowerClusters(), reco::LeafCandidate::p(), reco::GsfElectron::p4(), electronProducer_cfi::patElectrons, SuperClusterHelper::phi(), reco::LeafCandidate::phi(), SuperClusterHelper::phiCrySeed(), SuperClusterHelper::phiWidth(), SuperClusterHelper::preshowerEnergy(), SuperClusterHelper::preshowerEnergyOverRaw(), edm::Handle< T >::product(), reco::LeafCandidate::pt(), SuperClusterHelper::r9(), SuperClusterHelper::rawEnergy(), rho, SuperClusterHelper::seedEnergy(), SuperClusterHelper::seedEta(), SuperClusterHelper::seedPhi(), SuperClusterHelper::sep(), pat::Electron::setEcalRegressionEnergy(), SuperClusterHelper::sigmaIetaIeta(), SuperClusterHelper::spp(), SuperClusterHelper::subClusterE3x3(), SuperClusterHelper::subClusterEmax(), SuperClusterHelper::subClusterEnergy(), SuperClusterHelper::subClusterEta(), SuperClusterHelper::subClusterPhi(), reco::GsfElectron::trackMomentumAtVtx(), and reco::GsfElectron::trackMomentumError().

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

94 {
95 
96  assert(regressionEvaluator_->isInitialized());
97  if (!geomInitialized_) {
98  edm::ESHandle<CaloTopology> theCaloTopology;
99  setup.get<CaloTopologyRecord>().get(theCaloTopology);
100  ecalTopology_ = & (*theCaloTopology);
101 
102  edm::ESHandle<CaloGeometry> theCaloGeometry;
103  setup.get<CaloGeometryRecord>().get(theCaloGeometry);
104  caloGeometry_ = & (*theCaloGeometry);
105  geomInitialized_ = true;
106  }
107 
108 
109  //**************************************************************************
110  //Get Number of Vertices
111  //**************************************************************************
112  Handle<reco::VertexCollection> hVertexProduct;
113  event.getByLabel(verticesInputTag_,hVertexProduct);
114  const reco::VertexCollection inVertices = *(hVertexProduct.product());
115 
116  // loop through all vertices
117  Int_t nvertices = 0;
118  for (reco::VertexCollection::const_iterator inV = inVertices.begin();
119  inV != inVertices.end(); ++inV) {
120 
121  //pass these vertex cuts
122  if (inV->ndof() >= 4
123  && inV->position().Rho() <= 2.0
124  && fabs(inV->z()) <= 24.0
125  ) {
126  nvertices++;
127  }
128  }
129 
130  //**************************************************************************
131  //Get Rho
132  //**************************************************************************
133  double rho = 0;
134  Handle<double> hRhoKt6PFJets;
135  event.getByLabel(rhoInputTag_, hRhoKt6PFJets);
136  rho = (*hRhoKt6PFJets);
137 
138  //*************************************************************************
139  // Get the RecHits
140  //************************************************************************
141 
142  edm::Handle< EcalRecHitCollection > pEBRecHits;
143  edm::Handle< EcalRecHitCollection > pEERecHits;
144  if (useReducedRecHits_) {
145  event.getByLabel( recHitCollectionEB_, pEBRecHits );
146  event.getByLabel( recHitCollectionEE_, pEERecHits );
147  }
148 
149  edm::Handle<GsfElectronCollection> gsfCollectionH ;
150  edm::Handle<ElectronCollection> patCollectionH;
151  if ( inputCollectionType_ == 0 ) {
152  event.getByLabel ( inputElectrons_,gsfCollectionH ) ;
153  nElectrons_ = gsfCollectionH->size();
154  }
155  if ( inputCollectionType_ == 1 ) {
156  event.getByLabel ( inputElectrons_,patCollectionH ) ;
157  nElectrons_ = patCollectionH->size();
158  }
159 
160  // prepare the two even if only one is used
161  std::auto_ptr<ElectronCollection> patElectrons( new ElectronCollection ) ;
162 
163  // Fillers for ValueMaps:
164  std::auto_ptr<edm::ValueMap<double> > regrEnergyMap(new edm::ValueMap<double>() );
165  edm::ValueMap<double>::Filler energyFiller(*regrEnergyMap);
166 
167  std::auto_ptr<edm::ValueMap<double> > regrEnergyErrorMap(new edm::ValueMap<double>() );
168  edm::ValueMap<double>::Filler energyErrorFiller(*regrEnergyErrorMap);
169 
170 
171  // Reserve the vectors with outputs
172  std::vector<double> energyValues;
173  std::vector<double> energyErrorValues;
174  energyValues.reserve(nElectrons_);
175  energyErrorValues.reserve(nElectrons_);
176 
177 
178  for(unsigned iele=0; iele < nElectrons_ ; ++iele) {
179 
180  const GsfElectron * ele = ( inputCollectionType_ == 0 ) ? &(*gsfCollectionH)[iele] : &(*patCollectionH)[iele] ;
181  if (debug_) {
182  std::cout << "***********************************************************************\n";
183  std::cout << "Run Lumi Event: " << event.id().run() << " " << event.luminosityBlock() << " " << event.id().event() << "\n";
184  std::cout << "Pat Electron : " << ele->pt() << " " << ele->eta() << " " << ele->phi() << "\n";
185  }
186 
187  pat::Electron * myPatElectron = (inputCollectionType_ == 0 ) ? 0 : new pat::Electron((*patCollectionH)[iele]);
188  // Get RecHit Collection
189  const EcalRecHitCollection * recHits=0;
190  if (useReducedRecHits_) {
191  if(ele->isEB()) {
192  recHits = pEBRecHits.product();
193  } else
194  recHits = pEERecHits.product();
195  } else {
196  recHits = (*patCollectionH)[iele].recHits();
197  }
198 
199  SuperClusterHelper * mySCHelper = 0 ;
200  if ( inputCollectionType_ == 0 ) {
201  mySCHelper = new SuperClusterHelper(&(*ele),recHits,ecalTopology_,caloGeometry_);
202  } else if ( inputCollectionType_ == 1) {
203  mySCHelper = new SuperClusterHelper( &(*patCollectionH)[iele], recHits,ecalTopology_,caloGeometry_);
204  }
205 
206  // apply regression energy
207  Double_t FinalMomentum = 0;
208  Double_t FinalMomentumError = 0;
209  Double_t RegressionMomentum = 0;
210  Double_t RegressionMomentumError = 0;
211 
212  if (energyRegressionType_ == 1) {
213 
214  RegressionMomentum = regressionEvaluator_->regressionValueNoTrkVar( mySCHelper->rawEnergy(),
215  mySCHelper->eta(),
216  mySCHelper->phi(),
217  mySCHelper->r9(),
218  mySCHelper->etaWidth(),
219  mySCHelper->phiWidth(),
220  mySCHelper->clustersSize(),
221  mySCHelper->hadronicOverEm(),
222  rho,
223  nvertices,
224  mySCHelper->seedEta(),
225  mySCHelper->seedPhi(),
226  mySCHelper->seedEnergy(),
227  mySCHelper->e3x3(),
228  mySCHelper->e5x5(),
229  mySCHelper->sigmaIetaIeta(),
230  mySCHelper->spp(),
231  mySCHelper->sep(),
232  mySCHelper->eMax(),
233  mySCHelper->e2nd(),
234  mySCHelper->eTop(),
235  mySCHelper->eBottom(),
236  mySCHelper->eLeft(),
237  mySCHelper->eRight(),
238  mySCHelper->e2x5Max(),
239  mySCHelper->e2x5Top(),
240  mySCHelper->e2x5Bottom(),
241  mySCHelper->e2x5Left(),
242  mySCHelper->e2x5Right(),
243  mySCHelper->ietaSeed(),
244  mySCHelper->iphiSeed(),
245  mySCHelper->etaCrySeed(),
246  mySCHelper->phiCrySeed(),
247  mySCHelper->preshowerEnergyOverRaw(),
248  debug_);
249  RegressionMomentumError = regressionEvaluator_->regressionUncertaintyNoTrkVar(
250  mySCHelper->rawEnergy(),
251  mySCHelper->eta(),
252  mySCHelper->phi(),
253  mySCHelper->r9(),
254  mySCHelper->etaWidth(),
255  mySCHelper->phiWidth(),
256  mySCHelper->clustersSize(),
257  mySCHelper->hadronicOverEm(),
258  rho,
259  nvertices,
260  mySCHelper->seedEta(),
261  mySCHelper->seedPhi(),
262  mySCHelper->seedEnergy(),
263  mySCHelper->e3x3(),
264  mySCHelper->e5x5(),
265  mySCHelper->sigmaIetaIeta(),
266  mySCHelper->spp(),
267  mySCHelper->sep(),
268  mySCHelper->eMax(),
269  mySCHelper->e2nd(),
270  mySCHelper->eTop(),
271  mySCHelper->eBottom(),
272  mySCHelper->eLeft(),
273  mySCHelper->eRight(),
274  mySCHelper->e2x5Max(),
275  mySCHelper->e2x5Top(),
276  mySCHelper->e2x5Bottom(),
277  mySCHelper->e2x5Left(),
278  mySCHelper->e2x5Right(),
279  mySCHelper->ietaSeed(),
280  mySCHelper->iphiSeed(),
281  mySCHelper->etaCrySeed(),
282  mySCHelper->phiCrySeed(),
283  mySCHelper->preshowerEnergyOverRaw(),
284  debug_);
285 
286  // PAT method
287  if(inputCollectionType_ == 1) {
288  myPatElectron->setEcalRegressionEnergy(RegressionMomentum, RegressionMomentumError);
289  }
290  energyValues.push_back(RegressionMomentum);
291  energyErrorValues.push_back(RegressionMomentumError);
292 
293 
294  } else if (energyRegressionType_ == 2) {// ECAL regression with subcluster information
295  RegressionMomentum = regressionEvaluator_->regressionValueWithSubClusters(
296  mySCHelper->rawEnergy(),
297  mySCHelper->eta(),
298  mySCHelper->phi(),
299  mySCHelper->r9(),
300  mySCHelper->etaWidth(),
301  mySCHelper->phiWidth(),
302  mySCHelper->clustersSize(),
303  mySCHelper->hadronicOverEm(),
304  rho,
305  nvertices,
306  mySCHelper->seedEta(),
307  mySCHelper->seedPhi(),
308  mySCHelper->seedEnergy(),
309  mySCHelper->e3x3(),
310  mySCHelper->e5x5(),
311  mySCHelper->sigmaIetaIeta(),
312  mySCHelper->spp(),
313  mySCHelper->sep(),
314  mySCHelper->eMax(),
315  mySCHelper->e2nd(),
316  mySCHelper->eTop(),
317  mySCHelper->eBottom(),
318  mySCHelper->eLeft(),
319  mySCHelper->eRight(),
320  mySCHelper->e2x5Max(),
321  mySCHelper->e2x5Top(),
322  mySCHelper->e2x5Bottom(),
323  mySCHelper->e2x5Left(),
324  mySCHelper->e2x5Right(),
325  mySCHelper->ietaSeed(),
326  mySCHelper->iphiSeed(),
327  mySCHelper->etaCrySeed(),
328  mySCHelper->phiCrySeed(),
329  mySCHelper->preshowerEnergyOverRaw(),
330  ele->ecalDrivenSeed(),
331  ele->isEBEtaGap(),
332  ele->isEBPhiGap(),
333  ele->isEEDeeGap(),
334  mySCHelper->eSubClusters(),
335  mySCHelper->subClusterEnergy(1),
336  mySCHelper->subClusterEta(1),
337  mySCHelper->subClusterPhi(1),
338  mySCHelper->subClusterEmax(1),
339  mySCHelper->subClusterE3x3(1),
340  mySCHelper->subClusterEnergy(2),
341  mySCHelper->subClusterEta(2),
342  mySCHelper->subClusterPhi(2),
343  mySCHelper->subClusterEmax(2),
344  mySCHelper->subClusterE3x3(2),
345  mySCHelper->subClusterEnergy(3),
346  mySCHelper->subClusterEta(3),
347  mySCHelper->subClusterPhi(3),
348  mySCHelper->subClusterEmax(3),
349  mySCHelper->subClusterE3x3(3),
350  mySCHelper->nPreshowerClusters(),
351  mySCHelper->eESClusters(),
352  mySCHelper->esClusterEnergy(0),
353  mySCHelper->esClusterEta(0),
354  mySCHelper->esClusterPhi(0),
355  mySCHelper->esClusterEnergy(1),
356  mySCHelper->esClusterEta(1),
357  mySCHelper->esClusterPhi(1),
358  mySCHelper->esClusterEnergy(2),
359  mySCHelper->esClusterEta(2),
360  mySCHelper->esClusterPhi(2),
361  ele->isEB(),
362  debug_);
363  RegressionMomentumError = regressionEvaluator_->regressionUncertaintyWithSubClusters(
364  mySCHelper->rawEnergy(),
365  mySCHelper->eta(),
366  mySCHelper->phi(),
367  mySCHelper->r9(),
368  mySCHelper->etaWidth(),
369  mySCHelper->phiWidth(),
370  mySCHelper->clustersSize(),
371  mySCHelper->hadronicOverEm(),
372  rho,
373  nvertices,
374  mySCHelper->seedEta(),
375  mySCHelper->seedPhi(),
376  mySCHelper->seedEnergy(),
377  mySCHelper->e3x3(),
378  mySCHelper->e5x5(),
379  mySCHelper->sigmaIetaIeta(),
380  mySCHelper->spp(),
381  mySCHelper->sep(),
382  mySCHelper->eMax(),
383  mySCHelper->e2nd(),
384  mySCHelper->eTop(),
385  mySCHelper->eBottom(),
386  mySCHelper->eLeft(),
387  mySCHelper->eRight(),
388  mySCHelper->e2x5Max(),
389  mySCHelper->e2x5Top(),
390  mySCHelper->e2x5Bottom(),
391  mySCHelper->e2x5Left(),
392  mySCHelper->e2x5Right(),
393  mySCHelper->ietaSeed(),
394  mySCHelper->iphiSeed(),
395  mySCHelper->etaCrySeed(),
396  mySCHelper->phiCrySeed(),
397  mySCHelper->preshowerEnergyOverRaw(),
398  ele->ecalDrivenSeed(),
399  ele->isEBEtaGap(),
400  ele->isEBPhiGap(),
401  ele->isEEDeeGap(),
402  mySCHelper->eSubClusters(),
403  mySCHelper->subClusterEnergy(1),
404  mySCHelper->subClusterEta(1),
405  mySCHelper->subClusterPhi(1),
406  mySCHelper->subClusterEmax(1),
407  mySCHelper->subClusterE3x3(1),
408  mySCHelper->subClusterEnergy(2),
409  mySCHelper->subClusterEta(2),
410  mySCHelper->subClusterPhi(2),
411  mySCHelper->subClusterEmax(2),
412  mySCHelper->subClusterE3x3(2),
413  mySCHelper->subClusterEnergy(3),
414  mySCHelper->subClusterEta(3),
415  mySCHelper->subClusterPhi(3),
416  mySCHelper->subClusterEmax(3),
417  mySCHelper->subClusterE3x3(3),
418  mySCHelper->nPreshowerClusters(),
419  mySCHelper->eESClusters(),
420  mySCHelper->esClusterEnergy(0),
421  mySCHelper->esClusterEta(0),
422  mySCHelper->esClusterPhi(0),
423  mySCHelper->esClusterEnergy(1),
424  mySCHelper->esClusterEta(1),
425  mySCHelper->esClusterPhi(1),
426  mySCHelper->esClusterEnergy(2),
427  mySCHelper->esClusterEta(2),
428  mySCHelper->esClusterPhi(2),
429  ele->isEB(),
430  debug_);
431 
432  // PAT method
433  if(inputCollectionType_ == 1) {
434  myPatElectron->setEcalRegressionEnergy(RegressionMomentum, RegressionMomentumError);
435  }
436  energyValues.push_back(RegressionMomentum);
437  energyErrorValues.push_back(RegressionMomentumError);
438 
439 
440  }
441 
442  else if (energyRegressionType_ == 3) {
443  RegressionMomentum = regressionEvaluator_->regressionValueWithTrkVar(ele->p(),
444  mySCHelper->rawEnergy(),
445  mySCHelper->eta(),
446  mySCHelper->phi(),
447  mySCHelper->etaWidth(),
448  mySCHelper->phiWidth(),
449  mySCHelper->clustersSize(),
450  mySCHelper->hadronicOverEm(),
451  mySCHelper->r9(),
452  rho,
453  nvertices,
454  mySCHelper->seedEta(),
455  mySCHelper->seedPhi(),
456  mySCHelper->seedEnergy(),
457  mySCHelper->e3x3(),
458  mySCHelper->e5x5(),
459  mySCHelper->sigmaIetaIeta(),
460  mySCHelper->spp(),
461  mySCHelper->sep(),
462  mySCHelper->eMax(),
463  mySCHelper->e2nd(),
464  mySCHelper->eTop(),
465  mySCHelper->eBottom(),
466  mySCHelper->eLeft(),
467  mySCHelper->eRight(),
468  mySCHelper->e2x5Max(),
469  mySCHelper->e2x5Top(),
470  mySCHelper->e2x5Bottom(),
471  mySCHelper->e2x5Left(),
472  mySCHelper->e2x5Right(),
473  ele->pt(),
474  ele->trackMomentumAtVtx().R(),
475  ele->fbrem(),
476  ele->charge(),
477  ele->eSuperClusterOverP(),
478  mySCHelper->ietaSeed(),
479  mySCHelper->iphiSeed(),
480  mySCHelper->etaCrySeed(),
481  mySCHelper->phiCrySeed(),
482  mySCHelper->preshowerEnergy(),
483  debug_);
484  RegressionMomentumError = regressionEvaluator_->regressionUncertaintyWithTrkVar(
485  ele->p(),
486  mySCHelper->rawEnergy(),
487  mySCHelper->eta(),
488  mySCHelper->phi(),
489  mySCHelper->etaWidth(),
490  mySCHelper->phiWidth(),
491  mySCHelper->clustersSize(),
492  mySCHelper->hadronicOverEm(),
493  mySCHelper->r9(),
494  rho,
495  nvertices,
496  mySCHelper->seedEta(),
497  mySCHelper->seedPhi(),
498  mySCHelper->seedEnergy(),
499  mySCHelper->e3x3(),
500  mySCHelper->e5x5(),
501  mySCHelper->sigmaIetaIeta(),
502  mySCHelper->spp(),
503  mySCHelper->sep(),
504  mySCHelper->eMax(),
505  mySCHelper->e2nd(),
506  mySCHelper->eTop(),
507  mySCHelper->eBottom(),
508  mySCHelper->eLeft(),
509  mySCHelper->eRight(),
510  mySCHelper->e2x5Max(),
511  mySCHelper->e2x5Top(),
512  mySCHelper->e2x5Bottom(),
513  mySCHelper->e2x5Left(),
514  mySCHelper->e2x5Right(),
515  ele->pt(),
516  ele->trackMomentumAtVtx().R(),
517  ele->fbrem(),
518  ele->charge(),
519  ele->eSuperClusterOverP(),
520  mySCHelper->ietaSeed(),
521  mySCHelper->iphiSeed(),
522  mySCHelper->etaCrySeed(),
523  mySCHelper->phiCrySeed(),
524  mySCHelper->preshowerEnergy(),
525  debug_);
526  FinalMomentum = RegressionMomentum;
527  FinalMomentumError = RegressionMomentumError;
528  math::XYZTLorentzVector oldMomentum = ele->p4();
529  math::XYZTLorentzVector newMomentum = math::XYZTLorentzVector
530  ( oldMomentum.x()*FinalMomentum/oldMomentum.t(),
531  oldMomentum.y()*FinalMomentum/oldMomentum.t(),
532  oldMomentum.z()*FinalMomentum/oldMomentum.t(),
533  FinalMomentum ) ;
534 
535  myPatElectron->correctEcalEnergy(RegressionMomentum, RegressionMomentumError);
536  myPatElectron->correctMomentum(newMomentum,ele->trackMomentumError(),FinalMomentumError);
537 
538  energyValues.push_back(RegressionMomentum);
539  energyErrorValues.push_back(RegressionMomentumError);
540  } else {
541  cout << "Error: RegressionType = " << energyRegressionType_ << " is not supported.\n";
542  }
543 
544  if(inputCollectionType_ == 1) {
545  patElectrons->push_back(*myPatElectron);
546  }
547  if (myPatElectron) delete myPatElectron;
548  if (mySCHelper) delete mySCHelper;
549  } // loop on electrons
550 
551  // Write the new collection in the event (AOD case)
552  if(inputCollectionType_ == 1) {
553  event.put(patElectrons) ;
554  }
555 
556  // now AOD case: write ValueMaps
557  if (produceValueMaps_) {
558 
559  if ( inputCollectionType_ ==0 ) {
560  energyFiller.insert( gsfCollectionH, energyValues.begin(), energyValues.end() );
561  energyErrorFiller.insert( gsfCollectionH, energyErrorValues.begin(), energyErrorValues.end() );
562  } else if ( inputCollectionType_ ==1 ) {
563  energyFiller.insert( patCollectionH, energyValues.begin(), energyValues.end() );
564  energyErrorFiller.insert( patCollectionH, energyErrorValues.begin(), energyErrorValues.end() );
565  }
566 
567  energyFiller.fill();
568  energyErrorFiller.fill();
569  event.put(regrEnergyMap,nameEnergyReg_);
570  event.put(regrEnergyErrorMap,nameEnergyErrorReg_);
571  }
572 
573 }
reco::GsfElectron::correctEcalEnergy
void correctEcalEnergy(float newEnergy, float newEnergyError)
Definition: GsfElectron.h:729
reco::LeafCandidate::p
virtual double p() const
magnitude of momentum vector
Definition: LeafCandidate.h:117
reco::GsfElectron::trackMomentumError
float trackMomentumError() const
Definition: GsfElectron.h:715
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:335
reco::GsfElectron::p4
const LorentzVector & p4(P4Kind kind) const
Definition: GsfElectron.cc:204
reco::GsfElectron::eSuperClusterOverP
float eSuperClusterOverP() const
Definition: GsfElectron.h:229
SuperClusterHelper::esClusterEnergy
float esClusterEnergy(unsigned i) const
Definition: SuperClusterHelper.cc:160
SuperClusterHelper::sigmaIetaIeta
float sigmaIetaIeta() const
Definition: SuperClusterHelper.h:27
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:734
reco::GsfElectron::trackMomentumAtVtx
math::XYZVectorF trackMomentumAtVtx() const
Definition: GsfElectron.h:272
rho
Definition: DDAxes.h:10
reco::VertexCollection
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
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:639
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
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:338
reco::LeafCandidate::eta
virtual double eta() const
momentum pseudorapidity
Definition: LeafCandidate.h:143
SuperClusterHelper::eBottom
float eBottom() const
Definition: SuperClusterHelper.h:35
reco::GsfElectron::isEB
bool isEB() const
Definition: GsfElectron.h:330
SuperClusterHelper::e2x5Bottom
float e2x5Bottom() const
Definition: SuperClusterHelper.h:40
electronProducer_cfi.patElectrons
tuple patElectrons
Definition: electronProducer_cfi.py:3
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:30
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
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
reco::LeafCandidate::charge
virtual int charge() const
electric charge
Definition: LeafCandidate.h:100
SuperClusterHelper::eRight
float eRight() const
Definition: SuperClusterHelper.h:37
SuperClusterHelper::e2x5Top
float e2x5Top() const
Definition: SuperClusterHelper.h:39
reco::ElectronCollection
std::vector< Electron > ElectronCollection
collectin of Electron objects
Definition: ElectronFwd.h:9
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
RegressionEnergyPatElectronProducer::regressionEvaluator_
ElectronEnergyRegressionEvaluate * regressionEvaluator_
Definition: RegressionEnergyPatElectronProducer.h:45
SuperClusterHelper::esClusterPhi
float esClusterPhi(unsigned i) const
Definition: SuperClusterHelper.cc:168
SuperClusterHelper::subClusterPhi
float subClusterPhi(unsigned i) const
Definition: SuperClusterHelper.cc:148
reco::LeafCandidate::pt
virtual double pt() const
transverse momentum
Definition: LeafCandidate.cc:127
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
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
SuperClusterHelper::seedEta
float seedEta() const
Definition: SuperClusterHelper.h:47
pat::Electron
Analysis-level electron class.
Definition: Electron.h:52
edm::Handle::product
T const * product() const
Definition: Handle.h:74
reco::GsfElectron::isEBPhiGap
bool isEBPhiGap() const
Definition: GsfElectron.h:336
SuperClusterHelper::nPreshowerClusters
float nPreshowerClusters() const
Definition: SuperClusterHelper.h:70
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
SuperClusterHelper::seedPhi
float seedPhi() const
Definition: SuperClusterHelper.h:48
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
virtual double phi() const
momentum azimuthal angle
Definition: LeafCandidate.h:139
SuperClusterHelper::e2x5Left
float e2x5Left() const
Definition: SuperClusterHelper.h:41
pat::Electron::setEcalRegressionEnergy
void setEcalRegressionEnergy(double val, double err)
set regression1
Definition: Electron.h:215
reco::GsfElectron::ecalDrivenSeed
bool ecalDrivenSeed() const
Definition: GsfElectron.h:172

Member Data Documentation

const CaloGeometry* RegressionEnergyPatElectronProducer::caloGeometry_
private

Definition at line 52 of file RegressionEnergyPatElectronProducer.h.

bool RegressionEnergyPatElectronProducer::debug_
private

Definition at line 44 of file RegressionEnergyPatElectronProducer.h.

const CaloTopology* RegressionEnergyPatElectronProducer::ecalTopology_
private

Definition at line 51 of file RegressionEnergyPatElectronProducer.h.

uint32_t RegressionEnergyPatElectronProducer::energyRegressionType_
private

Definition at line 41 of file RegressionEnergyPatElectronProducer.h.

bool RegressionEnergyPatElectronProducer::geomInitialized_
private

Definition at line 46 of file RegressionEnergyPatElectronProducer.h.

uint32_t RegressionEnergyPatElectronProducer::inputCollectionType_
private

Definition at line 42 of file RegressionEnergyPatElectronProducer.h.

edm::InputTag RegressionEnergyPatElectronProducer::inputElectrons_
private

Definition at line 27 of file RegressionEnergyPatElectronProducer.h.

std::string RegressionEnergyPatElectronProducer::nameEnergyErrorReg_
private

Definition at line 39 of file RegressionEnergyPatElectronProducer.h.

std::string RegressionEnergyPatElectronProducer::nameEnergyReg_
private

Definition at line 38 of file RegressionEnergyPatElectronProducer.h.

unsigned RegressionEnergyPatElectronProducer::nElectrons_
private

Definition at line 53 of file RegressionEnergyPatElectronProducer.h.

bool RegressionEnergyPatElectronProducer::producePatElectrons_
private

Definition at line 47 of file RegressionEnergyPatElectronProducer.h.

bool RegressionEnergyPatElectronProducer::produceValueMaps_
private

Definition at line 48 of file RegressionEnergyPatElectronProducer.h.

edm::InputTag RegressionEnergyPatElectronProducer::recHitCollectionEB_
private

Definition at line 30 of file RegressionEnergyPatElectronProducer.h.

edm::InputTag RegressionEnergyPatElectronProducer::recHitCollectionEE_
private

Definition at line 31 of file RegressionEnergyPatElectronProducer.h.

ElectronEnergyRegressionEvaluate* RegressionEnergyPatElectronProducer::regressionEvaluator_
private

Definition at line 45 of file RegressionEnergyPatElectronProducer.h.

std::string RegressionEnergyPatElectronProducer::regressionInputFile_
private

Definition at line 43 of file RegressionEnergyPatElectronProducer.h.

edm::InputTag RegressionEnergyPatElectronProducer::rhoInputTag_
private

Definition at line 28 of file RegressionEnergyPatElectronProducer.h.

bool RegressionEnergyPatElectronProducer::useReducedRecHits_
private

Definition at line 34 of file RegressionEnergyPatElectronProducer.h.

edm::InputTag RegressionEnergyPatElectronProducer::verticesInputTag_
private

Definition at line 29 of file RegressionEnergyPatElectronProducer.h.

Generated for CMSSW Reference Manual by doxygen 1.8.5