Actions

History

Replay Output Variables » History » Revision 41

« Previous | Revision 41/52 (diff) | Next »
Sean Jeffas, 05/11/2023 10:11 AM

Replay Output Variables¶

Table of contents
Replay Output Variables
Description
Tracking Definition
- - Track Variables
Calorimeters, HCal and BBCal
GEM Definitions
Timing Hodoscope Variable Definitions

Description¶

One can search any working build of SBS-offline or Podd for “rVarDef” to find the location of these definitions.
From the build src directory: grep -nr “rvardef*” .
All definitions below are recorded in the following order: { <variable extension>, <Definition>, <SBS-offline designation> }

Tracking Definition¶

These definitions are defined in Podd. See github [https://github.com/JeffersonLab/analyzer].
- THaSpectrometer.cxx
All definitions below are accesed from the tree with the prepend bb.tr.
- Ex. bb.tr.vz

Track Variables¶

 { "tr.n",    "Number of tracks",             "GetNTracks()" },
 { "tr.x",    "Track x coordinate (m)",       "fTracks.THaTrack.fX" },
 { "tr.y",    "Track x coordinate (m)",       "fTracks.THaTrack.fY" },
 { "tr.th",   "Tangent of track theta angle", "fTracks.THaTrack.fTheta" },
 { "tr.ph",   "Tangent of track phi angle",   "fTracks.THaTrack.fPhi" },
 { "tr.p",    "Track momentum (GeV)",         "fTracks.THaTrack.fP" },
 { "tr.flag", "Track status flag",            "fTracks.THaTrack.fFlag" },
 { "tr.chi2", "Track's chi2 from hits",       "fTracks.THaTrack.fChi2" },
 { "tr.ndof", "Track's NDoF",                 "fTracks.THaTrack.fNDoF" },
 { "tr.d_x",  "Detector x coordinate (m)",    "fTracks.THaTrack.fDX" },
 { "tr.d_y",  "Detector y coordinate (m)",    "fTracks.THaTrack.fDY" },
 { "tr.d_th", "Detector tangent of theta",    "fTracks.THaTrack.fDTheta" },
 { "tr.d_ph", "Detector tangent of phi",      "fTracks.THaTrack.fDPhi" },
 { "tr.r_x",  "Rotated x coordinate (m)",     "fTracks.THaTrack.fRX" },
 { "tr.r_y",  "Rotated y coordinate (m)",     "fTracks.THaTrack.fRY" },
 { "tr.r_th", "Rotated tangent of theta",     "fTracks.THaTrack.fRTheta" },
 { "tr.r_ph", "Rotated tangent of phi",       "fTracks.THaTrack.fRPhi" },
 { "tr.tg_y", "Target y coordinate",          "fTracks.THaTrack.fTY"},
 { "tr.tg_th", "Tangent of target theta angle", "fTracks.THaTrack.fTTheta"},
 { "tr.tg_ph", "Tangent of target phi angle",   "fTracks.THaTrack.fTPhi"},    
 { "tr.tg_dp", "Target delta",                "fTracks.THaTrack.fDp"},
 { "tr.px",    "Lab momentum x (GeV)",        "fTracks.THaTrack.GetLabPx()"},
 { "tr.py",    "Lab momentum y (GeV)",        "fTracks.THaTrack.GetLabPy()"},
 { "tr.pz",    "Lab momentum z (GeV)",        "fTracks.THaTrack.GetLabPz()"},
 { "tr.vx",    "Vertex x (m)",                "fTracks.THaTrack.GetVertexX()"},
 { "tr.vy",    "Vertex y (m)",                "fTracks.THaTrack.GetVertexY()"},
 { "tr.vz",    "Vertex z (m)",                "fTracks.THaTrack.GetVertexZ()"},
 { "tr.pathl", "Pathlength from tg to fp (m)","fTracks.THaTrack.GetPathLen()"},
 { "tr.time",  "Time of track@Ref Plane (s)", "fTracks.THaTrack.GetTime()"},
 { "tr.dtime", "uncer of time (s)",           "fTracks.THaTrack.GetdTime()"},
 { "tr.beta",  "Beta of track",               "fTracks.THaTrack.GetBeta()"},
 { "tr.dbeta", "uncertainty of beta",         "fTracks.THaTrack.GetdBeta()"},
 { "status",   "Bits of completed analysis stages", "fStagesDone" }

Calorimeters, HCal and BBCal¶

HCal and BBCal share the same class so their variable definitions are the same, but with a different prefix.
- HCal variables have the prefix sbs.hcal.
- BBCal variables have the prefix bb.
These definitions from the following source files defined in SBS-offline. See github for more information.
- SBSCalorimeter.cxx
- SBSGenericDetector.cxx

HCal Variable Definitions¶

All definitions below are accessed from the tree with the prepend sbs.hcal.
- Ex. sbs.hcal.clus_blk.atime

BBCal (Shower + PreShower) Variable Definitions¶

All definitions below are accessed from the tree with the prepend bb.sh. for Shower and bb.ps. for PreShower
- Ex. bb.sh.e

ADC Variables¶

 { "adcrow", "Row for block in data vectors",  "fGood.ADCrow" }),
 { "adccol", "Col for block in data vectors",  "fGood.ADCcol" }),
 { "adcelemID", "Element ID for block in data vectors",  "fGood.ADCelemID" }),
 { "adclayer", "Layer for block in data vectors",  "fGood.ADClayer" }),
 { "ped", "Pedestal for block in data vectors",  "fGood.ped" }),
 { "a","ADC integral", "fGood.a"} );
 { "a_mult","ADC # hits in channel", "fGood.a_mult"} );
 { "a_p","ADC integral - ped", "fGood.a_p"} );
 { "a_c","(ADC integral - ped)*gain", "fGood.a_c"} );
 { "a_amp","ADC pulse amplitude", "fGood.a_amp"} );
 { "a_amp_p","ADC pulse amplitude -ped", "fGood.a_amp_p"} );
 { "a_amp_c","(ADC pulse amplitude -ped)*gain*AmpToIntRatio", "fGood.a_amp_p"} );
 { "a_amptrig_p","(ADC pulse amplitude -ped)*AmpToIntRatio", "fGood.a_amp_p"} );
 { "a_amptrig_c","(ADC pulse amplitude -ped)*gain*AmpToIntRatio", "fGood.a_amp_p"} );
 { "a_time","ADC pulse time", "fGood.a_time"} );
 { "hits.a",   "All ADC inntegrals",  "fRaw.a" });
 { "hits.a_amp",   "All ADC amplitudes",  "fRaw.a_amp" });
 { "hits.a_time",   "All ADC pulse times",  "fRaw.a_time" });

ADC Waveform Variables¶

 { "samps_idx", "Index in samples vector for given row-col module", "fGood.sidx" });
 { "nsamps" , "Number of samples for given row-col", "fGood.nsamps"});
 { "samps", "Calibrated ADC samples",  "fGood.samps" });
 { "samps_elemID", "Calibrated ADC samples",  "fGood.samps_elemID" });

TDC Variables¶

 { "tdcrow", "Row for block in data vectors",  "fGood.TDCrow" }),
 { "tdccol", "Col for block in data vectors",  "fGood.TDCcol" }),
 { "tdcelemID", "Element ID for block in data vectors",  "fGood.TDCelemID" }),
 { "tdclayer", "Layer for block in data vectors",  "fGood.TDClayer" }),
 { "tdc", "Calibrated TDC value", "fGood.t" });
 { "tdc_mult", "TDC # of hits per channel", "fGood.t_mult" });
 { "tdc_te", "Calibrated TDC trailing info", "fGood.t_te" });
 { "tdc_tot", "Time Over Threshold", "fGood.t_ToT" });
 { "hits.TDCelemID",   "All TDC Element ID",  "fRaw.TDCelemID" });
 { "hits.t",   "All TDC leading edge times",  "fRaw.t" });
 { "hits.t_te",   "All TDC trailing edge times",  "fRaw.t_te" });
 { "hits.t_tot",  "All TDC Time-over-threshold",  "fRaw.t_ToT" });

Cluster Variables¶

 { "nclus", "Number of clusters meeting threshold", "fNclus" },
 { "e",      "Energy (MeV) of largest cluster",    "GetE()" },
 { "e_c",    "Corrected Energy (MeV) of largest cluster",    "GetECorrected()" },
 { "atimeblk", "ADC time of highest energy block in the largest cluster", "GetAtime()" },
 { "tdctimeblk", "TDC time of highest energy block in the largest cluster", "GetTDCtime()" },
 { "eblk",   "Energy (MeV) of highest energy block in the largest cluster",    "GetEBlk()" },
 { "eblk_c", "Corrected Energy (MeV) of highest energy block in the largest cluster",    "GetEBlkCorrected()" },
 { "rowblk", "Row of block with highest energy in the largest cluster",    "GetRow()" },
 { "colblk", "Col of block with highest energy in the largest cluster",    "GetCol()" },
 { "x",      "x-position (mm) of largest cluster", "GetX()" },
 { "y",      "y-position (mm) of largest cluster", "GetY()" },
 { "nblk",   "Number of blocks in the largest cluster",    "GetNblk()" },
 { "idblk",  "Logic number of block with highest energy in cluster",    "GetBlkID()" },

Cluster Member Variables¶

 { "clus.e", "Energy of cluster", "fOutclus.e"},
 { "clus.atime", "ADC time of cluster", "fOutclus.atime"},
 { "clus.tdctime", "TDC time of cluster", "fOutclus.tdctime"},
 { "clus.e_c","Energy calibrated of cluster", "fOutclus.e_c"},
 { "clus.x", "x-position of cluster", "fOutclus.x"},
 { "clus.y", "y-position of cluster", "fOutclus.y"},
 { "clus.row","block row in cluster with highest energy",    "fOutclus.row" },
 { "clus.col","block col in cluster with highest energy",    "fOutclus.col" },
 { "clus.id","block number in cluster",    "fOutclus.id" },
 { "clus.nblk","number of blocks in cluster",    "fOutclus.n" },
 { "clus.eblk", "Energy of block with highest energy in cluster", "fOutclus.blk_e"},
 { "clus.eblk_c","Energy calibrated of block with highest energy in cluster", "fOutclus.blk_e_c"},

"Good" Block Variables¶

 { "goodblock.e", "Energy of good blocks", "fGoodBlocks.e"},
 { "goodblock.atime", "Energy of good blocks", "fGoodBlocks.ADCTime"},
 { "goodblock.tdctime", "Energy of good blocks", "fGoodBlocks.TDCTime"},
 { "goodblock.row", "Row of good blocks", "fGoodBlocks.row"},
 { "goodblock.col", "Col of good blocks", "fGoodBlocks.col"},
 { "goodblock.x", "x pos (m) of good blocks", "fGoodBlocks.x"},
 { "goodblock.y", "y pos (m) of good blocks", "fGoodBlocks.y"},
 { "goodblock.id", "Element ID of good blocks", "fGoodBlocks.id"},

GEM Definitions¶

All definitions below are accessed from the tree with the prepend bb.gem.
- ex. bb.gem.track.ntrack
All definitions coming from the module class, SBSGEMModule.cxx, has an extra prefix for that module.
GEM modules are labeled numerically as m1, m2, m3, etc. We will generically list this as m#.
- Therefore the prefix will be bb.gem.m#.
- ex. bb.gem.m3.strip.nstripsfired

Track Variables¶

