ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitAna/DataTree/interface/Muon.h

Comparing UserCode/MitAna/DataTree/interface/Muon.h (file contents):
Revision 1.14 by loizides, Wed Sep 10 03:33:27 2008 UTC vs.
Revision 1.43 by ceballos, Sat May 21 13:27:58 2011 UTC

#	Line 3 | Line 3
3		//
4		// Muon
5		//
6	<	// Details to be worked out...
6	>	// Classified into 3 Types
7	>	//  Standalone  : Muon fit from hits in the muon chambers
8	>	//  Tracker     : Tracker matched track to muon chambers with segments
9	>	//  Global      : Combined track and muon chambers fit
10		//
11	<	// Authors: C.Loizides, J.Bendavid, C.Paus
11	>	//  In the muon class all three muon classes exist and can be determined by checking
12	>	//  whether a fit track exists for such a Muon (eg HasTrackerTrk() == kTRUE). When
13	>	//  BestTrk function is called the global fit is returned, if that does not
14	>	//  exist the tracker fit is returned upon that failure the standalone muon
15	>	//  is subsequently returned. To consult more see:
16	>	//  http://cmsdoc.cern.ch/cms/Physics/muon/MPOG/Notes/MuonReco.pdf
17	>	//
18	>	// Quality Varaibles for Selection
19	>	//  Isolation : decomposed to IsoRNNXXXXX
20	>	//    NN = 03,05 to denote R =0.3,0.5 in Isolation Cone
21	>	//    XXXXX = SumPt - Sum of Pt of Tracks in Cone (using all Pt Tracks)
22	>	//    XXXXX = EmEt  - Sum of Et of Em component of Calo Towers  (Veto=0.08)
23	>	//    XXXXX = HadEt - Sum of Et of Had component of Calo Towers (Veto=0.1)
24	>	//    XXXXX = HoEt  - Sum of Pt of Ho component of Calo Towers  (Veto=0.1)
25	>	//    XXXXX = NTrk  - Number of Tracks within Cone (using all Pt Tracks)
26	>	//    XXXXX = NJet  - Sum of Jets inside Cone
27	>	//
28	>	// Muon Quality Variables
29	>	//  Extracted from the Muon Tracking Associator
30	>	//   For more se https://twiki.cern.ch/twiki/bin/view/CMS/TrackAssociator
31	>	//  Energy Variables : Energy within (5x5 Ecal Crystal/Hcal/Ho) along Track
32	>	//   using calo towers
33	>	//  S9 Energy Variables : Energy using reconstructed hits calo towers default
34	>	//  Segment Variables :
35	>	//   Segment variables are stored in array of 8:
36	>	//     0-3: Correspond to segments in 4 DT chambers  in->outward(3 has no Y res)
37	>	//     4-7: Correspond to segments in 4 CSC chambers in->out
38	>	//    If value undetermined 999999 is returned.
39	>	//   Variables:
40	>	//    DX,DY,PullX,PullY: Uncertainties/Pulls of propagated track
41	>	//     with respect to local muon segment
42	>	//   TrackDist,TrackDistErr: Summed Dist/Err (in X,Y) of segment with respect
43	>	//    to propagated track
44	>	//   NSegments : Number of segments in muon using Segment+Track Arbitration
45	>	//   NChambers : Number of muon chambers traversed in propagated track
46	>	//   NMatches  : Number of muon chambers with matches
47	>	//   LastHit   : Returns farest (from center) station with a recorded segment
48	>	//   LastStation  : Returns farest station using Segment+Track Arbitration
49	>	//
50	>	//  Muon Id Methods: Please see Muon Id Note(as of now unpublished):
51	>	//      https://www.cmsaf.mit.edu/twiki/pub/CmsHep/HepWAnalysis/MuonID-ingo.pdf
52	>	//   TMOneStation : Returns bool whether muon passes "Tracker Muon One StationId"
53	>	//    -Matching criteria for one of all segments matched to muon
54	>	//   TMLastStation : Returns bool whether muon passes "LastStation Id" criteria
55	>	//    -Matching criteria for last most segment
56	>	//
57	>	// Authors: J.Bendavid, C.Loizides, C.Paus, P.Harris
58		//--------------------------------------------------------------------------------------------------
59
60		#ifndef MITANA_DATATREE_MUON_H
61		#define MITANA_DATATREE_MUON_H
62
14	–	#include <TRef.h>
15	–	#include "MitAna/DataTree/interface/ChargedParticle.h"
63		#include "MitAna/DataTree/interface/Track.h"
64	+	#include "MitAna/DataTree/interface/ChargedParticle.h"
65	+	#include "MitAna/DataTree/interface/MuonQuality.h"
66
67	<	namespace mithep
68	<	{
20	<	class Muon : public ChargedParticle
21	<	{
67	>	namespace mithep {
68	>	class Muon : public ChargedParticle {
69		public:
70	<	Muon() {}
71	<	~Muon() {}
72	<
73	<	const Track   *BestTrk()            const;
74	<	const Track   *GlobalTrk()          const;
75	<	const Track   *StandaloneTrk()      const;
76	<	const Track   *TrackerTrk()         const;
77	<	const Track   *Trk()                const { return BestTrk();          }
78	<	Double_t       IsoR03SumPt()        const { return fIsoR03SumPt;       }
32	<	Double_t       IsoR03EmEt()         const { return fIsoR03EmEt;        }
33	<	Double_t       IsoR03HadEt()        const { return fIsoR03HadEt;       }
34	<	Double_t       IsoR03HoEt()         const { return fIsoR03HoEt;        }
35	<	Int_t          IsoR03NTracks()      const { return fIsoR03NTracks;     }
36	<	Int_t          IsoR03NJets()        const { return fIsoR03NJets;       }
37	<	Double_t       IsoR05SumPt()        const { return fIsoR05SumPt;       }
38	<	Double_t       IsoR05EmEt()         const { return fIsoR05EmEt;        }
39	<	Double_t       IsoR05HadEt()        const { return fIsoR05HadEt;       }
40	<	Double_t       IsoR05HoEt()         const { return fIsoR05HoEt;        }
41	<	Int_t          IsoR05NTracks()      const { return fIsoR05NTracks;     }
42	<	Int_t          IsoR05NJets()        const { return fIsoR05NJets;       }
43	<	Double_t       EmEnergy()           const { return fEmEnergy;          }
44	<	Double_t       HadEnergy()          const { return fHadEnergy;         }
45	<	Double_t       HoEnergy()           const { return fHoEnergy;          }
46	<	Double_t       EmS9Energy()         const { return fEmS9Energy;        }
47	<	Double_t       HadS9Energy()        const { return fHadS9Energy;       }
48	<	Double_t       HoS9Energy()         const { return fHoS9Energy;        }
49	<	Double_t       Mass()               const { return 105.658369e-3;      }
70	>	Muon();
71	>
72	>	enum EClassType {
73	>	kNone,              //no track assigned
74	>	kGlobal,            //"Global"
75	>	kTracker,           //"Tracker"
76	>	kSta,               //"Standalone"
77	>	kAny                //any "best" of the above
78	>	};
79
80	<	void           SetGlobalTrk(Track* t)                { fGlobalTrackRef = t;            }
81	<	void           SetStandaloneTrk(Track* t)            { fStandaloneTrackRef = t;        }
82	<	void           SetTrackerTrk(Track* t)               { fTrackerTrackRef = t;           }
83	<	void           SetIsoR03SumPt(Double_t isoR03SumPt)  { fIsoR03SumPt = isoR03SumPt;     }
84	<	void           SetIsoR03EmEt(Double_t isoR03EmEt)    { fIsoR03EmEt = isoR03EmEt;       }
85	<	void           SetIsoR03HadEt(Double_t isoR03HadEt)  { fIsoR03HadEt = isoR03HadEt;     }
86	<	void           SetIsoR03HoEt(Double_t isoR03HoEt)    { fIsoR03HoEt = isoR03HoEt;       }
87	<	void           SetIsoR03NTracks(Int_t isoR03NTracks) { fIsoR03NTracks = isoR03NTracks; }
88	<	void           SetIsoR03NJets(Int_t isoR03NJets)     { fIsoR03NJets = isoR03NJets;     }
89	<	void           SetIsoR05SumPt(Double_t isoR05SumPt)  { fIsoR05SumPt = isoR05SumPt;     }
90	<	void           SetIsoR05EmEt(Double_t isoR05EmEt)    { fIsoR05EmEt = isoR05EmEt;       }
91	<	void           SetIsoR05HadEt(Double_t isoR05HadEt)  { fIsoR05HadEt = isoR05HadEt;     }
92	<	void           SetIsoR05HoEt(Double_t isoR05HoEt)    { fIsoR05HoEt = isoR05HoEt;       }
93	<	void           SetIsoR05NTracks(Int_t isoR05NTracks) { fIsoR05NTracks = isoR05NTracks; }
94	<	void           SetIsoR05NJets(Int_t isoR05NJets)     { fIsoR05NJets = isoR05NJets;     }
95	<	void           SetEmEnergy(Double_t EmEnergy)        { fEmEnergy = EmEnergy;           }
96	<	void           SetHadEnergy(Double_t HadEnergy)      { fHadEnergy = HadEnergy;         }
97	<	void           SetHoEnergy(Double_t HoEnergy)        { fHoEnergy = HoEnergy;           }
98	<	void           SetEmS9Energy(Double_t EmS9Energy)    { fEmS9Energy = EmS9Energy;       }
99	<	void           SetHadS9Energy(Double_t HadS9Energy)  { fHadS9Energy = HadS9Energy;     }
100	<	void           SetHoS9Energy(Double_t HoS9Energy)    { fHoS9Energy = HoS9Energy;       }
80	>	const Track   *BestTrk()                       const;
81	>	const Track   *GlobalTrk()                     const { return fGlobalTrkRef.Obj();       }
82	>	const Track   *StandaloneTrk()                 const { return fStaTrkRef.Obj();          }
83	>	const Track   *TrackerTrk()                    const { return fTrkTrkRef.Obj();          }
84	>	const Track   *Trk()                           const { return BestTrk();                 }
85	>	Double_t       D0PV()                          const { return fD0PV;                     }
86	>	Double_t       D0PVErr()                       const { return fD0PVErr;                  }
87	>	Double_t       D0PVSignificance()              const { return fD0PV/fD0PVErr;            }
88	>	Double_t       Ip3dPV()                        const { return fIp3dPV;                   }
89	>	Double_t       Ip3dPVErr()                     const { return fIp3dPVErr;                }
90	>	Double_t       Ip3dPVSignificance()            const { return fIp3dPV/fIp3dPVErr;        }
91	>	Double_t       D0PVBS()                        const { return fD0PVBS;                   }
92	>	Double_t       D0PVBSErr()                     const { return fD0PVBSErr;                }
93	>	Double_t       D0PVBSSignificance()            const { return fD0PVBS/fD0PVBSErr;        }
94	>	Double_t       Ip3dPVBS()                      const { return fIp3dPVBS;                 }
95	>	Double_t       Ip3dPVBSErr()                   const { return fIp3dPVBSErr;              }
96	>	Double_t       Ip3dPVBSSignificance()          const { return fIp3dPVBS/fIp3dPVBSErr;    }
97	>	Double_t       D0PVUB()                          const { return fD0PVUB;                     }
98	>	Double_t       D0PVUBErr()                       const { return fD0PVUBErr;                  }
99	>	Double_t       D0PVUBSignificance()              const { return fD0PVUB/fD0PVUBErr;            }
100	>	Double_t       Ip3dPVUB()                        const { return fIp3dPVUB;                   }
101	>	Double_t       Ip3dPVUBErr()                     const { return fIp3dPVUBErr;                }
102	>	Double_t       Ip3dPVUBSignificance()            const { return fIp3dPVUB/fIp3dPVUBErr;        }
103	>	Double_t       D0PVUBBS()                        const { return fD0PVUBBS;                   }
104	>	Double_t       D0PVUBBSErr()                     const { return fD0PVUBBSErr;                }
105	>	Double_t       D0PVUBBSSignificance()            const { return fD0PVUBBS/fD0PVUBBSErr;        }
106	>	Double_t       Ip3dPVUBBS()                      const { return fIp3dPVUBBS;                 }
107	>	Double_t       Ip3dPVUBBSErr()                   const { return fIp3dPVUBBSErr;              }
108	>	Double_t       Ip3dPVUBBSSignificance()          const { return fIp3dPVUBBS/fIp3dPVUBBSErr;    }
109	>	Double_t       PVCompatibility()               const { return fPVCompatibility;          }
110	>	Double_t       PVBSCompatibility()             const { return fPVBSCompatibility;        }
111	>	Double_t       TrkKink()                       const { return fTrkKink;                  }
112	>	Double_t       GlbKink()                       const { return fGlbKink;                  }
113	>	Double_t       EmEnergy()                      const { return fEmEnergy;                 }
114	>	Double_t       EmS9Energy()                    const { return fEmS9Energy;               }
115	>	Double_t       GetDX(Int_t iStation)           const;
116	>	Double_t       GetDY(Int_t iStation)           const;
117	>	Double_t       GetPullX(Int_t iStation)        const;
118	>	Double_t       GetPullY(Int_t iStation)        const;
119	>	Double_t       GetTrackDist(Int_t iStation)    const;
120	>	Double_t       GetTrackDistErr(Int_t iStation) const;
121	>	Int_t          GetNSegments(Int_t iStation)    const;
122	>	Bool_t         Has(EClassType type)            const;
123	>	Bool_t         HasTrk()                        const;
124	>	Bool_t         HasGlobalTrk()                  const { return fGlobalTrkRef.IsValid();   }
125	>	Bool_t         HasStandaloneTrk()              const { return fStaTrkRef.IsValid();      }
126	>	Bool_t         HasTrackerTrk()                 const { return fTrkTrkRef.IsValid();      }
127	>	Double_t       HadEnergy()                     const { return fHadEnergy;                }
128	>	Double_t       HadS9Energy()                   const { return fHadS9Energy;              }
129	>	Double_t       HoEnergy()                      const { return fHoEnergy;                 }
130	>	Double_t       HoS9Energy()                    const { return fHoS9Energy;               }
131	>	EClassType     Is()                            const;
132	>	Bool_t         IsGlobalMuon()                  const { return fIsGlobalMuon;             }
133	>	Bool_t         IsTrackerMuon()                 const { return fIsTrackerMuon;            }
134	>	Bool_t         IsStandaloneMuon()              const { return fIsStandaloneMuon;         }
135	>	Bool_t         IsCaloMuon()                    const { return fIsCaloMuon;               }
136	>	Double_t       IsoR03SumPt()                   const { return fIsoR03SumPt;              }
137	>	Double_t       IsoR03EmEt()                    const { return fIsoR03EmEt;               }
138	>	Double_t       IsoR03HadEt()                   const { return fIsoR03HadEt;              }
139	>	Double_t       IsoR03HoEt()                    const { return fIsoR03HoEt;               }
140	>	UShort_t       IsoR03NTracks()                 const { return fIsoR03NTracks;            }
141	>	UShort_t       IsoR03NJets()                   const { return fIsoR03NJets;              }
142	>	Double_t       IsoR05SumPt()                   const { return fIsoR05SumPt;              }
143	>	Double_t       IsoR05EmEt()                    const { return fIsoR05EmEt;               }
144	>	Double_t       IsoR05HadEt()                   const { return fIsoR05HadEt;              }
145	>	Double_t       IsoR05HoEt()                    const { return fIsoR05HoEt;               }
146	>	UShort_t       IsoR05NTracks()                 const { return fIsoR05NTracks;            }
147	>	UShort_t       IsoR05NJets()                   const { return fIsoR05NJets;              }
148	>	UInt_t         NValidHits()                    const { return fNValidHits;               }
149	>	UInt_t         NChambers()                     const { return fNTraversedChambers;       }
150	>	UInt_t         NSegments()                     const { return fStationMask.NBitsSet();   }
151	>	UInt_t         NMatches()                      const { return fNMatches;                 }
152	>	Int_t          LastHit()                       const;
153	>	Int_t          LastStation(Double_t iMaxD, Double_t iMaxP)               const;
154	>	Int_t          LastStation(Int_t iMax=8)       const;
155	>	Int_t          ObjId()                         const { return ObjType()*1000+Is();       }
156	>	EObjType       ObjType()                       const { return kMuon;                     }
157	>	void           Print(Option_t *opt="")         const;
158	>	Bool_t         PromptTight(EClassType type)    const;
159	>	const MuonQuality  &Quality()                  const { return fQuality;                  }
160	>	MuonQuality        &Quality()                        { return fQuality;                  }
161	>	Bool_t         StationBit(Int_t bit)           const { return fStationMask.TestBit(bit); }
162	>	Bool_t         TMLastStation(Double_t iDYMin = 3, Double_t iPYMin = 3,
163	>	Double_t iDXMin = 3, Double_t iPXMin = 3,UInt_t iN = 2) const;
164	>	Bool_t         TMOneStation(Double_t iDYMin = 3, Double_t iPYMin = 3,
165	>	Double_t iDXMin = 3, Double_t iPXMin = 3,UInt_t iN = 1)  const;
166	>	void           SetCharge(Char_t x)                   { fCharge = x; ClearCharge();       }
167	>	void           SetGlobalTrk(const Track *t)
168	>	{ fGlobalTrkRef = t; ClearMom(); ClearCharge(); }
169	>	void           SetStandaloneTrk(const Track *t)
170	>	{ fStaTrkRef = t;    ClearMom(); ClearCharge(); }
171	>	void           SetTrackerTrk(const Track *t)
172	>	{ fTrkTrkRef = t;    ClearMom(); ClearCharge(); }
173	>	void           SetDX(Int_t iStation, Double_t iDX);
174	>	void           SetDY(Int_t iStation, Double_t iDY);
175	>	void           SetD0PV(Double_t x)                   { fD0PV = x;                        }
176	>	void           SetD0PVErr(Double_t x)                { fD0PVErr = x;                     }
177	>	void           SetIp3dPV(Double_t x)                 { fIp3dPV = x;                      }
178	>	void           SetIp3dPVErr(Double_t x)              { fIp3dPVErr = x;                   }
179	>	void           SetD0PVBS(Double_t x)                 { fD0PVBS = x;                      }
180	>	void           SetD0PVBSErr(Double_t x)              { fD0PVBSErr = x;                   }
181	>	void           SetIp3dPVBS(Double_t x)               { fIp3dPVBS = x;                    }
182	>	void           SetIp3dPVBSErr(Double_t x)            { fIp3dPVBSErr = x;                 }
183	>	void           SetD0PVUB(Double_t x)                   { fD0PVUB = x;                        }
184	>	void           SetD0PVUBErr(Double_t x)                { fD0PVUBErr = x;                     }
185	>	void           SetIp3dPVUB(Double_t x)                 { fIp3dPVUB = x;                      }
186	>	void           SetIp3dPVUBErr(Double_t x)              { fIp3dPVUBErr = x;                   }
187	>	void           SetD0PVUBBS(Double_t x)                 { fD0PVUBBS = x;                      }
188	>	void           SetD0PVUBBSErr(Double_t x)              { fD0PVUBBSErr = x;                   }
189	>	void           SetIp3dPVUBBS(Double_t x)               { fIp3dPVUBBS = x;                    }
190	>	void           SetIp3dPVUBBSErr(Double_t x)            { fIp3dPVUBBSErr = x;                 }
191	>	void           SetPVCompatibility(Double_t x)        { fPVCompatibility = x;             }
192	>	void           SetPVBSCompatibility(Double_t x)      { fPVBSCompatibility = x;           }
193	>	void           SetTrkKink(Double_t x)                { fTrkKink = x;                     }
194	>	void           SetGlbKink(Double_t x)                { fGlbKink = x;                     }
195	>	void           SetEmEnergy(Double_t EmEnergy)        { fEmEnergy = EmEnergy;             }
196	>	void           SetEmS9Energy(Double_t EmS9Energy)    { fEmS9Energy = EmS9Energy;         }
197	>	void           SetHadEnergy(Double_t HadEnergy)      { fHadEnergy = HadEnergy;           }
198	>	void           SetHadS9Energy(Double_t HadS9Energy)  { fHadS9Energy = HadS9Energy;       }
199	>	void           SetHoEnergy(Double_t HoEnergy)        { fHoEnergy = HoEnergy;             }
200	>	void           SetHoS9Energy(Double_t HoS9Energy)    { fHoS9Energy = HoS9Energy;         }
201	>	void           SetIsGlobalMuon(Bool_t b)             { fIsGlobalMuon = b;                }
202	>	void           SetIsTrackerMuon(Bool_t b)            { fIsTrackerMuon = b;               }
203	>	void           SetIsStandaloneMuon(Bool_t b)         { fIsStandaloneMuon = b;            }
204	>	void           SetIsCaloMuon(Bool_t b)               { fIsCaloMuon = b;                  }
205	>	void           SetIsoR03SumPt(Double_t isoR03SumPt)  { fIsoR03SumPt = isoR03SumPt;       }
206	>	void           SetIsoR03EmEt(Double_t isoR03EmEt)    { fIsoR03EmEt = isoR03EmEt;         }
207	>	void           SetIsoR03HadEt(Double_t isoR03HadEt)  { fIsoR03HadEt = isoR03HadEt;       }
208	>	void           SetIsoR03HoEt(Double_t isoR03HoEt)    { fIsoR03HoEt = isoR03HoEt;         }
209	>	void           SetIsoR03NTracks(UShort_t isoR03NTrk) { fIsoR03NTracks = isoR03NTrk;      }
210	>	void           SetIsoR03NJets(UShort_t isoR03NJets)  { fIsoR03NJets = isoR03NJets;       }
211	>	void           SetIsoR05SumPt(Double_t isoR05SumPt)  { fIsoR05SumPt = isoR05SumPt;       }
212	>	void           SetIsoR05EmEt(Double_t isoR05EmEt)    { fIsoR05EmEt = isoR05EmEt;         }
213	>	void           SetIsoR05HadEt(Double_t isoR05HadEt)  { fIsoR05HadEt = isoR05HadEt;       }
214	>	void           SetIsoR05HoEt(Double_t isoR05HoEt)    { fIsoR05HoEt = isoR05HoEt;         }
215	>	void           SetIsoR05NTracks(UShort_t isoR05NTrk) { fIsoR05NTracks = isoR05NTrk;      }
216	>	void           SetIsoR05NJets(UShort_t isoR05NJets)  { fIsoR05NJets = isoR05NJets;       }
217	>	void           SetNValidHits(UShort_t iNValidHits)   { fNValidHits  = iNValidHits;       }
218	>	void           SetNChambers(UShort_t iNTraCh)        { fNTraversedChambers = iNTraCh;    }
219	>	void           SetNSegments(Int_t iStation, Int_t NSegments);
220	>	void           SetNMatches(UShort_t iNMatCh)         { fNMatches = iNMatCh;              }
221	>	void           SetPtEtaPhi(Double_t pt, Double_t eta, Double_t phi);
222	>	void           SetPullX(Int_t iStation, Double_t iPullX);
223	>	void           SetPullY(Int_t iStation, Double_t iPullY);
224	>	void           SetStationMask(UInt_t iStMask)        { fStationMask.SetBits(iStMask);    }
225	>	void           SetTrackDist(Int_t iStation, Double_t iDist);
226	>	void           SetTrackDistErr(Int_t iStation, Double_t iDistErr);
227
228		protected:
229	<	TRef           fGlobalTrackRef;      //global combined track reference
230	<	TRef           fStandaloneTrackRef;  //standalone muon track reference
231	<	TRef           fTrackerTrackRef;     //tracker track reference
232	<	Double_t       fIsoR03SumPt;
233	<	Double_t       fIsoR03EmEt;
234	<	Double_t       fIsoR03HadEt;
235	<	Double_t       fIsoR03HoEt;
236	<	Int_t          fIsoR03NTracks;
237	<	Int_t          fIsoR03NJets;
238	<	Double_t       fIsoR05SumPt;
239	<	Double_t       fIsoR05EmEt;
240	<	Double_t       fIsoR05HadEt;
241	<	Double_t       fIsoR05HoEt;
242	<	Int_t          fIsoR05NTracks;
243	<	Int_t          fIsoR05NJets;
244	<	Double_t       fEmEnergy;
245	<	Double_t       fHadEnergy;
246	<	Double_t       fHoEnergy;
247	<	Double_t       fEmS9Energy;
248	<	Double_t       fHadS9Energy;
249	<	Double_t       fHoS9Energy;
229	>	Double_t       GetCharge()                     const;
230	>	Double_t       GetMass()                       const { return 105.658369e-3;             }
231	>	void           GetMom()                        const;
232	>
233	>	Vect3C         fMom;                 //stored three-momentum
234	>	Char_t         fCharge;              //stored charge - filled with -99 when reading old files
235	>	Ref<Track>     fGlobalTrkRef;        //global combined track reference
236	>	Ref<Track>     fStaTrkRef;           //standalone muon track reference
237	>	Ref<Track>     fTrkTrkRef;           //tracker track reference
238	>	Double32_t     fIsoR03SumPt;         //[0,0,14]isolation size R=0.3 sum pt
239	>	Double32_t     fIsoR03EmEt;          //[0,0,14]isolation size R=0.3 em  trans energy
240	>	Double32_t     fIsoR03HadEt;         //[0,0,14]isolation size R=0.3 had trans energy
241	>	Double32_t     fIsoR03HoEt;          //[0,0,14]isolation size R=0.3 ho  trans energy
242	>	UShort_t       fIsoR03NTracks;       //isolation size R=0.3 number of tracks
243	>	UShort_t       fIsoR03NJets;         //isolation size R=0.3 number of jets
244	>	Double32_t     fIsoR05SumPt;         //[0,0,14]isolation size R=0.5 sum pt
245	>	Double32_t     fIsoR05EmEt;          //[0,0,14]isolation size R=0.5 em  trans energy
246	>	Double32_t     fIsoR05HadEt;         //[0,0,14]isolation size R=0.5 had trans energy
247	>	Double32_t     fIsoR05HoEt;          //[0,0,14]isolation size R=0.5 ho  trans energy
248	>	UShort_t       fIsoR05NTracks;       //isolation size R=0.5 number of tracks
249	>	UShort_t       fIsoR05NJets;         //isolation size R=0.5 number of jets
250	>	Double32_t     fEmEnergy;            //[0,0,14]energy deposit in ecal
251	>	Double32_t     fHadEnergy;           //[0,0,14]energy deposit in hcal
252	>	Double32_t     fHoEnergy;            //[0,0,14]energy deposit in outer hcal
253	>	Double32_t     fEmS9Energy;          //[0,0,14]energy deposit in 3x3 ecal
254	>	Double32_t     fHadS9Energy;         //[0,0,14]energy deposit in 3x3 hcal
255	>	Double32_t     fHoS9Energy;          //[0,0,14]energy deposit in 3x3 outer hcal
256	>	Double32_t     fD0PV;                //[0,0,14]transverse impact parameter to signal PV
257	>	Double32_t     fD0PVErr;             //[0,0,14]transverse impact parameter uncertainty to signal PV
258	>	Double32_t     fIp3dPV;              //[0,0,14]3d impact parameter to signal PV
259	>	Double32_t     fIp3dPVErr;           //[0,0,14]3d impact parameter uncertainty to signal PV
260	>	Double32_t     fD0PVBS;              //[0,0,14]transverse impact parameter to signal PV w/ bs constraint
261	>	Double32_t     fD0PVBSErr;           //[0,0,14]transverse impact parameter uncertainty to signal PV w/ bs constraint
262	>	Double32_t     fIp3dPVBS;            //[0,0,14]3d impact parameter to signal PV w/ bs constraint
263	>	Double32_t     fIp3dPVBSErr;         //[0,0,14]3d impact parameter uncertainty to signal PV w/ bs constraint
264	>	Double32_t     fD0PVUB;                //[0,0,14]transverse impact parameter to signal PVUB (unbiased primary vertex - refit removing lepton track)
265	>	Double32_t     fD0PVUBErr;             //[0,0,14]transverse impact parameter uncertainty to signal PVUB
266	>	Double32_t     fIp3dPVUB;              //[0,0,14]3d impact parameter to signal PVUB
267	>	Double32_t     fIp3dPVUBErr;           //[0,0,14]3d impact parameter uncertainty to signal PVUB
268	>	Double32_t     fD0PVUBBS;              //[0,0,14]transverse impact parameter to signal PVUB w/ bs constraint
269	>	Double32_t     fD0PVUBBSErr;           //[0,0,14]transverse impact parameter uncertainty to signal PVUB w/ bs constraint
270	>	Double32_t     fIp3dPVUBBS;            //[0,0,14]3d impact parameter to signal PVUB w/ bs constraint
271	>	Double32_t     fIp3dPVUBBSErr;         //[0,0,14]3d impact parameter uncertainty to signal PVUB w/ bs constraint
272	>	Double32_t     fPVCompatibility;     //[0,0,14]chi^2 compatibility with signal PV (ndof=2)
273	>	Double32_t     fPVBSCompatibility;   //[0,0,14]chi^2 compatibility with signal PV w/ bs constraint (ndof=2)
274	>	Double32_t     fTrkKink;             //[0,0,14]kink algorithm output (tracker track)
275	>	Double32_t     fGlbKink;             //[0,0,14]kink algorithm output (global track)
276	>	UShort_t       fNValidHits;          //number of Valid hits in global fit
277	>	UShort_t       fNTraversedChambers;  //number of traversed chambers
278	>	UShort_t       fNMatches;            //number of muon chambers with matches
279	>	MuonQuality    fQuality;             //muon quality
280	>	BitMask8       fStationMask;         //bitmap of station with tracks, 0-3 DT, 4-7 CSCs
281	>	Double32_t     fDX[8];               //[0,0,14]uncertainty in x in given muon chamber
282	>	Double32_t     fDY[8];               //[0,0,14]uncertainty in y in given muon chamber
283	>	Double32_t     fPullX[8];            //[0,0,14]pull in x in given muon chamber
284	>	Double32_t     fPullY[8];            //[0,0,14]pull in y in given muon chamber
285	>	Double32_t     fTrackDist[8];        //[0,0,14]dist. to track in trans. plane in muon chamber
286	>	Double32_t     fTrackDistErr[8];     //[0,0,14]error of dist. to track in trans. plane
287	>	Int_t          fNSegments[8];        //number of segments in given muon chamber
288	>	Bool_t         fIsGlobalMuon;        //GlobalMuon algo flag
289	>	Bool_t         fIsTrackerMuon;       //TrackerMuon algo flag
290	>	Bool_t         fIsStandaloneMuon;    //StandaloneMuon algo flag
291	>	Bool_t         fIsCaloMuon;          //CaloMuon algo flag
292
293	<	ClassDef(Muon, 1) // Muon class
293	>	ClassDef(Muon, 8) // Muon class
294		};
295		}
296
#	Line 102 | Line 299 | inline const mithep::Track *mithep::Muon
299		{
300		// Return "best" track.
301
302	<	if (GlobalTrk())
302	>	if (HasTrackerTrk())
303	>	return TrackerTrk();
304	>	else if (HasGlobalTrk())
305		return GlobalTrk();
306	<	else if (StandaloneTrk())
306	>	else if (HasStandaloneTrk())
307		return StandaloneTrk();
109	–	else if (TrackerTrk())
110	–	return TrackerTrk();
308
309	+	Error("BestTrk", "No track reference found, returning NULL pointer.");
310		return 0;
311		}
312
313		//--------------------------------------------------------------------------------------------------
314	<	inline const mithep::Track *mithep::Muon::GlobalTrk() const
315	<	{
316	<	// Return global combined track.
314	>	inline Double_t mithep::Muon::GetCharge() const
315	>	{
316	>	// Return stored charge, unless it is set to invalid (-99),
317	>	// in that case get charge from track as before
318	>
319	>	if (fCharge==-99)
320	>	return mithep::ChargedParticle::GetCharge();
321	>	else
322	>	return fCharge;
323	>
324	>	}
325	>
326	>	//--------------------------------------------------------------------------------------------------
327	>	inline void mithep::Muon::GetMom() const
328	>	{
329	>	// Get momentum of the muon. We use an explicitly stored three vector, with the pdg mass,
330	>	// since the momentum vector may be computed non-trivially in cmssw (since the tracker
331	>	// information has better resolution apparently in some cases than the global fit.)
332	>	// If momentum is unfilled, fall back to old method of getting momentum from best track
333	>	// (for backwards compatibility.)
334	>
335	>	if (fMom.Rho()>0.0) {
336	>	fCachedMom.SetCoordinates(fMom.Rho(),fMom.Eta(),fMom.Phi(),GetMass());
337	>	}
338	>	else {
339	>	mithep::ChargedParticle::GetMom();
340	>	}
341	>
342	>	}
343	>
344	>	//--------------------------------------------------------------------------------------------------
345	>	inline Double_t mithep::Muon::GetDX(Int_t iStation) const
346	>	{
347	>	// Return uncertainty in x in given chamber.
348	>
349	>	assert(iStation >= 0 && iStation < 8);
350	>	return fDX[iStation];
351	>	}
352	>
353	>	//--------------------------------------------------------------------------------------------------
354	>	inline Double_t mithep::Muon::GetDY(Int_t iStation) const
355	>	{
356	>	// Return uncertainty in y in given chamber.
357	>
358	>	assert(iStation >= 0 && iStation < 8);
359	>	return fDY[iStation];
360	>	}
361	>
362	>	//--------------------------------------------------------------------------------------------------
363	>	inline Double_t mithep::Muon::GetPullX(Int_t iStation) const
364	>	{
365	>	// Return pull in x in given chamber.
366	>
367	>	assert(iStation >= 0 && iStation < 8);
368	>	return fPullX[iStation];
369	>	}
370	>
371	>	//--------------------------------------------------------------------------------------------------
372	>	inline Double_t mithep::Muon::GetPullY(Int_t iStation) const
373	>	{
374	>	// Return pull in y in given chamber.
375	>
376	>	assert(iStation >= 0 && iStation < 8);
377	>	return fPullY[iStation];
378	>	}
379	>
380	>	//--------------------------------------------------------------------------------------------------
381	>	inline Double_t mithep::Muon::GetTrackDist(Int_t iStation) const
382	>	{
383	>	// Return track distance in given chamber.
384	>
385	>	assert(iStation >= 0 && iStation < 8);
386	>	return fTrackDist[iStation];
387	>	}
388	>
389	>	//--------------------------------------------------------------------------------------------------
390	>	inline Double_t mithep::Muon::GetTrackDistErr(Int_t iStation) const
391	>	{
392	>	// Return error of track distance in given chamber.
393	>
394	>	assert(iStation >= 0 && iStation < 8);
395	>	return fTrackDistErr[iStation];
396	>	}
397	>
398	>	//--------------------------------------------------------------------------------------------------
399	>	inline Int_t mithep::Muon::GetNSegments(Int_t iStation) const
400	>	{
401	>	// Return number of segments in chamber.
402	>
403	>	assert(iStation >= 0 && iStation < 8);
404	>	return fNSegments[iStation];
405	>	}
406	>
407	>	//--------------------------------------------------------------------------------------------------
408	>	inline Bool_t mithep::Muon::Has(EClassType type) const
409	>	{
410	>	// Return true if the muon has a track of given class.
411	>
412	>	switch (type) {
413	>	case kAny:
414	>	if (HasTrk())
415	>	return kTRUE;
416	>	break;
417	>	case kGlobal:
418	>	if (HasGlobalTrk())
419	>	return kTRUE;
420	>	break;
421	>	case kTracker:
422	>	if (HasTrackerTrk())
423	>	return kTRUE;
424	>	break;
425	>	case kSta:
426	>	if (HasStandaloneTrk())
427	>	return kTRUE;
428	>	break;
429	>	case kNone:
430	>	if (!HasTrk())
431	>	return kTRUE;
432	>	break;
433	>	default:
434	>	break;
435	>	}
436	>
437	>	return kFALSE;
438	>	}
439	>
440	>	//--------------------------------------------------------------------------------------------------
441	>	inline Bool_t mithep::Muon::HasTrk() const
442	>	{
443	>	// Return true if the muon has assigned any kind of track.
444	>
445	>	return (HasGlobalTrk() || HasTrackerTrk() || HasStandaloneTrk());
446	>	}
447	>
448	>	//--------------------------------------------------------------------------------------------------
449	>	inline mithep::Muon::EClassType mithep::Muon::Is() const
450	>	{
451	>	// Return the "best" classification of the muon according to the assigned tracks.
452	>
453	>	if (HasGlobalTrk())
454	>	return kGlobal;
455	>	else if (HasTrackerTrk())
456	>	return kTracker;
457	>	else if (HasStandaloneTrk())
458	>	return kSta;
459	>
460	>	return kNone;
461	>	}
462	>
463	>	//--------------------------------------------------------------------------------------------------
464	>	inline Int_t mithep::Muon::LastHit() const
465	>	{
466	>	// Return the last hit, or -1 if no one found.
467	>
468	>	Int_t lId = -1;
469	>	for (Int_t i0 = 0; i0 < 8; ++i0) {
470	>	if (GetDX(i0) < 99999 || GetDY(i0) < 99999)
471	>	lId = i0;
472	>	}
473	>	return lId;
474	>	}
475	>
476	>	//--------------------------------------------------------------------------------------------------
477	>	inline Int_t mithep::Muon::LastStation(Int_t iMax) const
478	>	{
479	>	// Return the last station, or -1 of no one found.
480	>
481	>	Int_t lId = -1;
482	>	if(TMath::Abs(iMax) > 8)
483	>	iMax = 8;
484	>	for (Int_t i0 = 0; i0 < iMax; ++i0) {
485	>	if (StationBit(i0) && ((lId % 4) < (i0 % 4)))
486	>	lId = i0;
487	>	}
488	>	return lId;
489	>	}
490	>
491	>	//--------------------------------------------------------------------------------------------------
492	>	inline Int_t mithep::Muon::LastStation(Double_t iMaxD, Double_t iMaxP) const
493	>	{
494	>	// Return the last station for given deviation and relative error, or -1 if no one found.
495	>
496	>	Int_t lId = -1;
497	>	for (Int_t i0 = 0; i0 < 8; ++i0) {
498	>	if ((lId % 4) > (i0 % 4))
499	>	continue;
500	>	if (GetTrackDist(i0) < iMaxD &&
501	>	GetTrackDist(i0)/GetTrackDistErr(i0) < iMaxP)
502	>	lId = i0;
503	>	}
504	>	return lId;
505	>	}
506	>
507	>	//--------------------------------------------------------------------------------------------------
508	>	inline Bool_t mithep::Muon::PromptTight(EClassType type) const
509	>	{
510	>	// Return whether track for given class matches tight quality criteria.
511
512	<	return static_cast<const Track*>(fGlobalTrackRef.GetObject());
512	>	const mithep::Track *lTrack = 0;
513	>	switch (type) {
514	>	case kAny:
515	>	lTrack = BestTrk();
516	>	break;
517	>	case kGlobal:
518	>	lTrack = GlobalTrk();
519	>	break;
520	>	case kTracker:
521	>	lTrack = TrackerTrk();
522	>	break;
523	>	case kSta:
524	>	lTrack = StandaloneTrk();
525	>	break;
526	>	default:
527	>	break;
528	>	}
529	>
530	>	if (lTrack == 0)
531	>	return kFALSE;
532	>	if (lTrack->NHits() < 11)
533	>	return kFALSE;
534	>	if (lTrack->Chi2()/lTrack->Ndof() > 10.)
535	>	return kFALSE;
536	>	if (lTrack->D0() > 0.2)
537	>	return kFALSE;
538	>	if ((LastHit() % 4) == 0)
539	>	return kFALSE;
540	>	return kTRUE;
541		}
542
543		//--------------------------------------------------------------------------------------------------
544	<	inline const mithep::Track *mithep::Muon::StandaloneTrk() const
545	<	{
546	<	// Return standalone track.
544	>	inline Bool_t mithep::Muon::TMOneStation(Double_t iDYMin, Double_t iPYMin,
545	>	Double_t iDXMin, Double_t iPXMin, UInt_t iN) const
546	>	{
547	>	// Check if the muon is matched to at least one station (chamber).
548
549	<	return static_cast<const Track*>(fStandaloneTrackRef.GetObject());
549	>	if (NSegments() < iN)
550	>	return kFALSE; //second last one
551	>
552	>	Bool_t pGoodX  = kFALSE;
553	>	Bool_t pBadY   = kFALSE;
554	>	for (Int_t i0 = 0; i0 < 8; ++i0) {
555	>	if ((TMath::Abs(GetDX(i0))    < iDXMin  ||
556	>	TMath::Abs(GetPullX(i0)) < iPXMin))
557	>	pGoodX = kTRUE;
558	>	if (pGoodX &&
559	>	(TMath::Abs(GetDY(i0))    < iDYMin  ||
560	>	TMath::Abs(GetPullY(i0)) < iPYMin))
561	>	return kTRUE;
562	>	if (TMath::Abs(GetDY(i0)) < 999999)
563	>	pBadY = kTRUE;
564	>	if (i0 == 3 && pGoodX && !pBadY)
565	>	return kTRUE;
566	>	}
567	>	return kFALSE;
568		}
569
570		//--------------------------------------------------------------------------------------------------
571	<	inline const mithep::Track *mithep::Muon::TrackerTrk() const
572	<	{
573	<	// Return tracker track.
571	>	inline Bool_t mithep::Muon::TMLastStation(Double_t iDYMin, Double_t iPYMin,
572	>	Double_t iDXMin, Double_t iPXMin, UInt_t iN) const
573	>	{
574	>	// Check if the muon is matched to its last station (chamber).
575	>
576	>	if (NSegments() < iN)
577	>	return kFALSE; //second last one
578	>
579	>	Int_t lLast = LastStation(-3.,-3.); // last required station
580	>	if (lLast < 0)
581	>	return kFALSE;
582	>	if (GetDX(lLast) > 9999.)
583	>	return kFALSE;
584	>	lLast = LastStation(); //no requirements
585	>	if (lLast < 0)
586	>	return kFALSE;
587	>	if (!(TMath::Abs(GetDX(lLast))    < iDXMin  ||
588	>	TMath::Abs(GetPullX(lLast)) < iPXMin))
589	>	return kFALSE;
590	>	if (lLast == 3)
591	>	lLast = LastStation(3);
592	>	if (lLast < 0)
593	>	return kFALSE;
594	>	if (!(TMath::Abs(GetDY(lLast))    < iDYMin ||
595	>	TMath::Abs(GetPullY(lLast)) < iPYMin))
596	>	return kFALSE;
597	>	return kTRUE;
598	>	}
599
600	<	return static_cast<const Track*>(fTrackerTrackRef.GetObject());
600	>	//--------------------------------------------------------------------------------------------------
601	>	inline void mithep::Muon::SetDX(Int_t iStation, Double_t iDX)
602	>	{
603	>	// Return uncertainty in x in given chamber.
604	>
605	>	assert(iStation >= 0 && iStation < 8);
606	>	fDX[iStation] = iDX;
607	>	}
608	>
609	>	//--------------------------------------------------------------------------------------------------
610	>	inline void mithep::Muon::SetDY(Int_t iStation, Double_t iDY)
611	>	{
612	>	// Return uncertainty in y in given chamber.
613	>
614	>	assert(iStation >= 0 && iStation < 8);
615	>	fDY[iStation] = iDY;
616	>	}
617	>
618	>	//--------------------------------------------------------------------------------------------------
619	>	inline void mithep::Muon::SetPullX(Int_t iStation, Double_t iPullX)
620	>	{
621	>	// Set pull in x in given chamber.
622	>
623	>	assert(iStation >= 0 && iStation < 8);
624	>	fPullX[iStation] = iPullX;
625	>	}
626	>
627	>	//--------------------------------------------------------------------------------------------------
628	>	inline void mithep::Muon::SetPullY(Int_t iStation, Double_t iPullY)
629	>	{
630	>	// Set pull in y in given chamber.
631	>
632	>	assert(iStation >= 0 && iStation < 8);
633	>	fPullY[iStation] = iPullY;
634	>	}
635	>
636	>	//--------------------------------------------------------------------------------------------------
637	>	inline void mithep::Muon::SetTrackDist(Int_t iStation, Double_t iDist)
638	>
639	>	{
640	>	// Set track distance in given chamber.
641	>
642	>	assert(iStation >= 0 && iStation < 8);
643	>	fTrackDist[iStation] = iDist;
644	>	}
645	>
646	>	//--------------------------------------------------------------------------------------------------
647	>	inline void mithep::Muon::SetTrackDistErr(Int_t iStation, Double_t iDistErr)
648	>	{
649	>	// Set error of track distance in given chamber.
650	>
651	>	assert(iStation >= 0 && iStation < 8);
652	>	fTrackDistErr[iStation] = iDistErr;
653	>	}
654	>
655	>	//--------------------------------------------------------------------------------------------------
656	>	inline void mithep::Muon::SetNSegments(Int_t iStation, Int_t NSegments)
657	>	{
658	>	// Set number of segments in chamber.
659	>
660	>	assert(iStation >= 0 && iStation < 8);
661	>	fNSegments[iStation] = NSegments;
662	>	}
663	>
664	>	//-------------------------------------------------------------------------------------------------
665	>	inline void mithep::Muon::SetPtEtaPhi(Double_t pt, Double_t eta, Double_t phi)
666	>	{
667	>	// Set three-vector
668	>
669	>	fMom.Set(pt,eta,phi);
670	>	ClearMom();
671		}
672		#endif
673	+
674	+
675	+
676	+
677	+

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines