DataTree/interface/Electron.h

//--------------------------------------------------------------------------------------------------
// $Id: Electron.h,v 1.36 2009/08/07 20:12:50 ceballos Exp $
//
// Electron
//
// This class holds information about reconstructed electrons from CMSSW.
//
// Authors: C.Loizides, J.Bendavid, S.Xie
//--------------------------------------------------------------------------------------------------

#ifndef MITANA_DATATREE_ELECTRON_H
#define MITANA_DATATREE_ELECTRON_H
 
#include "MitAna/DataTree/interface/SuperCluster.h"
#include "MitAna/DataTree/interface/ChargedParticle.h"
#include "MitAna/DataCont/interface/Ref.h"

namespace mithep 
{
  class Electron : public ChargedParticle
  {
    public:
      Electron() : 
        fCharge(0),
        fESuperClusterOverP(0), fESeedClusterOverPout(0), fDeltaEtaSuperClTrkAtVtx(0),
        fDeltaEtaSeedClTrkAtCalo(0), fDeltaPhiSuperClTrkAtVtx(0), 
        fDeltaPhiSeedClTrkAtCalo(0), fFBrem(0), fHadronicOverEm(0), fHcalDepth1OverEcal(0),
        fHcalDepth2OverEcal(0), fNumberOfClusters(0), fE15(0), fE25Max(0),
        fE55(0), fCovEtaEta(0), fCoviEtaiEta(0),
        fCaloIsolation(0), fHcalJurassicIsolation(0),
        fHcalDepth1TowerSumEtDr04(0), fHcalDepth2TowerSumEtDr04(0),
        fEcalJurassicIsolation(0), fTrackIsolationDr04(0), fCaloTowerIsolation(0),
        fHcalDepth1TowerSumEtDr03(0), fHcalDepth2TowerSumEtDr03(0),
        fEcalRecHitSumEtDr03(0), fTrackIsolation(0), fPassLooseID(0),
        fPassTightID(0), fIDLikelihood(0), fPIn(0), fPOut(0), fFracSharedHits(0),
        fMva(0), fIsEnergyScaleCorrected(0), fIsMomentumCorrected(0),
        fClassification(0), fIsEB(), fIsEE(0), fIsEBEEGap(0), fIsEBEtaGap(0),
        fIsEBPhiGap(0), fIsEEDeeGap(0), fIsEERingGap(0),
        fIsEcalDriven(0), fIsTrackerDriven(0) {}

      const Track         *BestTrk()                const;
      Double_t             CaloIsolation()          const { return fCaloIsolation;       } // *DEPRECATED*
      Int_t                Classification()         const { return fClassification;      }
      Double_t             CovEtaEta()              const { return fCovEtaEta;           }
      Double_t             CoviEtaiEta()            const { return fCoviEtaiEta;         }
      Double_t             DeltaEtaSuperClusterTrackAtVtx() const 
                             { return fDeltaEtaSuperClTrkAtVtx; }
      Double_t             DeltaEtaSeedClusterTrackAtCalo() const 
                             { return fDeltaEtaSeedClTrkAtCalo; }
      Double_t             DeltaPhiSuperClusterTrackAtVtx() const 
                             { return fDeltaPhiSuperClTrkAtVtx; }
      Double_t             DeltaPhiSeedClusterTrackAtCalo() const 
                             { return fDeltaPhiSeedClTrkAtCalo; }
      Double_t             E15()                    const { return fE15;                }
      Double_t             E25Max()                 const { return fE25Max;             }
      Double_t             E55()                    const { return fE55;                }
      Double_t             ESuperClusterOverP()     const { return fESuperClusterOverP;            }
      Double_t             ESeedClusterOverPout()   const { return fESeedClusterOverPout;          }
      Double_t             ESeedClusterOverPIn()    const;
      Double_t             FBrem()                  const { return fFBrem;                         }
      Double_t             FBremOld()               const { return (PIn() - POut())/PIn();         }
      Double_t             FracSharedHits()         const { return fFracSharedHits;                }
      const Track         *GsfTrk()                 const { return fGsfTrackRef.Obj();             }
      Double_t             HadronicOverEm()         const { return fHadronicOverEm;                }
      Double_t             HcalDepth1OverEcal()     const { return fHcalDepth1OverEcal;            }
      Double_t             HcalDepth2OverEcal()     const { return fHcalDepth2OverEcal;            }
      Bool_t               HasGsfTrk()              const { return fGsfTrackRef.IsValid();         }
      Bool_t               HasTrackerTrk()          const { return fTrackerTrackRef.IsValid();     }
      Bool_t               HasSuperCluster()        const { return fSuperClusterRef.IsValid();     }
      Double_t             HcalIsolation()          const { return fHcalJurassicIsolation;         } // *DEPRECATED*
      Double_t             IDLikelihood()           const { return fIDLikelihood;                  }
      Bool_t               IsEnergyScaleCorrected() const { return fIsEnergyScaleCorrected;        }
      Bool_t               IsMomentumCorrected()    const { return fIsMomentumCorrected;           }
      Bool_t               IsEB()                   const { return fIsEB;                          }
      Bool_t               IsEE()                   const { return fIsEE;                          }
      Bool_t               IsEBEEGap()              const { return fIsEBEEGap;                     }
      Bool_t               IsEBEtaGap()             const { return fIsEBEtaGap;                    }
      Bool_t               IsEBPhiGap()             const { return fIsEBPhiGap;                    }
      Bool_t               IsEEDeeGap()             const { return fIsEEDeeGap;                    }
      Bool_t               IsEERingGap()            const { return fIsEERingGap;                   }
      Bool_t               IsEcalDriven()           const { return fIsEcalDriven;                  }
      Bool_t               IsTrackerDriven()        const { return fIsTrackerDriven;               }
      Double_t             Mva()                    const { return fMva;                           }
      Double_t             NumberOfClusters()       const { return fNumberOfClusters;              }
      EObjType             ObjType()                const { return kElectron;                      }
      Double_t             PassLooseID()            const { return fPassLooseID;                   }
      Double_t             PassTightID()            const { return fPassTightID;                   }
      Double_t             PIn()                    const { return fPIn;                           }
      Double_t             POut()                   const { return fPOut;                          }
      const SuperCluster  *SCluster()               const { return fSuperClusterRef.Obj();         }
      