These variables come from SBSGEMSpectrometerTracker.cxx

   { "track.ntrack", "number of tracks found", "fNtracks_found" },
   { "track.nhits", "number of hits on track", "fNhitsOnTrack" },
   { "track.x", "Track X (TRANSPORT)", "fXtrack" }, //might be redundant with spectrometer variables, but probably needed for "non-tracking" version
   { "track.y", "Track Y (TRANSPORT)", "fYtrack" },
   { "track.xp", "Track dx/dz (TRANSPORT)", "fXptrack" },
   { "track.yp", "Track dy/dz (TRANSPORT)", "fYptrack" },
   { "track.chi2ndf", "Track Chi2/ndf", "fChi2Track" },
   { "track.besttrack", "Index of 'best' track", "fBestTrackIndex" },

Cluster Variables¶

These variables come from SBSGEMSpectrometerTracker.cxx

   { "hit.ngoodhits", "Total number of hits on all found tracks", "fNgoodhits" },
   { "hit.trackindex", "Index of track containing this hit", "fHitTrackIndex" },
   { "hit.module", "Module index of this hit", "fHitModule" },
   { "hit.layer", "Layer index of this hit", "fHitLayer" },
   { "hit.nstripu", "number of U strips on this hit", "fHitNstripsU" },
   { "hit.nstripv", "number of V strips on this hit", "fHitNstripsV" },
   { "hit.ustripmax", "index of u strip with max ADC in this hit", "fHitUstripMax" },
   { "hit.vstripmax", "index of v strip with max ADC in this hit", "fHitVstripMax" },
   { "hit.ustriplo", "index of minimum u strip in this hit", "fHitUstripLo" },
   { "hit.vstriplo", "index of minimum v strip in this hit", "fHitVstripLo" },
   { "hit.ustriphi", "index of maximum u strip in this hit", "fHitUstripHi" },
   { "hit.vstriphi", "index of maximum v strip in this hit", "fHitVstripHi" },
   { "hit.u", "reconstructed hit position along u", "fHitUlocal" },
   { "hit.v", "reconstructed hit position along v", "fHitVlocal" },
   { "hit.xlocal", "reconstructed local x position of hit (internal module coordinates)", "fHitXlocal" },
   { "hit.ylocal", "reconstructed local y position of hit (internal module coordinates)", "fHitYlocal" },
   { "hit.xglobal", "reconstructed global x position of hit", "fHitXglobal" },
   { "hit.yglobal", "reconstructed global y position of hit", "fHitYglobal" },
   { "hit.zglobal", "reconstructed global z position of hit", "fHitZglobal" },
   { "hit.umoment", "U cluster moment (consult source code or A. Puckett for definition)", "fHitUmoment" },
   { "hit.vmoment", "V cluster moment (consult source code or A. Puckett for definition)", "fHitVmoment" },
   { "hit.usigma", "U cluster rms", "fHitUsigma" },
   { "hit.vsigma", "V cluster rms", "fHitVsigma" },
   { "hit.residu", "u hit residual with fitted track (inclusive method)", "fHitResidU" },
   { "hit.residv", "v hit residual with fitted track (inclusive method)", "fHitResidV" },
   { "hit.eresidu", "u hit residual with fitted track (exclusive method)", "fHitEResidU" },
   { "hit.eresidv", "v hit residual with fitted track (exclusive method)", "fHitEResidV" },
   { "hit.ADCU", "cluster ADC sum, U strips", "fHitUADC" },
   { "hit.ADCV", "cluster ADC sum, V strips", "fHitVADC" },
   { "hit.ADCavg", "cluster ADC average", "fHitADCavg" },
   { "hit.ADCmaxstripU", "ADC sum of max U strip", "fHitUADCmaxstrip" },
   { "hit.ADCmaxstripV", "ADC sum of max V strip", "fHitVADCmaxstrip" },
   { "hit.ADCmaxsampU", "max sample of max U strip", "fHitUADCmaxsample" },
   { "hit.ADCmaxsampV", "max sample of max V strip", "fHitVADCmaxsample" },
   { "hit.ADCmaxsampUclust", "max U cluster-summed ADC time sample", "fHitUADCmaxclustsample" },
   { "hit.ADCmaxsampVclust", "max V cluster-summed ADC time sample", "fHitVADCmaxclustsample" },
   { "hit.ADCasym", "Hit ADC asymmetry: (ADCU - ADCV)/(ADCU + ADCV)", "fHitADCasym" },
   { "hit.Utime", "cluster timing based on U strips", "fHitUTime" },
   { "hit.Vtime", "cluster timing based on V strips", "fHitVTime" },
   { "hit.UtimeMaxStrip", "cluster timing based on U strips", "fHitUTimeMaxStrip" },
   { "hit.VtimeMaxStrip", "cluster timing based on V strips", "fHitVTimeMaxStrip" },
   { "hit.deltat", "cluster U time - V time", "fHitDeltaT" },
   { "hit.Tavg", "hit T average", "fHitTavg" },
   { "hit.isampmaxUclust", "peak time sample in cluster-summed U ADC samples", "fHitIsampMaxUclust" },
   { "hit.isampmaxVclust", "peak time sample in cluster-summed V ADC samples", "fHitIsampMaxVclust" },
   { "hit.isampmaxUstrip", "peak time sample in max U strip", "fHitIsampMaxUstrip" },
   { "hit.isampmaxVstrip", "peak time sample in max V strip", "fHitIsampMaxVstrip" },
   { "hit.ccor_clust", "correlation coefficient between cluster-summed U and V samples", "fHitCorrCoeffClust" },
   { "hit.ccor_strip", "correlation coefficient between U and V samples on strips with max ADC", "fHitCorrCoeffMaxStrip" },
   { "hit.ENABLE_CM_U", "Enable CM flag for max U strip in this hit", "fHitU_ENABLE_CM" },
   { "hit.ENABLE_CM_V", "Enable CM flag for max V strip in this hit", "fHitV_ENABLE_CM" },
   { "hit.CM_GOOD_U", "Enable CM flag for max U strip in this hit", "fHitU_CM_GOOD" },
   { "hit.CM_GOOD_V", "Enable CM flag for max V strip in this hit", "fHitV_CM_GOOD" },
   { "hit.BUILD_ALL_SAMPLES_U", "Enable CM flag for max U strip in this hit", "fHitU_BUILD_ALL_SAMPLES" },
   { "hit.BUILD_ALL_SAMPLES_V", "Enable CM flag for max V strip in this hit", "fHitV_BUILD_ALL_SAMPLES" },
   { "hit.ADCfrac0_Umax", "Max U strip ADC0/ADCsum", "fHitADCfrac0_MaxUstrip" },
   { "hit.ADCfrac1_Umax", "Max U strip ADC1/ADCsum", "fHitADCfrac1_MaxUstrip" },
   { "hit.ADCfrac2_Umax", "Max U strip ADC2/ADCsum", "fHitADCfrac2_MaxUstrip" },
   { "hit.ADCfrac3_Umax", "Max U strip ADC3/ADCsum", "fHitADCfrac3_MaxUstrip" },
   { "hit.ADCfrac4_Umax", "Max U strip ADC4/ADCsum", "fHitADCfrac4_MaxUstrip" },
   { "hit.ADCfrac5_Umax", "Max U strip ADC5/ADCsum", "fHitADCfrac5_MaxUstrip" },
   { "hit.ADCfrac0_Vmax", "Max V strip ADC0/ADCsum", "fHitADCfrac0_MaxVstrip" },
   { "hit.ADCfrac1_Vmax", "Max V strip ADC1/ADCsum", "fHitADCfrac1_MaxVstrip" },
   { "hit.ADCfrac2_Vmax", "Max V strip ADC2/ADCsum", "fHitADCfrac2_MaxVstrip" },
   { "hit.ADCfrac3_Vmax", "Max V strip ADC3/ADCsum", "fHitADCfrac3_MaxVstrip" },
   { "hit.ADCfrac4_Vmax", "Max V strip ADC4/ADCsum", "fHitADCfrac4_MaxVstrip" },
   { "hit.ADCfrac5_Vmax", "Max V strip ADC5/ADCsum", "fHitADCfrac5_MaxVstrip" },
   { "nlayershit", "number of layers with any strip fired", "fNlayers_hit" },
   { "nlayershitu", "number of layers with any U strip fired", "fNlayers_hitU" },
   { "nlayershitv", "number of layers with any V strip fired", "fNlayers_hitV" },
   { "nlayershituv", "number of layers with at least one 2D hit", "fNlayers_hitUV" },
   { "nstripsu_layer", "total number of U strips fired by layer", "fNstripsU_layer" },
   { "nstripsv_layer", "total number of V strips fired by layer", "fNstripsV_layer" },
   { "nclustu_layer", "total number of U clusters by layer", "fNclustU_layer" },
   { "nclustv_layer", "total number of V clusters by layer", "fNclustV_layer" },
   { "n2Dhit_layer", "total_number of 2D hits by layer", "fN2Dhit_layer" },
   { "clust.nclustu",   "Number of clusters in u",   "fNclustU" },
   { "clust.clustu_strips",   "u clusters strip multiplicity",   "fUclusters.nstrips" },
   { "clust.clustu_pos",   "u clusters position",   "fUclusters.hitpos_mean" },
   { "clust.clustu_adc",   "u clusters adc sum",   "fUclusters.clusterADCsum" },
   { "clust.clustu_time",   "u clusters time",   "fUclusters.t_mean" },
   { "clust.nclustv",   "Number of clusters in v",   "fNclustV" },
   { "clust.clustv_strips",   "v clusters strip multiplicity",   "fVclusters.nstrips" },
   { "clust.clustv_pos",   "v clusters position",   "fVclusters.hitpos_mean" },
   { "clust.clustv_adc",   "v clusters adc sum",   "fVclusters.clusterADCsum" },
   { "clust.clustv_time",   "v clusters time",   "fVclusters.t_mean" },
   { "hit.nhits2d",   "Number of 2d hits",   "fN2Dhits" },
   { "hit.hitx",   "local X coordinate of hit",   "fHits.xhit" },
   { "hit.hity",   "local Y coordinate of hit",   "fHits.yhit" },
   { "hit.hitxg",   "transport X coordinate of hit",   "fHits.xghit" },
   { "hit.hityg",   "transport Y coordinate of hit",   "fHits.yghit" },
   { "hit.hitADCasym",   "hit ADC asymmetry (ADCU-ADCV)/2",   "fHits.ADCasym" },
   { "hit.hitADCavg",  "(ADCU+ADCV)/2", "fHits.Ehit" },
   { "hit.hitTdiff",   "hit time difference (u-v)",   "fHits.tdiff" },
   { "hit.hitTavg",   "average time of 2D hit", "fHits.thitcorr" },
   { "hit.hit_iuclust", "index in u cluster array", "fHits.iuclust" },
   { "hit.hit_ivclust", "index in v cluster array", "fHits.ivclust" },
   { "hit.ontrack", "hit is on track", "fHits.ontrack" },

