Replay Output Variables » History » Revision 45
Revision 44 (Sean Jeffas, 05/11/2023 10:14 AM) → Revision 45/52 (Sean Jeffas, 10/23/2023 03:42 PM)
h1. Replay Output Variables
{{toc}}
h1. 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> }
h1. 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*
h3. Track Variables
<pre>
{ "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" }
</code></pre>
h1. 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
h3. HCal Variable Definitions
* All definitions below are accessed from the tree with the prepend *sbs.hcal*.
** Ex. *sbs.hcal.clus_blk.atime*
h3. 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*
h3. ADC Variables
<pre>
{ "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" });
</code></pre>
h3. ADC Waveform Variables
<pre>
{ "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" });
</code></pre>
h3. TDC Variables
<pre>
{ "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" });
</code></pre>
h3. Cluster Variables
<pre>
{ "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()" },
</code></pre>
h3. Cluster Member Variables
<pre>
{ "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"},
</code></pre>
h3. "Good" Block Variables
<pre>
{ "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"},
</code></pre>
h1. 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*
h3. Track Variables
* These variables come from SBSGEMSpectrometerTracker.cxx
<pre>
{ "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" },
</code></pre>
h3. Cluster Variables
* These variables come from SBSGEMSpectrometerTracker.cxx
<pre>
{ "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.x", "hit.hitx", "local X coordinate of hit", "fHits.xhit" },
{ "hit.y", "hit.hity", "local Y coordinate of hit", "fHits.yhit" },
{ "hit.xg", "hit.hitxg", "transport X coordinate of hit", "fHits.xghit" },
{ "hit.yg", "hit.hityg", "transport Y coordinate of hit", "fHits.yghit" },
{ "hit.ADCasym", "hit.hitADCasym", "hit ADC asymmetry (ADCU-ADCV)/2", "fHits.ADCasym" },
{ "hit.ADCavg", "hit.hitADCavg", "(ADCU+ADCV)/2", "fHits.Ehit" },
{ "hit.Tdiff", "hit.hitTdiff", "hit time difference (u-v)", "fHits.tdiff" },
{ "hit.Tavg", "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" },
</code></pre>
h3. 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*
<pre>
{ "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 },
</code></pre>
h3. Timing Variables
* These variables come from SBSGEMModule.cxx
<pre>
{ "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" },
</code></pre>
h1. 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*
h3. Scint. Bar TDC Variables
<pre>
{ "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"},
</code></pre>
h3. Scint. Bar ADC Variables
<pre>
{ "bar.adc.id", "ADC Hit Bar ID", "fGoodBarIDsADC"},
{ "bar.adc.mean", "ADC Hit Bar Mean [bins]", "fGoodBarADCmean"},
{ "bar.adc.L.a", "Left ADC [bins]", "fGoodBarADCLa"},
{ "bar.adc.L.ap", "Left ADC ped corr [bins]", "fGoodBarADCLap"},
{ "bar.adc.L.ac", "Left ADC ped corr [GeV]", "fGoodBarADCLac"},
{ "bar.adc.R.a", "Right ADC [bins]", "fGoodBarADCRa"},
{ "bar.adc.R.ap", "Right ADC ped corr [bins]", "fGoodBarADCRap"},
{ "bar.adc.R.ac", "Right ADC ped corr [GeV]", "fGoodBarADCRac"},
</code></pre>
h3. All Cluster Variables
<pre>
{ "allclus.size", "cluster size", "fOutClus.n"},
{ "allclus.id", "cluster max bar id", "fOutClus.id" },
{ "allclus.xmean", "cluster mean X", "fOutClus.x"},
{ "allclus.ymean", "cluster mean Y", "fOutClus.y"},
{ "allclus.tmean", "cluster mean T", "fOutClus.t"},
{ "allclus.totmean", "cluster mean ToT", "fOutClus.tot"},
{ "allclus.tdiff", "cluster max bar tdiff", "fOutClus.tdiff"},
{ "allclus.itrack", "track index", "fOutClus.trackindex"},
</code></pre>
h3. Cluster Bar Variables
<pre>
{ "clus.bar.tdc.id", "main clus TDC Hit Bar ID", "fMainClusBars.id"},
{ "clus.bar.tdc.meantime", "main clus Bar Mean Time [ns]", "fMainClusBars.t"},
{ "clus.bar.tdc.meantot", "main clus Bar Mean ToT [ns]", "fMainClusBars.tot"},
{ "clus.bar.tdc.timediff", "main clus Bar Time Diff [ns]", "fMainClusBars.tdiff"},
{ "clus.bar.tdc.timehitpos","main clus Bar Time Hit pos from L [m]","fMainClusBars.y"},
{ "clus.bar.tdc.vpos", "main clus Bar vertical position [m]", "fMainClusBars.x"},
{ "clus.bar.tdc.itrack", "main clus Bar track index", "fMainClusBars.trackindex" },
</code></pre>
h3. Cluster Variables
<pre>
{ "nclus", "number of clusters", "GetNClusters()"},
{ "clus.id", "cluster max bar id", "fMainClus.id"},
{ "clus.size", "cluster size", "fMainClus.n"},
{ "clus.xmean", "cluster mean X", "fMainClus.x"},
{ "clus.ymean", "cluster mean Y", "fMainClus.y"},
{ "clus.tmean", "cluster mean T", "fMainClus.t"},
{ "clus.totmean", "cluster mean ToT", "fMainClus.tot"},
{ "clus.tdiff", "cluster max bar tdiff", "fMainClus.tdiff"},
{ "clus.trackindex", "cluster track index", "fMainClus.trackindex"},
</code></pre>
h3. Generic Detector TDC Variables
<pre>
{ "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" });
{ "nhits", "Nhits", "fNhits" },
{ "nrefhits", "Number of reference time hits", "fNRefhits" },
{ "ngoodTDChits", "NGoodTDChits", "fNGoodTDChits" },
{ "ngoodADChits", "NGoodADChits", "fNGoodADChits" },
</code></pre>