CMS 3D CMS Logo

GsfElectron.h
Go to the documentation of this file.
1 #ifndef GsfElectron_h
2 #define GsfElectron_h
3 
8 //#include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
14 //#include "DataFormats/Math/interface/LorentzVector.h"
18 #include <vector>
19 #include <limits>
20 
21 namespace reco
22  {
23 
24 
25 /****************************************************************************
26  * \class reco::GsfElectron
27  *
28  * An Electron with a GsfTrack seeded from an ElectronSeed.
29  * Renamed from PixelMatchGsfElectron.
30  * Originally adapted from the TRecElectron class in ORCA.
31  *
32  * \author Claude Charlot - Laboratoire Leprince-Ringuet - École polytechnique, CNRS/IN2P3
33  * \author David Chamont - Laboratoire Leprince-Ringuet - École polytechnique, CNRS/IN2P3
34  *
35  ****************************************************************************/
36 
37 class GsfElectron : public RecoCandidate
38  {
39 
40  //=======================================================
41  // Constructors
42  //
43  // The clone() method with arguments, and the copy
44  // constructor with edm references is designed for
45  // someone which want to duplicates all
46  // collections.
47  //=======================================================
48 
49  public :
50 
51  // some nested structures defined later on
52  struct ChargeInfo ;
53  struct TrackClusterMatching ;
54  struct TrackExtrapolations ;
55  struct ClosestCtfTrack ;
56  struct FiducialFlags ;
57  struct ShowerShape ;
58  struct IsolationVariables ;
59  struct ConversionRejection ;
61  struct SaturationInfo ;
62 
63  GsfElectron() ;
64  GsfElectron( const GsfElectronCoreRef & ) ;
66  (
67  const GsfElectron &,
68  const GsfElectronCoreRef &
69  ) ;
71  (
72  const GsfElectron & electron,
73  const GsfElectronCoreRef & core,
75  const TrackRef & closestCtfTrack,
76  const TrackBaseRef & conversionPartner,
77  const GsfTrackRefVector & ambiguousTracks
78  ) ;
80  (
81  int charge,
82  const ChargeInfo &,
83  const GsfElectronCoreRef &,
84  const TrackClusterMatching &,
85  const TrackExtrapolations &,
86  const ClosestCtfTrack &,
87  const FiducialFlags &,
88  const ShowerShape &,
89  const ConversionRejection &
90  ) ;
92  (
93  int charge,
94  const ChargeInfo &,
95  const GsfElectronCoreRef &,
96  const TrackClusterMatching &,
97  const TrackExtrapolations &,
98  const ClosestCtfTrack &,
99  const FiducialFlags &,
100  const ShowerShape &,
101  const ShowerShape &,
102  const ConversionRejection &,
103  const SaturationInfo &
104  ) ;
105  GsfElectron * clone() const override ;
107  (
108  const GsfElectronCoreRef & core,
109  const CaloClusterPtr & electronCluster,
110  const TrackRef & closestCtfTrack,
111  const TrackBaseRef & conversionPartner,
112  const GsfTrackRefVector & ambiguousTracks
113  ) const ;
114  ~GsfElectron() override {} ;
115 
116  private:
117 
118  void init() ;
119 
120 
121  //=======================================================
122  // Candidate methods and complementary information
123  //
124  // The gsf electron producer has tried to best evaluate
125  // the four momentum and charge and given those values to
126  // the GsfElectron constructor, which forwarded them to
127  // the Candidate constructor. Those values can be retreived
128  // with getters inherited from Candidate : p4() and charge().
129  //=======================================================
130 
131  public:
132 
133  // Inherited from Candidate
134  // const LorentzVector & charge() const ;
135  // const LorentzVector & p4() const ;
136 
137  // Complementary struct
138  struct ChargeInfo
139  {
145  : scPixCharge(0), isGsfCtfScPixConsistent(false),
146  isGsfScPixConsistent(false), isGsfCtfConsistent(false)
147  {}
148  } ;
149 
150  // Charge info accessors
151  // to get gsf track charge: gsfTrack()->charge()
152  // to get ctf track charge, if closestCtfTrackRef().isNonnull(): closestCtfTrackRef()->charge()
153  int scPixCharge() const { return chargeInfo_.scPixCharge ; }
157  const ChargeInfo & chargeInfo() const { return chargeInfo_ ; }
158 
159  // Candidate redefined methods
160  bool isElectron() const override { return true ; }
161  bool overlap( const Candidate & ) const override ;
162 
163  private:
164 
165  // Complementary attributes
167 
168 
169  //=======================================================
170  // Core Attributes
171  //
172  // They all have been computed before, when building the
173  // collection of GsfElectronCore instances. Each GsfElectron
174  // has a reference toward a GsfElectronCore.
175  //=======================================================
176 
177  public:
178 
179  // accessors
180  virtual GsfElectronCoreRef core() const ;
181  void setCore(const reco::GsfElectronCoreRef &core) { core_ = core; }
182 
183  // forward core methods
184  SuperClusterRef superCluster() const override { return core()->superCluster() ; }
185  GsfTrackRef gsfTrack() const override { return core()->gsfTrack() ; }
186  virtual TrackRef closestTrack() const { return core()->ctfTrack() ; }
187  float ctfGsfOverlap() const { return core()->ctfGsfOverlap() ; }
188  bool ecalDrivenSeed() const { return core()->ecalDrivenSeed() ; }
189  bool trackerDrivenSeed() const { return core()->trackerDrivenSeed() ; }
190  virtual SuperClusterRef parentSuperCluster() const { return core()->parentSuperCluster() ; }
191 
192  // backward compatibility
194  {
195  TrackRef ctfTrack ; // best matching ctf track
196  float shFracInnerHits ; // fraction of common hits between the ctf and gsf tracks
197  ClosestCtfTrack() : shFracInnerHits(0.) {}
198  ClosestCtfTrack( TrackRef track, float sh ) : ctfTrack(track), shFracInnerHits(sh) {}
199  } ;
200  float shFracInnerHits() const { return core()->ctfGsfOverlap() ; }
201  virtual TrackRef closestCtfTrackRef() const { return core()->ctfTrack() ; }
202  virtual ClosestCtfTrack closestCtfTrack() const { return ClosestCtfTrack(core()->ctfTrack(),core()->ctfGsfOverlap()) ; }
203 
204  private:
205 
206  // attributes
208 
209 
210  //=======================================================
211  // Track-Cluster Matching Attributes
212  //=======================================================
213 
214  public:
215 
217  {
218  CaloClusterPtr electronCluster ; // basic cluster best matching gsf track
219  float eSuperClusterOverP ; // the supercluster energy / track momentum at the PCA to the beam spot
220  float eSeedClusterOverP ; // the seed cluster energy / track momentum at the PCA to the beam spot
221  float eSeedClusterOverPout ; // the seed cluster energy / track momentum at calo extrapolated from the outermost track state
222  float eEleClusterOverPout ; // the electron cluster energy / track momentum at calo extrapolated from the outermost track state
223  float deltaEtaSuperClusterAtVtx ; // the supercluster eta - track eta position at calo extrapolated from innermost track state
224  float deltaEtaSeedClusterAtCalo ; // the seed cluster eta - track eta position at calo extrapolated from the outermost track state
225  float deltaEtaEleClusterAtCalo ; // the electron cluster eta - track eta position at calo extrapolated from the outermost state
226  float deltaPhiEleClusterAtCalo ; // the electron cluster phi - track phi position at calo extrapolated from the outermost track state
227  float deltaPhiSuperClusterAtVtx ; // the supercluster phi - track phi position at calo extrapolated from the innermost track state
228  float deltaPhiSeedClusterAtCalo ; // the seed cluster phi - track phi position at calo extrapolated from the outermost track state
230  : eSuperClusterOverP(0.),
231  eSeedClusterOverP(0.),
232  eSeedClusterOverPout(0.),
233  eEleClusterOverPout(0.),
234  deltaEtaSuperClusterAtVtx(std::numeric_limits<float>::max()),
235  deltaEtaSeedClusterAtCalo(std::numeric_limits<float>::max()),
236  deltaEtaEleClusterAtCalo(std::numeric_limits<float>::max()),
237  deltaPhiEleClusterAtCalo(std::numeric_limits<float>::max()),
238  deltaPhiSuperClusterAtVtx(std::numeric_limits<float>::max()),
239  deltaPhiSeedClusterAtCalo(std::numeric_limits<float>::max())
240  {}
241  } ;
242 
243  // accessors
255  float deltaEtaSeedClusterTrackAtVtx() const { return superCluster().isNonnull() && superCluster()->seed().isNonnull() ?
257  }
259 
260  // for backward compatibility, usefull ?
263 
264 
265  private:
266 
267  // attributes
269 
270 
271  //=======================================================
272  // Track extrapolations
273  //=======================================================
274 
275  public :
276 
278  {
279  math::XYZPointF positionAtVtx ; // the track PCA to the beam spot
280  math::XYZPointF positionAtCalo ; // the track PCA to the supercluster position
281  math::XYZVectorF momentumAtVtx ; // the track momentum at the PCA to the beam spot
282  math::XYZVectorF momentumAtCalo ; // the track momentum extrapolated at the supercluster position from the innermost track state
283  math::XYZVectorF momentumOut ; // the track momentum extrapolated at the seed cluster position from the outermost track state
284  math::XYZVectorF momentumAtEleClus ; // the track momentum extrapolated at the ele cluster position from the outermost track state
285  math::XYZVectorF momentumAtVtxWithConstraint ; // the track momentum at the PCA to the beam spot using bs constraint
286  } ;
287 
288  // accessors
297 
298  // setter (if you know what you're doing)
300 
301  // for backward compatibility
304 
305 
306  private:
307 
308  // attributes
310 
311 
312  //=======================================================
313  // SuperCluster direct access
314  //=======================================================
315 
316  public :
317 
318  // direct accessors
319  math::XYZPoint superClusterPosition() const { return superCluster()->position() ; } // the super cluster position
320  int basicClustersSize() const { return superCluster()->clustersSize() ; } // number of basic clusters inside the supercluster
321  CaloCluster_iterator basicClustersBegin() const { return superCluster()->clustersBegin() ; }
322  CaloCluster_iterator basicClustersEnd() const { return superCluster()->clustersEnd() ; }
323 
324  // for backward compatibility
325  math::XYZPoint caloPosition() const { return superCluster()->position() ; }
326 
327 
328 
329  //=======================================================
330  // Fiducial Flags
331  //=======================================================
332 
333  public :
334 
336  {
337  bool isEB ; // true if particle is in ECAL Barrel
338  bool isEE ; // true if particle is in ECAL Endcaps
339  bool isEBEEGap ; // true if particle is in the crack between EB and EE
340  bool isEBEtaGap ; // true if particle is in EB, and inside the eta gaps between modules
341  bool isEBPhiGap ; // true if particle is in EB, and inside the phi gaps between modules
342  bool isEEDeeGap ; // true if particle is in EE, and inside the gaps between dees
343  bool isEERingGap ; // true if particle is in EE, and inside the gaps between rings
345  : isEB(false), isEE(false), isEBEEGap(false),
346  isEBEtaGap(false), isEBPhiGap(false),
347  isEEDeeGap(false), isEERingGap(false)
348  {}
349  } ;
350 
351  // accessors
352  bool isEB() const { return fiducialFlags_.isEB ; }
353  bool isEE() const { return fiducialFlags_.isEE ; }
354  bool isGap() const { return ((isEBEEGap())||(isEBGap())||(isEEGap())) ; }
355  bool isEBEEGap() const { return fiducialFlags_.isEBEEGap ; }
356  bool isEBGap() const { return (isEBEtaGap()||isEBPhiGap()) ; }
357  bool isEBEtaGap() const { return fiducialFlags_.isEBEtaGap ; }
358  bool isEBPhiGap() const { return fiducialFlags_.isEBPhiGap ; }
359  bool isEEGap() const { return (isEEDeeGap()||isEERingGap()) ; }
360  bool isEEDeeGap() const { return fiducialFlags_.isEEDeeGap ; }
361  bool isEERingGap() const { return fiducialFlags_.isEERingGap ; }
362  const FiducialFlags & fiducialFlags() const { return fiducialFlags_ ; }
363  // setters... not necessary in regular situations
364  // but handy for late stage modifications of electron objects
365  void setFFlagIsEB(const bool b) { fiducialFlags_.isEB = b; }
366  void setFFlagIsEE(const bool b) { fiducialFlags_.isEE = b; }
367  void setFFlagIsEBEEGap(const bool b) { fiducialFlags_.isEBEEGap = b; }
372 
373  private:
374 
375  // attributes
377 
378 
379  //=======================================================
380  // Shower Shape Variables
381  //=======================================================
382 
383  public :
384 
385  struct ShowerShape
386  {
387  float sigmaEtaEta ; // weighted cluster rms along eta and inside 5x5 (absolute eta)
388  float sigmaIetaIeta ; // weighted cluster rms along eta and inside 5x5 (Xtal eta)
389  float sigmaIphiIphi ; // weighted cluster rms along phi and inside 5x5 (Xtal phi)
390  float e1x5 ; // energy inside 1x5 in etaxphi around the seed Xtal
391  float e2x5Max ; // energy inside 2x5 in etaxphi around the seed Xtal (max bwt the 2 possible sums)
392  float e5x5 ; // energy inside 5x5 in etaxphi around the seed Xtal
393  float r9 ; // ratio of the 3x3 energy and supercluster energy
394  float hcalDepth1OverEcal ; // hcal over ecal seed cluster energy using 1st hcal depth (using hcal towers within a cone)
395  float hcalDepth2OverEcal ; // hcal over ecal seed cluster energy using 2nd hcal depth (using hcal towers within a cone)
396  std::vector<CaloTowerDetId> hcalTowersBehindClusters ; //
397  float hcalDepth1OverEcalBc ; // hcal over ecal seed cluster energy using 1st hcal depth (using hcal towers behind clusters)
398  float hcalDepth2OverEcalBc ; // hcal over ecal seed cluster energy using 2nd hcal depth (using hcal towers behind clusters)
400  float eMax;
401  float e2nd;
402  float eTop;
403  float eLeft;
404  float eRight;
405  float eBottom;
406  float e2x5Top;
407  float e2x5Left;
408  float e2x5Right;
409  float e2x5Bottom;
411  : sigmaEtaEta(std::numeric_limits<float>::max()),
412  sigmaIetaIeta(std::numeric_limits<float>::max()),
413  sigmaIphiIphi(std::numeric_limits<float>::max()),
414  e1x5(0.), e2x5Max(0.), e5x5(0.),
415  r9(-std::numeric_limits<float>::max()),
416  hcalDepth1OverEcal(0.), hcalDepth2OverEcal(0.),
417  hcalDepth1OverEcalBc(0.), hcalDepth2OverEcalBc(0.),
418  sigmaIetaIphi(0.f),
419  eMax(0.f),
420  e2nd(0.f),
421  eTop(0.f),
422  eLeft(0.f),
423  eRight(0.f),
424  eBottom(0.f),
425  e2x5Top(0.f),
426  e2x5Left(0.f),
427  e2x5Right(0.f),
428  e2x5Bottom(0.f)
429  {}
430  } ;
431 
432  // accessors
433  float sigmaEtaEta() const { return showerShape_.sigmaEtaEta ; }
434  float sigmaIetaIeta() const { return showerShape_.sigmaIetaIeta ; }
435  float sigmaIphiIphi() const { return showerShape_.sigmaIphiIphi ; }
436  float e1x5() const { return showerShape_.e1x5 ; }
437  float e2x5Max() const { return showerShape_.e2x5Max ; }
438  float e5x5() const { return showerShape_.e5x5 ; }
439  float r9() const { return showerShape_.r9 ; }
442  float hcalOverEcal() const { return hcalDepth1OverEcal() + hcalDepth2OverEcal() ; }
443  const std::vector<CaloTowerDetId> & hcalTowersBehindClusters() const { return showerShape_.hcalTowersBehindClusters ; }
446  float hcalOverEcalBc() const { return hcalDepth1OverEcalBc() + hcalDepth2OverEcalBc() ; }
447  float eLeft() const { return showerShape_.eLeft; }
448  float eRight() const { return showerShape_.eRight; }
449  float eTop() const { return showerShape_.eTop; }
450  float eBottom() const { return showerShape_.eBottom; }
451  const ShowerShape & showerShape() const { return showerShape_ ; }
452  // non-zero-suppressed and no-fractions shower shapes
453  // ecal energy is always that from the full 5x5
457  float full5x5_e1x5() const { return full5x5_showerShape_.e1x5 ; }
458  float full5x5_e2x5Max() const { return full5x5_showerShape_.e2x5Max ; }
459  float full5x5_e5x5() const { return full5x5_showerShape_.e5x5 ; }
460  float full5x5_r9() const { return full5x5_showerShape_.r9 ; }
469  float full5x5_e2x5Top() const { return full5x5_showerShape_.e2x5Top; }
471  float full5x5_eLeft() const { return full5x5_showerShape_.eLeft; }
472  float full5x5_eRight() const { return full5x5_showerShape_.eRight; }
473  float full5x5_eTop() const { return full5x5_showerShape_.eTop; }
474  float full5x5_eBottom() const { return full5x5_showerShape_.eBottom; }
476 
477  // setters (if you know what you're doing)
480 
481  // for backward compatibility (this will only ever be the ZS shapes!)
482  float scSigmaEtaEta() const { return sigmaEtaEta() ; }
483  float scSigmaIEtaIEta() const { return sigmaIetaIeta() ; }
484  float scE1x5() const { return e1x5() ; }
485  float scE2x5Max() const { return e2x5Max() ; }
486  float scE5x5() const { return e5x5() ; }
487  float hadronicOverEm() const {return hcalOverEcal();}
488  float hadronicOverEm1() const {return hcalDepth1OverEcal();}
489  float hadronicOverEm2() const {return hcalDepth2OverEcal();}
490 
491 
492  private:
493 
494  // attributes
497 
498  //=======================================================
499  // SaturationInfo
500  //=======================================================
501 
502  public :
503 
504  struct SaturationInfo {
508  : nSaturatedXtals(0), isSeedSaturated(false) {};
509  } ;
510 
511  // accessors
514  const SaturationInfo& saturationInfo() const { return saturationInfo_; }
516 
517  private:
518 
520 
521  //=======================================================
522  // Isolation Variables
523  //=======================================================
524 
525  public :
526 
528  {
529  float tkSumPt ; // track iso deposit with electron footprint removed
530  float ecalRecHitSumEt ; // ecal iso deposit with electron footprint removed
531  float hcalDepth1TowerSumEt ; // hcal depht 1 iso deposit with electron footprint removed
532  float hcalDepth2TowerSumEt ; // hcal depht 2 iso deposit with electron footprint removed
533  float hcalDepth1TowerSumEtBc ; // hcal depht 1 iso deposit without towers behind clusters
534  float hcalDepth2TowerSumEtBc ; // hcal depht 2 iso deposit without towers behind clusters
536  : tkSumPt(0.), ecalRecHitSumEt(0.),
537  hcalDepth1TowerSumEt(0.), hcalDepth2TowerSumEt(0.),
538  hcalDepth1TowerSumEtBc(0.), hcalDepth2TowerSumEtBc(0.)
539  {}
540  } ;
541 
542  // 03 accessors
543  float dr03TkSumPt() const { return dr03_.tkSumPt ; }
544  float dr03EcalRecHitSumEt() const { return dr03_.ecalRecHitSumEt ; }
551  const IsolationVariables & dr03IsolationVariables() const { return dr03_ ; }
552 
553  // 04 accessors
554  float dr04TkSumPt() const { return dr04_.tkSumPt ; }
555  float dr04EcalRecHitSumEt() const { return dr04_.ecalRecHitSumEt ; }
562  const IsolationVariables & dr04IsolationVariables() const { return dr04_ ; }
563 
564  // setters ?!?
565  void setDr03Isolation( const IsolationVariables & dr03 ) { dr03_ = dr03 ; }
566  void setDr04Isolation( const IsolationVariables & dr04 ) { dr04_ = dr04 ; }
567 
568  // for backward compatibility
569  void setIsolation03( const IsolationVariables & dr03 ) { dr03_ = dr03 ; }
570  void setIsolation04( const IsolationVariables & dr04 ) { dr04_ = dr04 ; }
571  const IsolationVariables & isolationVariables03() const { return dr03_ ; }
572  const IsolationVariables & isolationVariables04() const { return dr04_ ; }
573 
574  private:
575 
576  // attributes
579 
580 
581  //=======================================================
582  // Conversion Rejection Information
583  //=======================================================
584 
585  public :
586 
588  {
589  int flags ; // -max:not-computed, other: as computed by Puneeth conversion code
590  TrackBaseRef partner ; // conversion partner
591  float dist ; // distance to the conversion partner
592  float dcot ; // difference of cot(angle) with the conversion partner track
593  float radius ; // signed conversion radius
595  : flags(-1),
596  dist(std::numeric_limits<float>::max()),
597  dcot(std::numeric_limits<float>::max()),
598  radius(std::numeric_limits<float>::max())
599  {}
600  } ;
601 
602  // accessors
603  int convFlags() const { return conversionRejection_.flags ; }
605  float convDist() const { return conversionRejection_.dist ; }
606  float convDcot() const { return conversionRejection_.dcot ; }
607  float convRadius() const { return conversionRejection_.radius ; }
609 
610  private:
611 
612  // attributes
614 
615 
616  //=======================================================
617  // Pflow Information
618  //=======================================================
619 
620  public:
621 
623  {
624  //first three data members that changed names, according to DataFormats/MuonReco/interface/MuonPFIsolation.h
627  float sumPhotonEt;
628  //then four new data members, corresponding to DataFormats/MuonReco/interface/MuonPFIsolation.h
632  float sumPUPt;
633  //new pf cluster based isolation values
634  float sumEcalClusterEt; //sum pt of ecal clusters, vetoing clusters part of electron
635  float sumHcalClusterEt; //sum pt of hcal clusters, vetoing clusters part of electron
637  sumChargedHadronPt(0),sumNeutralHadronEt(0),sumPhotonEt(0),sumChargedParticlePt(0),
638  sumNeutralHadronEtHighThreshold(0),sumPhotonEtHighThreshold(0),sumPUPt(0),
639  sumEcalClusterEt(0),sumHcalClusterEt(0){};
640  } ;
641 
642  struct MvaInput
643  {
644  int earlyBrem ; // Early Brem detected (-2=>unknown,-1=>could not be evaluated,0=>wrong,1=>true)
645  int lateBrem ; // Late Brem detected (-2=>unknown,-1=>could not be evaluated,0=>wrong,1=>true)
646  float sigmaEtaEta ; // Sigma-eta-eta with the PF cluster
647  float hadEnergy ; // Associated PF Had Cluster energy
648  float deltaEta ; // PF-cluster GSF track delta-eta
649  int nClusterOutsideMustache ; // -2 => unknown, -1 =>could not be evaluated, 0 and more => number of clusters
652  : earlyBrem(-2), lateBrem(-2),
653  sigmaEtaEta(std::numeric_limits<float>::max()),
654  hadEnergy(0.),
655  deltaEta(std::numeric_limits<float>::max()),
656  nClusterOutsideMustache(-2),
657  etOutsideMustache(-std::numeric_limits<float>::max())
658  {}
659  } ;
660 
661  struct MvaOutput
662  {
663  int status ; // see PFCandidateElectronExtra::StatusFlag
664  float mva_Isolated ;
665  float mva_e_pi ;
666  float mvaByPassForIsolated ; // complementary MVA used in preselection
668  : status(-1), mva_Isolated(-999999999.),mva_e_pi(-999999999.), mvaByPassForIsolated(-999999999.)
669  {}
670  } ;
671 
672  // accessors
674  //backwards compat functions for pat::Electron
675  float ecalPFClusterIso() const { return pfIso_.sumEcalClusterEt; };
676  float hcalPFClusterIso() const { return pfIso_.sumHcalClusterEt; };
677 
678  const MvaInput & mvaInput() const { return mvaInput_ ; }
679  const MvaOutput & mvaOutput() const { return mvaOutput_ ; }
680 
681  // setters
683  void setMvaInput( const MvaInput & mi ) { mvaInput_ = mi ; }
684  void setMvaOutput( const MvaOutput & mo ) { mvaOutput_ = mo ; }
685 
686  // for backward compatibility
687  float mva_Isolated() const { return mvaOutput_.mva_Isolated ; }
688  float mva_e_pi() const { return mvaOutput_.mva_e_pi ; }
689 
690  private:
691 
695 
696 
697  //=======================================================
698  // Preselection and Ambiguity
699  //=======================================================
700 
701  public :
702 
703  // accessors
704  bool ecalDriven() const ; // return true if ecalDrivenSeed() and passingCutBasedPreselection()
707  bool ambiguous() const { return ambiguous_ ; }
711 
712  // setters
715  void setAmbiguous( bool flag ) { ambiguous_ = flag ; }
718 
719  // backward compatibility
721  bool passingMvaPreselection() const { return passMvaPreslection_ ; }
722 
723  private:
724 
725  // attributes
728  bool passMvaPreslection_ ; // to be removed : passPflowPreslection_
729  bool ambiguous_ ;
730  GsfTrackRefVector ambiguousGsfTracks_ ; // ambiguous gsf tracks
731 
732 
733  //=======================================================
734  // Brem Fractions and Classification
735  //=======================================================
736 
737  public :
738 
740  {
741  float trackFbrem ; // the brem fraction from gsf fit: (track momentum in - track momentum out) / track momentum in
742  float superClusterFbrem ; // the brem fraction from supercluster: (supercluster energy - electron cluster energy) / supercluster energy
744  : trackFbrem(-1.e30), superClusterFbrem(-1.e30)
745  {}
746  } ;
748 
749  // accessors
750  float trackFbrem() const { return classVariables_.trackFbrem ; }
753  Classification classification() const { return class_ ; }
754 
755  // utilities
756  int numberOfBrems() const { return basicClustersSize()-1 ; }
757  float fbrem() const { return trackFbrem() ; }
758 
759  // setters
763  void setClassification( Classification myclass ) { class_ = myclass ; }
764 
765  private:
766 
767  // attributes
769  Classification class_ ; // fbrem and number of clusters based electron classification
770 
771 
772  //=======================================================
773  // Corrections
774  //
775  // The only methods, with classification, which modify
776  // the electrons after they have been constructed.
777  // They change a given characteristic, such as the super-cluster
778  // energy, and propagate the change consistently
779  // to all the depending attributes.
780  // We expect the methods to be called in a given order
781  // and so to store specific kind of corrections
782  // 1) classify()
783  // 2) correctEcalEnergy() : depending on classification and eta
784  // 3) correctMomemtum() : depending on classification and ecal energy and tracker momentum errors
785  //
786  // Beware that correctEcalEnergy() is modifying few attributes which
787  // were potentially used for preselection, whose value used in
788  // preselection will not be available any more :
789  // hcalDepth1OverEcal, hcalDepth2OverEcal, eSuperClusterOverP,
790  // eSeedClusterOverP, eEleClusterOverPout.
791  //=======================================================
792 
793  public :
794 
796 
797  struct Corrections
798  {
799  bool isEcalEnergyCorrected ; // true if ecal energy has been corrected
800  float correctedEcalEnergy ; // corrected energy (if !isEcalEnergyCorrected this value is identical to the supercluster energy)
801  float correctedEcalEnergyError ; // error on energy
802  //bool isMomentumCorrected ; // DEPRECATED
803  float trackMomentumError ; // track momentum error from gsf fit
804  //
805  LorentzVector fromSuperClusterP4 ; // for P4_FROM_SUPER_CLUSTER
806  float fromSuperClusterP4Error ; // for P4_FROM_SUPER_CLUSTER
807  LorentzVector combinedP4 ; // for P4_COMBINATION
808  float combinedP4Error ; // for P4_COMBINATION
809  LorentzVector pflowP4 ; // for P4_PFLOW_COMBINATION
810  float pflowP4Error ; // for P4_PFLOW_COMBINATION
811  P4Kind candidateP4Kind ; // say which momentum has been stored in reco::Candidate
812  //
814  : isEcalEnergyCorrected(false), correctedEcalEnergy(0.), correctedEcalEnergyError(999.),
815  /*isMomentumCorrected(false),*/ trackMomentumError(999.),
816  fromSuperClusterP4Error(999.), combinedP4Error(999.), pflowP4Error(999.),
817  candidateP4Kind(P4_UNKNOWN)
818  {}
819  } ;
820 
821  // setters
822  void setCorrectedEcalEnergyError( float newEnergyError ) ;
823  void setCorrectedEcalEnergy( float newEnergy ) ;
825  void setP4( P4Kind kind, const LorentzVector & p4, float p4Error, bool setCandidate ) ;
826  using RecoCandidate::setP4 ;
827 
828  // accessors
833  const LorentzVector & p4( P4Kind kind ) const ;
834  using RecoCandidate::p4 ;
835  float p4Error( P4Kind kind ) const ;
837  const Corrections & corrections() const { return corrections_ ; }
838 
839  // bare setter (if you know what you're doing)
841 
842  // for backward compatibility
844  float ecalEnergy() const { return correctedEcalEnergy() ; }
845  float ecalEnergyError() const { return correctedEcalEnergyError() ; }
846  //bool isMomentumCorrected() const { return corrections_.isMomentumCorrected ; }
847  float caloEnergy() const { return correctedEcalEnergy() ; }
848  bool isEnergyScaleCorrected() const { return isEcalEnergyCorrected() ; }
849  void correctEcalEnergy( float newEnergy, float newEnergyError )
850  {
851  setCorrectedEcalEnergy(newEnergy) ;
852  setEcalEnergyError(newEnergyError) ;
853  }
854  void correctMomentum( const LorentzVector & p4, float trackMomentumError, float p4Error )
855  { setTrackMomentumError(trackMomentumError) ; setP4(P4_COMBINATION,p4,p4Error,true) ; }
856 
857 
858  private:
859 
860  // attributes
862 
863  public:
866  float dPhi1 ;
868  float dPhi2 ;
870  float dRz1 ;
872  float dRz2 ;
874  unsigned char subdetectors ;
876  dPhi1(-999),
877  dPhi2(-999),
878  dRz1(-999),
879  dRz2(-999),
880  subdetectors(0)
881  {}
883  };
884  void setPixelMatchSubdetectors(int sd1, int sd2){ pixelMatchVariables_.subdetectors = 10*sd1+sd2 ; }
885  void setPixelMatchDPhi1(float dPhi1){ pixelMatchVariables_.dPhi1 = dPhi1 ; }
886  void setPixelMatchDPhi2(float dPhi2){ pixelMatchVariables_.dPhi2 = dPhi2 ; }
887  void setPixelMatchDRz1 (float dRz1 ){ pixelMatchVariables_.dRz1 = dRz1 ; }
888  void setPixelMatchDRz2 (float dRz2 ){ pixelMatchVariables_.dRz2 = dRz2 ; }
889 
892  float pixelMatchDPhi1() const { return pixelMatchVariables_.dPhi1 ; }
893  float pixelMatchDPhi2() const { return pixelMatchVariables_.dPhi2 ; }
894  float pixelMatchDRz1 () const { return pixelMatchVariables_.dRz1 ; }
895  float pixelMatchDRz2 () const { return pixelMatchVariables_.dRz2 ; }
896  private:
898  } ;
899 
900  } // namespace reco
901 
902 #endif
const PflowIsolationVariables & pfIsolationVariables() const
Definition: GsfElectron.h:673
CaloCluster_iterator basicClustersEnd() const
Definition: GsfElectron.h:322
float sigmaIphiIphi() const
Definition: GsfElectron.h:435
CaloClusterPtr electronCluster() const
Definition: GsfElectron.h:244
bool isEEGap() const
Definition: GsfElectron.h:359
void setDr04Isolation(const IsolationVariables &dr04)
Definition: GsfElectron.h:566
const ShowerShape & showerShape() const
Definition: GsfElectron.h:451
float dPhi1
Pixel match variable: deltaPhi for innermost hit.
Definition: GsfElectron.h:866
GsfTrackRef gsfTrack() const override
reference to a GsfTrack
Definition: GsfElectron.h:185
float dr04HcalTowerSumEt() const
Definition: GsfElectron.h:558
float full5x5_eLeft() const
Definition: GsfElectron.h:471
unsigned char subdetectors
Subdetectors for first and second pixel hit.
Definition: GsfElectron.h:874
void correctEcalEnergy(float newEnergy, float newEnergyError)
Definition: GsfElectron.h:849
void setTrackFbrem(float fbrem)
Definition: GsfElectron.h:760
MvaInput mvaInput_
Definition: GsfElectron.h:693
PixelMatchVariables pixelMatchVariables_
Definition: GsfElectron.h:897
void setP4(P4Kind kind, const LorentzVector &p4, float p4Error, bool setCandidate)
Definition: GsfElectron.cc:199
float nSaturatedXtals() const
Definition: GsfElectron.h:512
void setPassCutBasedPreselection(bool flag)
Definition: GsfElectron.h:713
virtual TrackRef closestCtfTrackRef() const
Definition: GsfElectron.h:201
float trackMomentumError() const
Definition: GsfElectron.h:832
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:253
GsfTrackRefVector::const_iterator ambiguousGsfTracksBegin() const
Definition: GsfElectron.h:709
void setFFlagIsEE(const bool b)
Definition: GsfElectron.h:366
void setPixelMatchDRz2(float dRz2)
Definition: GsfElectron.h:888
float scSigmaEtaEta() const
Definition: GsfElectron.h:482
void setCore(const reco::GsfElectronCoreRef &core)
Definition: GsfElectron.h:181
const Corrections & corrections() const
Definition: GsfElectron.h:837
bool isEBEtaGap() const
Definition: GsfElectron.h:357
float dr03HcalDepth1TowerSumEtBc() const
Definition: GsfElectron.h:548
virtual SuperClusterRef parentSuperCluster() const
Definition: GsfElectron.h:190
float eSuperClusterOverP() const
Definition: GsfElectron.h:245
float dRz2
Pixel match variable: deltaRz for second hit.
Definition: GsfElectron.h:872
P4Kind candidateP4Kind() const
Definition: GsfElectron.h:836
const TrackExtrapolations & trackExtrapolations() const
Definition: GsfElectron.h:296
float full5x5_e5x5() const
Definition: GsfElectron.h:459
float full5x5_hcalDepth1OverEcalBc() const
Definition: GsfElectron.h:464
void setPixelMatchDPhi1(float dPhi1)
Definition: GsfElectron.h:885
math::XYZVectorF trackMomentumAtVtxWithConstraint() const
Definition: GsfElectron.h:295
GsfElectron * clone() const override
returns a clone of the Candidate object
Definition: GsfElectron.cc:161
const IsolationVariables & isolationVariables03() const
Definition: GsfElectron.h:571
bool isEBEEGap() const
Definition: GsfElectron.h:355
float dr04HcalDepth1TowerSumEt() const
Definition: GsfElectron.h:556
float hcalDepth2OverEcal() const
Definition: GsfElectron.h:441
bool overlap(const Candidate &) const override
check overlap with another candidate
Definition: GsfElectron.cc:152
float full5x5_e1x5() const
Definition: GsfElectron.h:457
const SaturationInfo & saturationInfo() const
Definition: GsfElectron.h:514
float pixelMatchDRz2() const
Definition: GsfElectron.h:895
float hadronicOverEm1() const
Definition: GsfElectron.h:488
Classification class_
Definition: GsfElectron.h:769
void correctMomentum(const LorentzVector &p4, float trackMomentumError, float p4Error)
Definition: GsfElectron.h:854
float full5x5_hcalDepth2OverEcal() const
Definition: GsfElectron.h:462
math::XYZVectorF trackMomentumAtVtx() const
Definition: GsfElectron.h:291
ConversionRejection conversionRejection_
Definition: GsfElectron.h:613
Definition: __init__.py:1
void setMvaInput(const MvaInput &mi)
Definition: GsfElectron.h:683
void setSaturationInfo(const SaturationInfo &s)
Definition: GsfElectron.h:515
float sumPUPt
sum pt of charged Particles not from PV (for Pu corrections)
Definition: GsfElectron.h:632
float p4Error(P4Kind kind) const
Definition: GsfElectron.cc:237
float full5x5_sigmaIphiIphi() const
Definition: GsfElectron.h:456
void setShowerShape(const ShowerShape &s)
Definition: GsfElectron.h:478
float isSeedSaturated() const
Definition: GsfElectron.h:513
float dr04TkSumPt() const
Definition: GsfElectron.h:554
Corrections corrections_
Definition: GsfElectron.h:861
float pixelMatchDPhi2() const
Definition: GsfElectron.h:893
SaturationInfo saturationInfo_
Definition: GsfElectron.h:519
int charge() const final
electric charge
Definition: LeafCandidate.h:91
float sumNeutralHadronEtHighThreshold
sum pt of neutral hadrons with a higher threshold
Definition: GsfElectron.h:630
bool isEERingGap() const
Definition: GsfElectron.h:361
bool passingCutBasedPreselection() const
Definition: GsfElectron.h:705
bool passingMvaPreselection() const
Definition: GsfElectron.h:721
cv
Definition: cuy.py:362
float dr03HcalDepth2TowerSumEt() const
Definition: GsfElectron.h:546
float sumChargedParticlePt
sum-pt of charged Particles(inludes e/mu)
Definition: GsfElectron.h:629
float fbrem() const
Definition: GsfElectron.h:757
const std::vector< CaloTowerDetId > & hcalTowersBehindClusters() const
Definition: GsfElectron.h:443
void setAmbiguous(bool flag)
Definition: GsfElectron.h:715
GsfTrackRefVector ambiguousGsfTracks_
Definition: GsfElectron.h:730
ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< float > > XYZPointF
point in space with cartesian internal representation
Definition: Point3D.h:10
float scE2x5Max() const
Definition: GsfElectron.h:485
float e2x5Max() const
Definition: GsfElectron.h:437
float eBottom() const
Definition: GsfElectron.h:450
const_iterator end() const
Termination of iteration.
Definition: RefVector.h:253
int basicClustersSize() const
Definition: GsfElectron.h:320
float convDist() const
Definition: GsfElectron.h:605
ChargeInfo chargeInfo_
Definition: GsfElectron.h:166
float convRadius() const
Definition: GsfElectron.h:607
void setPfIsolationVariables(const PflowIsolationVariables &iso)
Definition: GsfElectron.h:682
math::XYZPointF TrackPositionAtVtx() const
Definition: GsfElectron.h:302
void setDr03Isolation(const IsolationVariables &dr03)
Definition: GsfElectron.h:565
bool isEEDeeGap() const
Definition: GsfElectron.h:360
void setMvaOutput(const MvaOutput &mo)
Definition: GsfElectron.h:684
float dr04HcalTowerSumEtBc() const
Definition: GsfElectron.h:561
bool ambiguous() const
Definition: GsfElectron.h:707
const IsolationVariables & dr04IsolationVariables() const
Definition: GsfElectron.h:562
const ClassificationVariables & classificationVariables() const
Definition: GsfElectron.h:752
float superClusterFbrem() const
Definition: GsfElectron.h:751
bool isEcalEnergyCorrected() const
Definition: GsfElectron.h:829
bool isElectron() const override
Definition: GsfElectron.h:160
bool isEE() const
Definition: GsfElectron.h:353
const_iterator begin() const
Initialize an iterator over the RefVector.
Definition: RefVector.h:248
bool isEB() const
Definition: GsfElectron.h:352
void setPixelMatchSubdetectors(int sd1, int sd2)
Definition: GsfElectron.h:884
virtual reco::TrackRef track() const
reference to a Track
GsfTrackRefVector::const_iterator ambiguousGsfTracksEnd() const
Definition: GsfElectron.h:710
void setSuperClusterFbrem(float fbrem)
Definition: GsfElectron.h:761
float convDcot() const
Definition: GsfElectron.h:606
float full5x5_sigmaIetaIeta() const
Definition: GsfElectron.h:455
void clearAmbiguousGsfTracks()
Definition: GsfElectron.h:716
~GsfElectron() override
Definition: GsfElectron.h:114
void setFFlagIsEBEEGap(const bool b)
Definition: GsfElectron.h:367
bool isGsfScPixChargeConsistent() const
Definition: GsfElectron.h:155
int pixelMatchSubdetector1() const
Definition: GsfElectron.h:890
const IsolationVariables & isolationVariables04() const
Definition: GsfElectron.h:572
float full5x5_e2x5Top() const
Definition: GsfElectron.h:469
void setFFlagIsEBEtaGap(const bool b)
Definition: GsfElectron.h:368
PflowIsolationVariables pfIso_
Definition: GsfElectron.h:692
bool isGap() const
Definition: GsfElectron.h:354
float dr04HcalDepth2TowerSumEt() const
Definition: GsfElectron.h:557
math::XYZVectorF trackMomentumAtCalo() const
Definition: GsfElectron.h:292
bool isGsfCtfChargeConsistent() const
Definition: GsfElectron.h:156
float pixelMatchDPhi1() const
Definition: GsfElectron.h:892
float deltaEtaSuperClusterTrackAtVtx() const
Definition: GsfElectron.h:249
void setFFlagIsEERingGap(const bool b)
Definition: GsfElectron.h:371
float dPhi2
Pixel match variable: deltaPhi for second hit.
Definition: GsfElectron.h:868
void setCorrectedEcalEnergyError(float newEnergyError)
Definition: GsfElectron.cc:179
float sigmaIetaIeta() const
Definition: GsfElectron.h:434
float hadronicOverEm() const
Definition: GsfElectron.h:487
float dr03HcalDepth2TowerSumEtBc() const
Definition: GsfElectron.h:549
float eSeedClusterOverP() const
Definition: GsfElectron.h:246
MvaOutput mvaOutput_
Definition: GsfElectron.h:694
float dr04EcalRecHitSumEt() const
Definition: GsfElectron.h:555
FiducialFlags fiducialFlags_
Definition: GsfElectron.h:376
float deltaPhiSeedClusterTrackAtCalo() const
Definition: GsfElectron.h:253
const MvaInput & mvaInput() const
Definition: GsfElectron.h:678
float sumPhotonEtHighThreshold
sum pt of PF photons with a higher threshold
Definition: GsfElectron.h:631
float full5x5_sigmaEtaEta() const
Definition: GsfElectron.h:454
ShowerShape showerShape_
Definition: GsfElectron.h:495
float trackFbrem() const
Definition: GsfElectron.h:750
math::XYZVectorF trackMomentumOut() const
Definition: GsfElectron.h:293
float sumPhotonEt
sum pt of PF photons // old float photonIso ;
Definition: GsfElectron.h:627
float deltaPhiSuperClusterTrackAtVtx() const
Definition: GsfElectron.h:252
int numberOfBrems() const
Definition: GsfElectron.h:756
float eLeft() const
Definition: GsfElectron.h:447
float hcalOverEcal() const
Definition: GsfElectron.h:442
void setPassMvaPreselection(bool flag)
Definition: GsfElectron.h:720
float dr04HcalDepth1TowerSumEtBc() const
Definition: GsfElectron.h:559
float dr03TkSumPt() const
Definition: GsfElectron.h:543
math::XYZPointF trackPositionAtCalo() const
Definition: GsfElectron.h:290
void setFFlagIsEBPhiGap(const bool b)
Definition: GsfElectron.h:369
std::vector< CaloTowerDetId > hcalTowersBehindClusters
Definition: GsfElectron.h:396
float dr03HcalDepth1TowerSumEt() const
Definition: GsfElectron.h:545
double f[11][100]
float eTop() const
Definition: GsfElectron.h:449
math::XYZPointF TrackPositionAtCalo() const
Definition: GsfElectron.h:303
const LorentzVector & p4() const final
four-momentum Lorentz vector
Definition: LeafCandidate.h:99
float eEleClusterOverPout() const
Definition: GsfElectron.h:248
float sumNeutralHadronEt
sum pt of neutral hadrons // old float neutralHadronIso ;
Definition: GsfElectron.h:626
float eSeedClusterOverPout() const
Definition: GsfElectron.h:247
void setFFlagIsEB(const bool b)
Definition: GsfElectron.h:365
float full5x5_hcalOverEcalBc() const
Definition: GsfElectron.h:466
float hcalPFClusterIso() const
Definition: GsfElectron.h:676
ROOT::Math::DisplacementVector3D< ROOT::Math::Cartesian3D< float > > XYZVectorF
spatial vector with cartesian internal representation
Definition: Vector3D.h:17
float hadronicOverEm2() const
Definition: GsfElectron.h:489
int pixelMatchSubdetector2() const
Definition: GsfElectron.h:891
float hcalOverEcalBc() const
Definition: GsfElectron.h:446
int scPixCharge() const
Definition: GsfElectron.h:153
float scSigmaIEtaIEta() const
Definition: GsfElectron.h:483
float pixelMatchDRz1() const
Definition: GsfElectron.h:894
void setIsolation04(const IsolationVariables &dr04)
Definition: GsfElectron.h:570
IsolationVariables dr04_
Definition: GsfElectron.h:578
float ecalEnergyError() const
Definition: GsfElectron.h:845
float deltaPhiEleClusterTrackAtCalo() const
Definition: GsfElectron.h:254
void setDeltaPhiSuperClusterAtVtx(float dphi)
Definition: GsfElectron.h:262
bool isEnergyScaleCorrected() const
Definition: GsfElectron.h:848
void setEcalEnergyError(float energyError)
Definition: GsfElectron.h:843
void setTrackMomentumError(float trackMomentumError)
Definition: GsfElectron.cc:195
math::XYZPoint superClusterPosition() const
Definition: GsfElectron.h:319
float full5x5_hcalDepth1OverEcal() const
Definition: GsfElectron.h:461
float deltaEtaSeedClusterTrackAtVtx() const
Definition: GsfElectron.h:255
float hcalDepth1OverEcal() const
Definition: GsfElectron.h:440
float shFracInnerHits() const
Definition: GsfElectron.h:200
float correctedEcalEnergy() const
Definition: GsfElectron.h:830
void setPixelMatchDPhi2(float dPhi2)
Definition: GsfElectron.h:886
ClassificationVariables classVariables_
Definition: GsfElectron.h:768
bool isEBGap() const
Definition: GsfElectron.h:356
GsfElectronCoreRef core_
Definition: GsfElectron.h:207
ShowerShape full5x5_showerShape_
Definition: GsfElectron.h:496
TrackBaseRef convPartner() const
Definition: GsfElectron.h:604
float full5x5_e2x5Bottom() const
Definition: GsfElectron.h:470
const ChargeInfo & chargeInfo() const
Definition: GsfElectron.h:157
float full5x5_e2x5Max() const
Definition: GsfElectron.h:458
float eRight() const
Definition: GsfElectron.h:448
CaloCluster_iterator basicClustersBegin() const
Definition: GsfElectron.h:321
void clear()
Clear the vector.
Definition: RefVector.h:147
float deltaEtaEleClusterTrackAtCalo() const
Definition: GsfElectron.h:251
void setClassification(Classification myclass)
Definition: GsfElectron.h:763
float e1x5() const
Definition: GsfElectron.h:436
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:12
Classification classification() const
Definition: GsfElectron.h:753
float hcalDepth2OverEcalBc() const
Definition: GsfElectron.h:445
const MvaOutput & mvaOutput() const
Definition: GsfElectron.h:679
float full5x5_hcalOverEcal() const
Definition: GsfElectron.h:463
math::XYZPoint caloPosition() const
Definition: GsfElectron.h:325
GsfTrackRefVector::size_type ambiguousGsfTracksSize() const
Definition: GsfElectron.h:708
float dr04HcalDepth2TowerSumEtBc() const
Definition: GsfElectron.h:560
double b
Definition: hdecay.h:120
float full5x5_eBottom() const
Definition: GsfElectron.h:474
float full5x5_hcalDepth2OverEcalBc() const
Definition: GsfElectron.h:465
float full5x5_eTop() const
Definition: GsfElectron.h:473
float ecalPFClusterIso() const
Definition: GsfElectron.h:675
float ecalEnergy() const
Definition: GsfElectron.h:844
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Candidate.h:37
virtual GsfElectronCoreRef core() const
Definition: GsfElectron.cc:8
float mva_Isolated() const
Definition: GsfElectron.h:687
float dr03EcalRecHitSumEt() const
Definition: GsfElectron.h:544
math::XYZVectorF trackMomentumAtEleClus() const
Definition: GsfElectron.h:294
float mva_e_pi() const
Definition: GsfElectron.h:688
float e5x5() const
Definition: GsfElectron.h:438
float dr03HcalTowerSumEtBc() const
Definition: GsfElectron.h:550
float full5x5_r9() const
Definition: GsfElectron.h:460
math::XYZVectorF momentumAtVtxWithConstraint
Definition: GsfElectron.h:285
float correctedEcalEnergyError() const
Definition: GsfElectron.h:831
void setCorrectedEcalEnergy(float newEnergy)
Definition: GsfElectron.cc:182
void setIsolation03(const IsolationVariables &dr03)
Definition: GsfElectron.h:569
float r9() const
Definition: GsfElectron.h:439
float deltaEtaSeedClusterTrackAtCalo() const
Definition: GsfElectron.h:250
const ShowerShape & full5x5_showerShape() const
Definition: GsfElectron.h:475
fixed size matrix
void setTrackExtrapolations(const TrackExtrapolations &te)
Definition: GsfElectron.h:299
const IsolationVariables & dr03IsolationVariables() const
Definition: GsfElectron.h:551
int convFlags() const
Definition: GsfElectron.h:603
math::XYZPointF trackPositionAtVtx() const
Definition: GsfElectron.h:289
float full5x5_eRight() const
Definition: GsfElectron.h:472
bool isEBPhiGap() const
Definition: GsfElectron.h:358
bool isGsfCtfScPixChargeConsistent() const
Definition: GsfElectron.h:154
SuperClusterRef superCluster() const override
reference to a SuperCluster
Definition: GsfElectron.h:184
ClosestCtfTrack(TrackRef track, float sh)
Definition: GsfElectron.h:198
const TrackClusterMatching & trackClusterMatching() const
Definition: GsfElectron.h:258
bool trackerDrivenSeed() const
Definition: GsfElectron.h:189
void setPassPflowPreselection(bool flag)
Definition: GsfElectron.h:714
void push_back(value_type const &ref)
Add a Ref<C, T> to the RefVector.
Definition: RefVector.h:69
size_type size() const
Size of the RefVector.
Definition: RefVector.h:107
float dr03HcalTowerSumEt() const
Definition: GsfElectron.h:547
const ConversionRejection & conversionRejectionVariables() const
Definition: GsfElectron.h:608
void setDeltaEtaSuperClusterAtVtx(float de)
Definition: GsfElectron.h:261
float dRz1
Pixel match variable: deltaRz for innermost hit.
Definition: GsfElectron.h:870
void setCorrections(const Corrections &c)
Definition: GsfElectron.h:840
void setClassificationVariables(const ClassificationVariables &cv)
Definition: GsfElectron.h:762
float scE5x5() const
Definition: GsfElectron.h:486
TrackClusterMatching trackClusterMatching_
Definition: GsfElectron.h:268
bool passCutBasedPreselection_
Definition: GsfElectron.h:726
float hcalDepth1OverEcalBc() const
Definition: GsfElectron.h:444
IsolationVariables dr03_
Definition: GsfElectron.h:577
void addAmbiguousGsfTrack(const reco::GsfTrackRef &t)
Definition: GsfElectron.h:717
float sumChargedHadronPt
sum-pt of charged Hadron // old float chargedHadronIso ;
Definition: GsfElectron.h:625
void full5x5_setShowerShape(const ShowerShape &s)
Definition: GsfElectron.h:479
TrackExtrapolations trackExtrapolations_
Definition: GsfElectron.h:309
float full5x5_e2x5Right() const
Definition: GsfElectron.h:468
float caloEnergy() const
Definition: GsfElectron.h:847
bool ecalDriven() const
Definition: GsfElectron.cc:174
void setFFlagIsEEDeeGap(const bool b)
Definition: GsfElectron.h:370
bool passPflowPreselection_
Definition: GsfElectron.h:727
float ctfGsfOverlap() const
Definition: GsfElectron.h:187
const FiducialFlags & fiducialFlags() const
Definition: GsfElectron.h:362
void setP4(const LorentzVector &p4) final
set 4-momentum
void setPixelMatchDRz1(float dRz1)
Definition: GsfElectron.h:887
virtual ClosestCtfTrack closestCtfTrack() const
Definition: GsfElectron.h:202
float sigmaEtaEta() const
Definition: GsfElectron.h:433
float scE1x5() const
Definition: GsfElectron.h:484
float full5x5_e2x5Left() const
Definition: GsfElectron.h:467
virtual TrackRef closestTrack() const
Definition: GsfElectron.h:186
float energyError(float E, float *par)
bool ecalDrivenSeed() const
Definition: GsfElectron.h:188
bool passingPflowPreselection() const
Definition: GsfElectron.h:706