#ifndef STNTUPLE_TStnMuon #define STNTUPLE_TStnMuon class CdfMuon; class MuonStub; class TStnTrack; struct StnMuonsBlock_t; #include #include class TStnMuon : public TStnLepton { friend class TMuonLinker; friend Int_t StntupleInitMuon(TStnMuon*, const CdfMuon*); friend Int_t StnRun1InitMuon (TStnMuon*, const StnMuonsBlock_t*, Int_t i); public: enum { kCmu = 0x10000, kCmp = 0x20000, kCmx = 0x40000, kBmu = 0x80000, kNFreeInts = 5, kNFreeFloats = 5 }; //----------------------------------------------------------------------------- // data members // fTrind : was track+Naxseg<<16 + Nstseg<<20 // Vanished integer data members: fNasl, fNssl ? // Vanished float data members: fRawpt, fPt, fPhi, fIso, fTIso, fZtrk, fVtxocc, // fDteta, fTime, fSigmaT, fZv, fD0, fChi2z0, fChi2d0, fEveta // All the f[system]Stub* and the like got renamed //----------------------------------------------------------------------------- protected: Int_t fNumber; //? Int_t fIdwrd; // bit-packed ID word Int_t fIswrd; // bit-packed isolation code Int_t fFid; // bit-packed fiducial code Int_t fTrind; // track + 2nd best track Int_t fIstub; // packed word with stub indices Int_t fDet; // byte-packed detector code // bits 0- 4 : CMU wedge // bit 5 : CMU side // bits 8-10 : CMP chamber // bits 11-12 : CMP region // bits 16-20 : CMX wedge // bits 21 : CMX Side // bits 24-28 : BMU wedge // bits 29 : BMU side Int_t fNStubs; // total number of muon stubs Int_t fNHitTowers; // byte-backed numbers of hit towers Int_t fNHits[2]; // byte-packed numbers of hits // ****** CSP section // [0]: closest counter // [1]: closest hit counter Int_t fCspCode[2]; // code of the CSP counter Int_t fCspData[2]; // TDC data // ****** added in v6 //no need Int_t fEntryTower; // Tower Entered the Calorimeter Int_t fExitTower; // Tower Exited the Calorimeter Int_t fHitMask; // bits 0-3 CMU Hits // bits 4-7 CMP Hits // bits 8-13 CMX Hits // bits 14-17 BMU Hits // bits 24-27 Muon type Int_t fInt[kNFreeInts]; // spares //----------------------------------------------------------------------------- // float section //----------------------------------------------------------------------------- Float_t fCray; // code set by the cosmic ray filter Float_t fBte; Float_t fStat; // muon status code Float_t fHadTdcTime; // mean had TDC (over hit towers) Float_t fSigmaT; // sigma(time), != 0 if N(had towers)>1 //----------------------------------------------------------------------------- // cached parameters of the best track: need them to cut on the muons w/o // reading in the track block //----------------------------------------------------------------------------- Float_t fZv; // Z0 of the muon track Float_t fD0; // impact parameter of the muon track Float_t fTIso; // sumPt(0.4)/ muon track Pt //----------------------------------------------------------------------------- // calorimetry data //----------------------------------------------------------------------------- Float_t fEHad; // HAD energy in the hit tower(s) Float_t fEEm; // EM energy in the hit tower(s) Float_t fEHadNeighb; // HAD energy in the neighbor tower(s) Float_t fEEmNeighb; // EM energy in the neighbor tower(s) //----------------------------------------------------------------------------- // data members added in V4 Anyes //----------------------------------------------------------------------------- Float_t fConeR4Et; Float_t fConeR7Et; Float_t fConeR4EmFrac; Float_t fConeR7EmFrac; //----------------------------------------------------------------------------- // added in v6 -> no need //----------------------------------------------------------------------------- Float_t fCalEta [3]; // Point Entered the Calorimeter Float_t fCalPhi [3]; // Point Exited the Calorimeter //----------------------------------------------------------------------------- // CMU stub //----------------------------------------------------------------------------- Float_t fCmuStubX; // X-coord of the stub wrt the chamber Float_t fCmuStubDxDy; // stub -DxDy Float_t fCmuDelX; // delta(X) : stub-track Float_t fCmuDelDxDy; // delta(DxDy): stub-track Float_t fCmuStubChi2X; // chi**2 of fit in YX Float_t fCmuStubZ; // Z-coord of the stub wrt the chamber Float_t fCmuStubDzDy; // stub DzDy Float_t fCmuDelZ; // delta(Z) : stub-track Float_t fCmuDelDzDy; // delta(DzDy): stub-track Float_t fCmuStubChi2Z; // chi**2 of fit in ZX Float_t fCmuChi2Link; // chi**2 of the track-stub link Float_t fCmuStubPos [3]; // CMU stub pos (global coord. sys) Float_t fCmuTrackPos[3]; // muon track extrap. position at CMU Float_t fCmuTrackDir[3]; // muon track extrap. direction at CMU //----------------------------------------------------------------------------- // CMP stub //----------------------------------------------------------------------------- Float_t fCmpStubX; // X-coord of the stub wrt the chamber Float_t fCmpStubDxDy; // stub -DxDy Float_t fCmpDelX; // delta(X) : stub-track Float_t fCmpDelDxDy; // delta(DxDy): stub-track Float_t fCmpStubChi2X; // chi**2 of fit in YX Float_t fCmpChi2Link; // chi**2 of track-stub link for CMP Float_t fCmpStubPos [3]; // stub pos in global coord sys Float_t fCmpTrackPos[3]; // position of track extrap. to CMP Float_t fCmpTrackDir[3]; // direction of track extrap. to the CMP //----------------------------------------------------------------------------- // CSP section: [0]: closest counter, [1]: closest hit counter //----------------------------------------------------------------------------- Float_t fCspX[2]; Float_t fCspZ[2]; //----------------------------------------------------------------------------- // CMX stub //----------------------------------------------------------------------------- Float_t fCmxStubX; // X-coord of the stub wrt the chamber Float_t fCmxStubDxDy; // stub -DxDy Float_t fCmxDelX; // delta(X) : stub-track Float_t fCmxDelDxDy; // delta(DxDy): stub-track Float_t fCmxStubChi2X; // chi**2 of fit in YX Float_t fCmxStubZ; // Z-coord of the stub wrt the chamber Float_t fCmxStubDzDy; // stub DzDy Float_t fCmxDelZ; // delta(Z) : stub-track Float_t fCmxDelDzDy; // delta(DzDy): stub-track Float_t fCmxStubChi2Z; // chi**2 of fit in ZX Float_t fCmxChi2Link; // chi**2 of track-stub link for CMX Float_t fCmxStubPos [3]; // Global 3 point for fitted stub Float_t fCmxTrackPos[3]; // extrap track pos at CMX Float_t fCmxTrackDir[3]; // extrap track dir at CMX //----------------------------------------------------------------------------- // BMU stub: parameters to be specified //----------------------------------------------------------------------------- Float_t fBmuStubX; // X-coord of the stub wrt the chamber Float_t fBmuStubDxDy; // stub -DxDy Float_t fBmuDelX; // delta(X) : stub-track Float_t fBmuDelDxDy; // delta(DxDy): stub-track Float_t fBmuStubChi2X; // chi**2 of fit in YX Float_t fBmuStubZ; // Z-coord of the stub wrt the chamber Float_t fBmuStubDzDy; // stub DzDy Float_t fBmuDelZ; // delta(Z) : stub-track Float_t fBmuDelDzDy; // delta(DzDy): stub-track Float_t fBmuStubChi2Z; // chi**2 of fit in ZX Float_t fBmuChi2Link; // chi**2 of track-stub link for BMU Float_t fBmuStubPos [3]; // Global 3 point for fitted stub Float_t fBmuTrackPos[3]; // extrap track pos at BMU Float_t fBmuTrackDir[3]; // extrap track dir at BMU Float_t fBcPt; // Beam-constrained Cot-only Pt Float_t fCmuFidX; // distances to the neaserest chamber edge Float_t fCmuFidZ; Float_t fCmpFidX; Float_t fCmpFidZ; Float_t fCmxFidX; // including miniskirt, keystone when they're on Float_t fCmxFidZ; Float_t fBmuFidX; Float_t fBmuFidZ; Float_t fCmxFidX2; // always ignoring miniskirt and keystone Float_t fCmxFidZ2; Float_t fFloat[kNFreeFloats]; // spares CdfMuon* fCdfMuon; // ! marks end of record MuonStub* fCmuStub; // ! MuonStub* fCmpStub; // ! MuonStub* fCmxStub; // ! MuonStub* fBmuStub; // ! //----------------------------------------------------------------------------- // transient-only data members - make sure they are set at run-time // before you started using them //----------------------------------------------------------------------------- TStnTrack* fTrack; // ! TLorentzVector fCorrMom; // ! beam-constrained, Larry-corrected Float_t fTmp[10]; // ! //------------------------------------------------------------------------------ // functions //------------------------------------------------------------------------------ public: // ****** constructors and destructor TStnMuon(Int_t Number = -1); TStnMuon(GENP_PARTICLE* p); virtual ~TStnMuon(); // ****** init methods // ****** accessors Int_t Type () const { return kMuon; } Int_t Detector () const { return (fHitMask >> 24) & 0xff; } Int_t DetCode () const { return fDet; } Int_t HasCmuStub() const { return (fHitMask >> 24) & 0x1; } Int_t HasCmpStub() const { return (fHitMask >> 25) & 0x1; } Int_t HasCmxStub() const { return (fHitMask >> 26) & 0x1; } Int_t HasBmuStub() const { return (fHitMask >> 27) & 0x1; } Int_t HasStub(Int_t i) const {return (fHitMask >> (24+i)) & 0x1; } Int_t NStubs() { return fNStubs;} Int_t CmuWedge () const { return (fDet ) & 0x1f; } Int_t CmuSide () const { return (fDet >> 5) & 0x1 ; } Int_t Side () const { printf("TStnMuon::Side() deprecated; use CmuSide()\n"); return CmuSide(); } Int_t CmpChamber() const { return (fDet >> 8) & 0x7 ; } Int_t CmpRegion () const { return (fDet >> 11) & 0x3 ; } Int_t CmxWedge () const { return (fDet >> 16) & 0x1f; } Int_t CmxSide () const { return (fDet >> 21) & 0x1 ; } Int_t BmuWedge () const { return (fDet >> 24) & 0x1f; } Int_t BmuSide () const { return (fDet >> 29) & 0x1 ; } Int_t EntryTower() const { return fEntryTower;} Int_t ExitTower () const { return fExitTower;} Float_t StatusCode() const { return fStat; } Int_t Number () const { return fNumber;} Float_t Cray () const { return fCray ;} Float_t Bte () const { return fBte; } Float_t HadEnergy () const { return fEHad; } Float_t EmEnergy () const { return fEEm; } Float_t CalEnergy () const { return fEHad+fEEm; } Float_t HadTdcTime() const { return fHadTdcTime; } Float_t Time () const { printf("TStnMuon::Time() deprecated; use HadTdcTime()\n"); return HadTdcTime(); } Float_t SigmaT () const { return fSigmaT; } Int_t IDWord () const { return fIdwrd; } Int_t IdWord () const { Error("IdWord","Obsolete, use TStnMuon::IDWord(). Pasha"); return IDWord(); } Int_t IsoWord () const { return fIswrd; } Int_t FidCode () const { return fFid; } Int_t NHitsCmuStub() const { return (fNHits[0] ) & 0xff; } Int_t NHitsCmpStub() const { return (fNHits[0] >> 8) & 0xff; } Int_t NHitsCmxStub() const { return (fNHits[0] >> 16) & 0xff; } Int_t NHitsBmuStub() const { return (fNHits[0] >> 24) & 0xff; } Int_t NHitsStub(Int_t i) const { return (fNHits[0] >> 8*i) & 0xff; } Int_t NCmuHits () const { return NHitsCmuStub() ; } Int_t NCmpHits () const { return NHitsCmpStub() ; } Int_t NCmxHits () const { return NHitsCmxStub() ; } Int_t NBmuHits () const { return NHitsBmuStub() ; } Int_t NHitsWord () const { return fNHits[0] ; } Int_t IsStubless () const { return (fNHits[0] == 0); } Int_t NHitsCmuWedge () const { return (fNHits[1] ) & 0xff; } Int_t NHitsCmpChamber() const { return (fNHits[1] >> 8) & 0xff; } Int_t NHitsCmxChamber() const { return (fNHits[1] >> 16) & 0xff; } Int_t NHitsBmuChamber() const { return (fNHits[1] >> 24) & 0xff; } Int_t NHitsChamber(Int_t i) const { return (fNHits[1] >> 8*i) & 0xff; } // this function returns either best or // the 2nd best track number Int_t TrackNumber(Int_t I = 0) const { int it = (fTrind >> (16*I)) & 0xffff; return ( it == 0xffff) ? -1 : it ; } Int_t SecondBestTrackNumber() const { int it = ((fTrind >> 16) & 0xffff); return ( it == 0xffff) ? -1 : it ; } // cached track parameters Float_t Zv () const { printf(" TStMuon::Zv is obsolete, use TStMuon::Z0. thanks, Pasha\n"); return fZv; } Float_t TrackPt () const { return Momentum()->Pt(); } Float_t TrackBcPt () const { return fBcPt; } // beam-constr. cot-only Float_t Z0 () const { return fZv; } Float_t D0 () const { return fD0; } Float_t TIso () const { return fTIso; } Int_t CmuStubNumber () const { return (fIstub ) & 0xff; } Int_t CmpStubNumber () const { return (fIstub >> 8) & 0xff; } Int_t CmxStubNumber () const { return (fIstub >> 16) & 0xff; } Int_t BmuStubNumber () const { return (fIstub >> 24) & 0xff; } Int_t NHitEmTowers () const { return (fNHitTowers ) & 0xff; } Int_t NNbrEmTowers () const { return (fNHitTowers >> 8) & 0xff; } Int_t NHitHadTowers() const { return (fNHitTowers >> 16) & 0xff; } Int_t NNbrHadTowers() const { return (fNHitTowers >> 24) & 0xff; } Float_t EEmNeighb () const { return fEEmNeighb; } Float_t EHadNeighb () const { return fEHadNeighb; } Float_t ENeighb () const { return fEEmNeighb+fEHadNeighb; } Float_t Iso () const { return fConeR4Et; } Float_t ConeR4Et () const { return fConeR4Et; } Float_t ConeR7Et () const { return fConeR7Et; } Float_t ConeR4EmFrac () const { return fConeR4EmFrac; } Float_t ConeR7EmFrac () const { return fConeR7EmFrac; } //----------------------------------------------------------------------------- // CMU section //----------------------------------------------------------------------------- Int_t CmuHitMask () const { return (fHitMask & 0xf); } Float_t CmuStubDxDy () const { return fCmuStubDxDy; } Float_t CmuDelX () const { return fCmuDelX; } Float_t CmuDelDxDy () const { return fCmuDelDxDy; } Float_t CmuStubChi2X () const { return fCmuStubChi2X; } Float_t CmuStubX () const { return fCmuStubX; } Float_t CmuStubZ () const { return fCmuStubZ; } Float_t CmuStubDzDy () const { return fCmuStubDzDy; } Float_t CmuDelDzDy () const { return fCmuDelDzDy; } Float_t CmuStubChi2Z () const { return fCmuStubChi2Z; } Float_t CmuChi2Link () const { return fCmuChi2Link; } // as defined by CdfMuon, all the track // and stub coordinates are in global // coordinate system Float_t CmuStubY () const { return fCmuStubPos[1]; } void GetCmuStubPos(TVector3& vec) { vec.SetXYZ(fCmuStubPos[0],fCmuStubPos[1],fCmuStubPos[2]); } void GetCmuTrackPos(TVector3& vec) { vec.SetXYZ(fCmuTrackPos[0],fCmuTrackPos[1],fCmuTrackPos[2]); } void GetCmuTrackDir(TVector3& vec) { vec.SetXYZ(fCmuTrackDir[0],fCmuTrackDir[1],fCmuTrackDir[2]); } Float_t CmuDelZ () const { return fCmuStubPos[2]-fCmuTrackPos[2];} Float_t TrackCmuX () const { return fCmuStubX-fCmuDelX; } Float_t TrackCmuZ () const { return fCmuStubZ-fCmuDelZ; } Float_t TrackCmuDxDy () const { return fCmuStubDxDy-fCmuDelDxDy; } Float_t TrackCmuDzDy () const { return fCmuStubDzDy-fCmuDelDzDy; } Float_t CmuFidX () const { return fCmuFidX; } Float_t CmuFidZ () const { return fCmuFidZ; } //----------------------------------------------------------------------------- // CMP section //----------------------------------------------------------------------------- Int_t CmpHitMask () const { return ((fHitMask >> 4) & 0xf); } Float_t CmpStubX () const { return fCmpStubX; } Float_t CmpStubDxDy () const { return fCmpStubDxDy; } Float_t CmpDelX () const { return fCmpDelX;} Float_t CmpDelDxDy () const { return fCmpDelDxDy; } Float_t CmpStubChi2X () const { return fCmpStubChi2X; } Float_t CmpChi2Link () const { return fCmpChi2Link; } Float_t TrackCmpDxDy () const { return fCmpStubDxDy-fCmpDelDxDy; } void GetCmpStubPos (TVector3& vec) { vec.SetXYZ(fCmpStubPos[0],fCmpStubPos[1],fCmpStubPos[2]); } Float_t TrackCmpX () const { return fCmpTrackPos[0]; } Float_t TrackCmpY () const { return fCmpTrackPos[1]; } Float_t TrackCmpZ () const { return fCmpTrackPos[2]; } void GetCmpTrackPos(TVector3& vec) { vec.SetXYZ(fCmpTrackPos[0],fCmpTrackPos[1],fCmpTrackPos[2]); } void GetCmpTrackDir(TVector3& vec) { vec.SetXYZ(fCmpTrackDir[0],fCmpTrackDir[1],fCmpTrackDir[2]); } Float_t CmpFidX () const { return fCmpFidX; } Float_t CmpFidZ () const { return fCmpFidZ; } //----------------------------------------------------------------------------- // CMX methods //----------------------------------------------------------------------------- Int_t CmxHitMask () const { return ((fHitMask >> 8) & 0x3f); } Float_t CmxStubX () const { return fCmxStubX; } // Float_t CmxStubY () const { return fCmxStubY; } Float_t CmxStubZ () const { return fCmxStubZ; } Float_t CmxStubDxDy () const { return fCmxStubDxDy; } Float_t CmxDelDxDy () const { return fCmxDelDxDy; } Float_t CmxStubChi2X () const { return fCmxStubChi2X; } Float_t CmxStubDzDy () const { return fCmxStubDzDy; } Float_t CmxDelX () const { return fCmxDelX; } Float_t CmxDelZ () const { return fCmxDelZ; } Float_t CmxDelDzDy () const { return fCmxDelDzDy; } Float_t CmxStubChi2Z () const { return fCmxStubChi2Z; } Float_t CmxChi2Link () const { return fCmxChi2Link; } void GetCmxStubPos (TVector3& vec) { vec.SetXYZ(fCmxStubPos[0],fCmxStubPos[1],fCmxStubPos[2]); } void GetCmxTrackPos(TVector3& vec) { vec.SetXYZ(fCmxTrackPos[0],fCmxTrackPos[1],fCmxTrackPos[2]); } void GetCmxTrackDir(TVector3& vec) { vec.SetXYZ(fCmxTrackDir[0],fCmxTrackDir[1],fCmxTrackDir[2]); } // fiducial distances considering minskirt and keystone, when they are on Float_t CmxFidX () const { return fCmxFidX; } Float_t CmxFidZ () const { return fCmxFidZ; } // fiducial distances always ignoring minskirt and keystone Float_t CmxFidX2 () const { return fCmxFidX2; } Float_t CmxFidZ2 () const { return fCmxFidZ2; } //----------------------------------------------------------------------------- // BMU methods //----------------------------------------------------------------------------- Int_t BmuHitMask () const { return ((fHitMask >> 14) & 0xf); } Float_t BmuStubX () const { return fBmuStubX; } // Float_t BmuStubY () const { return fBmuStubY; } Float_t BmuStubZ () const { return fBmuStubZ; } Float_t BmuStubDxDy () const { return fBmuStubDxDy; } Float_t BmuDelDxDy () const { return fBmuDelDxDy; } Float_t BmuStubChi2X () const { return fBmuStubChi2X; } Float_t BmuStubDzDy () const { return fBmuStubDzDy; } Float_t BmuDelX () const { return fBmuDelX; } Float_t BmuDelZ () const { return fBmuDelZ; } Float_t BmuDelDzDy () const { return fBmuDelDzDy; } Float_t BmuStubChi2Z () const { return fBmuStubChi2Z; } Float_t BmuChi2Link () const { return fBmuChi2Link; } void GetBmuStubPos (TVector3& vec) { vec.SetXYZ(fBmuStubPos[0],fBmuStubPos[1],fBmuStubPos[2]); } void GetBmuTrackPos(TVector3& vec) { vec.SetXYZ(fBmuTrackPos[0],fBmuTrackPos[1],fBmuTrackPos[2]); } void GetBmuTrackDir(TVector3& vec) { vec.SetXYZ(fBmuTrackDir[0],fBmuTrackDir[1],fBmuTrackDir[2]); } Float_t BmuFidX () const { return fBmuFidX; } Float_t BmuFidZ () const { return fBmuFidZ; } //----------------------------------------------------------------------------- // CSP methods //----------------------------------------------------------------------------- Int_t CspCode(int i) const { return fCspCode[i]; } Int_t CspData(int i) const { return fCspData[i]; } Float_t CspX (int i) const { return fCspX [i]; } Float_t CspZ (int i) const { return fCspZ [i]; } // use these methods from within // StntupleMakerModule only CdfMuon* GetCdfMuon() { return fCdfMuon; } MuonStub* GetCmuStub() { return fCmuStub; } MuonStub* GetCmpStub() { return fCmpStub; } MuonStub* GetCmxStub() { return fCmxStub; } MuonStub* GetBmuStub() { return fBmuStub; } //----------------------------------------------------------------------------- // accessors for transient-only data members - make sure those are // initialized - initialization is up to you! //----------------------------------------------------------------------------- TStnTrack* Track () const { return fTrack; } TLorentzVector* CorrMom () { return &fCorrMom; } Float_t& Tmp (Int_t i) { return fTmp[i]; } //----------------------------------------------------------------------------- // setters //----------------------------------------------------------------------------- void SetTIso (Double_t TIso ) { fTIso = TIso; } void SetBcPt (Float_t Pt ) { fBcPt = Pt; } void SetNumber (Int_t Number) { fNumber = Number; } void SetIdWord (Int_t IdWord) { fIdwrd = IdWord; } void SetTrackNumber (Int_t It ) { fTrind = (fTrind & 0xffff0000) | (It & 0xffff); } void SetSecondBestTrackNumber (Int_t It) { fTrind = (fTrind & 0xffff) | ((It & 0xffff) << 16); } void SetDetCode (Int_t Code) { fDet = Code; } void SetCmuStubNumber(Int_t ICmu) { fIstub |= (ICmu << 0); } void SetCmpStubNumber(Int_t ICmp) { fIstub |= (ICmp << 8); } void SetCmxStubNumber(Int_t ICmx) { fIstub |= (ICmx << 16); } void SetBmuStubNumber(Int_t IBmu) { fIstub |= (IBmu << 24); } void SetCspData(Int_t I, Int_t GeomCode, Int_t Time, Double_t XHit, Double_t ZHit); void SetHadTdcTime(Float_t Time ) { fHadTdcTime = Time; } void SetSigmaT (Float_t Sigma) { fSigmaT = Sigma; } void SetTrack (TStnTrack* Track) { fTrack = Track; } //----------------------------------------------------------------------------- // overloaded methods of TObject //----------------------------------------------------------------------------- void Print(Option_t* opt = "") const; // copy contents of '*this' into Obj virtual void Copy (TObject& Obj) const; //----------------------------------------------------------------------------- // schema evolution //----------------------------------------------------------------------------- // read versions 1 and 2 of TStnMuon void ReadV1 (TBuffer &R__b); void ReadV2 (TBuffer &R__b); void ReadV3 (TBuffer &R__b); // versions 4 and 5 void ReadV45(TBuffer &R__b); ClassDef(TStnMuon,8) }; #endif