Strip Variables¶

These variables come from SBSGEMModule.cxx
GEM modules are labeled numerically as m1, m2, m3, etc. We will generically list this as m#.
For the module definitions below there is an extra prefix for each module, bb.gem.m#.
- ex. bb.gem.m3.strip.nstripsfired

   { "strip.nstripsfired", "Number of strips fired", kUInt, 0, &fNstrips_hit },
   { "strip.nstrips_keep", "Number of fired strips passing basic timing cuts", kUInt, 0, &fNstrips_keep },
   { "strip.nstrips_keepU", "Number of U/X strips passing basic timing cuts", kUInt, 0, &fNstrips_keepU },
   { "strip.nstrips_keepV", "Number of V/Y strips passing basic timing cuts", kUInt, 0, &fNstrips_keepV },
   { "strip.nstrips_keep_lmax", "Number of strips passing local max thresholds and basic timing cuts", kUInt, 0, &fNstrips_keep_lmax },
   { "strip.nstrips_keep_lmaxU", "Number of U/X strips passing local max thresholds and basic timing cuts", kUInt, 0, &fNstrips_keep_lmaxU },
   { "strip.nstrips_keep_lmaxV", "Number of V/Y strips passing local max thresholds and basic timing cuts", kUInt, 0, &fNstrips_keep_lmaxV },
   { "strip.istrip", "strip index", kUInt, 0, &(fStrip[0]), &fNstrips_hit },
   { "strip.IsU", "U strip?", kUInt, 0, &(fStripIsU[0]), &fNstrips_hit },
   { "strip.IsV", "V strip?", kUInt, 0, &(fStripIsV[0]), &fNstrips_hit },
   { "strip.ADCsamples", "ADC samples (index = isamp+Nsamples*istrip)", kDouble, 0, &(fADCsamples1D[0]), &fNdecoded_ADCsamples },
   { "strip.rawADCsamples", "raw ADC samples (no baseline subtraction)", kInt, 0, &(fRawADCsamples1D[0]), &fNdecoded_ADCsamples },
   { "strip.ADCsum", "Sum of ADC samples on a strip", kDouble, 0, &(fADCsums[0]), &fNstrips_hit },
   { "strip.isampmax", "sample in which max ADC occurred on a strip", kUInt, 0, &(fMaxSamp[0]), &fNstrips_hit },
   { "strip.ADCmax", "Value of max ADC sample on a strip", kDouble, 0, &(fADCmax[0]), &fNstrips_hit },
   { "strip.Tmean", "ADC-weighted mean strip time", kDouble, 0, &(fTmean[0]), &fNstrips_hit },
   { "strip.Tsigma", "ADC-weighted rms strip time", kDouble, 0, &(fTsigma[0]), &fNstrips_hit },
   { "strip.Tcorr", "Corrected strip time", kDouble, 0, &(fTcorr[0]), &fNstrips_hit },
   { "strip.Tfit", "Fitted strip time", kDouble, 0, &(fStripTfit[0]), &fNstrips_hit },
   { "strip.Tdiff", "time diff. wrt max strip in cluster (or perhaps cluster tmean)", kDouble, 0, &(fStripTdiff[0]), &fNstrips_hit },
   { "strip.TSchi2", "chi2 of strip pulse shape (time samples) wrt average good strip pulse shape", kDouble, 0, &(fStripTSchi2[0]), &fNstrips_hit },
   { "strip.CorrCoeff", "Correlation coefficient of strip wrt max strip on cluster (or perhaps cluster tmean)", kDouble, 0, &(fStripCorrCoeff[0]), &fNstrips_hit },
   { "strip.itrack", "Index of track containing this strip (-1 if not on any track)", kInt, 0, &(fStripTrackIndex[0]), &fNstrips_hit },
   { "strip.ontrack", "Is this strip on any track (0/1)?", kUInt, 0, &(fStripOnTrack[0]), &fNstrips_hit },
   { "strip.ADCavg", "average of ADC samples on a strip", kDouble, 0, &(fStripADCavg[0]), &fNstrips_hit },
   { "strip.ENABLE_CM", "online common-mode enabled?", kUInt, 0, &(fStrip_ENABLE_CM[0]), &fNstrips_hit },
   { "strip.CM_GOOD", "common-mode out of range? (online failed)", kUInt, 0, &(fStrip_CM_GOOD[0]), &fNstrips_hit },
   { "strip.BUILD_ALL_SAMPLES", "online or offline zero suppression", kUInt, 0, &(fStrip_BUILD_ALL_SAMPLES[0]), &fNstrips_hit },
   { "strip.ontrackU", "U strip on track", kUInt, 0, &(fStripUonTrack[0]), &fNstrips_hit },
   { "strip.ontrackV", "V strip on track", kUInt, 0, &(fStripVonTrack[0]), &fNstrips_hit },

