Revision as of 17:09, 25 March 2022

Descriptions

One can search any working build of SBS-offline 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> },

HCal Variable Definitions

Notes

These definitions from the following source files defined in SBS-offline. See github for more information.
- SBSCalorimeter.cxx
- SBSGenericDetector.cxx
All definitions below are accessed from the tree with the prepend sbs.hcal.
- Ex. sbs.hcal.clus_blk.atime

Definitions

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"},

Primary Cluster Member Variables

 { "clus_blk.e", "Energy of block in main cluster", "fMainclusblk.e"},
 { "clus_blk.e_c","Energy calibrated of block in main cluster", "fMainclusblk.e_c"},
 { "clus_blk.x", "x-position of block in main cluster", "fMainclusblk.x"},
 { "clus_blk.y", "y-position of block in main cluster", "fMainclusblk.y"},
 { "clus_blk.row","block row in main cluster",    "fMainclusblk.row" },
 { "clus_blk.atime","block ADC time in main cluster",    "fMainclusblk.atime" },
 { "clus_blk.tdctime","block TDC time in main cluster",    "fMainclusblk.tdctime" },
 { "clus_blk.col","block col in main cluster",    "fMainclusblk.col" },
 { "clus_blk.id","block number in main cluster",    "fMainclusblk.id" },

"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"},

BBCal (Shower + PreShower) Variable Definitions

Notes

These definitions from the following source files defined in SBS-offline. See github for more information.
- SBSCalorimeter.cxx
- SBSGenericDetector.cxx
All definitions below are accessed from the tree with the prepend bb.sh. for Shower and bb.ps. for PreShower
- Ex. bb.sh.e

Definitions

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" });

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"},

Primary Cluster Member Variables

 { "clus_blk.e", "Energy of block in main cluster", "fMainclusblk.e"},
 { "clus_blk.e_c","Energy calibrated of block in main cluster", "fMainclusblk.e_c"},
 { "clus_blk.x", "x-position of block in main cluster", "fMainclusblk.x"},
 { "clus_blk.y", "y-position of block in main cluster", "fMainclusblk.y"},
 { "clus_blk.row","block row in main cluster",    "fMainclusblk.row" },
 { "clus_blk.atime","block ADC time in main cluster",    "fMainclusblk.atime" },
 { "clus_blk.tdctime","block TDC time in main cluster",    "fMainclusblk.tdctime" },
 { "clus_blk.col","block col in main cluster",    "fMainclusblk.col" },
 { "clus_blk.id","block number in main cluster",    "fMainclusblk.id" },

"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 Variable Definitions

Notes

Definitions are found in the following scripts
- SBSGEMSpectrometerTracker.cxx
- SBSGEMModule.cxx
All definitions below are accessed from the tree with the prepend bb.gem.

Definitions

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" },

These variables come from SBSGEMModule.cxx

   { "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

   { "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" },

Single Arm Electron Kinematics Variable Definitions

Notes

These are presented as-is pending better documentation.
All definitions below are accessed from the tree with the prepend e.kine
- Ex. e.kine.nu

Kinematical Variables

   { "W2", "W^2, Invariant Mass Transfer Squared", "" },
   { "Q2", "Q^2, Inverse Momentum Transfer Squared", "" },
   { "angle", "e' angle wrt beamline", "" },
   { "epsilon", "Epsilon", "" },
   { "nu", "Scattered nucleon momentum", "" },
   { "omega", "", "" },
   { "ph_q", "Virtual photon momentum", "" },
   { "q3m", "", "" },
   { "q_x", "Q x-component", "" },
   { "q_y", "Q y-component", "" },
   { "q_z", "Q z-component", "" },
   { "th_q", "Q theta wrt beamline", "" },
   { "x_bj", "Bjorken X", "" },

Event Class Definitions

Notes

These definitions are implemented by default for root trees via the event class and can be viewed in more detail here.
All definitions below are accessed from the tree with the prepend fEvtHdr.
- Ex. fEvtHdr.fEvtNum

Definitions

   { "fEvtNum", "Index of event number", N/A },
   { "fRun", "Index for run", N/A },

Difference between revisions of "SBS Replay Variable Names"

Revision as of 17:09, 25 March 2022

Contents

Descriptions

HCal Variable Definitions

Notes

Definitions

ADC Variables

ADC Waveform Variables

TDC Variables

Cluster Variables

Cluster Member Variables

Primary Cluster Member Variables

"Good" Block Variables

BBCal (Shower + PreShower) Variable Definitions

Notes

Definitions

ADC Variables

ADC Waveform Variables

Cluster Variables

Cluster Member Variables

Primary Cluster Member Variables

"Good" Block Variables

GEM Variable Definitions

Notes

Definitions

Track Variables

Cluster Variables

Strip Variables

Timing Variables

Single Arm Electron Kinematics Variable Definitions

Notes

Kinematical Variables

Event Class Definitions

Notes

Definitions

Navigation menu

Search