      Double_t             EcalRecHitIsoDr04()      const { return fEcalJurassicIsolation;         }
      Double_t             HcalTowerSumEtDr04()     const { return HcalDepth1TowerSumEtDr04() +
                                                                   HcalDepth2TowerSumEtDr04();     }
      Double_t             HcalDepth1TowerSumEtDr04() const { return fHcalDepth1TowerSumEtDr04;    }
      Double_t             HcalDepth2TowerSumEtDr04() const { return fHcalDepth2TowerSumEtDr04;    }
      Double_t             TrackIsolationDr04()     const { return fTrackIsolationDr04;            }
      Double_t             EcalRecHitIsoDr03()      const { return fEcalRecHitSumEtDr03;           }
      Double_t             HcalTowerSumEtDr03()     const { return fCaloTowerIsolation;            }
      Double_t             HcalDepth1TowerSumEtDr03() const { return fHcalDepth1TowerSumEtDr03;    }
      Double_t             HcalDepth2TowerSumEtDr03() const { return fHcalDepth2TowerSumEtDr03;    }
      Double_t             TrackIsolationDr03()     const { return fTrackIsolation;                }
      
      
      void                 SetCharge(Char_t x)                    { fCharge = x;                   }
      void                 SetClassification(Int_t x)             { fClassification = x;           }
      void                 SetCovEtaEta(Double_t CovEtaEta)       { fCovEtaEta = CovEtaEta;        }
      void                 SetCoviEtaiEta(Double_t CoviEtaiEta)   { fCoviEtaiEta = CoviEtaiEta;    }
      void                 SetDeltaEtaSuperClusterTrackAtVtx(Double_t x)  
                             { fDeltaEtaSuperClTrkAtVtx = x;   }
      void                 SetDeltaEtaSeedClusterTrackAtCalo(Double_t x)  
                             { fDeltaEtaSeedClTrkAtCalo = x;   }
      void                 SetDeltaPhiSuperClusterTrackAtVtx(Double_t x)  
                             { fDeltaPhiSuperClTrkAtVtx = x;   }
      void                 SetDeltaPhiSeedClusterTrackAtCalo(Double_t x)  
                             { fDeltaPhiSeedClTrkAtCalo = x;   }
      void                 SetE15(Double_t x)                     { fE15 = x;                      }
      void                 SetE25Max(Double_t x)                  { fE25Max = x;                   }
      void                 SetE55(Double_t x)                     { fE55 = x;                      }
      void                 SetESeedClusterOverPout(Double_t x)    { fESeedClusterOverPout = x;     }
      void                 SetESuperClusterOverP(Double_t x)      { fESuperClusterOverP = x;       }
      void                 SetFBrem(Double_t x)                   { fFBrem = x;                    }
      void                 SetFracSharedHits(Double_t x)          { fFracSharedHits = x;           }
      void                 SetGsfTrk(const Track* t)                     
                             { fGsfTrackRef = t; ClearCharge(); }
      void                 SetHadronicOverEm(Double_t x)          { fHadronicOverEm = x;           }
      void                 SetHcalDepth1OverEcal(Double_t x)      { fHcalDepth1OverEcal = x;       }
      void                 SetHcalDepth2OverEcal(Double_t x)      { fHcalDepth2OverEcal = x;       }
      void                 SetIDLikelihood(Double_t likelihood)   { fIDLikelihood = likelihood;    }
      void                 SetIsEnergyScaleCorrected(Bool_t x)    { fIsEnergyScaleCorrected = x;   }
      void                 SetIsMomentumCorrected(Bool_t x)       { fIsMomentumCorrected = x;      }
      void                 SetNumberOfClusters(Double_t x)        { fNumberOfClusters = x;         }
      void                 SetPIn(Double_t PIn)                   { fPIn = PIn;                    }
      void                 SetPOut(Double_t POut)                 { fPOut = POut;                  }
      void                 SetPassLooseID(Double_t passLooseID)   { fPassLooseID = passLooseID;    }
      void                 SetPassTightID(Double_t passTightID)   { fPassTightID = passTightID;    }
      void                 SetPtEtaPhi(Double_t pt, Double_t eta, Double_t phi);
      void                 SetSuperCluster(const SuperCluster* sc) 
                             { fSuperClusterRef = sc; }
      void                 SetTrackerTrk(const Track* t)                 
                             { fTrackerTrackRef = t; ClearCharge(); }
      void                 SetEcalRecHitIsoDr04(Double_t x)        { fEcalJurassicIsolation = x;    }
      void                 SetHcalDepth1TowerSumEtDr04(Double_t x) { fHcalDepth1TowerSumEtDr04 = x; }
      void                 SetHcalDepth2TowerSumEtDr04(Double_t x) { fHcalDepth2TowerSumEtDr04 = x; }
      void                 SetTrackIsolationDr04(Double_t x)       { fTrackIsolationDr04 = x;       }
      void                 SetEcalRecHitIsoDr03(Double_t x)        { fEcalRecHitSumEtDr03 = x;      }
      void                 SetHcalTowerSumEtDr03(Double_t x)       { fCaloTowerIsolation = x;       }
      void                 SetHcalDepth1TowerSumEtDr03(Double_t x) { fHcalDepth1TowerSumEtDr03 = x; }
      void                 SetHcalDepth2TowerSumEtDr03(Double_t x) { fHcalDepth2TowerSumEtDr03 = x; }
      void                 SetTrackIsolationDr03(Double_t x)       { fTrackIsolation = x;   }
      void                 SetMva(Double_t x)                      { fMva = x;              }
      void                 SetIsEB(Bool_t b)                       { fIsEB = b;             }
      void                 SetIsEE(Bool_t b)                       { fIsEE = b;             }
      void                 SetIsEBEEGap(Bool_t b)                  { fIsEBEEGap = b;        }
      void                 SetIsEBEtaGap(Bool_t b)                 { fIsEBEtaGap = b;       }
      void                 SetIsEBPhiGap(Bool_t b)                 { fIsEBPhiGap = b;       }
      void                 SetIsEEDeeGap(Bool_t b)                 { fIsEEDeeGap = b;       }
      void                 SetIsEERingGap(Bool_t b)                { fIsEERingGap = b;      }
      void                 SetIsEcalDriven(Bool_t b)               { fIsEcalDriven = b;     }
      void                 SetIsTrackerDriven(Bool_t b)            { fIsTrackerDriven = b;  }
      
     
      const Track         *TrackerTrk()            const { return fTrackerTrackRef.Obj();   }
      const Track         *Trk()                   const { return BestTrk();                }

