Project

General

Profile

Replay Output Variables » History » Version 44

Sean Jeffas, 05/11/2023 10:14 AM

1 1 Sean Jeffas
h1. Replay Output Variables
2 2 Sean Jeffas
3 18 Sean Jeffas
{{toc}}
4
5 2 Sean Jeffas
h1. Description
6
7
* One can search any working build of SBS-offline or Podd for “rVarDef” to find the location of these definitions.
8
* From the build src directory: grep -nr “rvardef*” .
9 3 Sean Jeffas
* All definitions below are recorded in the following order: { <variable extension>, <Definition>, <SBS-offline designation> }
10
11
h1. Tracking Definition
12
13 5 Sean Jeffas
* These definitions are defined in Podd. See github [https://github.com/JeffersonLab/analyzer].
14 3 Sean Jeffas
** THaSpectrometer.cxx
15 15 Sean Jeffas
* All definitions below are accesed from the tree with the prepend *bb.tr*.
16
** Ex. *bb.tr.vz*
17 6 Sean Jeffas
18 10 Sean Jeffas
h3. Track Variables
19 6 Sean Jeffas
20 11 Sean Jeffas
<pre>
21 12 Sean Jeffas
 { "tr.n",    "Number of tracks",             "GetNTracks()" },
22 8 Sean Jeffas
 { "tr.x",    "Track x coordinate (m)",       "fTracks.THaTrack.fX" },
23
 { "tr.y",    "Track x coordinate (m)",       "fTracks.THaTrack.fY" },
24
 { "tr.th",   "Tangent of track theta angle", "fTracks.THaTrack.fTheta" },
25
 { "tr.ph",   "Tangent of track phi angle",   "fTracks.THaTrack.fPhi" },
26
 { "tr.p",    "Track momentum (GeV)",         "fTracks.THaTrack.fP" },
27
 { "tr.flag", "Track status flag",            "fTracks.THaTrack.fFlag" },
28
 { "tr.chi2", "Track's chi2 from hits",       "fTracks.THaTrack.fChi2" },
29
 { "tr.ndof", "Track's NDoF",                 "fTracks.THaTrack.fNDoF" },
30
 { "tr.d_x",  "Detector x coordinate (m)",    "fTracks.THaTrack.fDX" },
31
 { "tr.d_y",  "Detector y coordinate (m)",    "fTracks.THaTrack.fDY" },
32
 { "tr.d_th", "Detector tangent of theta",    "fTracks.THaTrack.fDTheta" },
33
 { "tr.d_ph", "Detector tangent of phi",      "fTracks.THaTrack.fDPhi" },
34
 { "tr.r_x",  "Rotated x coordinate (m)",     "fTracks.THaTrack.fRX" },
35
 { "tr.r_y",  "Rotated y coordinate (m)",     "fTracks.THaTrack.fRY" },
36
 { "tr.r_th", "Rotated tangent of theta",     "fTracks.THaTrack.fRTheta" },
37
 { "tr.r_ph", "Rotated tangent of phi",       "fTracks.THaTrack.fRPhi" },
38
 { "tr.tg_y", "Target y coordinate",          "fTracks.THaTrack.fTY"},
39
 { "tr.tg_th", "Tangent of target theta angle", "fTracks.THaTrack.fTTheta"},
40
 { "tr.tg_ph", "Tangent of target phi angle",   "fTracks.THaTrack.fTPhi"},    
41
 { "tr.tg_dp", "Target delta",                "fTracks.THaTrack.fDp"},
42
 { "tr.px",    "Lab momentum x (GeV)",        "fTracks.THaTrack.GetLabPx()"},
43
 { "tr.py",    "Lab momentum y (GeV)",        "fTracks.THaTrack.GetLabPy()"},
44
 { "tr.pz",    "Lab momentum z (GeV)",        "fTracks.THaTrack.GetLabPz()"},
45
 { "tr.vx",    "Vertex x (m)",                "fTracks.THaTrack.GetVertexX()"},
46
 { "tr.vy",    "Vertex y (m)",                "fTracks.THaTrack.GetVertexY()"},
47
 { "tr.vz",    "Vertex z (m)",                "fTracks.THaTrack.GetVertexZ()"},
48
 { "tr.pathl", "Pathlength from tg to fp (m)","fTracks.THaTrack.GetPathLen()"},
49
 { "tr.time",  "Time of track@Ref Plane (s)", "fTracks.THaTrack.GetTime()"},
50
 { "tr.dtime", "uncer of time (s)",           "fTracks.THaTrack.GetdTime()"},
51
 { "tr.beta",  "Beta of track",               "fTracks.THaTrack.GetBeta()"},
52
 { "tr.dbeta", "uncertainty of beta",         "fTracks.THaTrack.GetdBeta()"},
53
 { "status",   "Bits of completed analysis stages", "fStagesDone" }
54 7 Sean Jeffas
</code></pre>
55 13 Sean Jeffas
56 25 Sean Jeffas
h1. Calorimeters, HCal and BBCal
57
58
* HCal and BBCal share the same class so their variable definitions are the same, but with a different prefix.
59
** HCal variables have the prefix *sbs.hcal.*
60
** BBCal variables have the prefix *bb.*
61 1 Sean Jeffas
* These definitions from the following source files defined in SBS-offline. See github for more information.
62
** SBSCalorimeter.cxx
63
** SBSGenericDetector.cxx
64 27 Sean Jeffas
65 28 Sean Jeffas
h3. HCal Variable Definitions
66 27 Sean Jeffas
67 1 Sean Jeffas
* All definitions below are accessed from the tree with the prepend *sbs.hcal*.
68
** Ex. *sbs.hcal.clus_blk.atime*
69
70 28 Sean Jeffas
h3. BBCal (Shower + PreShower) Variable Definitions
71 27 Sean Jeffas
72
* All definitions below are accessed from the tree with the prepend *bb.sh.* for Shower and *bb.ps.* for PreShower
73
** Ex. *bb.sh.e*
74
75 16 Sean Jeffas
h3. ADC Variables
76
77
78
<pre>
79
 { "adcrow", "Row for block in data vectors",  "fGood.ADCrow" }),
80
 { "adccol", "Col for block in data vectors",  "fGood.ADCcol" }),
81
 { "adcelemID", "Element ID for block in data vectors",  "fGood.ADCelemID" }),
82
 { "adclayer", "Layer for block in data vectors",  "fGood.ADClayer" }),
83
 { "ped", "Pedestal for block in data vectors",  "fGood.ped" }),
84
 { "a","ADC integral", "fGood.a"} );
85
 { "a_mult","ADC # hits in channel", "fGood.a_mult"} );
86
 { "a_p","ADC integral - ped", "fGood.a_p"} );
87
 { "a_c","(ADC integral - ped)*gain", "fGood.a_c"} );
88
 { "a_amp","ADC pulse amplitude", "fGood.a_amp"} );
89
 { "a_amp_p","ADC pulse amplitude -ped", "fGood.a_amp_p"} );
90
 { "a_amp_c","(ADC pulse amplitude -ped)*gain*AmpToIntRatio", "fGood.a_amp_p"} );
91
 { "a_amptrig_p","(ADC pulse amplitude -ped)*AmpToIntRatio", "fGood.a_amp_p"} );
92
 { "a_amptrig_c","(ADC pulse amplitude -ped)*gain*AmpToIntRatio", "fGood.a_amp_p"} );
93
 { "a_time","ADC pulse time", "fGood.a_time"} );
94
 { "hits.a",   "All ADC inntegrals",  "fRaw.a" });
95
 { "hits.a_amp",   "All ADC amplitudes",  "fRaw.a_amp" });
96
 { "hits.a_time",   "All ADC pulse times",  "fRaw.a_time" });
97
</code></pre>
98 17 Sean Jeffas
99
h3. ADC Waveform Variables
100
101
<pre>
102
 { "samps_idx", "Index in samples vector for given row-col module", "fGood.sidx" });
103
 { "nsamps" , "Number of samples for given row-col", "fGood.nsamps"});
104
 { "samps", "Calibrated ADC samples",  "fGood.samps" });
105
 { "samps_elemID", "Calibrated ADC samples",  "fGood.samps_elemID" });
106
</code></pre>
107 19 Sean Jeffas
108
h3. TDC Variables
109
110
<pre>
111
 { "tdcrow", "Row for block in data vectors",  "fGood.TDCrow" }),
112
 { "tdccol", "Col for block in data vectors",  "fGood.TDCcol" }),
113
 { "tdcelemID", "Element ID for block in data vectors",  "fGood.TDCelemID" }),
114
 { "tdclayer", "Layer for block in data vectors",  "fGood.TDClayer" }),
115
 { "tdc", "Calibrated TDC value", "fGood.t" });
116
 { "tdc_mult", "TDC # of hits per channel", "fGood.t_mult" });
117
 { "tdc_te", "Calibrated TDC trailing info", "fGood.t_te" });
118
 { "tdc_tot", "Time Over Threshold", "fGood.t_ToT" });
119
 { "hits.TDCelemID",   "All TDC Element ID",  "fRaw.TDCelemID" });
120
 { "hits.t",   "All TDC leading edge times",  "fRaw.t" });
121
 { "hits.t_te",   "All TDC trailing edge times",  "fRaw.t_te" });
122
 { "hits.t_tot",  "All TDC Time-over-threshold",  "fRaw.t_ToT" });
123
</code></pre>
124 20 Sean Jeffas
125
h3. Cluster Variables
126
127
<pre>
128
 { "nclus", "Number of clusters meeting threshold", "fNclus" },
129
 { "e",      "Energy (MeV) of largest cluster",    "GetE()" },
130
 { "e_c",    "Corrected Energy (MeV) of largest cluster",    "GetECorrected()" },
131
 { "atimeblk", "ADC time of highest energy block in the largest cluster", "GetAtime()" },