Timing Variables¶

These variables come from SBSGEMModule.cxx

   { "time.T0_by_APV", "Coarse MPD timestamp of first event", "fT0_by_APV" },
   { "time.Tref_coarse", "Reference coarse MPD time stamp for this event", "fTref_coarse" },
   { "time.Tcoarse_by_APV", "Coarse MPD timestamp by APV relative to Tref_coarse", "fTcoarse_by_APV" },
   { "time.Tfine_by_APV", "Fine MPD timestamp by APV", "fTfine_by_APV" },
   { "time.EventCount_by_APV", "MPD event counter by APV (these should all agree in any one event)", "fEventCount_by_APV" },
   { "time.T_ns_by_APV", "Time stamp in ns relative to coarse T_ref", "fTimeStamp_ns_by_APV" },

Timing Hodoscope Variable Definitions¶

These definitions from the following source files defined in SBS-offline. See github for more information.
- SBSTimingHodoscope.cxx
- SBSGenericDetector.cxx
All definitions below are accessed from the tree with the prepend bb.hodotdc.
- Ex. bb.hodotdc.tdc_tot

Scint. Bar TDC Variables

   { "bar.ngoodbars",          "Number of good bars",                  "GetGoodBarsSize()"},
   { "bar.tdc.id",             "TDC Hit Bar ID",                       "fGoodBarIDsTDC"},
   { "bar.tdc.meantime",       "Bar Mean Time [ns]",                   "fGoodBarTDCmean"},
   { "bar.tdc.timediff",       "Bar Time Diff [ns]",                   "fGoodBarTDCdiff"},
   { "bar.tdc.timehitpos",     "Bar Time Hit pos from L [m]",          "fGoodBarTDCpos"},
   { "bar.tdc.vpos",           "Bar vertical position [m]",            "fGoodBarTDCvpos"},
   { "bar.tdc.L.le",           "Left pmt time LE [ns]",                "fGoodBarTDCLle"},
   { "bar.tdc.L.leW",          "Left pmt time LE walk corr [ns]",      "fGoodBarTDCLleW"},
   { "bar.tdc.L.te",           "Left pmt time TE [ns]",                "fGoodBarTDCLte"},
   { "bar.tdc.L.teW",          "Left pmt time TE walk corr [ns]",      "fGoodBarTDCLteW"},
   { "bar.tdc.L.tot",          "Left pmt tot [ns]",                    "fGoodBarTDCLtot"},
   { "bar.tdc.L.totW",         "Left pmt tot walk corr [ns]",          "fGoodBarTDCLtotW"},
   { "bar.tdc.R.le",           "Right pmt time LE [ns]",               "fGoodBarTDCRle"},
   { "bar.tdc.R.leW",          "Right pmt time LE walk corr [ns]",     "fGoodBarTDCRleW"},
   { "bar.tdc.R.te",           "Right pmt time TE [ns]",               "fGoodBarTDCRte"},
   { "bar.tdc.R.teW",          "Right pmt time TE walk corr [ns[",     "fGoodBarTDCRteW"},
   { "bar.tdc.R.tot",          "Right pmt tot [ns[",                   "fGoodBarTDCRtot"},
   { "bar.tdc.R.totW",         "Right pmt tot walk corr [ns]",         "fGoodBarTDCRtotW"},

Files (0)

Updated by Sean Jeffas over 1 year ago · 41 revisions

Project

General

Profile

Hall A » SBS experiments » SBS-analysis

Wiki

Replay Output Variables » History » Revision 41

Replay Output Variables¶

Description¶

Tracking Definition¶

Track Variables¶

Calorimeters, HCal and BBCal¶

HCal Variable Definitions¶

BBCal (Shower + PreShower) Variable Definitions¶

ADC Variables¶

ADC Waveform Variables¶

TDC Variables¶

Cluster Variables¶

Cluster Member Variables¶

"Good" Block Variables¶

GEM Definitions¶

Track Variables¶

Cluster Variables¶

Strip Variables¶

Timing Variables¶

Timing Hodoscope Variable Definitions¶