    protected:
      Double_t             GetCharge()             const;
      Double_t             GetMass()               const { return 0.51099892e-3;            }
      void                 GetMom()                const;

      Vect3C               fMom;                       //stored three-momentum
      Char_t               fCharge;                    //stored charge - filled with -99 when reading old files
      Ref<Track>           fGsfTrackRef;               //gsf track reference
      Ref<Track>           fTrackerTrackRef;           //tracker track reference
      Ref<SuperCluster>    fSuperClusterRef;           //reference to SuperCluster
      Double32_t           fESuperClusterOverP;        //[0,0,14]super cluster e over p ratio
      Double32_t           fESeedClusterOverPout;      //[0,0,14]seed cluster e over p mom
      Double32_t           fDeltaEtaSuperClTrkAtVtx;   //[0,0,14]delta eta of super cluster with trk
      Double32_t           fDeltaEtaSeedClTrkAtCalo;   //[0,0,14]delta eta of seeed cluster with trk
      Double32_t           fDeltaPhiSuperClTrkAtVtx;   //[0,0,14]delta phi of super cluster with trk
      Double32_t           fDeltaPhiSeedClTrkAtCalo;   //[0,0,14]delta phi of seeed cluster with trk
      Double32_t           fFBrem;                     //[0,0,14]brem fraction
      Double32_t           fHadronicOverEm;            //[0,0,14]hadronic over em fraction *DEPRECATED*
      Double32_t           fHcalDepth1OverEcal;        //[0,0,14]hadronic over em fraction depth1
      Double32_t           fHcalDepth2OverEcal;        //[0,0,14]hadronic over em fraction depth2
      Double32_t           fNumberOfClusters;          //[0,0,14]number of associated clusters
      Double32_t           fE15;                       //[0,0,14]1x5 crystal energy
      Double32_t           fE25Max;                    //[0,0,14]2x5 crystal energy (max of two possible sums)
      Double32_t           fE55;                       //[0,0,14]5x5 crystal energy
      Double32_t           fCovEtaEta;                 //[0,0,14]variance eta-eta
      Double32_t           fCoviEtaiEta;               //[0,0,14]covariance eta-eta (in crystals)
      Double32_t           fCaloIsolation;             //[0,0,14](non-jura) ecal isolation based on rechits dR 0.3 *DEPRECATED*
      Double32_t           fHcalJurassicIsolation;     //[0,0,14]hcal jura iso dR 0.4 *DEPRECATED*
      Double32_t           fHcalDepth1TowerSumEtDr04;  //[0,0,14]hcal depth1 tower based isolation dR 0.4
      Double32_t           fHcalDepth2TowerSumEtDr04;  //[0,0,14]hcal depth2 tower based isolation dR 0.4
      Double32_t           fEcalJurassicIsolation;     //[0,0,14]ecal jura iso dR 0.4 *RENAMING*
      Double32_t           fTrackIsolationDr04;        //[0,0,14]isolation based on tracks dR 0.4
      Double32_t           fCaloTowerIsolation;        //[0,0,14]hcal tower based isolation dR 0.3 *DEPRECATED*
      Double32_t           fHcalDepth1TowerSumEtDr03;  //[0,0,14]hcal depth1 tower based isolation dR 0.3
      Double32_t           fHcalDepth2TowerSumEtDr03;  //[0,0,14]hcal depth2 tower based isolation dR 0.3
      Double32_t           fEcalRecHitSumEtDr03;       //[0,0,14]ecal jura iso dR 0.3
      Double32_t           fTrackIsolation;            //[0,0,14]isolation based on tracks dR 0.3 *RENAMING*
      Double32_t           fPassLooseID;               //[0,0,14]pass loose id
      Double32_t           fPassTightID;               //[0,0,14]pass tight id
      Double32_t           fIDLikelihood;              //[0,0,14]likelihood value
      Double32_t           fPIn;                       //[0,0,14]momentum at vtx
      Double32_t           fPOut;                      //[0,0,14]momentum at ecal surface
      Double32_t           fFracSharedHits;            //[0,0,14]fraction of shared hits btw gsf and std. track
      Double32_t           fMva;                       //[0,0,14] pflow mva output
      Bool_t               fIsEnergyScaleCorrected;    //class dependent escale correction
      Bool_t               fIsMomentumCorrected;       //class dependent E-p combination 
      Int_t                fClassification;            //classification (see GsfElectron.h)
      Bool_t               fIsEB;                      //is ECAL barrel
      Bool_t               fIsEE;                      //is ECAL Endcap
      Bool_t               fIsEBEEGap;                 //is in barrel-endcap gap
      Bool_t               fIsEBEtaGap;                //is in EB eta module gap
      Bool_t               fIsEBPhiGap;                //is in EB phi module gap
      Bool_t               fIsEEDeeGap;                //is in EE dee gap
      Bool_t               fIsEERingGap;               //is in EE ring gap
      Bool_t               fIsEcalDriven;              //is std. egamma electron
      Bool_t               fIsTrackerDriven;           //is pflow track-seeded electron