132
 { "tdctimeblk", "TDC time of highest energy block in the largest cluster", "GetTDCtime()" },
133
 { "eblk",   "Energy (MeV) of highest energy block in the largest cluster",    "GetEBlk()" },
134
 { "eblk_c", "Corrected Energy (MeV) of highest energy block in the largest cluster",    "GetEBlkCorrected()" },
135
 { "rowblk", "Row of block with highest energy in the largest cluster",    "GetRow()" },
136
 { "colblk", "Col of block with highest energy in the largest cluster",    "GetCol()" },
137
 { "x",      "x-position (mm) of largest cluster", "GetX()" },
138
 { "y",      "y-position (mm) of largest cluster", "GetY()" },
139
 { "nblk",   "Number of blocks in the largest cluster",    "GetNblk()" },
140
 { "idblk",  "Logic number of block with highest energy in cluster",    "GetBlkID()" },
141
</code></pre>
142
143
h3. Cluster Member Variables
144
145
<pre>
146
 { "clus.e", "Energy of cluster", "fOutclus.e"},
147
 { "clus.atime", "ADC time of cluster", "fOutclus.atime"},
148
 { "clus.tdctime", "TDC time of cluster", "fOutclus.tdctime"},
149
 { "clus.e_c","Energy calibrated of cluster", "fOutclus.e_c"},
150
 { "clus.x", "x-position of cluster", "fOutclus.x"},
151
 { "clus.y", "y-position of cluster", "fOutclus.y"},
152
 { "clus.row","block row in cluster with highest energy",    "fOutclus.row" },
153
 { "clus.col","block col in cluster with highest energy",    "fOutclus.col" },
154
 { "clus.id","block number in cluster",    "fOutclus.id" },
155
 { "clus.nblk","number of blocks in cluster",    "fOutclus.n" },
156
 { "clus.eblk", "Energy of block with highest energy in cluster", "fOutclus.blk_e"},
157
 { "clus.eblk_c","Energy calibrated of block with highest energy in cluster", "fOutclus.blk_e_c"},
158
</code></pre>
159
160
h3. "Good" Block Variables
161
162
<pre>
163
 { "goodblock.e", "Energy of good blocks", "fGoodBlocks.e"},
164
 { "goodblock.atime", "Energy of good blocks", "fGoodBlocks.ADCTime"},
165
 { "goodblock.tdctime", "Energy of good blocks", "fGoodBlocks.TDCTime"},
166 21 Sean Jeffas
 { "goodblock.row", "Row of good blocks", "fGoodBlocks.row"},
167
 { "goodblock.col", "Col of good blocks", "fGoodBlocks.col"},
168 23 Sean Jeffas
 { "goodblock.x", "x pos (m) of good blocks", "fGoodBlocks.x"},
169
 { "goodblock.y", "y pos (m) of good blocks", "fGoodBlocks.y"},
170
 { "goodblock.id", "Element ID of good blocks", "fGoodBlocks.id"},
171
</code></pre>
172
173 1 Sean Jeffas
h1. GEM Definitions
174 30 Sean Jeffas
175
* All definitions below are accessed from the tree with the prepend *bb.gem.*
176 34 Sean Jeffas
** ex. *bb.gem.track.ntrack*
177 35 Sean Jeffas
* All definitions coming from the module class, SBSGEMModule.cxx, has an extra prefix for that module. 
178
* GEM modules are labeled numerically as m1, m2, m3, etc. We will generically list this as *m#*.
179
** Therefore the prefix will be *bb.gem.m#.*
180
** ex. *bb.gem.m3.strip.nstripsfired*
181
182 31 Sean Jeffas
183
h3. Track Variables
184
185
* These variables come from SBSGEMSpectrometerTracker.cxx
186 33 Sean Jeffas
187
<pre>
188
   { "track.ntrack", "number of tracks found", "fNtracks_found" },
189
   { "track.nhits", "number of hits on track", "fNhitsOnTrack" },
190
   { "track.x", "Track X (TRANSPORT)", "fXtrack" }, //might be redundant with spectrometer variables, but probably needed for "non-tracking" version
191
   { "track.y", "Track Y (TRANSPORT)", "fYtrack" },
192
   { "track.xp", "Track dx/dz (TRANSPORT)", "fXptrack" },
193
   { "track.yp", "Track dy/dz (TRANSPORT)", "fYptrack" },
194
   { "track.chi2ndf", "Track Chi2/ndf", "fChi2Track" },
195
   { "track.besttrack", "Index of 'best' track", "fBestTrackIndex" },
196
</code></pre>
197
198
h3. Cluster Variables
199
200
* These variables come from SBSGEMSpectrometerTracker.cxx
201
202
<pre>
203
   { "hit.ngoodhits", "Total number of hits on all found tracks", "fNgoodhits" },
204
   { "hit.trackindex", "Index of track containing this hit", "fHitTrackIndex" },
205
   { "hit.module", "Module index of this hit", "fHitModule" },
206
   { "hit.layer", "Layer index of this hit", "fHitLayer" },
