CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
GsfElectronAlgo.cc
Go to the documentation of this file.
1 
9 
12 
28 
34 
42 
45 
47 
50 
51 
53 
54 
55 #include "CLHEP/Units/GlobalPhysicalConstants.h"
56 
57 #include <TMath.h>
58 #include <Math/VectorUtil.h>
59 #include <Math/Point3D.h>
60 #include <sstream>
61 #include <algorithm>
62 
63 
64 using namespace edm ;
65 using namespace std ;
66 using namespace reco ;
67 
68 
69 //===================================================================
70 // GsfElectronAlgo::GeneralData
71 //===================================================================
72 
73 // general data and helpers
75  {
76  // constructors
78  ( const InputTagsConfiguration &,
79  const StrategyConfiguration &,
80  const CutsConfiguration & cutsCfg,
81  const CutsConfiguration & cutsCfgPflow,
82  const ElectronHcalHelper::Configuration & hcalCfg,
83  const ElectronHcalHelper::Configuration & hcalCfgPflow,
84  const IsolationConfiguration &,
85  const SpikeConfiguration &,
86  EcalClusterFunctionBaseClass * superClusterErrorFunction ) ;
87  ~GeneralData() ;
88 
89  // configurables
96 
97  // additional configuration and helpers
100  } ;
101 
103  ( const InputTagsConfiguration & inputConfig,
104  const StrategyConfiguration & strategyConfig,
105  const CutsConfiguration & cutsConfig,
106  const CutsConfiguration & cutsConfigPflow,
107  const ElectronHcalHelper::Configuration & hcalConfig,
108  const ElectronHcalHelper::Configuration & hcalConfigPflow,
109  const IsolationConfiguration & isoConfig,
110  const SpikeConfiguration & spikeConfig,
111  EcalClusterFunctionBaseClass * superClusterErrorFunc
112  )
113  : inputCfg(inputConfig),
114  strategyCfg(strategyConfig),
115  cutsCfg(cutsConfig),
116  cutsCfgPflow(cutsConfigPflow),
117  isoCfg(isoConfig),
118  spikeCfg(spikeConfig),
119  hcalHelper(new ElectronHcalHelper(hcalConfig)),
120  hcalHelperPflow(new ElectronHcalHelper(hcalConfigPflow)),
121  superClusterErrorFunction(superClusterErrorFunc)
122  {}
123 
125  {
126  delete hcalHelper ;
127  delete hcalHelperPflow ;
128  }
129 
130 //===================================================================
131 // GsfElectronAlgo::EventSetupData
132 //===================================================================
133 
135  {
136  EventSetupData() ;
137  ~EventSetupData() ;
138 
139  unsigned long long cacheIDGeom ;
140  unsigned long long cacheIDTopo ;
141  unsigned long long cacheIDTDGeom ;
142  unsigned long long cacheIDMagField ;
143  unsigned long long cacheChStatus ;
144  unsigned long long cacheSevLevel ;
145 
151 // edm::ESHandle<EcalSeverityLevelAlgo> sevLevel;
152 
156 } ;
157 
159  : cacheIDGeom(0), cacheIDTopo(0), cacheIDTDGeom(0), cacheIDMagField(0),cacheChStatus(0),
160  mtsTransform(0), constraintAtVtx(0), mtsMode(new MultiTrajectoryStateMode)
161  {}
162 
164  {
165  delete mtsMode ;
166  delete constraintAtVtx ;
167  delete mtsTransform ;
168  }
169 
170 
171 //===================================================================
172 // GsfElectronAlgo::EventData
173 //===================================================================
174 
176  {
177  // general
181 
182  EventData() ;
183  ~EventData() ;
184 
185  // utilities
186  void retreiveOriginalTrackCollections
187  ( const reco::TrackRef &, const reco::GsfTrackRef & ) ;
188 
189  // input collections
202 
203  // isolation helpers
204  ElectronTkIsolation * tkIsolation03, * tkIsolation04 ;
205  EgammaTowerIsolation * hadDepth1Isolation03, * hadDepth1Isolation04 ;
206  EgammaTowerIsolation * hadDepth2Isolation03, * hadDepth2Isolation04 ;
209  EgammaRecHitIsolation * ecalBarrelIsol03, * ecalBarrelIsol04 ;
210  EgammaRecHitIsolation * ecalEndcapIsol03, * ecalEndcapIsol04 ;
211  } ;
212 
214  : event(0), beamspot(0),
215  originalCtfTrackCollectionRetreived(false),
216  originalGsfTrackCollectionRetreived(false),
217  tkIsolation03(0), tkIsolation04(0),
218  hadDepth1Isolation03(0), hadDepth1Isolation04(0),
219  hadDepth2Isolation03(0), hadDepth2Isolation04(0),
220  ecalBarrelHitsMeta(0), ecalEndcapHitsMeta(0),
221  ecalBarrelIsol03(0), ecalBarrelIsol04(0),
222  ecalEndcapIsol03(0), ecalEndcapIsol04(0)
223  {
225  }
226 
228  {
229  delete tkIsolation03 ;
230  delete tkIsolation04 ;
231  delete hadDepth1Isolation03 ;
232  delete hadDepth1Isolation04 ;
233  delete hadDepth2Isolation03 ;
234  delete hadDepth2Isolation04 ;
235  delete ecalBarrelHitsMeta ;
236  delete ecalEndcapHitsMeta ;
237  delete ecalBarrelIsol03 ;
238  delete ecalBarrelIsol04 ;
239  delete ecalEndcapIsol03 ;
240  delete ecalEndcapIsol04 ;
241 
242  GsfElectronPtrCollection::const_iterator it ;
243  for ( it = electrons->begin() ; it != electrons->end() ; it++ )
244  { delete (*it) ; }
245  delete electrons ;
246  }
247 
249  ( const reco::TrackRef & ctfTrack, const reco::GsfTrackRef & gsfTrack )
250  {
251  if ((!originalCtfTrackCollectionRetreived)&&(ctfTrack.isNonnull()))
252  {
253  event->get(ctfTrack.id(),originalCtfTracks) ;
254  originalCtfTrackCollectionRetreived = true ;
255  }
256  if ((!originalGsfTrackCollectionRetreived)&&(gsfTrack.isNonnull()))
257  {
258  event->get(gsfTrack.id(),originalGsfTracks) ;
259  originalGsfTrackCollectionRetreived = true ;
260  }
261  }
262 
263 
264 //===================================================================
265 // GsfElectronAlgo::ElectronData
266 //===================================================================
267 
269  {
270  // Refs to subproducts
277 
278  // constructors
280  ( const reco::GsfElectronCoreRef & core,
281  const reco::BeamSpot & bs ) ;
282  ~ElectronData() ;
283 
284  // utilities
285  void checkCtfTrack( edm::Handle<reco::TrackCollection> currentCtfTracks ) ;
286  void computeCharge( int & charge, reco::GsfElectron::ChargeInfo & info ) ;
287  CaloClusterPtr getEleBasicCluster( const MultiTrajectoryStateTransform * ) ;
288  bool calculateTSOS( const MultiTrajectoryStateTransform *, GsfConstraintAtVertex * ) ;
289  void calculateMode( const MultiTrajectoryStateMode * mtsMode ) ;
290  Candidate::LorentzVector computeMomemtum() ;
291 
292  // TSOS
300 
301  // mode
302  GlobalVector innMom, seedMom, eleMom, sclMom, vtxMom, outMom ;
303  GlobalPoint innPos, seedPos, elePos, sclPos, vtxPos, outPos ;
305  } ;
306 
308  ( const reco::GsfElectronCoreRef & core,
309  const reco::BeamSpot & bs )
310  : coreRef(core),
311  gsfTrackRef(coreRef->gsfTrack()),
312  superClusterRef(coreRef->superCluster()),
313  ctfTrackRef(coreRef->ctfTrack()), shFracInnerHits(coreRef->ctfGsfOverlap()),
314  beamSpot(bs)
315  {}
316 
318  {}
319 
321  {
322  if (!ctfTrackRef.isNull()) return ;
323 
324  // Code below from Puneeth Kalavase
325 
326  shFracInnerHits = 0 ;
327  const TrackCollection * ctfTrackCollection = currentCtfTracks.product() ;
328 
329  // get the Hit Pattern for the gsfTrack
330  const HitPattern & gsfHitPattern = gsfTrackRef->hitPattern() ;
331 
332  unsigned int counter ;
333  TrackCollection::const_iterator ctfTkIter ;
334  for ( ctfTkIter = ctfTrackCollection->begin() , counter = 0 ;
335  ctfTkIter != ctfTrackCollection->end() ; ctfTkIter++, counter++ )
336  {
337 
338  double dEta = gsfTrackRef->eta() - ctfTkIter->eta() ;
339  double dPhi = gsfTrackRef->phi() - ctfTkIter->phi() ;
340  double pi = acos(-1.);
341  if(std::abs(dPhi) > pi) dPhi = 2*pi - std::abs(dPhi) ;
342 
343  // dont want to look at every single track in the event!
344  if (sqrt(dEta*dEta + dPhi*dPhi) > 0.3) continue ;
345 
346  unsigned int shared = 0 ;
347  int gsfHitCounter = 0 ;
348  int numGsfInnerHits = 0 ;
349  int numCtfInnerHits = 0 ;
350 
351  // get the CTF Track Hit Pattern
352  const HitPattern & ctfHitPattern = ctfTkIter->hitPattern() ;
353 
354  trackingRecHit_iterator elHitsIt ;
355  for ( elHitsIt = gsfTrackRef->recHitsBegin() ;
356  elHitsIt != gsfTrackRef->recHitsEnd() ;
357  elHitsIt++, gsfHitCounter++ )
358  {
359  if (!((**elHitsIt).isValid())) //count only valid Hits
360  { continue ; }
361 
362  // look only in the pixels/TIB/TID
363  uint32_t gsfHit = gsfHitPattern.getHitPattern(gsfHitCounter) ;
364  if (!(gsfHitPattern.pixelHitFilter(gsfHit) ||
365  gsfHitPattern.stripTIBHitFilter(gsfHit) ||
366  gsfHitPattern.stripTIDHitFilter(gsfHit) ) )
367  { continue ; }
368 
369  numGsfInnerHits++ ;
370 
371  int ctfHitsCounter = 0 ;
372  numCtfInnerHits = 0 ;
373  trackingRecHit_iterator ctfHitsIt ;
374  for ( ctfHitsIt = ctfTkIter->recHitsBegin() ;
375  ctfHitsIt != ctfTkIter->recHitsEnd() ;
376  ctfHitsIt++, ctfHitsCounter++ )
377  {
378  if(!((**ctfHitsIt).isValid())) //count only valid Hits!
379  { continue ; }
380 
381  uint32_t ctfHit = ctfHitPattern.getHitPattern(ctfHitsCounter);
382  if( !(ctfHitPattern.pixelHitFilter(ctfHit) ||
383  ctfHitPattern.stripTIBHitFilter(ctfHit) ||
384  ctfHitPattern.stripTIDHitFilter(ctfHit) ) )
385  { continue ; }
386 
387  numCtfInnerHits++ ;
388 
389  if( (**elHitsIt).sharesInput(&(**ctfHitsIt),TrackingRecHit::all) )
390  {
391  shared++ ;
392  break ;
393  }
394 
395  } //ctfHits iterator
396 
397  } //gsfHits iterator
398 
399  if ((numGsfInnerHits==0)||(numCtfInnerHits==0))
400  { continue ; }
401 
402  if ( static_cast<float>(shared)/min(numGsfInnerHits,numCtfInnerHits) > shFracInnerHits )
403  {
404  shFracInnerHits = static_cast<float>(shared)/min(numGsfInnerHits, numCtfInnerHits);
405  ctfTrackRef = TrackRef(currentCtfTracks,counter);
406  }
407  } //ctfTrack iterator
408  }
409 
412  {
413  // determine charge from SC
414  GlobalPoint orig, scpos ;
415  ele_convert(beamSpot.position(),orig) ;
416  ele_convert(superClusterRef->position(),scpos) ;
417  GlobalVector scvect(scpos-orig) ;
418  GlobalPoint inntkpos = innTSOS.globalPosition() ;
419  GlobalVector inntkvect = GlobalVector(inntkpos-orig) ;
420  float dPhiInnEle=normalized_phi(scvect.phi()-inntkvect.phi()) ;
421  if(dPhiInnEle>0) info.scPixCharge = -1 ;
422  else info.scPixCharge = 1 ;
423 
424  // flags
425  int chargeGsf = gsfTrackRef->charge() ;
426  info.isGsfScPixConsistent = ((chargeGsf*info.scPixCharge)>0) ;
427  info.isGsfCtfConsistent = (ctfTrackRef.isNonnull()&&((chargeGsf*ctfTrackRef->charge())>0)) ;
429 
430  // default charge
431  if (info.isGsfScPixConsistent||ctfTrackRef.isNull())
432  { charge = info.scPixCharge ; }
433  else
434  { charge = ctfTrackRef->charge() ; }
435  }
436 
438  ( const MultiTrajectoryStateTransform * mtsTransform )
439  {
440  CaloClusterPtr eleRef ;
441  TrajectoryStateOnSurface tempTSOS ;
442  TrajectoryStateOnSurface outTSOS = mtsTransform->outerStateOnSurface(*gsfTrackRef) ;
443  float dphimin = 1.e30 ;
444  for (CaloCluster_iterator bc=superClusterRef->clustersBegin(); bc!=superClusterRef->clustersEnd(); bc++)
445  {
446  GlobalPoint posclu((*bc)->position().x(),(*bc)->position().y(),(*bc)->position().z()) ;
447  tempTSOS = mtsTransform->extrapolatedState(outTSOS,posclu) ;
448  if (!tempTSOS.isValid()) tempTSOS=outTSOS ;
449  GlobalPoint extrap = tempTSOS.globalPosition() ;
450  float dphi = EleRelPointPair(posclu,extrap,beamSpot.position()).dPhi() ;
451  if (std::abs(dphi)<dphimin)
452  {
453  dphimin = std::abs(dphi) ;
454  eleRef = (*bc);
455  eleTSOS = tempTSOS ;
456  }
457  }
458  return eleRef ;
459  }
460 
462  ( const MultiTrajectoryStateTransform * mtsTransform, GsfConstraintAtVertex * constraintAtVtx )
463  {
464  //at innermost point
465  innTSOS = mtsTransform->innerStateOnSurface(*gsfTrackRef);
466  if (!innTSOS.isValid()) return false;
467 
468  //at vertex
469  // innermost state propagation to the beam spot position
470  GlobalPoint bsPos ;
471  ele_convert(beamSpot.position(),bsPos) ;
472  vtxTSOS = mtsTransform->extrapolatedState(innTSOS,bsPos) ;
473  if (!vtxTSOS.isValid()) vtxTSOS=innTSOS;
474 
475  //at seed
476  outTSOS = mtsTransform->outerStateOnSurface(*gsfTrackRef);
477  if (!outTSOS.isValid()) return false;
478 
479  // TrajectoryStateOnSurface seedTSOS
480  seedTSOS = mtsTransform->extrapolatedState(outTSOS,
481  GlobalPoint(superClusterRef->seed()->position().x(),
482  superClusterRef->seed()->position().y(),
483  superClusterRef->seed()->position().z()));
484  if (!seedTSOS.isValid()) seedTSOS=outTSOS;
485 
486  // at scl
487  sclTSOS = mtsTransform->extrapolatedState(innTSOS,GlobalPoint(superClusterRef->x(),superClusterRef->y(),superClusterRef->z()));
488  if (!sclTSOS.isValid()) sclTSOS=outTSOS;
489 
490  // constrained momentum
491  constrainedVtxTSOS = constraintAtVtx->constrainAtBeamSpot(*gsfTrackRef,beamSpot);
492 
493  return true ;
494  }
495 
497  {
498  mtsMode->momentumFromModeCartesian(innTSOS,innMom) ;
499  mtsMode->positionFromModeCartesian(innTSOS,innPos) ;
500  mtsMode->momentumFromModeCartesian(seedTSOS,seedMom) ;
501  mtsMode->positionFromModeCartesian(seedTSOS,seedPos) ;
502  mtsMode->momentumFromModeCartesian(eleTSOS,eleMom) ;
503  mtsMode->positionFromModeCartesian(eleTSOS,elePos) ;
504  mtsMode->momentumFromModeCartesian(sclTSOS,sclMom) ;
505  mtsMode->positionFromModeCartesian(sclTSOS,sclPos) ;
506  mtsMode->momentumFromModeCartesian(vtxTSOS,vtxMom) ;
507  mtsMode->positionFromModeCartesian(vtxTSOS,vtxPos) ;
508  mtsMode->momentumFromModeCartesian(outTSOS,outMom);
509  mtsMode->positionFromModeCartesian(outTSOS,outPos) ;
510  mtsMode->momentumFromModeCartesian(constrainedVtxTSOS,vtxMomWithConstraint);
511  }
512 
514  {
515  double scale = superClusterRef->energy()/vtxMom.mag() ;
517  ( vtxMom.x()*scale,vtxMom.y()*scale,vtxMom.z()*scale,
518  superClusterRef->energy() ) ;
519  }
520 
521 
522 //===================================================================
523 // GsfElectronAlgo
524 //===================================================================
525 
527  ( const InputTagsConfiguration & inputCfg,
528  const StrategyConfiguration & strategyCfg,
529  const CutsConfiguration & cutsCfg,
530  const CutsConfiguration & cutsCfgPflow,
531  const ElectronHcalHelper::Configuration & hcalCfg,
532  const ElectronHcalHelper::Configuration & hcalCfgPflow,
533  const IsolationConfiguration & isoCfg,
534  const SpikeConfiguration & spikeCfg,
535  EcalClusterFunctionBaseClass * superClusterErrorFunction
536  )
537  : generalData_(new GeneralData(inputCfg,strategyCfg,cutsCfg,cutsCfgPflow,hcalCfg,hcalCfgPflow,isoCfg,spikeCfg,superClusterErrorFunction)),
540  {}
541 
543  {
544  delete generalData_ ;
545  delete eventSetupData_ ;
546  delete eventData_ ;
547  delete electronData_ ;
548  }
549 
551  {
552  // get EventSetupRecords if needed
553  bool updateField(false);
555  updateField = true;
558  }
559 
560  bool updateGeometry(false);
562  updateGeometry = true;
565  }
566 
567  if ( updateField || updateGeometry ) {
568  delete eventSetupData_->mtsTransform ;
572  }
573 
575  eventSetupData_->cacheIDGeom=es.get<CaloGeometryRecord>().cacheIdentifier();
577  }
578 
580  eventSetupData_->cacheIDTopo=es.get<CaloTopologyRecord>().cacheIdentifier();
582  }
583 
586 
589 
590 
592  eventSetupData_->cacheChStatus=es.get<EcalChannelStatusRcd>().cacheIdentifier();
594  }
595 
596 // if(eventSetupData_->cacheSevLevel != es.get<EcalSeverityLevelAlgoRcd>().cacheIdentifier()){
597 // eventSetupData_->cacheSevLevel = es.get<EcalSeverityLevelAlgoRcd>().cacheIdentifier();
598 // es.get<EcalSeverityLevelAlgoRcd>().get(eventSetupData_->sevLevel);
599 // }
600  }
601 
603  {
604  GsfElectronPtrCollection::const_iterator it ;
605  for
606  ( it = eventData_->electrons->begin() ;
607  it != eventData_->electrons->end() ;
608  it++ )
609  { outEle.push_back(**it) ; }
610  }
611 
613  {
614  if (eventData_!=0)
615  { throw cms::Exception("GsfElectronAlgo|InternalError")<<"unexpected event data" ; }
616  eventData_ = new EventData ;
617 
618  // init the handles linked to the current event
619  eventData_->event = &event ;
625  event.getByLabel(generalData_->inputCfg.hcalTowersTag,eventData_->towers) ;
626  event.getByLabel(generalData_->inputCfg.pfMVA,eventData_->pfMva) ;
627  event.getByLabel(generalData_->inputCfg.seedsTag,eventData_->seeds) ;
628 
629  // get the beamspot from the Event:
630  edm::Handle<reco::BeamSpot> recoBeamSpotHandle ;
631  event.getByLabel(generalData_->inputCfg.beamSpotTag,recoBeamSpotHandle) ;
632  eventData_->beamspot = recoBeamSpotHandle.product() ;
633 
634  // prepare access to hcal data
637 
638  // Isolation algos
639  float extRadiusSmall=0.3, extRadiusLarge=0.4 ;
640  float intRadiusBarrel=generalData_->isoCfg.intRadiusBarrelTk, intRadiusEndcap=generalData_->isoCfg.intRadiusEndcapTk, stripBarrel=generalData_->isoCfg.stripBarrelTk, stripEndcap=generalData_->isoCfg.stripEndcapTk ;
642  eventData_->tkIsolation03 = new ElectronTkIsolation(extRadiusSmall,intRadiusBarrel,intRadiusEndcap,stripBarrel,stripEndcap,ptMin,maxVtxDist,drb,eventData_->currentCtfTracks.product(),eventData_->beamspot->position()) ;
643  eventData_->tkIsolation04 = new ElectronTkIsolation(extRadiusLarge,intRadiusBarrel,intRadiusEndcap,stripBarrel,stripEndcap,ptMin,maxVtxDist,drb,eventData_->currentCtfTracks.product(),eventData_->beamspot->position()) ;
644 
645  float egHcalIsoConeSizeOutSmall=0.3, egHcalIsoConeSizeOutLarge=0.4;
646  float egHcalIsoConeSizeIn=generalData_->isoCfg.intRadiusHcal,egHcalIsoPtMin=generalData_->isoCfg.etMinHcal;
647  int egHcalDepth1=1, egHcalDepth2=2;
648  eventData_->hadDepth1Isolation03 = new EgammaTowerIsolation(egHcalIsoConeSizeOutSmall,egHcalIsoConeSizeIn,egHcalIsoPtMin,egHcalDepth1,eventData_->towers.product()) ;
649  eventData_->hadDepth2Isolation03 = new EgammaTowerIsolation(egHcalIsoConeSizeOutSmall,egHcalIsoConeSizeIn,egHcalIsoPtMin,egHcalDepth2,eventData_->towers.product()) ;
650  eventData_->hadDepth1Isolation04 = new EgammaTowerIsolation(egHcalIsoConeSizeOutLarge,egHcalIsoConeSizeIn,egHcalIsoPtMin,egHcalDepth1,eventData_->towers.product()) ;
651  eventData_->hadDepth2Isolation04 = new EgammaTowerIsolation(egHcalIsoConeSizeOutLarge,egHcalIsoConeSizeIn,egHcalIsoPtMin,egHcalDepth2,eventData_->towers.product()) ;
652 
653  float egIsoConeSizeOutSmall=0.3, egIsoConeSizeOutLarge=0.4, egIsoJurassicWidth=generalData_->isoCfg.jurassicWidth;
654  float egIsoPtMinBarrel=generalData_->isoCfg.etMinBarrel,egIsoEMinBarrel=generalData_->isoCfg.eMinBarrel, egIsoConeSizeInBarrel=generalData_->isoCfg.intRadiusEcalBarrel;
655  float egIsoPtMinEndcap=generalData_->isoCfg.etMinEndcaps,egIsoEMinEndcap=generalData_->isoCfg.eMinEndcaps, egIsoConeSizeInEndcap=generalData_->isoCfg.intRadiusEcalEndcaps;
658  eventData_->ecalBarrelIsol03 = new EgammaRecHitIsolation(egIsoConeSizeOutSmall,egIsoConeSizeInBarrel,egIsoJurassicWidth,egIsoPtMinBarrel,egIsoEMinBarrel,eventSetupData_->caloGeom,eventData_->ecalBarrelHitsMeta/*,eventSetupData_->sevLevel.product()*/,DetId::Ecal);
659  eventData_->ecalBarrelIsol04 = new EgammaRecHitIsolation(egIsoConeSizeOutLarge,egIsoConeSizeInBarrel,egIsoJurassicWidth,egIsoPtMinBarrel,egIsoEMinBarrel,eventSetupData_->caloGeom,eventData_->ecalBarrelHitsMeta/*,eventSetupData_->sevLevel.product()*/,DetId::Ecal);
660  eventData_->ecalEndcapIsol03 = new EgammaRecHitIsolation(egIsoConeSizeOutSmall,egIsoConeSizeInEndcap,egIsoJurassicWidth,egIsoPtMinEndcap,egIsoEMinEndcap,eventSetupData_->caloGeom,eventData_->ecalEndcapHitsMeta/*,eventSetupData_->sevLevel.product()*/,DetId::Ecal);
661  eventData_->ecalEndcapIsol04 = new EgammaRecHitIsolation(egIsoConeSizeOutLarge,egIsoConeSizeInEndcap,egIsoJurassicWidth,egIsoPtMinEndcap,egIsoEMinEndcap,eventSetupData_->caloGeom,eventData_->ecalEndcapHitsMeta/*,eventSetupData_->sevLevel.product()*/,DetId::Ecal);
665  //eventData_->ecalBarrelIsol03->doSpikeRemoval(eventData_->reducedEBRecHits.product(),eventSetupData_->chStatus.product(),generalData_->spikeCfg.severityLevelCut);//,generalData_->spikeCfg.severityRecHitThreshold,generalData_->spikeCfg.spikeId,generalData_->spikeCfg.spikeIdThreshold);
670  //eventData_->ecalBarrelIsol04->doSpikeRemoval(eventData_->reducedEBRecHits.product(),eventSetupData_->chStatus.product(),generalData_->spikeCfg.severityLevelCut);//,generalData_->spikeCfg.severityRecHitThreshold,generalData_->spikeCfg.spikeId,generalData_->spikeCfg.spikeIdThreshold);
678  }
679 
681  {
682  if (eventData_==0)
683  { throw cms::Exception("GsfElectronAlgo|InternalError")<<"lacking event data" ; }
684  delete eventData_ ;
685  eventData_ = 0 ;
686  }
687 
688 void GsfElectronAlgo::displayInternalElectrons( const std::string & title ) const
689  {
690  LogTrace("GsfElectronAlgo") << "========== " << title << " ==========";
691  LogTrace("GsfElectronAlgo") << "Event: " << eventData_->event->id();
692  LogTrace("GsfElectronAlgo") << "Number of electrons: " << eventData_->electrons->size() ;
693  GsfElectronPtrCollection::const_iterator it ;
694  for ( it = eventData_->electrons->begin(); it != eventData_->electrons->end(); it++ )
695  {
696  LogTrace("GsfElectronAlgo") << "Electron with charge, pt, eta, phi: " << (*it)->charge() << " , "
697  << (*it)->pt() << " , " << (*it)->eta() << " , " << (*it)->phi();
698  }
699  LogTrace("GsfElectronAlgo") << "=================================================";
700  }
701 
703  {
704  if (electronData_!=0)
705  { throw cms::Exception("GsfElectronAlgo|InternalError")<<"unexpected electron data" ; }
706 
707  const GsfElectronCoreCollection * coreCollection = eventData_->coreElectrons.product() ;
708  for ( unsigned int i=0 ; i<coreCollection->size() ; ++i )
709  {
710  // check there is no existing electron with this core
712  bool coreFound = false ;
713  GsfElectronPtrCollection::const_iterator itrEle ;
714  for
715  ( itrEle = eventData_->electrons->begin() ;
716  itrEle != eventData_->electrons->end() ;
717  itrEle++ )
718  {
719  if ((*itrEle)->core()==coreRef)
720  {
721  coreFound = true ;
722  break ;
723  }
724  }
725  if (coreFound) continue ;
726 
727  // check there is a super-cluster
728  if (coreRef->superCluster().isNull()) continue ;
729 
730  // prepare internal structure for electron specific data
731  delete electronData_ ;
732  electronData_ = new ElectronData(coreRef,*eventData_->beamspot) ;
733 
734  // calculate and check Trajectory StatesOnSurface....
736 
737  createElectron() ;
738 
739  } // loop over tracks
740 
741  delete electronData_ ;
742  electronData_ = 0 ;
743  }
744 
746  {
747  const GsfElectronCollection * oldElectrons = eventData_->previousElectrons.product() ;
749  GsfElectronCollection::const_iterator electron ;
750  for
751  ( electron = oldElectrons->begin() ;
752  electron != oldElectrons->end() ;
753  ++electron )
754  {
755  const GsfTrackRef electronGsfTrackRef = electron->gsfTrack() ;
756  unsigned int icore ;
757  for ( icore=0 ; icore<newCores->size() ; ++icore )
758  {
759  if (electronGsfTrackRef==(*newCores)[icore].gsfTrack())
760  {
762  eventData_->electrons->push_back(new GsfElectron(*electron,coreRef)) ;
763  break ;
764  }
765  }
766  }
767  }
768 
770  {
771  GsfElectronPtrCollection::iterator el ;
772  for
773  ( el = eventData_->electrons->begin() ;
774  el != eventData_->electrons->end() ;
775  el++ )
776  {
777  // MVA
778  // we check that the value is never inferior to the no-cut value
779  // we generally use in the configuration file for minMVA.
780  GsfTrackRef gsfTrackRef = (*el)->gsfTrack() ;
781  float mva = (*eventData_->pfMva.product())[gsfTrackRef] ;
782  double noCutMin = -999999999 ;
783  if (mva<noCutMin) { throw cms::Exception("GsfElectronAlgo|UnexpectedMvaValue")<<"unexpected MVA value: "<<mva ; }
784  (*el)->setMva(mva) ;
785  // Preselection
787  }
788  }
789 
791  { return (ele->passingCutBasedPreselection()||ele->passingMvaPreselection()) ; }
792 
794  {
796  GsfElectronPtrCollection::iterator eitr = eventData_->electrons->begin() ;
797  while (eitr!=eventData_->electrons->end())
798  {
799  LogTrace("GsfElectronAlgo")<<"========== removed not preselected "<<ei<<"/"<<emax<<"==========" ;
800  if (isPreselected(*eitr))
801  { ++eitr ; ++ei ; }
802  else
803  { delete (*eitr) ; eitr = eventData_->electrons->erase(eitr) ; ++ei ; }
804  }
805  }
806 
808  {
809  // default value
810  ele->setPassCutBasedPreselection(false) ;
811 
812  // kind of seeding
813  bool eg = ele->core()->ecalDrivenSeed() ;
814  bool pf = ele->core()->trackerDrivenSeed() && !ele->core()->ecalDrivenSeed() ;
815  if (eg&&pf) { throw cms::Exception("GsfElectronAlgo|BothEcalAndPureTrackerDriven")<<"An electron cannot be both egamma and purely pflow" ; }
816  if ((!eg)&&(!pf)) { throw cms::Exception("GsfElectronAlgo|NeitherEcalNorPureTrackerDriven")<<"An electron cannot be neither egamma nor purely pflow" ; }
818 
819  // Et cut
820  double etaValue = EleRelPoint(ele->superCluster()->position(),bs.position()).eta() ;
821  double etValue = ele->superCluster()->energy()/cosh(etaValue) ;
822  LogTrace("GsfElectronAlgo") << "Et : " << etValue ;
823  if (ele->isEB() && (etValue < cfg->minSCEtBarrel)) return ;
824  if (ele->isEE() && (etValue < cfg->minSCEtEndcaps)) return ;
825  LogTrace("GsfElectronAlgo") << "Et criteria are satisfied";
826 
827  // E/p cut
828  double eopValue = ele->eSuperClusterOverP() ;
829  LogTrace("GsfElectronAlgo") << "E/p : " << eopValue ;
830  if (ele->isEB() && (eopValue > cfg->maxEOverPBarrel)) return ;
831  if (ele->isEE() && (eopValue > cfg->maxEOverPEndcaps)) return ;
832  if (ele->isEB() && (eopValue < cfg->minEOverPBarrel)) return ;
833  if (ele->isEE() && (eopValue < cfg->minEOverPEndcaps)) return ;
834  LogTrace("GsfElectronAlgo") << "E/p criteria are satisfied";
835 
836  // HoE cuts
837  LogTrace("GsfElectronAlgo") << "HoE1 : " << ele->hcalDepth1OverEcal() << ", HoE2 : " << ele->hcalDepth2OverEcal();
838  double had = ele->hcalOverEcal()*ele->superCluster()->energy() ;
839  const reco::CaloCluster & seedCluster = *(ele->superCluster()->seed()) ;
840  int detector = seedCluster.hitsAndFractions()[0].first.subdetId() ;
841  bool HoEveto = false ;
842  if (detector==EcalBarrel && (had<cfg->maxHBarrel || (had/ele->superCluster()->energy())<cfg->maxHOverEBarrel)) HoEveto=true;
843  else if (detector==EcalEndcap && (had<cfg->maxHEndcaps || (had/ele->superCluster()->energy())<cfg->maxHOverEEndcaps)) HoEveto=true;
844  if ( !HoEveto ) return ;
845  LogTrace("GsfElectronAlgo") << "H/E criteria are satisfied";
846 
847  // delta eta criteria
848  double deta = ele->deltaEtaSuperClusterTrackAtVtx() ;
849  LogTrace("GsfElectronAlgo") << "delta eta : " << deta ;
850  if (ele->isEB() && (std::abs(deta) > cfg->maxDeltaEtaBarrel)) return ;
851  if (ele->isEE() && (std::abs(deta) > cfg->maxDeltaEtaEndcaps)) return ;
852  LogTrace("GsfElectronAlgo") << "Delta eta criteria are satisfied";
853 
854  // delta phi criteria
855  double dphi = ele->deltaPhiSuperClusterTrackAtVtx();
856  LogTrace("GsfElectronAlgo") << "delta phi : " << dphi;
857  if (ele->isEB() && (std::abs(dphi) > cfg->maxDeltaPhiBarrel)) return ;
858  if (ele->isEE() && (std::abs(dphi) > cfg->maxDeltaPhiEndcaps)) return ;
859  LogTrace("GsfElectronAlgo") << "Delta phi criteria are satisfied";
860 
861  // sigma ieta ieta
862  LogTrace("GsfElectronAlgo") << "sigma ieta ieta : " << ele->sigmaIetaIeta();
863  if (ele->isEB() && (ele->sigmaIetaIeta() > cfg->maxSigmaIetaIetaBarrel)) return ;
864  if (ele->isEE() && (ele->sigmaIetaIeta() > cfg->maxSigmaIetaIetaEndcaps)) return ;
865  LogTrace("GsfElectronAlgo") << "Sigma ieta ieta criteria are satisfied";
866 
867  // fiducial
868  if (!ele->isEB() && cfg->isBarrel) return ;
869  if (!ele->isEE() && cfg->isEndcaps) return ;
870  if (cfg->isFiducial && (ele->isEBEEGap()||ele->isEBEtaGap()||ele->isEBPhiGap()||ele->isEERingGap()||ele->isEEDeeGap())) return ;
871  LogTrace("GsfElectronAlgo") << "Fiducial flags criteria are satisfied";
872 
873  // seed in TEC
874  edm::RefToBase<TrajectorySeed> seed = ele->gsfTrack()->extra()->seedRef() ;
875  ElectronSeedRef elseed = seed.castTo<ElectronSeedRef>() ;
876  if (eg && !generalData_->cutsCfg.seedFromTEC)
877  {
878  if (elseed.isNull())
879  { throw cms::Exception("GsfElectronAlgo|NotElectronSeed")<<"The GsfTrack seed is not an ElectronSeed ?!" ; }
880  else
881  { if (elseed->subDet2()==6) return ; }
882  }
883 
884  // transverse impact parameter
885  if (std::abs(ele->gsfTrack()->dxy(bs.position()))>cfg->maxTIP) return ;
886  LogTrace("GsfElectronAlgo") << "TIP criterion is satisfied" ;
887 
888  LogTrace("GsfElectronAlgo") << "All cut based criteria are satisfied" ;
889  ele->setPassCutBasedPreselection(true) ;
890  }
891 
893  {
894  ele->setPassMvaPreselection(false) ;
895  if (ele->core()->ecalDrivenSeed())
896  { if (ele->mva()>=generalData_->cutsCfg.minMVA) ele->setPassMvaPreselection(true) ; }
897  else
898  { if (ele->mva()>=generalData_->cutsCfgPflow.minMVA) ele->setPassMvaPreselection(true) ; }
899  if (ele->passingMvaPreselection())
900  { LogTrace("GsfElectronAlgo") << "Mva criterion is satisfied" ; }
901  }
902 
904  {
905  // eventually check ctf track
908 
909  // charge ID
910  int eleCharge ;
911  GsfElectron::ChargeInfo eleChargeInfo ;
912  electronData_->computeCharge(eleCharge,eleChargeInfo) ;
913 
914  // electron basic cluster
916 
917  // Seed cluster
918  const reco::CaloCluster & seedCluster = *(electronData_->superClusterRef->seed()) ;
919 
920  // seed Xtal
921  // temporary, till CaloCluster->seed() is made available
922  DetId seedXtalId = seedCluster.hitsAndFractions()[0].first ;
923 
925 
926 
927  //====================================================
928  // Candidate attributes
929  //====================================================
930 
932 
933 
934  //====================================================
935  // Track-Cluster Matching
936  //====================================================
937 
939  tcMatching.electronCluster = elbcRef ;
941  tcMatching.eSeedClusterOverP = (electronData_->vtxMom.mag()>0.)?(seedCluster.energy()/electronData_->vtxMom.mag()):(-1) ;
942  tcMatching.eSeedClusterOverPout = (electronData_->seedMom.mag()>0.)?(seedCluster.energy()/electronData_->seedMom.mag()):(-1.) ;
943  tcMatching.eEleClusterOverPout = (electronData_->eleMom.mag()>0.)?(elbcRef->energy()/electronData_->eleMom.mag()):(-1.) ;
944 
946  tcMatching.deltaEtaSuperClusterAtVtx = scAtVtx.dEta() ;
947  tcMatching.deltaPhiSuperClusterAtVtx = scAtVtx.dPhi() ;
948 
949  EleRelPointPair seedAtCalo(seedCluster.position(),electronData_->seedPos,eventData_->beamspot->position()) ;
950  tcMatching.deltaEtaSeedClusterAtCalo = seedAtCalo.dEta() ;
951  tcMatching.deltaPhiSeedClusterAtCalo = seedAtCalo.dPhi() ;
952 
953  EleRelPointPair ecAtCalo(elbcRef->position(),electronData_->elePos,eventData_->beamspot->position()) ;
954  tcMatching.deltaEtaEleClusterAtCalo = ecAtCalo.dEta() ;
955  tcMatching.deltaPhiEleClusterAtCalo = ecAtCalo.dPhi() ;
956 
957 
958  //=======================================================
959  // Track extrapolations
960  //=======================================================
961 
970 
971 
972  //=======================================================
973  // Closest Ctf Track
974  //=======================================================
975 
977  ctfInfo.ctfTrack = electronData_->ctfTrackRef ;
979 
980 
981  //====================================================
982  // FiducialFlags, using nextToBoundary definition of gaps
983  //====================================================
984 
985  reco::GsfElectron::FiducialFlags fiducialFlags ;
986  int detector = seedXtalId.subdetId() ;
987  double feta=std::abs(electronData_->superClusterRef->position().eta()) ;
988  if (detector==EcalBarrel)
989  {
990  fiducialFlags.isEB = true ;
991  EBDetId ebdetid(seedXtalId);
992  if (EBDetId::isNextToEtaBoundary(ebdetid))
993  {
994  if (ebdetid.ietaAbs()==85)
995  { fiducialFlags.isEBEEGap = true ; }
996  else
997  { fiducialFlags.isEBEtaGap = true ; }
998  }
999  if (EBDetId::isNextToPhiBoundary(ebdetid))
1000  { fiducialFlags.isEBPhiGap = true ; }
1001  }
1002  else if (detector==EcalEndcap)
1003  {
1004  fiducialFlags.isEE = true ;
1005  EEDetId eedetid(seedXtalId);
1006  if (EEDetId::isNextToRingBoundary(eedetid))
1007  {
1008  if (std::abs(feta)<2.)
1009  { fiducialFlags.isEBEEGap = true ; }
1010  else
1011  { fiducialFlags.isEERingGap = true ; }
1012  }
1013  if (EEDetId::isNextToDBoundary(eedetid))
1014  { fiducialFlags.isEEDeeGap = true ; }
1015  }
1016  else
1017  { throw cms::Exception("GsfElectronAlgo|UnknownXtalRegion")<<"createElectron(): do not know if it is a barrel or endcap seed cluster !!!!" ; }
1018 
1019 
1020  //====================================================
1021  // ShowerShape
1022  //====================================================
1023 
1024  reco::GsfElectron::ShowerShape showerShape ;
1025  const CaloTopology * topology = eventSetupData_->caloTopo.product() ;
1027  const EcalRecHitCollection * reducedRecHits = 0 ;
1028  if (fiducialFlags.isEB)
1029  { reducedRecHits = eventData_->reducedEBRecHits.product() ; }
1030  else
1031  { reducedRecHits = eventData_->reducedEERecHits.product() ; }
1032  std::vector<float> covariances = EcalClusterTools::covariances(seedCluster,reducedRecHits,topology,geometry) ;
1033  std::vector<float> localCovariances = EcalClusterTools::localCovariances(seedCluster,reducedRecHits,topology) ;
1034  showerShape.sigmaEtaEta = sqrt(covariances[0]) ;
1035  showerShape.sigmaIetaIeta = sqrt(localCovariances[0]) ;
1036  showerShape.e1x5 = EcalClusterTools::e1x5(seedCluster,reducedRecHits,topology) ;
1037  showerShape.e2x5Max = EcalClusterTools::e2x5Max(seedCluster,reducedRecHits,topology) ;
1038  showerShape.e5x5 = EcalClusterTools::e5x5(seedCluster,reducedRecHits,topology) ;
1039 
1041  if (electronData_->coreRef->ecalDrivenSeed())
1042  {
1043  showerShape.hcalDepth1OverEcal = generalData_->hcalHelper->hcalESumDepth1(*theClus)/theClus->energy() ;
1044  showerShape.hcalDepth2OverEcal = generalData_->hcalHelper->hcalESumDepth2(*theClus)/theClus->energy() ;
1045  }
1046  else
1047  {
1048  showerShape.hcalDepth1OverEcal = generalData_->hcalHelperPflow->hcalESumDepth1(*theClus)/theClus->energy() ;
1049  showerShape.hcalDepth2OverEcal = generalData_->hcalHelperPflow->hcalESumDepth2(*theClus)/theClus->energy() ;
1050  }
1051 
1052 
1053  //====================================================
1054  // ConversionRejection
1055  //====================================================
1056 
1058 
1059  ConversionFinder conversionFinder ;
1060  double BInTesla = eventSetupData_->magField->inTesla(GlobalPoint(0.,0.,0.)).z() ;
1062  if (!ctfTracks.isValid()) { ctfTracks = eventData_->currentCtfTracks ; }
1063 
1064  // values of conversionInfo.flag()
1065  // -9999 : Partner track was not found
1066  // 0 : Partner track found in the CTF collection using
1067  // 1 : Partner track found in the CTF collection using
1068  // 2 : Partner track found in the GSF collection using
1069  // 3 : Partner track found in the GSF collection using the electron's GSF track
1070  ConversionInfo conversionInfo = conversionFinder.getConversionInfo
1071  (*electronData_->coreRef,ctfTracks,eventData_->originalGsfTracks,BInTesla) ;
1072 
1074  conversionVars.flags = conversionInfo.flag() ;
1075  conversionVars.dist = conversionInfo.dist() ;
1076  conversionVars.dcot = conversionInfo.dcot() ;
1077  conversionVars.radius = conversionInfo.radiusOfConversion() ;
1078  if ((conversionVars.flags==0)or(conversionVars.flags==1))
1079  conversionVars.partner = TrackBaseRef(conversionInfo.conversionPartnerCtfTk()) ;
1080  else if ((conversionVars.flags==2)or(conversionVars.flags==3))
1081  conversionVars.partner = TrackBaseRef(conversionInfo.conversionPartnerGsfTk()) ;
1082 
1083 
1084  //====================================================
1085  // brems fraction
1086  //====================================================
1087 
1088  float fbrem = (electronData_->outMom.mag()>0.)?((electronData_->innMom.mag()-electronData_->outMom.mag())/electronData_->innMom.mag()):1.e30 ;
1089 
1090 
1091  //====================================================
1092  // Go !
1093  //====================================================
1094 
1095  GsfElectron * ele = new
1096  GsfElectron
1097  ( momentum,eleCharge,eleChargeInfo,electronData_->coreRef,
1098  tcMatching, tkExtra, ctfInfo,
1099  fiducialFlags,showerShape,
1100  conversionVars,
1101  fbrem) ;
1102 
1103  // set corrections + classification
1104  ElectronClassification theClassifier;
1105  theClassifier.correct(*ele);
1106  // energy corrections only for ecalDriven electrons
1107  if (ele->core()->ecalDrivenSeed()) {
1110  ElectronMomentumCorrector theMomCorrector;
1111  theMomCorrector.correct(*ele,electronData_->vtxTSOS);
1112  }
1113 
1114 
1115  // now isolation variables
1125  ele->setIsolation03(dr03);
1126  ele->setIsolation04(dr04);
1127 
1128  // preselection flag
1130 
1131  LogTrace("GsfElectronAlgo")<<"Constructed new electron with energy "<< ele->p4().e() ;
1132 
1133  eventData_->electrons->push_back(ele) ;
1134  }
1135 
1136 
1137 //=======================================================================================
1138 // Ambiguity solving
1139 //=======================================================================================
1140 
1141 //bool better_electron( const reco::GsfElectron * e1, const reco::GsfElectron * e2 )
1142 // { return (std::abs(e1->eSuperClusterOverP()-1)<std::abs(e2->eSuperClusterOverP()-1)) ; }
1143 
1144 void GsfElectronAlgo::setAmbiguityData( bool ignoreNotPreselected )
1145  {
1146  GsfElectronPtrCollection::iterator e1, e2 ;
1151  else
1152  { throw cms::Exception("GsfElectronAlgo|UnknownAmbiguitySortingStrategy")<<"value of generalData_->strategyCfg.ambSortingStrategy is : "<<generalData_->strategyCfg.ambSortingStrategy ; }
1153 
1154  // init
1155  for
1156  ( e1 = eventData_->electrons->begin() ;
1157  e1 != eventData_->electrons->end() ;
1158  ++e1 )
1159  {
1160  (*e1)->clearAmbiguousGsfTracks() ;
1161  (*e1)->setAmbiguous(false) ;
1162  }
1163 
1164  // resolve when e/g SC is found
1165  for
1166  ( e1 = eventData_->electrons->begin() ;
1167  e1 != eventData_->electrons->end() ;
1168  ++e1 )
1169  {
1170  if ((*e1)->ambiguous()) continue ;
1171  if ( ignoreNotPreselected && !isPreselected(*e1) ) continue ;
1172 
1173  SuperClusterRef scRef1 = (*e1)->superCluster();
1174  CaloClusterPtr eleClu1 = (*e1)->electronCluster();
1175  LogDebug("GsfElectronAlgo")
1176  << "Blessing electron with E/P " << (*e1)->eSuperClusterOverP()
1177  << ", cluster " << scRef1.get()
1178  << " & track " << (*e1)->gsfTrack().get() ;
1179 
1180  for
1181  ( e2 = e1, ++e2 ;
1182  e2 != eventData_->electrons->end() ;
1183  ++e2 )
1184  {
1185  if ((*e2)->ambiguous()) continue ;
1186  if ( ignoreNotPreselected && !isPreselected(*e2) ) continue ;
1187 
1188  SuperClusterRef scRef2 = (*e2)->superCluster();
1189  CaloClusterPtr eleClu2 = (*e2)->electronCluster();
1190 
1191  // search if same cluster
1192  bool sameCluster = false ;
1194  { sameCluster = (scRef1==scRef2) ; }
1196  {
1197  float eMin = 1. ;
1198  float threshold = eMin*cosh(EleRelPoint(scRef1->position(),eventData_->beamspot->position()).eta()) ;
1199  sameCluster =
1201  (EgAmbiguityTools::sharedEnergy(&(*scRef1->seed()),&(*eleClu2),eventData_->reducedEBRecHits,eventData_->reducedEERecHits)>=threshold) ||
1203  (EgAmbiguityTools::sharedEnergy(&(*scRef1->seed()),&(*scRef2->seed()),eventData_->reducedEBRecHits,eventData_->reducedEERecHits)>=threshold) ) ;
1204  }
1205  else
1206  { throw cms::Exception("GsfElectronAlgo|UnknownAmbiguityClustersOverlapStrategy")<<"value of generalData_->strategyCfg.ambClustersOverlapStrategy is : "<<generalData_->strategyCfg.ambClustersOverlapStrategy ; }
1207 
1208  // main instructions
1209  if (sameCluster)
1210  {
1211  LogDebug("GsfElectronAlgo")
1212  << "Discarding electron with E/P " << (*e2)->eSuperClusterOverP()
1213  << ", cluster " << scRef2.get()
1214  << " and track " << (*e2)->gsfTrack().get() ;
1215  (*e1)->addAmbiguousGsfTrack((*e2)->gsfTrack()) ;
1216  (*e2)->setAmbiguous(true) ;
1217  }
1218  else if ((*e1)->gsfTrack()==(*e2)->gsfTrack())
1219  {
1220  LogDebug("GsfElectronAlgo")
1221  << "Forgetting electron with E/P " << (*e2)->eSuperClusterOverP()
1222  << ", cluster " << scRef2.get()
1223  << " and track " << (*e2)->gsfTrack().get() ;
1224  (*e2)->setAmbiguous(true) ;
1225  }
1226  }
1227  }
1228  }
1229 
1231  {
1232  GsfElectronPtrCollection::size_type ei = 1, emax = eventData_->electrons->size() ;
1233  GsfElectronPtrCollection::iterator eitr = eventData_->electrons->begin() ;
1234  while (eitr!=eventData_->electrons->end())
1235  {
1236  LogTrace("GsfElectronAlgo")<<"========== remove ambiguous "<<ei<<"/"<<emax<<"==========" ;
1237  if ((*eitr)->ambiguous())
1238  { delete (*eitr) ; eitr = eventData_->electrons->erase(eitr) ; ++ei ; }
1239  else
1240  { ++eitr ; ++ei ; }
1241  }
1242  }
1243 
#define LogDebug(id)
TrajectoryStateOnSurface constrainAtBeamSpot(const reco::GsfTrack &, const reco::BeamSpot &) const
(multi)TSOS after including the beamspot
ElectronHcalHelper * hcalHelperPflow
edm::Handle< reco::TrackCollection > originalCtfTracks
double hcalESumDepth2(const reco::SuperCluster &)
unsigned long long cacheIdentifier() const
edm::Handle< reco::ElectronSeedCollection > seeds
const MultiTrajectoryStateMode * mtsMode
bool isPreselected(reco::GsfElectron *ele)
const math::XYZPoint & position() const
cluster centroid position
Definition: CaloCluster.h:112
int i
Definition: DBlmapReader.cc:9
edm::Handle< edm::ValueMap< float > > pfMva
GeneralData * generalData_
const CutsConfiguration cutsCfgPflow
static bool isNextToEtaBoundary(EBDetId id)
Definition: EBDetId.cc:175
reco::GsfTrackRef conversionPartnerGsfTk() const
GsfElectronAlgo(const InputTagsConfiguration &, const StrategyConfiguration &, const CutsConfiguration &cutsCfg, const CutsConfiguration &cutsCfgPflow, const ElectronHcalHelper::Configuration &hcalCfg, const ElectronHcalHelper::Configuration &hcalCfgPflow, const IsolationConfiguration &, const SpikeConfiguration &, EcalClusterFunctionBaseClass *superClusterErrorFunction)
void setPassCutBasedPreselection(bool flag)
Definition: GsfElectron.h:503
bool positionFromModeCartesian(const TrajectoryStateOnSurface tsos, GlobalPoint &position) const
virtual void correct(reco::GsfElectron &)
bool isEBEtaGap() const
Definition: GsfElectron.h:339
void setMvaPreselectionFlag(reco::GsfElectron *ele)
double radiusOfConversion() const
void clonePreviousElectrons()
float eSuperClusterOverP() const
Definition: GsfElectron.h:201
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventIDconst &, edm::Timestampconst & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
bool isBetter(const reco::GsfElectron *, const reco::GsfElectron *)
void retreiveOriginalTrackCollections(const reco::TrackRef &, const reco::GsfTrackRef &)
bool isEBEEGap() const
Definition: GsfElectron.h:337
float hcalDepth2OverEcal() const
Definition: GsfElectron.h:383
double getEtSum(const reco::Candidate *emObject) const
const IsolationConfiguration isoCfg
void beginEvent(edm::Event &)
TrajectoryStateOnSurface sclTSOS
Geom::Phi< T > phi() const
Definition: PV3DBase.h:63
EventSetupData * eventSetupData_
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
std::vector< Track > TrackCollection
collection of Tracks
Definition: TrackFwd.h:10
double dist() const
#define abs(x)
Definition: mlp_lapack.h:159
bool stripTIBHitFilter(uint32_t pattern) const
Definition: HitPattern.cc:170
const std::vector< std::pair< DetId, float > > & hitsAndFractions() const
Definition: CaloCluster.h:178
#define min(a, b)
Definition: mlp_lapack.h:161
void checkSetup(const edm::EventSetup &)
bool isEERingGap() const
Definition: GsfElectron.h:343
bool passingCutBasedPreselection() const
Definition: GsfElectron.h:497
bool passingMvaPreselection() const
Definition: GsfElectron.h:498
void computeCharge(int &charge, reco::GsfElectron::ChargeInfo &info)
SuperClusterRef superCluster() const
reference to a SuperCluster
Definition: GsfElectron.h:166
bool momentumFromModeCartesian(const TrajectoryStateOnSurface tsos, GlobalVector &momentum) const
void checkCtfTrack(edm::Handle< reco::TrackCollection > currentCtfTracks)
const InputTagsConfiguration inputCfg
edm::ESHandle< EcalChannelStatus > chStatus
TrajectoryStateOnSurface innTSOS
void doFlagChecks(const std::vector< int > v)
uint16_t size_type
bool isEEDeeGap() const
Definition: GsfElectron.h:342
double charge(const std::vector< uint8_t > &Ampls)
std::vector< GsfElectron > GsfElectronCollection
collection of GsfElectron objects
EgammaTowerIsolation * hadDepth1Isolation03
T eta() const
const StrategyConfiguration strategyCfg
bool isEE() const
Definition: GsfElectron.h:335
bool isEB() const
Definition: GsfElectron.h:334
Candidate::LorentzVector computeMomemtum()
TrajectoryStateOnSurface outerStateOnSurface(const reco::GsfTrack &tk) const
edm::ESHandle< CaloTopology > caloTopo
return((rh^lh)&mask)
reco::TrackRef conversionPartnerCtfTk() const
static std::vector< float > covariances(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const CaloGeometry *geometry, float w0=4.7)
EgammaRecHitIsolation * ecalBarrelIsol04
TrajectoryStateOnSurface constrainedVtxTSOS
EgammaTowerIsolation * hadDepth2Isolation03
EgammaTowerIsolation * hadDepth1Isolation04
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:248
ElectronTkIsolation * tkIsolation03
float mva() const
Definition: GsfElectron.h:500
void setUseNumCrystals(bool b=true)
float deltaEtaSuperClusterTrackAtVtx() const
Definition: GsfElectron.h:205
bool isNull() const
Checks for null.
Definition: Ref.h:244
T mag() const
Definition: PV3DBase.h:61
float sigmaIetaIeta() const
Definition: GsfElectron.h:378
static std::vector< float > localCovariances(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, float w0=4.7)
TrajectoryStateOnSurface extrapolatedState(const TrajectoryStateOnSurface tsos, const GlobalPoint &point) const
void setCutBasedPreselectionFlag(reco::GsfElectron *ele, const reco::BeamSpot &)
double dPhi(double phi1, double phi2)
Definition: JetUtil.h:30
edm::RefToBase< reco::Track > TrackBaseRef
persistent reference to a Track, using views
Definition: TrackFwd.h:22
EgammaRecHitIsolation * ecalEndcapIsol03
float threshold
Definition: crabWrap.py:319
RealType normalized_phi(RealType phi)
T sqrt(T t)
Definition: SSEVec.h:28
GsfConstraintAtVertex * constraintAtVtx
static bool isNextToPhiBoundary(EBDetId id)
Definition: EBDetId.cc:180
float deltaPhiSuperClusterTrackAtVtx() const
Definition: GsfElectron.h:208
std::vector< GsfElectronCore > GsfElectronCoreCollection
void correct(reco::GsfElectron &, TrajectoryStateOnSurface &)
void readEvent(edm::Event &)
float hcalOverEcal() const
Definition: GsfElectron.h:384
void setPassMvaPreselection(bool flag)
Definition: GsfElectron.h:504
const MultiTrajectoryStateTransform * mtsTransform
static bool isNextToRingBoundary(EEDetId id)
Definition: EEDetId.cc:391
std::list< reco::GsfElectron * > GsfElectronPtrCollection
double energy() const
cluster energy
Definition: CaloCluster.h:109
const CutsConfiguration cutsCfg
ElectronHcalHelper * hcalHelper
const reco::BeamSpot * beamspot
edm::ESHandle< MagneticField > magField
GsfElectronPtrCollection * electrons
CaloClusterPtr getEleBasicCluster(const MultiTrajectoryStateTransform *)
static bool isNextToDBoundary(EEDetId id)
Definition: EEDetId.cc:383
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
GeneralData(const InputTagsConfiguration &, const StrategyConfiguration &, const CutsConfiguration &cutsCfg, const CutsConfiguration &cutsCfgPflow, const ElectronHcalHelper::Configuration &hcalCfg, const ElectronHcalHelper::Configuration &hcalCfgPflow, const IsolationConfiguration &, const SpikeConfiguration &, EcalClusterFunctionBaseClass *superClusterErrorFunction)
bool isValid() const
Definition: HandleBase.h:76
bool pixelHitFilter(uint32_t pattern) const
Definition: HitPattern.cc:138
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:39
void setIsolation04(const IsolationVariables &dr04)
Definition: GsfElectron.h:443
#define LogTrace(id)
virtual GsfElectronCoreRef core() const
Definition: GsfElectron.h:163
edm::Handle< reco::GsfElectronCollection > previousElectrons
float hcalDepth1OverEcal() const
Definition: GsfElectron.h:382
GsfTrackRef gsfTrack() const
reference to a GsfTrack
Definition: GsfElectron.h:167
Definition: DetId.h:20
EgammaRecHitIsolation * ecalBarrelIsol03
EcalRecHitMetaCollection * ecalBarrelHitsMeta
int flag() const
const SpikeConfiguration spikeCfg
EcalClusterFunctionBaseClass * superClusterErrorFunction
const T & get() const
Definition: EventSetup.h:55
REF castTo() const
cast to a concrete type
Definition: RefToBase.h:236
edm::Ref< TrackCollection > TrackRef
persistent reference to a Track
Definition: TrackFwd.h:14
T const * product() const
Definition: ESHandle.h:62
const reco::GsfTrackRef gsfTrackRef
void ele_convert(const Type1 &obj1, Type2 &obj2)
T const * product() const
Definition: Handle.h:74
bool calculateTSOS(const MultiTrajectoryStateTransform *, GsfConstraintAtVertex *)
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Candidate.h:39
edm::Handle< EcalRecHitCollection > reducedEBRecHits
double getPtTracks(const reco::GsfElectron *) const
TrajectoryStateOnSurface innerStateOnSurface(const reco::GsfTrack &tk) const
TrajectoryStateOnSurface seedTSOS
std::vector< int > recHitFlagsToBeExcluded
void setIsolation03(const IsolationVariables &dr03)
Definition: GsfElectron.h:442
ESHandle< TrackerGeometry > geometry
edm::EventID id() const
Definition: EventBase.h:56
edm::Handle< reco::GsfTrackCollection > originalGsfTracks
EgammaTowerIsolation * hadDepth2Isolation04
void setVetoClustered(bool b=true)
SimpleCaloRecHitMetaCollection< EcalRecHitCollection > EcalRecHitMetaCollection
const reco::GsfElectronCoreRef coreRef
bool isEBPhiGap() const
Definition: GsfElectron.h:340
edm::Handle< reco::TrackCollection > currentCtfTracks
static float e2x5Max(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
edm::ESHandle< CaloGeometry > caloGeom
void removeAmbiguousElectrons()
static float e5x5(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
void displayInternalElectrons(const std::string &title) const
EgammaRecHitIsolation * ecalEndcapIsol04
static float e1x5(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
float sharedEnergy(const reco::CaloCluster *, const reco::CaloCluster *, edm::Handle< EcalRecHitCollection > &reducedEBRecHits, edm::Handle< EcalRecHitCollection > &reducedEERecHits)
void removeNotPreselectedElectrons()
const reco::SuperClusterRef superClusterRef
TrajectoryStateOnSurface eleTSOS
edm::Handle< EcalRecHitCollection > reducedEERecHits
const Point & position() const
position
Definition: BeamSpot.h:63
EventData * eventData_
double dcot() const
TrajectoryStateOnSurface outTSOS
ElectronData(const reco::GsfElectronCoreRef &core, const reco::BeamSpot &bs)
void copyElectrons(reco::GsfElectronCollection &)
ProductID id() const
Accessor for product ID.
Definition: Ref.h:254
ElectronTkIsolation * tkIsolation04
double pi
ElectronData * electronData_
double getTowerEtSum(const reco::Candidate *) const
edm::ESHandle< TrackerGeometry > trackerHandle
void setAmbiguityData(bool ignoreNotPreselected=true)
double hcalESumDepth1(const reco::SuperCluster &)
T const * get() const
Returns C++ pointer to the item.
Definition: Ref.h:239
uint32_t getHitPattern(int position) const
Definition: HitPattern.cc:86
virtual void init(const edm::EventSetup &es)=0
edm::Handle< reco::GsfElectronCoreCollection > coreElectrons
virtual const LorentzVector & p4() const
four-momentum Lorentz vector
int ietaAbs() const
get the absolute value of the crystal ieta
Definition: EBDetId.h:42
void doSpikeRemoval(const EcalRecHitCollection *const recHits, const EcalChannelStatus *const chStatus, const int &severityLevelCut=3, const float &sevRecHitThresh=5.0, const EcalSeverityLevelAlgo::SpikeId &id=EcalSeverityLevelAlgo::kSwissCross, const float &spIdThresh=0.95)
bool stripTIDHitFilter(uint32_t pattern) const
Definition: HitPattern.cc:177
edm::Handle< CaloTowerCollection > towers
EcalSeverityLevelAlgo::SpikeId spikeId
void calculateMode(const MultiTrajectoryStateMode *mtsMode)
void correct(reco::GsfElectron &, const reco::BeamSpot &bs, bool applyEtaCorrection=true)
math::PtEtaPhiELorentzVectorF LorentzVector
EcalRecHitMetaCollection * ecalEndcapHitsMeta
Global3DVector GlobalVector
Definition: GlobalVector.h:10
void checkSetup(const edm::EventSetup &)
TrajectoryStateOnSurface vtxTSOS
const reco::BeamSpot beamSpot