    ClassDef(Electron, 3) // Electron class
  };
}

//--------------------------------------------------------------------------------------------------
inline const mithep::Track *mithep::Electron::BestTrk() const
{
  // Return "best" track.

  if (HasGsfTrk())
    return GsfTrk();
  else if (HasTrackerTrk())
    return TrackerTrk();

  return 0;
}

//--------------------------------------------------------------------------------------------------
inline Double_t mithep::Electron::GetCharge() const
{
  // Return stored charge, unless it is set to invalid (-99),
  // in that case get charge from track as before

  if (fCharge==-99)
    return mithep::ChargedParticle::GetCharge();
  else
    return fCharge;

}

//--------------------------------------------------------------------------------------------------
inline void mithep::Electron::GetMom() const
{
  // Get momentum of the electron. We use an explicitly stored three vector, with the pdg mass,
  // since the momentum vector may be computed non-trivially in cmssw

  fCachedMom.SetCoordinates(fMom.Rho(),fMom.Eta(),fMom.Phi(),GetMass());
}

//-------------------------------------------------------------------------------------------------
inline Double_t mithep::Electron::ESeedClusterOverPIn() const
{
  // Return energy of the SuperCluster seed divided by the magnitude 
  // of the track momentum at the vertex.
  
  return SCluster()->Seed()->Energy() / PIn();
}

