//----------------------------------------------------------------------------- // Dec 15 2000 P.Murat: description of STNTUPLE muon // ------------------------------------------------- // here is some information on the packing format for different words: // // fNHitTowers : numbers of hit calorimeter towers, packed into an integer: // bits 0- 7 - N_hit_em_tow // bits 8-15 - N_nbr_em_tow // bits 16-23 - N_hit_had_tow // bits 24-31 - N_nbr_had_tow // fNHits[0] : numbers of stub hits packed into an integer: // bits 0- 7 - number of hits on CMU stub // bits 8-15 - number of hits on CMP stub // bits 16-23 - number of hits on CMX stub // bits 24-31 - number of hits on BMU stub // // fNHits[1] : total numbers of hits in the chamber where the stub was found, // truncated to 255 in [very unlikely] case if it is greater // bits 0- 7 - number of hits on CMU wedge // bits 8-15 - number of hits on CMP chamber // bits 16-23 - number of hits on CMX **** // bits 24-31 - number of hits on BMU **** // // fTrind : packed track information // bits 0-15 - track_number // bits 16-19 - number of COT axial segments // bits 20-23 - number of COT stereo segments // // fDet : packed detector information // bits 0- 4 - CMU wedge number (0-24) // bit 5 - CMU side (0:WEST, 1:EAST) // bits 8-11 - CMP chamber within the region (0-6) // bits 12-13 - CMP region(side) (0-3) // bits 14-15 - unused // bit 16 - if 1, muon has CMU stub // bit 17 - if 1, muon has CMP stub // bit 18 - if 1, muon has CMX stub // bit 19 - if 1, muon has BMU stub // //----------------------------------------------------------------------------- #ifdef __GNUG__ #pragma implementation #endif #ifdef CDF1 #include "run1cpp/bnk/GenpParticle.hh" #endif #include "Stntuple/obj/TStnDataBlock.hh" #include "Stntuple/obj/TStnMuon.hh" ClassImp(TStnMuon) class CdfTrack; struct StnMuon_v35_t { Int_t fNumber; Int_t fNasl; // *** obsolete , will go away Int_t fNssl; // *** obsolete, will go away Int_t fTrind; // track + Naxseg<<16 + Nstseg<<20 Int_t fIstub; // packed word with stub indices Int_t fIdwrd; // bit-packed ID word Int_t fIswrd; // bit-packed isolation code Int_t fFid; // bit-packed fiducial code Int_t fDet; // byte-packed detector code Int_t fNStubs; // total number of muon stubs Int_t fNHitTowers; // byte-backed numbers of hits 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 // **************** here the float // section starts Float_t fRawpt; Float_t fPt; // don't use, use Momentum()->Pt() Float_t fPhi; // don't use, use Momentum()->Phi() Float_t fIso; // calorimetry isolation (filled?) Float_t fTiso; // track isolation (cone 0.4) Float_t fCray; Float_t fZtrk; Float_t fBte; Float_t fVtxocc; // VTX occupancy (for Run I) Float_t fDteta; // detector eta? may not be filled Float_t fStat; // muon status code Float_t fTime; // mean had TDC (over hit towers) Float_t fSigmaT; // sigma(time), != 0 if N(had towers)>1 Float_t fZv; Float_t fD0; // more track-related data Float_t fChi2z0; Float_t fChi2d0; // 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) Float_t fEveta; // event eta (Run 1, don't use) // ****** 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 // ****** 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 // ****** 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 fCmxChi2Link; // chi**2 of track-stub link for CMP // ****** CSP section ****** // [0]: closest counter // [1]: closest hit counter Float_t fCspX[2]; Float_t fCspZ[2]; // *********** data members added in V4 // added later by Anyes in v4, // thus append it to the end Float_t fConeR4Et; Float_t fConeR7Et; Float_t fConeR4EmFrac; Float_t fConeR7EmFrac; 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 CdfTrack* fCdfTrack; //! also helps to mark end of record }; //______________________________________________________________________________ void TStnMuon::ReadV1(TBuffer &R__b) { // Stream in version 1 of TStnMuon. StnMuon_v35_t muon; Int_t int_tmp; TStnLepton::Streamer(R__b); R__b >> muon.fRawpt; R__b >> muon.fPt; R__b >> muon.fPhi; R__b >> muon.fIso; R__b >> muon.fTiso; R__b >> muon.fCray; R__b >> muon.fZtrk; R__b >> muon.fBte; R__b >> muon.fVtxocc; R__b >> muon.fDteta; R__b >> muon.fNumber; R__b >> muon.fNasl; R__b >> muon.fNssl; R__b >> muon.fStat; R__b >> muon.fTime; R__b >> muon.fTrind; R__b >> muon.fIstub; R__b >> muon.fIdwrd; R__b >> muon.fIswrd; R__b >> muon.fFid; R__b >> muon.fDet; // hmm ... was fStubNHits... R__b >> int_tmp; R__b >> muon.fNHitTowers; R__b >> muon.fNHits[0]; R__b >> muon.fZv; R__b >> muon.fD0; R__b >> muon.fEHad; R__b >> muon.fEEm; R__b >> muon.fEveta; R__b >> muon.fCmuDelX; R__b >> muon.fCmuDelZ; R__b >> muon.fCmuDelDxDy; R__b >> muon.fCmuDelDzDy; R__b >> muon.fCmuStubX; R__b >> muon.fCmuStubDxDy; R__b >> muon.fCmuStubZ; R__b >> muon.fCmuStubDzDy; R__b >> fCmuStubChi2X; R__b >> muon.fCmuStubChi2Z; R__b >> muon.fEHadNeighb; R__b >> muon.fEEmNeighb; R__b >> muon.fChi2z0; R__b >> muon.fChi2d0; R__b >> muon.fCmuChi2Link; R__b.ReadStaticArray(muon.fCspCode); R__b.ReadStaticArray(muon.fCspData); R__b.ReadStaticArray(muon.fCspX); R__b.ReadStaticArray(muon.fCspZ); // fCmpStub number doesn't exist any longer R__b >> int_tmp; muon.fIstub = muon.fIstub | (int_tmp << 8); R__b >> muon.fCmpChi2Link; // ***** the missing piece - copy the data // into *this (hope nobody is reading ntuples // with V1 ... - do nothing } //______________________________________________________________________________ void TStnMuon::ReadV2(TBuffer &R__b) { // Stream in version 2 of TStnMuon. struct TStnMuon_V2 { Int_t fNumber; Int_t fNasl; // *** obsolete , will go away Int_t fNssl; // *** obsolete, will go away Int_t fTrind; // track + Naxseg<<16 + Nstseg<<20 Int_t fIstub; // packed word with stub indices Int_t fIdwrd; // bit-packed ID word Int_t fIswrd; // bit-packed isolation code Int_t fFid; // bit-packed fiducial code Int_t fDet; // byte-packed detector code Int_t fStubNHits; // *** obsolete, will go away Int_t fNHitTowers; // byte-backed numbers of hits 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 // **************** here the float // section starts Float_t fRawpt; Float_t fPt; Float_t fPhi; Float_t fIso; Float_t fTiso; Float_t fCray; Float_t fZtrk; Float_t fBte; Float_t fVtxocc; Float_t fDteta; Float_t fStat; // muon status code Float_t fTime; // mean had TDC (over hit towers) Float_t fSigmaT; // sigma(time), != 0 if N(had towers)>1 Float_t fZv; Float_t fD0; Float_t fEHad; Float_t fEEm; Float_t fEveta; Float_t fDelX; // delta(X) : stub-track Float_t fDelZ; // delta(Z) : stub-track Float_t fDelDxDy; // delta(DxDy): stub-track Float_t fDelDzDy; // delta(DzDy): stub-track Float_t fStubX; // X-coord of the stub wrt the chamber Float_t fStubDxDy; // stub -DxDy Float_t fStubZ; // Z-coord of the stub wrt the chamber Float_t fStubDzDy; // stub DzDy Float_t fStubChi2X; // chi**2 of fit in YX Float_t fStubChi2Z; // chi**2 of fit in ZX Float_t fEHadNeighb; Float_t fEEmNeighb; Float_t fChi2z0; Float_t fChi2d0; Float_t fChi2Link; Float_t fCmpChi2Link; // link chi**2 for CMP // ****** CSP section ****** // [0]: closest counter // [1]: closest hit counter Float_t fCspX[2]; Float_t fCspZ[2]; Float_t fEOR; // helper to mark end of record } muon; int nwi = ((Int_t*)&muon.fRawpt)-&muon.fNumber; int nwf = &muon.fEOR-&muon.fRawpt; TStnLepton::Streamer(R__b); // integer block didn't change, it is // the block of floats which did R__b.ReadFastArray(&fNumber,nwi); // read the old data record R__b.ReadFastArray(&muon.fRawpt,nwf); // so now we need to figure how to // repack the old data into new record } //______________________________________________________________________________ void TStnMuon::ReadV3(TBuffer &R__b) { // Stream in version 3 of TStnMuon. StnMuon_v35_t muon; int nwi = ((Int_t*)&muon.fRawpt)-&muon.fNumber; int nwf = &muon.fConeR4Et-&muon.fRawpt; int nw_zero = ((Float_t*)&muon.fCdfTrack)-&muon.fConeR4Et; TStnLepton::Streamer(R__b); // integer block didn't change, it is // the block of floats which did R__b.ReadFastArray(&muon.fNumber,nwi); // read the old data record R__b.ReadFastArray(&muon.fRawpt,nwf); memset(&muon.fConeR4Et,0,sizeof(Int_t)*nw_zero); // copy data from the local buffer // into *this } //______________________________________________________________________________ void TStnMuon::ReadV45(TBuffer &R__b) { // Stream in version 4,5 of TStnMuon. StnMuon_v35_t muon; int nwi = ((Int_t* )&muon.fRawpt )-&muon.fNumber; int nwf = ((Float_t*)&muon.fCdfTrack)-&muon.fRawpt; TStnLepton::Streamer(R__b); // integer block didn't change, it is // the block of floats which did R__b.ReadFastArray(&muon.fNumber,nwi); // read the old data record R__b.ReadFastArray(&muon.fRawpt,nwf); //----------------------------------------------------------------------------- // copy the data back into *this: // 1) integers //----------------------------------------------------------------------------- fNumber = muon.fNumber; fIdwrd = muon.fIdwrd; fIswrd = muon.fIswrd; fFid = muon.fFid; fTrind = muon.fTrind; fIstub = muon.fIstub; // bit assignments have changed in V6 fDet = muon.fDet&0xffff; fNStubs = muon.fNStubs; fNHitTowers = muon.fNHitTowers; fNHits[0] = muon.fNHits[0]; fNHits[1] = muon.fNHits[1]; fCspCode[0] = muon.fCspCode[0]; fCspCode[1] = muon.fCspCode[1]; fCspData[0] = muon.fCspData[0]; fCspData[1] = muon.fCspData[1]; fEntryTower = 0; fExitTower = 0; fHitMask = ((muon.fDet >> 16) & 0xff) << 24; //----------------------------------------------------------------------------- // 2) floats //----------------------------------------------------------------------------- fCray = muon.fCray; fBte = muon.fBte; fStat = muon.fStat; fHadTdcTime = TStnDataBlock::kUndefined; fSigmaT = TStnDataBlock::kUndefined; fZv = muon.fZtrk; fD0 = muon.fD0; fTIso = muon.fTiso; fEHad = muon.fEHad; fEEm = muon.fEEm; fEHadNeighb = muon.fEHadNeighb; fEEmNeighb = muon.fEEmNeighb; //----------------------------------------------------------------------------- // data members added in V4 by Anyes //----------------------------------------------------------------------------- fConeR4Et = muon.fConeR4Et; fConeR7Et = muon.fConeR7Et; fConeR4EmFrac = muon.fConeR4EmFrac; fConeR7EmFrac = muon.fConeR7EmFrac; //----------------------------------------------------------------------------- // added in v6 by Abe/Peter/Henry, thus undefined //----------------------------------------------------------------------------- for (int i=0; i<3; i++) { fCalEta[i] = TStnDataBlock::kUndefined; fCalPhi[i] = TStnDataBlock::kUndefined; } //----------------------------------------------------------------------------- // CMU stub //----------------------------------------------------------------------------- fCmuStubX = muon.fCmuStubX; fCmuStubDxDy = muon.fCmuStubDxDy; fCmuDelX = muon.fCmuDelX; fCmuDelDxDy = muon.fCmuDelDxDy; fCmuStubChi2X = muon.fCmuStubChi2X; fCmuStubZ = muon.fCmuStubZ; fCmuStubDzDy = muon.fCmuStubDzDy; fCmuDelZ = muon.fCmuDelZ; fCmuDelDzDy = muon.fCmuDelDzDy; fCmuStubChi2Z = muon.fCmuStubChi2Z; fCmuChi2Link = muon.fCmuChi2Link; // added in V6, thus undefined for (int i=0; i<3; i++) { fCmuStubPos[i] = TStnDataBlock::kUndefined; fCmuTrackPos[i] = TStnDataBlock::kUndefined; fCmuTrackDir[i] = TStnDataBlock::kUndefined; } //----------------------------------------------------------------------------- // CMP stub //----------------------------------------------------------------------------- fCmpStubX = muon.fCmpStubX; fCmpStubDxDy = muon.fCmpStubDxDy; fCmpDelX = muon.fCmpDelX; fCmpDelDxDy = muon.fCmpDelDxDy; fCmpStubChi2X = muon.fCmpStubChi2X; fCmpChi2Link = muon.fCmpChi2Link; // added in V6, thus undefined for (int i=0; i<3; i++) { fCmpStubPos [i] = TStnDataBlock::kUndefined; fCmpTrackPos[i] = TStnDataBlock::kUndefined; fCmpTrackDir[i] = TStnDataBlock::kUndefined; } //----------------------------------------------------------------------------- // CSP section: [0]: closest counter, [1]: closest hit counter //----------------------------------------------------------------------------- for (int i=0; i<2; i++) { fCspX[i] = muon.fCspX[i]; fCspZ[i] = muon.fCspZ[i]; } //----------------------------------------------------------------------------- // CMX //----------------------------------------------------------------------------- fCmxStubX = muon.fCmxStubX; fCmxStubDxDy = muon.fCmxStubDxDy; fCmxDelX = muon.fCmxDelX; fCmxDelDxDy = muon.fCmxDelDxDy; fCmxStubChi2X = muon.fCmxStubChi2X; fCmxStubZ = muon.fCmxStubZ; fCmxStubDzDy = muon.fCmxStubDzDy; fCmxDelZ = muon.fCmxDelZ; fCmxDelDzDy = muon.fCmxDelDzDy; fCmxStubChi2Z = muon.fCmxStubChi2Z; fCmxChi2Link = muon.fCmxChi2Link; // added in V6, thus undefined for (int i=0; i<3; i++) { fCmxStubPos [i] = TStnDataBlock::kUndefined; fCmxTrackPos[i] = TStnDataBlock::kUndefined; fCmxTrackDir[i] = TStnDataBlock::kUndefined; } //----------------------------------------------------------------------------- // BMU: added in V6, thus undefined //----------------------------------------------------------------------------- fBmuStubX = TStnDataBlock::kUndefined; fBmuStubDxDy = TStnDataBlock::kUndefined; fBmuDelX = TStnDataBlock::kUndefined; fBmuDelDxDy = TStnDataBlock::kUndefined; fBmuStubChi2X = TStnDataBlock::kUndefined; fBmuStubZ = TStnDataBlock::kUndefined; fBmuStubDzDy = TStnDataBlock::kUndefined; fBmuDelZ = TStnDataBlock::kUndefined; fBmuDelDzDy = TStnDataBlock::kUndefined; fBmuStubChi2Z = TStnDataBlock::kUndefined; fBmuChi2Link = TStnDataBlock::kUndefined; for (int i=0; i<3; i++) { fBmuStubPos [i] = TStnDataBlock::kUndefined; fBmuTrackPos[i] = TStnDataBlock::kUndefined; fBmuTrackDir[i] = TStnDataBlock::kUndefined; } } //______________________________________________________________________________ void TStnMuon::Streamer(TBuffer &R__b) { // Stream an object of class TStnMuon. // numbers of integer and float words int nwi = ((Int_t* )&fCray )-&fNumber; int nwf = ((Float_t*)&fCdfMuon )-&fCray; if (R__b.IsReading()) { Version_t R__v = R__b.ReadVersion(); if (R__v == 1) { // read version 1 ReadV1(R__b); } else if (R__v == 2) { // read version 2 ReadV2(R__b); } else if (R__v == 3) { // read version 3 ReadV3(R__b); } else if ((R__v == 4) || (R__v == 5)) { // read version 4 or 5 ReadV45(R__b); } else if (R__v == 6) { // read version 6 TStnLepton::Streamer(R__b); nwi = 18; nwf = 101; R__b.ReadFastArray(&fNumber,nwi); R__b.ReadFastArray(&fCray ,nwf); } else if (R__v == 7) { TStnLepton::Streamer(R__b); nwi = 23; // uncomment these when streamer version is updated to 8 nwf = 107; R__b.ReadFastArray(&fNumber,nwi); R__b.ReadFastArray(&fCray ,nwf); } else if (R__v == 8) { // current version: 8 TStnLepton::Streamer(R__b); //nwi = 23; // uncomment these when streamer version is updated to 9 //nwf = 117; R__b.ReadFastArray(&fNumber,nwi); R__b.ReadFastArray(&fCray ,nwf); } else { Error("Streamer", "Unknown version of TStnMuon"); } } else { R__b.WriteVersion(TStnMuon::IsA()); TStnLepton::Streamer(R__b); R__b.WriteFastArray(&fNumber,nwi); R__b.WriteFastArray(&fCray ,nwf); } } //_____________________________________________________________________________ TStnMuon::TStnMuon(Int_t Number) { fNumber = Number; fIstub = -1; for (int i=0; iPt(); if (pt > 9999.99) pt = 9999.99; float status = pt; if (Charge() < 0) status = -status; printf("%2i %1i %1i %2i %8.2f %5.2f %5.2f %6.2f %6.2f %6.2f %6.2f %6.2f %6.2f", Number(), Detector(), CmuSide(), CmuWedge(), status, Momentum()->Eta(), Momentum()->Phi(), Momentum()->Px(), Momentum()->Py(), EmEnergy(), HadEnergy(), ConeR4Et(), TIso()); float time = HadTdcTime(); if (time > 999) time = 999; printf(" %7.2f %4.0f ", Z0(), time); int first = 1; if (HasCmuStub()) { float cmu_x = (CmuStubX () < 999.99) ? CmuStubX () : 999.99; float cmu_dxdy = (CmuStubDxDy () < 999.99) ? CmuStubDxDy () : 999.99; float cmu_delx = (CmuDelX () < 999.99) ? CmuDelX () : 999.99; float cmu_deldxdy = (CmuDelDxDy () < 999.99) ? CmuDelDxDy () : 999.99; float cmu_chi2x = (CmuStubChi2X() < 999.99) ? CmuStubChi2X() : 999.99; float cmu_z = (CmuStubZ () < 999.99) ? CmuStubZ () : 999.99; float cmu_dzdy = (CmuStubDzDy () < 999.99) ? CmuStubDzDy () : 999.99; float cmu_delz = (CmuDelZ () < 999.99) ? CmuDelZ () : 999.99; float cmu_deldzdy = (CmuDelDzDy () < 999.99) ? CmuDelDzDy () : 999.99; float cmu_chi2z = (CmuStubChi2Z() < 999.99) ? CmuStubChi2Z() : 999.99; printf("%7.2f %7.2f %8.3f %8.3f %7.2f CMU(x)\n", cmu_x, cmu_dxdy, cmu_delx, cmu_deldxdy, cmu_chi2x); printf(" "); printf(" "); printf("%7.2f %7.2f %8.3f %8.3f %7.2f CMU(z)\n", cmu_z, cmu_dzdy, cmu_delz, cmu_deldzdy, cmu_chi2z); first = 0; } if (HasCmpStub()) { float cmp_x = (CmpStubX () < 999.99) ? CmpStubX () : 999.99; float cmp_dxdy = (CmpStubDxDy () < 999.99) ? CmpStubDxDy () : 999.99; float cmp_delx = (CmpDelX () < 999.99) ? CmpDelX () : 999.99; float cmp_deldxdy = (CmpDelDxDy () < 999.99) ? CmpDelDxDy () : 999.99; float cmp_chi2x = (CmpStubChi2X() < 999.99) ? CmpStubChi2X() : 999.99; if (! first) { printf(" "); printf(" "); } printf("%7.2f %7.2f %8.3f %8.3f %7.2f CMP(x)\n", cmp_x, cmp_dxdy, cmp_delx, cmp_deldxdy, cmp_chi2x); first = 0; } if (HasCmxStub()) { float cmx_x = (CmxStubX () < 999.99) ? CmxStubX () : 999.99; float cmx_dxdy = (CmxStubDxDy () < 999.99) ? CmxStubDxDy () : 999.99; float cmx_delx = (CmxDelX () < 999.99) ? CmxDelX () : 999.99; float cmx_deldxdy = (CmxDelDxDy () < 999.99) ? CmxDelDxDy () : 999.99; float cmx_chi2x = (CmxStubChi2X() < 999.99) ? CmxStubChi2X() : 999.99; if (! first) { printf(" "); printf(" "); } printf("%7.2f %7.2f %8.3f %8.3f %7.2f CMX(x)\n", cmx_x, cmx_dxdy, cmx_delx, cmx_deldxdy, cmx_chi2x); first = 0; } if (HasBmuStub()) { float bmu_x = (BmuStubX () < 999.99) ? BmuStubX () : 999.99; float bmu_dxdy = (BmuStubDxDy () < 999.99) ? BmuStubDxDy () : 999.99; float bmu_delx = (BmuDelX () < 999.99) ? BmuDelX () : 999.99; float bmu_deldxdy = (BmuDelDxDy () < 999.99) ? BmuDelDxDy () : 999.99; float bmu_chi2x = (BmuStubChi2X() < 999.99) ? BmuStubChi2X() : 999.99; if (! first) { printf(" "); printf(" "); } printf("%7.2f %7.2f %8.3f %8.3f %7.2f BMU(x)\n", bmu_x, bmu_dxdy, bmu_delx, bmu_deldxdy, bmu_chi2x); first = 0; } if (first) printf("\n"); } }