207
   { "hit.nstripu", "number of U strips on this hit", "fHitNstripsU" },
208
   { "hit.nstripv", "number of V strips on this hit", "fHitNstripsV" },
209
   { "hit.ustripmax", "index of u strip with max ADC in this hit", "fHitUstripMax" },
210
   { "hit.vstripmax", "index of v strip with max ADC in this hit", "fHitVstripMax" },
211
   { "hit.ustriplo", "index of minimum u strip in this hit", "fHitUstripLo" },
212
   { "hit.vstriplo", "index of minimum v strip in this hit", "fHitVstripLo" },
213
   { "hit.ustriphi", "index of maximum u strip in this hit", "fHitUstripHi" },
214
   { "hit.vstriphi", "index of maximum v strip in this hit", "fHitVstripHi" },
215
   { "hit.u", "reconstructed hit position along u", "fHitUlocal" },
216
   { "hit.v", "reconstructed hit position along v", "fHitVlocal" },
217
   { "hit.xlocal", "reconstructed local x position of hit (internal module coordinates)", "fHitXlocal" },
218
   { "hit.ylocal", "reconstructed local y position of hit (internal module coordinates)", "fHitYlocal" },
219
   { "hit.xglobal", "reconstructed global x position of hit", "fHitXglobal" },
220
   { "hit.yglobal", "reconstructed global y position of hit", "fHitYglobal" },
221
   { "hit.zglobal", "reconstructed global z position of hit", "fHitZglobal" },
222
   { "hit.umoment", "U cluster moment (consult source code or A. Puckett for definition)", "fHitUmoment" },
223
   { "hit.vmoment", "V cluster moment (consult source code or A. Puckett for definition)", "fHitVmoment" },
224
   { "hit.usigma", "U cluster rms", "fHitUsigma" },
225
   { "hit.vsigma", "V cluster rms", "fHitVsigma" },
226
   { "hit.residu", "u hit residual with fitted track (inclusive method)", "fHitResidU" },
227
   { "hit.residv", "v hit residual with fitted track (inclusive method)", "fHitResidV" },
228
   { "hit.eresidu", "u hit residual with fitted track (exclusive method)", "fHitEResidU" },
229
   { "hit.eresidv", "v hit residual with fitted track (exclusive method)", "fHitEResidV" },
230
   { "hit.ADCU", "cluster ADC sum, U strips", "fHitUADC" },
231
   { "hit.ADCV", "cluster ADC sum, V strips", "fHitVADC" },
232
   { "hit.ADCavg", "cluster ADC average", "fHitADCavg" },
233
   { "hit.ADCmaxstripU", "ADC sum of max U strip", "fHitUADCmaxstrip" },
234
   { "hit.ADCmaxstripV", "ADC sum of max V strip", "fHitVADCmaxstrip" },
235
   { "hit.ADCmaxsampU", "max sample of max U strip", "fHitUADCmaxsample" },
236
   { "hit.ADCmaxsampV", "max sample of max V strip", "fHitVADCmaxsample" },
237
   { "hit.ADCmaxsampUclust", "max U cluster-summed ADC time sample", "fHitUADCmaxclustsample" },
238
   { "hit.ADCmaxsampVclust", "max V cluster-summed ADC time sample", "fHitVADCmaxclustsample" },
239
   { "hit.ADCasym", "Hit ADC asymmetry: (ADCU - ADCV)/(ADCU + ADCV)", "fHitADCasym" },
240
   { "hit.Utime", "cluster timing based on U strips", "fHitUTime" },
241
   { "hit.Vtime", "cluster timing based on V strips", "fHitVTime" },
242
   { "hit.UtimeMaxStrip", "cluster timing based on U strips", "fHitUTimeMaxStrip" },
243
   { "hit.VtimeMaxStrip", "cluster timing based on V strips", "fHitVTimeMaxStrip" },
244
   { "hit.deltat", "cluster U time - V time", "fHitDeltaT" },
245
   { "hit.Tavg", "hit T average", "fHitTavg" },
246
   { "hit.isampmaxUclust", "peak time sample in cluster-summed U ADC samples", "fHitIsampMaxUclust" },
247
   { "hit.isampmaxVclust", "peak time sample in cluster-summed V ADC samples", "fHitIsampMaxVclust" },
248
   { "hit.isampmaxUstrip", "peak time sample in max U strip", "fHitIsampMaxUstrip" },
249
   { "hit.isampmaxVstrip", "peak time sample in max V strip", "fHitIsampMaxVstrip" },
250
   { "hit.ccor_clust", "correlation coefficient between cluster-summed U and V samples", "fHitCorrCoeffClust" },
251
   { "hit.ccor_strip", "correlation coefficient between U and V samples on strips with max ADC", "fHitCorrCoeffMaxStrip" },
252
   { "hit.ENABLE_CM_U", "Enable CM flag for max U strip in this hit", "fHitU_ENABLE_CM" },
253
   { "hit.ENABLE_CM_V", "Enable CM flag for max V strip in this hit", "fHitV_ENABLE_CM" },