//-------------------------------------------------------------------------------------------------
inline void mithep::Electron::SetPtEtaPhi(Double_t pt, Double_t eta, Double_t phi)
{
  // Set three-vector
  
  fMom.Set(pt,eta,phi);
  ClearMom();
}
#endif
Revision:	1.37
Committed:	Fri Oct 30 14:16:00 2009 UTC (15 years, 6 months ago) by bendavid
Content type:	text/plain
Branch:	MAIN
Changes since 1.36:	+19 -2 lines
Log Message:	Add support for explicitly stored electron charge, backwards compatibility using schema evolution
#	User	Rev	Content
1	bendavid	1.1	//--------------------------------------------------------------------------------------------------
2	bendavid	1.37	// $Id: Electron.h,v 1.36 2009/08/07 20:12:50 ceballos Exp $
3	bendavid	1.1	//
4	paus	1.3	// Electron
5	bendavid	1.1	//
6	loizides	1.29	// This class holds information about reconstructed electrons from CMSSW.
7	bendavid	1.1	//
8	sixie	1.13	// Authors: C.Loizides, J.Bendavid, S.Xie
9	bendavid	1.1	//--------------------------------------------------------------------------------------------------
10
11	loizides	1.23	#ifndef MITANA_DATATREE_ELECTRON_H
12			#define MITANA_DATATREE_ELECTRON_H
13	loizides	1.6
14	sixie	1.13	#include "MitAna/DataTree/interface/SuperCluster.h"
15	bendavid	1.11	#include "MitAna/DataTree/interface/ChargedParticle.h"
16	bendavid	1.24	#include "MitAna/DataCont/interface/Ref.h"
17	loizides	1.6
18	bendavid	1.1	namespace mithep
19			{
20	bendavid	1.11	class Electron : public ChargedParticle
21	bendavid	1.1	{
22			public:
23	loizides	1.34	Electron() :
24	bendavid	1.37	fCharge(0),
25	loizides	1.34	fESuperClusterOverP(0), fESeedClusterOverPout(0), fDeltaEtaSuperClTrkAtVtx(0),
26			fDeltaEtaSeedClTrkAtCalo(0), fDeltaPhiSuperClTrkAtVtx(0),
27			fDeltaPhiSeedClTrkAtCalo(0), fFBrem(0), fHadronicOverEm(0), fHcalDepth1OverEcal(0),
28	bendavid	1.35	fHcalDepth2OverEcal(0), fNumberOfClusters(0), fE15(0), fE25Max(0),
29			fE55(0), fCovEtaEta(0), fCoviEtaiEta(0),
30	loizides	1.34	fCaloIsolation(0), fHcalJurassicIsolation(0),
31			fHcalDepth1TowerSumEtDr04(0), fHcalDepth2TowerSumEtDr04(0),
32			fEcalJurassicIsolation(0), fTrackIsolationDr04(0), fCaloTowerIsolation(0),
33			fHcalDepth1TowerSumEtDr03(0), fHcalDepth2TowerSumEtDr03(0),
34			fEcalRecHitSumEtDr03(0), fTrackIsolation(0), fPassLooseID(0),
35			fPassTightID(0), fIDLikelihood(0), fPIn(0), fPOut(0), fFracSharedHits(0),
36			fMva(0), fIsEnergyScaleCorrected(0), fIsMomentumCorrected(0),
37			fClassification(0), fIsEB(), fIsEE(0), fIsEBEEGap(0), fIsEBEtaGap(0),
38			fIsEBPhiGap(0), fIsEEDeeGap(0), fIsEERingGap(0),
39			fIsEcalDriven(0), fIsTrackerDriven(0) {}
40	loizides	1.29
41			const Track *BestTrk() const;
42	ceballos	1.36	Double_t CaloIsolation() const { return fCaloIsolation; } // DEPRECATED
43	loizides	1.34	Int_t Classification() const { return fClassification; }
44			Double_t CovEtaEta() const { return fCovEtaEta; }
45			Double_t CoviEtaiEta() const { return fCoviEtaiEta; }
46	loizides	1.27	Double_t DeltaEtaSuperClusterTrackAtVtx() const
47			{ return fDeltaEtaSuperClTrkAtVtx; }
48			Double_t DeltaEtaSeedClusterTrackAtCalo() const
49			{ return fDeltaEtaSeedClTrkAtCalo; }
50			Double_t DeltaPhiSuperClusterTrackAtVtx() const
51			{ return fDeltaPhiSuperClTrkAtVtx; }
52			Double_t DeltaPhiSeedClusterTrackAtCalo() const
53			{ return fDeltaPhiSeedClTrkAtCalo; }
54	loizides	1.34	Double_t E15() const { return fE15; }
55			Double_t E25Max() const { return fE25Max; }
56			Double_t E55() const { return fE55; }
57	loizides	1.29	Double_t ESuperClusterOverP() const { return fESuperClusterOverP; }
58			Double_t ESeedClusterOverPout() const { return fESeedClusterOverPout; }
59			Double_t ESeedClusterOverPIn() const;
60	bendavid	1.33	Double_t FBrem() const { return fFBrem; }
61			Double_t FBremOld() const { return (PIn() - POut())/PIn(); }
62			Double_t FracSharedHits() const { return fFracSharedHits; }
63	loizides	1.29	const Track *GsfTrk() const { return fGsfTrackRef.Obj(); }
64	loizides	1.30	Double_t HadronicOverEm() const { return fHadronicOverEm; }
65	bendavid	1.33	Double_t HcalDepth1OverEcal() const { return fHcalDepth1OverEcal; }
66			Double_t HcalDepth2OverEcal() const { return fHcalDepth2OverEcal; }
67	loizides	1.29	Bool_t HasGsfTrk() const { return fGsfTrackRef.IsValid(); }
68			Bool_t HasTrackerTrk() const { return fTrackerTrackRef.IsValid(); }
69			Bool_t HasSuperCluster() const { return fSuperClusterRef.IsValid(); }
70	ceballos	1.36	Double_t HcalIsolation() const { return fHcalJurassicIsolation; } // DEPRECATED
71	loizides	1.29	Double_t IDLikelihood() const { return fIDLikelihood; }
72			Bool_t IsEnergyScaleCorrected() const { return fIsEnergyScaleCorrected; }
73			Bool_t IsMomentumCorrected() const { return fIsMomentumCorrected; }
74	bendavid	1.33	Bool_t IsEB() const { return fIsEB; }
75			Bool_t IsEE() const { return fIsEE; }
76			Bool_t IsEBEEGap() const { return fIsEBEEGap; }
77			Bool_t IsEBEtaGap() const { return fIsEBEtaGap; }
78			Bool_t IsEBPhiGap() const { return fIsEBPhiGap; }
79			Bool_t IsEEDeeGap() const { return fIsEEDeeGap; }
80			Bool_t IsEERingGap() const { return fIsEERingGap; }
81			Bool_t IsEcalDriven() const { return fIsEcalDriven; }
82			Bool_t IsTrackerDriven() const { return fIsTrackerDriven; }
83			Double_t Mva() const { return fMva; }
84	loizides	1.29	Double_t NumberOfClusters() const { return fNumberOfClusters; }
85			EObjType ObjType() const { return kElectron; }
86			Double_t PassLooseID() const { return fPassLooseID; }
87			Double_t PassTightID() const { return fPassTightID; }
88			Double_t PIn() const { return fPIn; }
89			Double_t POut() const { return fPOut; }
90			const SuperCluster *SCluster() const { return fSuperClusterRef.Obj(); }
91	bendavid	1.33
92			Double_t EcalRecHitIsoDr04() const { return fEcalJurassicIsolation; }
93			Double_t HcalTowerSumEtDr04() const { return HcalDepth1TowerSumEtDr04() +
94			HcalDepth2TowerSumEtDr04(); }
95			Double_t HcalDepth1TowerSumEtDr04() const { return fHcalDepth1TowerSumEtDr04; }
96			Double_t HcalDepth2TowerSumEtDr04() const { return fHcalDepth2TowerSumEtDr04; }
97			Double_t TrackIsolationDr04() const { return fTrackIsolationDr04; }
98			Double_t EcalRecHitIsoDr03() const { return fEcalRecHitSumEtDr03; }
99			Double_t HcalTowerSumEtDr03() const { return fCaloTowerIsolation; }
100			Double_t HcalDepth1TowerSumEtDr03() const { return fHcalDepth1TowerSumEtDr03; }
101			Double_t HcalDepth2TowerSumEtDr03() const { return fHcalDepth2TowerSumEtDr03; }
102			Double_t TrackIsolationDr03() const { return fTrackIsolation; }
103
104
105	bendavid	1.37	void SetCharge(Char_t x) { fCharge = x; }
106	loizides	1.29	void SetClassification(Int_t x) { fClassification = x; }
107			void SetCovEtaEta(Double_t CovEtaEta) { fCovEtaEta = CovEtaEta; }
108			void SetCoviEtaiEta(Double_t CoviEtaiEta) { fCoviEtaiEta = CoviEtaiEta; }
109	loizides	1.27	void SetDeltaEtaSuperClusterTrackAtVtx(Double_t x)
110			{ fDeltaEtaSuperClTrkAtVtx = x; }
111			void SetDeltaEtaSeedClusterTrackAtCalo(Double_t x)
112			{ fDeltaEtaSeedClTrkAtCalo = x; }
113			void SetDeltaPhiSuperClusterTrackAtVtx(Double_t x)
114			{ fDeltaPhiSuperClTrkAtVtx = x; }
115			void SetDeltaPhiSeedClusterTrackAtCalo(Double_t x)
116			{ fDeltaPhiSeedClTrkAtCalo = x; }
117	bendavid	1.33	void SetE15(Double_t x) { fE15 = x; }
118			void SetE25Max(Double_t x) { fE25Max = x; }
119			void SetE55(Double_t x) { fE55 = x; }
120	loizides	1.29	void SetESeedClusterOverPout(Double_t x) { fESeedClusterOverPout = x; }
121			void SetESuperClusterOverP(Double_t x) { fESuperClusterOverP = x; }
122	bendavid	1.33	void SetFBrem(Double_t x) { fFBrem = x; }
123			void SetFracSharedHits(Double_t x) { fFracSharedHits = x; }
124	loizides	1.29	void SetGsfTrk(const Track* t)
125	bendavid	1.31	{ fGsfTrackRef = t; ClearCharge(); }
126	loizides	1.29	void SetHadronicOverEm(Double_t x) { fHadronicOverEm = x; }
127	bendavid	1.33	void SetHcalDepth1OverEcal(Double_t x) { fHcalDepth1OverEcal = x; }
128			void SetHcalDepth2OverEcal(Double_t x) { fHcalDepth2OverEcal = x; }
129	loizides	1.29	void SetIDLikelihood(Double_t likelihood) { fIDLikelihood = likelihood; }
130			void SetIsEnergyScaleCorrected(Bool_t x) { fIsEnergyScaleCorrected = x; }
131			void SetIsMomentumCorrected(Bool_t x) { fIsMomentumCorrected = x; }
132			void SetNumberOfClusters(Double_t x) { fNumberOfClusters = x; }
133			void SetPIn(Double_t PIn) { fPIn = PIn; }
134			void SetPOut(Double_t POut) { fPOut = POut; }
135			void SetPassLooseID(Double_t passLooseID) { fPassLooseID = passLooseID; }
136			void SetPassTightID(Double_t passTightID) { fPassTightID = passTightID; }
137	bendavid	1.31	void SetPtEtaPhi(Double_t pt, Double_t eta, Double_t phi);
138			void SetSuperCluster(const SuperCluster* sc)
139			{ fSuperClusterRef = sc; }
140	loizides	1.29	void SetTrackerTrk(const Track* t)
141	bendavid	1.31	{ fTrackerTrackRef = t; ClearCharge(); }
142	bendavid	1.33	void SetEcalRecHitIsoDr04(Double_t x) { fEcalJurassicIsolation = x; }
143			void SetHcalDepth1TowerSumEtDr04(Double_t x) { fHcalDepth1TowerSumEtDr04 = x; }
144			void SetHcalDepth2TowerSumEtDr04(Double_t x) { fHcalDepth2TowerSumEtDr04 = x; }
145			void SetTrackIsolationDr04(Double_t x) { fTrackIsolationDr04 = x; }
146	loizides	1.34	void SetEcalRecHitIsoDr03(Double_t x) { fEcalRecHitSumEtDr03 = x; }
147	bendavid	1.33	void SetHcalTowerSumEtDr03(Double_t x) { fCaloTowerIsolation = x; }
148			void SetHcalDepth1TowerSumEtDr03(Double_t x) { fHcalDepth1TowerSumEtDr03 = x; }
149			void SetHcalDepth2TowerSumEtDr03(Double_t x) { fHcalDepth2TowerSumEtDr03 = x; }
150	loizides	1.34	void SetTrackIsolationDr03(Double_t x) { fTrackIsolation = x; }
151			void SetMva(Double_t x) { fMva = x; }
152			void SetIsEB(Bool_t b) { fIsEB = b; }
153			void SetIsEE(Bool_t b) { fIsEE = b; }
154			void SetIsEBEEGap(Bool_t b) { fIsEBEEGap = b; }
155			void SetIsEBEtaGap(Bool_t b) { fIsEBEtaGap = b; }
156			void SetIsEBPhiGap(Bool_t b) { fIsEBPhiGap = b; }
157			void SetIsEEDeeGap(Bool_t b) { fIsEEDeeGap = b; }
158			void SetIsEERingGap(Bool_t b) { fIsEERingGap = b; }
159			void SetIsEcalDriven(Bool_t b) { fIsEcalDriven = b; }
160			void SetIsTrackerDriven(Bool_t b) { fIsTrackerDriven = b; }
161	bendavid	1.33
162
163	loizides	1.34	const Track *TrackerTrk() const { return fTrackerTrackRef.Obj(); }
164			const Track *Trk() const { return BestTrk(); }
165	sixie	1.13
166	loizides	1.8	protected:
167	bendavid	1.37	Double_t GetCharge() const;
168	loizides	1.34	Double_t GetMass() const { return 0.51099892e-3; }
169	loizides	1.27	void GetMom() const;
170	loizides	1.25
171	bendavid	1.31	Vect3C fMom; //stored three-momentum
172	bendavid	1.37	Char_t fCharge; //stored charge - filled with -99 when reading old files
173	loizides	1.27	Ref<Track> fGsfTrackRef; //gsf track reference
174			Ref<Track> fTrackerTrackRef; //tracker track reference
175			Ref<SuperCluster> fSuperClusterRef; //reference to SuperCluster
176	loizides	1.29	Double32_t fESuperClusterOverP; //[0,0,14]super cluster e over p ratio
177			Double32_t fESeedClusterOverPout; //[0,0,14]seed cluster e over p mom
178			Double32_t fDeltaEtaSuperClTrkAtVtx; //[0,0,14]delta eta of super cluster with trk
179			Double32_t fDeltaEtaSeedClTrkAtCalo; //[0,0,14]delta eta of seeed cluster with trk
180			Double32_t fDeltaPhiSuperClTrkAtVtx; //[0,0,14]delta phi of super cluster with trk
181			Double32_t fDeltaPhiSeedClTrkAtCalo; //[0,0,14]delta phi of seeed cluster with trk
182	bendavid	1.33	Double32_t fFBrem; //[0,0,14]brem fraction
183			Double32_t fHadronicOverEm; //[0,0,14]hadronic over em fraction DEPRECATED
184			Double32_t fHcalDepth1OverEcal; //[0,0,14]hadronic over em fraction depth1
185			Double32_t fHcalDepth2OverEcal; //[0,0,14]hadronic over em fraction depth2
186	loizides	1.29	Double32_t fNumberOfClusters; //[0,0,14]number of associated clusters
187	bendavid	1.33	Double32_t fE15; //[0,0,14]1x5 crystal energy
188			Double32_t fE25Max; //[0,0,14]2x5 crystal energy (max of two possible sums)
189	loizides	1.29	Double32_t fE55; //[0,0,14]5x5 crystal energy
190			Double32_t fCovEtaEta; //[0,0,14]variance eta-eta
191			Double32_t fCoviEtaiEta; //[0,0,14]covariance eta-eta (in crystals)
192	bendavid	1.33	Double32_t fCaloIsolation; //[0,0,14](non-jura) ecal isolation based on rechits dR 0.3 DEPRECATED
193			Double32_t fHcalJurassicIsolation; //[0,0,14]hcal jura iso dR 0.4 DEPRECATED
194			Double32_t fHcalDepth1TowerSumEtDr04; //[0,0,14]hcal depth1 tower based isolation dR 0.4
195			Double32_t fHcalDepth2TowerSumEtDr04; //[0,0,14]hcal depth2 tower based isolation dR 0.4
196			Double32_t fEcalJurassicIsolation; //[0,0,14]ecal jura iso dR 0.4 RENAMING
197			Double32_t fTrackIsolationDr04; //[0,0,14]isolation based on tracks dR 0.4
198			Double32_t fCaloTowerIsolation; //[0,0,14]hcal tower based isolation dR 0.3 DEPRECATED
199			Double32_t fHcalDepth1TowerSumEtDr03; //[0,0,14]hcal depth1 tower based isolation dR 0.3
200			Double32_t fHcalDepth2TowerSumEtDr03; //[0,0,14]hcal depth2 tower based isolation dR 0.3
201			Double32_t fEcalRecHitSumEtDr03; //[0,0,14]ecal jura iso dR 0.3
202			Double32_t fTrackIsolation; //[0,0,14]isolation based on tracks dR 0.3 RENAMING
203	loizides	1.29	Double32_t fPassLooseID; //[0,0,14]pass loose id
204			Double32_t fPassTightID; //[0,0,14]pass tight id
205			Double32_t fIDLikelihood; //[0,0,14]likelihood value
206			Double32_t fPIn; //[0,0,14]momentum at vtx
207			Double32_t fPOut; //[0,0,14]momentum at ecal surface
208	bendavid	1.33	Double32_t fFracSharedHits; //[0,0,14]fraction of shared hits btw gsf and std. track
209			Double32_t fMva; //[0,0,14] pflow mva output
210	loizides	1.29	Bool_t fIsEnergyScaleCorrected; //class dependent escale correction
211			Bool_t fIsMomentumCorrected; //class dependent E-p combination
212			Int_t fClassification; //classification (see GsfElectron.h)
213	bendavid	1.33	Bool_t fIsEB; //is ECAL barrel
214			Bool_t fIsEE; //is ECAL Endcap
215			Bool_t fIsEBEEGap; //is in barrel-endcap gap
216			Bool_t fIsEBEtaGap; //is in EB eta module gap
217			Bool_t fIsEBPhiGap; //is in EB phi module gap
218			Bool_t fIsEEDeeGap; //is in EE dee gap
219			Bool_t fIsEERingGap; //is in EE ring gap
220			Bool_t fIsEcalDriven; //is std. egamma electron
221			Bool_t fIsTrackerDriven; //is pflow track-seeded electron
222	sixie	1.13
223	bendavid	1.37	ClassDef(Electron, 3) // Electron class
224	bendavid	1.1	};
225	loizides	1.4	}
226	loizides	1.8
227	loizides	1.9	//--------------------------------------------------------------------------------------------------
228	loizides	1.10	inline const mithep::Track *mithep::Electron::BestTrk() const
229	loizides	1.9	{
230	loizides	1.10	// Return "best" track.
231
232	bendavid	1.24	if (HasGsfTrk())
233	loizides	1.10	return GsfTrk();
234	bendavid	1.24	else if (HasTrackerTrk())
235	loizides	1.10	return TrackerTrk();
236	loizides	1.9
237	loizides	1.10	return 0;
238	loizides	1.9	}
239
240	loizides	1.25	//--------------------------------------------------------------------------------------------------
241	bendavid	1.37	inline Double_t mithep::Electron::GetCharge() const
242			{
243			// Return stored charge, unless it is set to invalid (-99),
244			// in that case get charge from track as before
245
246			if (fCharge==-99)
247			return mithep::ChargedParticle::GetCharge();
248			else
249			return fCharge;
250
251			}
252
253			//--------------------------------------------------------------------------------------------------
254	loizides	1.25	inline void mithep::Electron::GetMom() const
255	sixie	1.14	{
256	bendavid	1.31	// Get momentum of the electron. We use an explicitly stored three vector, with the pdg mass,
257			// since the momentum vector may be computed non-trivially in cmssw
258	sixie	1.14
259	bendavid	1.31	fCachedMom.SetCoordinates(fMom.Rho(),fMom.Eta(),fMom.Phi(),GetMass());
260	bendavid	1.18	}
261
262			//-------------------------------------------------------------------------------------------------
263	loizides	1.25	inline Double_t mithep::Electron::ESeedClusterOverPIn() const
264	bendavid	1.18	{
265	loizides	1.25	// Return energy of the SuperCluster seed divided by the magnitude
266			// of the track momentum at the vertex.
267
268			return SCluster()->Seed()->Energy() / PIn();
269	bendavid	1.18	}
270	bendavid	1.31
271			//-------------------------------------------------------------------------------------------------
272			inline void mithep::Electron::SetPtEtaPhi(Double_t pt, Double_t eta, Double_t phi)
273			{
274			// Set three-vector
275
276			fMom.Set(pt,eta,phi);
277			ClearMom();
278			}
279	loizides	1.8	#endif