254
   { "hit.CM_GOOD_U", "Enable CM flag for max U strip in this hit", "fHitU_CM_GOOD" },
255
   { "hit.CM_GOOD_V", "Enable CM flag for max V strip in this hit", "fHitV_CM_GOOD" },
256
   { "hit.BUILD_ALL_SAMPLES_U", "Enable CM flag for max U strip in this hit", "fHitU_BUILD_ALL_SAMPLES" },
257
   { "hit.BUILD_ALL_SAMPLES_V", "Enable CM flag for max V strip in this hit", "fHitV_BUILD_ALL_SAMPLES" },
258
   { "hit.ADCfrac0_Umax", "Max U strip ADC0/ADCsum", "fHitADCfrac0_MaxUstrip" },
259
   { "hit.ADCfrac1_Umax", "Max U strip ADC1/ADCsum", "fHitADCfrac1_MaxUstrip" },
260
   { "hit.ADCfrac2_Umax", "Max U strip ADC2/ADCsum", "fHitADCfrac2_MaxUstrip" },
261
   { "hit.ADCfrac3_Umax", "Max U strip ADC3/ADCsum", "fHitADCfrac3_MaxUstrip" },
262
   { "hit.ADCfrac4_Umax", "Max U strip ADC4/ADCsum", "fHitADCfrac4_MaxUstrip" },
263
   { "hit.ADCfrac5_Umax", "Max U strip ADC5/ADCsum", "fHitADCfrac5_MaxUstrip" },
264
   { "hit.ADCfrac0_Vmax", "Max V strip ADC0/ADCsum", "fHitADCfrac0_MaxVstrip" },
265
   { "hit.ADCfrac1_Vmax", "Max V strip ADC1/ADCsum", "fHitADCfrac1_MaxVstrip" },
266
   { "hit.ADCfrac2_Vmax", "Max V strip ADC2/ADCsum", "fHitADCfrac2_MaxVstrip" },
267
   { "hit.ADCfrac3_Vmax", "Max V strip ADC3/ADCsum", "fHitADCfrac3_MaxVstrip" },
268
   { "hit.ADCfrac4_Vmax", "Max V strip ADC4/ADCsum", "fHitADCfrac4_MaxVstrip" },
269
   { "hit.ADCfrac5_Vmax", "Max V strip ADC5/ADCsum", "fHitADCfrac5_MaxVstrip" },
270
   { "nlayershit", "number of layers with any strip fired", "fNlayers_hit" },
271
   { "nlayershitu", "number of layers with any U strip fired", "fNlayers_hitU" },
272
   { "nlayershitv", "number of layers with any V strip fired", "fNlayers_hitV" },
273
   { "nlayershituv", "number of layers with at least one 2D hit", "fNlayers_hitUV" },
274
   { "nstripsu_layer", "total number of U strips fired by layer", "fNstripsU_layer" },
275
   { "nstripsv_layer", "total number of V strips fired by layer", "fNstripsV_layer" },
276
   { "nclustu_layer", "total number of U clusters by layer", "fNclustU_layer" },
277
   { "nclustv_layer", "total number of V clusters by layer", "fNclustV_layer" },
278
   { "n2Dhit_layer", "total_number of 2D hits by layer", "fN2Dhit_layer" },
279 36 Sean Jeffas
   { "clust.nclustu",   "Number of clusters in u",   "fNclustU" },
280
   { "clust.clustu_strips",   "u clusters strip multiplicity",   "fUclusters.nstrips" },
281
   { "clust.clustu_pos",   "u clusters position",   "fUclusters.hitpos_mean" },
282
   { "clust.clustu_adc",   "u clusters adc sum",   "fUclusters.clusterADCsum" },
283
   { "clust.clustu_time",   "u clusters time",   "fUclusters.t_mean" },
284
   { "clust.nclustv",   "Number of clusters in v",   "fNclustV" },
285
   { "clust.clustv_strips",   "v clusters strip multiplicity",   "fVclusters.nstrips" },
286
   { "clust.clustv_pos",   "v clusters position",   "fVclusters.hitpos_mean" },
287
   { "clust.clustv_adc",   "v clusters adc sum",   "fVclusters.clusterADCsum" },
288
   { "clust.clustv_time",   "v clusters time",   "fVclusters.t_mean" },
289
   { "hit.nhits2d",   "Number of 2d hits",   "fN2Dhits" },
290
   { "hit.hitx",   "local X coordinate of hit",   "fHits.xhit" },
291
   { "hit.hity",   "local Y coordinate of hit",   "fHits.yhit" },
292
   { "hit.hitxg",   "transport X coordinate of hit",   "fHits.xghit" },
293
   { "hit.hityg",   "transport Y coordinate of hit",   "fHits.yghit" },
294
   { "hit.hitADCasym",   "hit ADC asymmetry (ADCU-ADCV)/2",   "fHits.ADCasym" },
295
   { "hit.hitADCavg",  "(ADCU+ADCV)/2", "fHits.Ehit" },
296
   { "hit.hitTdiff",   "hit time difference (u-v)",   "fHits.tdiff" },
297
   { "hit.hitTavg",   "average time of 2D hit", "fHits.thitcorr" },
298
   { "hit.hit_iuclust", "index in u cluster array", "fHits.iuclust" },
299
   { "hit.hit_ivclust", "index in v cluster array", "fHits.ivclust" },
300
   { "hit.ontrack", "hit is on track", "fHits.ontrack" },
301 34 Sean Jeffas
</code></pre>
302
303
h3. Strip Variables
304
305
* These variables come from SBSGEMModule.cxx
306
* GEM modules are labeled numerically as m1, m2, m3, etc. We will generically list this as *m#*.
307
* For the module definitions below there is an extra prefix for each module, *bb.gem.m#.*
308
** ex. *bb.gem.m3.strip.nstripsfired*
309
310
<pre>
311
   { "strip.nstripsfired", "Number of strips fired", kUInt, 0, &fNstrips_hit },
312
   { "strip.nstrips_keep", "Number of fired strips passing basic timing cuts", kUInt, 0, &fNstrips_keep },
313
   { "strip.nstrips_keepU", "Number of U/X strips passing basic timing cuts", kUInt, 0, &fNstrips_keepU },
314
   { "strip.nstrips_keepV", "Number of V/Y strips passing basic timing cuts", kUInt, 0, &fNstrips_keepV },
315
   { "strip.nstrips_keep_lmax", "Number of strips passing local max thresholds and basic timing cuts", kUInt, 0, &fNstrips_keep_lmax },
316
   { "strip.nstrips_keep_lmaxU", "Number of U/X strips passing local max thresholds and basic timing cuts", kUInt, 0, &fNstrips_keep_lmaxU },
317
   { "strip.nstrips_keep_lmaxV", "Number of V/Y strips passing local max thresholds and basic timing cuts", kUInt, 0, &fNstrips_keep_lmaxV },
318
   { "strip.istrip", "strip index", kUInt, 0, &(fStrip[0]), &fNstrips_hit },
319
   { "strip.IsU", "U strip?", kUInt, 0, &(fStripIsU[0]), &fNstrips_hit },
320
   { "strip.IsV", "V strip?", kUInt, 0, &(fStripIsV[0]), &fNstrips_hit },
321
   { "strip.ADCsamples", "ADC samples (index = isamp+Nsamples*istrip)", kDouble, 0, &(fADCsamples1D[0]), &fNdecoded_ADCsamples },
322
   { "strip.rawADCsamples", "raw ADC samples (no baseline subtraction)", kInt, 0, &(fRawADCsamples1D[0]), &fNdecoded_ADCsamples },
323
   { "strip.ADCsum", "Sum of ADC samples on a strip", kDouble, 0, &(fADCsums[0]), &fNstrips_hit },
324
   { "strip.isampmax", "sample in which max ADC occurred on a strip", kUInt, 0, &(fMaxSamp[0]), &fNstrips_hit },
325
   { "strip.ADCmax", "Value of max ADC sample on a strip", kDouble, 0, &(fADCmax[0]), &fNstrips_hit },
326
   { "strip.Tmean", "ADC-weighted mean strip time", kDouble, 0, &(fTmean[0]), &fNstrips_hit },
327
   { "strip.Tsigma", "ADC-weighted rms strip time", kDouble, 0, &(fTsigma[0]), &fNstrips_hit },
328
   { "strip.Tcorr", "Corrected strip time", kDouble, 0, &(fTcorr[0]), &fNstrips_hit },
329
   { "strip.Tfit", "Fitted strip time", kDouble, 0, &(fStripTfit[0]), &fNstrips_hit },
330
   { "strip.Tdiff", "time diff. wrt max strip in cluster (or perhaps cluster tmean)", kDouble, 0, &(fStripTdiff[0]), &fNstrips_hit },
331
   { "strip.TSchi2", "chi2 of strip pulse shape (time samples) wrt average good strip pulse shape", kDouble, 0, &(fStripTSchi2[0]), &fNstrips_hit },
332
   { "strip.CorrCoeff", "Correlation coefficient of strip wrt max strip on cluster (or perhaps cluster tmean)", kDouble, 0, &(fStripCorrCoeff[0]), &fNstrips_hit },
333
   { "strip.itrack", "Index of track containing this strip (-1 if not on any track)", kInt, 0, &(fStripTrackIndex[0]), &fNstrips_hit },
334
   { "strip.ontrack", "Is this strip on any track (0/1)?", kUInt, 0, &(fStripOnTrack[0]), &fNstrips_hit },
335
   { "strip.ADCavg", "average of ADC samples on a strip", kDouble, 0, &(fStripADCavg[0]), &fNstrips_hit },
336
   { "strip.ENABLE_CM", "online common-mode enabled?", kUInt, 0, &(fStrip_ENABLE_CM[0]), &fNstrips_hit },
337
   { "strip.CM_GOOD", "common-mode out of range? (online failed)", kUInt, 0, &(fStrip_CM_GOOD[0]), &fNstrips_hit },
338
   { "strip.BUILD_ALL_SAMPLES", "online or offline zero suppression", kUInt, 0, &(fStrip_BUILD_ALL_SAMPLES[0]), &fNstrips_hit },
339
   { "strip.ontrackU", "U strip on track", kUInt, 0, &(fStripUonTrack[0]), &fNstrips_hit },
340
   { "strip.ontrackV", "V strip on track", kUInt, 0, &(fStripVonTrack[0]), &fNstrips_hit },
341 36 Sean Jeffas
</code></pre>
342
343 37 Sean Jeffas
h3. Timing Variables
344 36 Sean Jeffas
345 37 Sean Jeffas
* These variables come from SBSGEMModule.cxx
346 36 Sean Jeffas
347
<pre>
348 37 Sean Jeffas
   { "time.T0_by_APV", "Coarse MPD timestamp of first event", "fT0_by_APV" },
349
   { "time.Tref_coarse", "Reference coarse MPD time stamp for this event", "fTref_coarse" },
350
   { "time.Tcoarse_by_APV", "Coarse MPD timestamp by APV relative to Tref_coarse", "fTcoarse_by_APV" },
351
   { "time.Tfine_by_APV", "Fine MPD timestamp by APV", "fTfine_by_APV" },
352
   { "time.EventCount_by_APV", "MPD event counter by APV (these should all agree in any one event)", "fEventCount_by_APV" },
353
   { "time.T_ns_by_APV", "Time stamp in ns relative to coarse T_ref", "fTimeStamp_ns_by_APV" },
354 33 Sean Jeffas
</code></pre>
355 38 Sean Jeffas
356
h1. Timing Hodoscope Variable Definitions
357
358
* These definitions from the following source files defined in SBS-offline. See github for more information.
359
** SBSTimingHodoscope.cxx
360
** SBSGenericDetector.cxx
361
* All definitions below are accessed from the tree with the prepend *bb.hodotdc.*
362 39 Sean Jeffas
** Ex. *bb.hodotdc.tdc_tot*
363 38 Sean Jeffas
364 1 Sean Jeffas
h3. Scint. Bar TDC Variables
365 42 Sean Jeffas
366 41 Sean Jeffas
<pre>
367 39 Sean Jeffas
   { "bar.ngoodbars",          "Number of good bars",                  "GetGoodBarsSize()"},
368
   { "bar.tdc.id",             "TDC Hit Bar ID",                       "fGoodBarIDsTDC"},
369
   { "bar.tdc.meantime",       "Bar Mean Time [ns]",                   "fGoodBarTDCmean"},
370
   { "bar.tdc.timediff",       "Bar Time Diff [ns]",                   "fGoodBarTDCdiff"},
371
   { "bar.tdc.timehitpos",     "Bar Time Hit pos from L [m]",          "fGoodBarTDCpos"},
372
   { "bar.tdc.vpos",           "Bar vertical position [m]",            "fGoodBarTDCvpos"},
373
   { "bar.tdc.L.le",           "Left pmt time LE [ns]",                "fGoodBarTDCLle"},
374
   { "bar.tdc.L.leW",          "Left pmt time LE walk corr [ns]",      "fGoodBarTDCLleW"},
375
   { "bar.tdc.L.te",           "Left pmt time TE [ns]",                "fGoodBarTDCLte"},
376
   { "bar.tdc.L.teW",          "Left pmt time TE walk corr [ns]",      "fGoodBarTDCLteW"},
377
   { "bar.tdc.L.tot",          "Left pmt tot [ns]",                    "fGoodBarTDCLtot"},
378
   { "bar.tdc.L.totW",         "Left pmt tot walk corr [ns]",          "fGoodBarTDCLtotW"},
379
   { "bar.tdc.R.le",           "Right pmt time LE [ns]",               "fGoodBarTDCRle"},
380
   { "bar.tdc.R.leW",          "Right pmt time LE walk corr [ns]",     "fGoodBarTDCRleW"},
381
   { "bar.tdc.R.te",           "Right pmt time TE [ns]",               "fGoodBarTDCRte"},
382
   { "bar.tdc.R.teW",          "Right pmt time TE walk corr [ns[",     "fGoodBarTDCRteW"},
383
   { "bar.tdc.R.tot",          "Right pmt tot [ns[",                   "fGoodBarTDCRtot"},
384 1 Sean Jeffas
   { "bar.tdc.R.totW",         "Right pmt tot walk corr [ns]",         "fGoodBarTDCRtotW"},
385 41 Sean Jeffas
</code></pre>
386 43 Sean Jeffas
387
h3. Scint. Bar ADC Variables
388
389
<pre>
390
   { "bar.adc.id",             "ADC Hit Bar ID",                       "fGoodBarIDsADC"},
391
   { "bar.adc.mean",           "ADC Hit Bar Mean [bins]",              "fGoodBarADCmean"},
392
   { "bar.adc.L.a",            "Left ADC [bins]",                      "fGoodBarADCLa"},
393
   { "bar.adc.L.ap",           "Left ADC ped corr [bins]",             "fGoodBarADCLap"},
394
   { "bar.adc.L.ac",           "Left ADC ped corr [GeV]",              "fGoodBarADCLac"},
395
   { "bar.adc.R.a",            "Right ADC [bins]",                     "fGoodBarADCRa"},
396
   { "bar.adc.R.ap",           "Right ADC ped corr [bins]",            "fGoodBarADCRap"},
397
   { "bar.adc.R.ac",           "Right ADC ped corr [GeV]",             "fGoodBarADCRac"},
398
</code></pre>
399
400
h3. All Cluster Variables
401
402
<pre>
403
   { "allclus.size",           "cluster size",                         "fOutClus.n"},
404
   { "allclus.id",             "cluster max bar id",                   "fOutClus.id" },
405
   { "allclus.xmean",          "cluster mean X",                       "fOutClus.x"},
406
   { "allclus.ymean",          "cluster mean Y",                       "fOutClus.y"},
407
   { "allclus.tmean",          "cluster mean T",                       "fOutClus.t"},
408
   { "allclus.totmean",        "cluster mean ToT",                     "fOutClus.tot"},
409
   { "allclus.tdiff",          "cluster max bar tdiff",                "fOutClus.tdiff"},
410
   { "allclus.itrack",         "track index",                          "fOutClus.trackindex"},
411
</code></pre>
412 44 Sean Jeffas
413
h3. Cluster Bar Variables
414
415
<pre>
416
   { "clus.bar.tdc.id",        "main clus TDC Hit Bar ID",             "fMainClusBars.id"},
417
   { "clus.bar.tdc.meantime",  "main clus Bar Mean Time [ns]",         "fMainClusBars.t"},
418
   { "clus.bar.tdc.meantot",   "main clus Bar Mean ToT [ns]",          "fMainClusBars.tot"},
419
   { "clus.bar.tdc.timediff",  "main clus Bar Time Diff [ns]",         "fMainClusBars.tdiff"},
420
   { "clus.bar.tdc.timehitpos","main clus Bar Time Hit pos from L [m]","fMainClusBars.y"},
421
   { "clus.bar.tdc.vpos",      "main clus Bar vertical position [m]",  "fMainClusBars.x"},
422
   { "clus.bar.tdc.itrack",    "main clus Bar track index",            "fMainClusBars.trackindex" },
423
</code></pre>
424
425
h3. Cluster Variables
426
427
<pre>
428
   { "nclus",                  "number of clusters",                   "GetNClusters()"},
429
   { "clus.id",                "cluster max bar id",                   "fMainClus.id"},
430
   { "clus.size",              "cluster size",                         "fMainClus.n"},
431
   { "clus.xmean",             "cluster mean X",                       "fMainClus.x"},
432
   { "clus.ymean",             "cluster mean Y",                       "fMainClus.y"},
433
   { "clus.tmean",             "cluster mean T",                       "fMainClus.t"},
434
   { "clus.totmean",           "cluster mean ToT",                     "fMainClus.tot"},
435
   { "clus.tdiff",             "cluster max bar tdiff",                "fMainClus.tdiff"},
436
   { "clus.trackindex",        "cluster track index",                  "fMainClus.trackindex"},
437
</code></pre>
438
439
h3. Generic Detector TDC Variables
440
441
<pre>
442
   { "tdcrow",                 "Row for block in data vectors",        "fGood.TDCrow" }),
443
   { "tdccol",                 "Col for block in data vectors",        "fGood.TDCcol" }),
444
   { "tdcelemID",              "Element ID for block in data vectors", "fGood.TDCelemID" }),
445
   { "tdclayer",               "Layer for block in data vectors",      "fGood.TDClayer" }),
446
   { "tdc",                    "Calibrated TDC value",                 "fGood.t" });
447
   { "tdc_mult",               "TDC # of hits per channel",            "fGood.t_mult" });
448
   { "tdc_te",                 "Calibrated TDC trailing info",         "fGood.t_te" });
449
   { "tdc_tot",                "Time Over Threshold",                  "fGood.t_ToT" });
450
   { "hits.TDCelemID",         "All TDC Element ID",                   "fRaw.TDCelemID" });
451
   { "hits.t",                 "All TDC leading edge times",           "fRaw.t" });
452
   { "hits.t_te",              "All TDC trailing edge times",          "fRaw.t_te" });
453
   { "hits.t_tot",             "All TDC Time-over-threshold",          "fRaw.t_ToT" });
454
   { "nhits",                  "Nhits",                                "fNhits" },
455
   { "nrefhits",               "Number of reference time hits",        "fNRefhits" },
456
   { "ngoodTDChits",           "NGoodTDChits",                         "fNGoodTDChits" },
457
   { "ngoodADChits",           "NGoodADChits",                         "fNGoodADChits" },
458
</code></pre>