List of Analyzer ROOT variable names

From Hall A Wiki
Revision as of 15:23, 16 June 2020 by Brads (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search

Culled from a semi-recent analyzer build using this script:

#!/usr/bin/perl -w
# Usage: 
#   Save script as 'printVars' then cd into the source directory for the
#   analyzer and BB libs and pass the script the C files you care about: ie.
#   % ./printVars analyzer/*/*.C  d2n/bigbitelib/*.cxx d2n/BBNormAna/*.cxx

for (@ARGV) {
  my $file=$_;
  open INF,"<$file" or die "Can't open '$file': $!\n";

  my $output="";
  LINE:
  while(<INF>) {
    if(/Int_t\s+(\w+)::DefineVariables\s*\(\s*(EMode\s+)?mode\s*\)/) {
      $object=$1;

      BLOCK:
      while(<INF>) {
        if(/^\s+RVarDef vars\[\] = {/) {
          $output .= $_;
          while(<INF>) {
            $output .= $_;
            next BLOCK if /^\s*}\s*;/;
            last LINE if /^\s*return\s+/;
          }
        }
      }
    }
  }
  if ( $output !~ /^\s*$/s ) {
    printf("\n\n<b>%-30s</b>  (%s)\n", $object, $file);
    print "<pre>\n";
    print $output;
    print "</pre>\n";
  }
  close(INF);
}

NOTE: This is just a general reference. Look at the replay.C file (or equivalent) to understand what the object names are for your detector class. There are classes and variables here that will NOT be in a typical ROOT file.

Class Variable List

THaBeam (analyzer/src/THaBeam.C)

  RVarDef vars[] = {
    { "x", "reconstructed x-position at nom. interaction point", "fPosition.fX"},
    { "y", "reconstructed y-position at nom. interaction point", "fPosition.fY"},
    { "z", "reconstructed z-position at nom. interaction point", "fPosition.fZ"},
    { "dir.x", "reconstructed x-component of beam direction", "fDirection.fX"},
    { "dir.y", "reconstructed y-component of beam direction", "fDirection.fY"},
    { "dir.z", "reconstructed z-component of beam direction", "fDirection.fZ"},
    { 0 }
  };


THaBPM (analyzer/src/THaBPM.C)

  RVarDef vars[] = {
    { "rawcur.1", "current in antenna 1", "GetRawSignal0()"},
    { "rawcur.2", "current in antenna 2", "GetRawSignal1()"},
    { "rawcur.3", "current in antenna 3", "GetRawSignal2()"},
    { "rawcur.4", "current in antenna 4", "GetRawSignal3()"},
    { "x", "reconstructed x-position", "fPosition.fX"},
    { "y", "reconstructed y-position", "fPosition.fY"},
    { "z", "reconstructed z-position", "fPosition.fZ"},
    { "rotpos1", "position in bpm system","GetRotPosX()"},
    { "rotpos2", "position in bpm system","GetRotPosY()"},
    { 0 }
  };


THaCherenkov (analyzer/src/THaCherenkov.C)

  RVarDef vars[] = {
    { "nthit",  "Number of Left paddles TDC times",  "fNThit" },
    { "nahit",  "Number of Right paddles TDC times", "fNAhit" },
    { "t",      "TDC values",                        "fT" },
    { "t_c",    "Corrected TDC values",              "fT_c" },
    { "a",      "ADC values",                        "fA" },
    { "a_p",    "Ped-subtracted ADC values ",        "fA_p" },
    { "a_c",    "Corrected ADC values",              "fA_c" },
    { "asum_p", "Sum of ADC minus pedestal values",  "fASUM_p" },
    { "asum_c", "Sum of corrected ADC amplitudes",   "fASUM_c" },
    { "trx",    "x-position of track in det plane",  "fTrackProj.THaTrackProj.fX" },
    { "try",    "y-position of track in det plane",  "fTrackProj.THaTrackProj.fY" },
    { "trpath", "TRCS pathlen of track to det plane","fTrackProj.THaTrackProj.fPathl" },
    { 0 }
  };


THaCoincTime (analyzer/src/THaCoincTime.C)

  RVarDef vars[] = {
    { "d_trig","Measured TDC start+delay of spec 2 (1), by spec 1 (2)", "fdTdc" },
    { "ntr1",  "Number of tracks in first spec.",  "fNTr1" },
    { "ntr2",  "Number of tracks in first spec.",  "fNTr2" },
    { "vx_t1", "Time of track from spec1 at target vertex", "fVxTime1" },
    { "vx_t2", "Time of track from spec2 at target vertex", "fVxTime2" },
    { "ncomb", "Number of track combinations considered",   "fNtimes" },
    { "ct_2by1", "Coinc. times of tracks, d_trig from spec 1", "fDiffT2by1" },
    { "ct_1by2", "Coinc. times of tracks, d_trig from spec 2", "fDiffT1by2" },
    { "trind1",  "Track indices for spec1 match entries in ct_*", "fTrInd1" },
    { "trind2",  "Track indices for spec2 match entries in ct_*", "fTrInd2" },
    { 0 }
  };


THaEpicsEbeam (analyzer/src/THaEpicsEbeam.C)

  RVarDef vars[] = {
    { "ecorr", "Beam energy correction (output-input) (GeV)", "fEcorr" },
    { 0 }
  };


THaPhotoReaction (analyzer/src/THaPhotoReaction.C)

  RVarDef vars[] = {
    { "EGamma",   "Real Brem. Photon Energy (GeV)", "fEGamma"},
    { "angle",    "Scattering Angle (rad)",         "fScatAngle"},
    { "angle_cm", "Scattering Angle(rad) in CM",    "fScatAngleCM"},
    { 0 }
  };


THaPrimaryKine (analyzer/src/THaPrimaryKine.C)

  RVarDef vars[] = {
    { "Q2",      "4-momentum transfer squared (GeV^2)",     "fQ2" },
    { "omega",   "Energy transfer (GeV)",                   "fOmega" },
    { "W2",      "Invariant mass of recoil system (GeV^2)", "fW2" }, 
    { "x_bj",    "Bjorken x",                               "fXbj" },
    { "angle",   "Scattering angle (rad)",                  "fScatAngle" },
    { "epsilon", "Virtual photon polarization factor",      "fEpsilon" },
    { "q3m",     "Magnitude of 3-momentum transfer",        "fQ3mag" },
    { "th_q",    "Theta of 3-momentum vector (rad)",        "fThetaQ" },
    { "ph_q",    "Phi of 3-momentum vector (rad)",          "fPhiQ" },
    { "nu",      "Energy transfer (GeV)",                   "fOmega" },
    { "q_x",     "x-cmp of Photon vector in the lab",       "fQ.X()" },
    { "q_y",     "y-cmp of Photon vector in the lab",       "fQ.Y()" },
    { "q_z",     "z-cmp of Photon vector in the lab",       "fQ.Z()" },
    { 0 }
  };


THaRaster (analyzer/src/THaRaster.C)

  RVarDef vars[] = {
    { "rawcur.x", "current in horizontal raster", "GetRawPosX()" },
    { "rawcur.y", "current in vertical raster", "GetRawPosY()"},
    { "rawslope.x", "derivative of current in horizontal raster", "GetRawSlopeX()" },
    { "rawslope.y", "derivative of current in vertical raster", "GetRawSlopeY()"},
    { "bpma.x", "reconstructed x-position at 1st bpm", "GetPosBPMAX()"},
    { "bpma.y", "reconstructed y-position at 1st bpm", "GetPosBPMAY()"},
    { "bpma.z", "reconstructed z-position at 1st bpm", "GetPosBPMAZ()"},
    { "bpmb.x", "reconstructed x-position at 2nd bpm", "GetPosBPMBX()"},
    { "bpmb.y", "reconstructed y-position at 2nd bpm", "GetPosBPMBY()"},
    { "bpmb.z", "reconstructed z-position at 2nd bpm", "GetPosBPMBZ()"},
    { "target.x", "reconstructed x-position at nom. interaction point", "GetPosTarX()"},
    { "target.y", "reconstructed y-position at nom. interaction point", "GetPosTarY()"},
    { "target.z", "reconstructed z-position at nom. interaction point", "GetPosTarZ()"},
    { "target.dir.x", "reconstructed x-component of beam direction", "fDirection.fX"},
    { "target.dir.y", "reconstructed y-component of beam direction", "fDirection.fY"},
    { "target.dir.z", "reconstructed z-component of beam direction", "fDirection.fZ"},
    { 0 }
  };


THaScintillator (analyzer/src/THaScintillator.C)

  RVarDef vars[] = {
    { "nlthit", "Number of Left paddles TDC times",  "fLTNhit" },
    { "nrthit", "Number of Right paddles TDC times", "fRTNhit" },
    { "nlahit", "Number of Left paddles ADCs amps",  "fLANhit" },
    { "nrahit", "Number of Right paddles ADCs amps", "fRANhit" },
    { "lt",     "TDC values left side",              "fLT" },
    { "lt_c",   "Corrected times left side",         "fLT_c" },
    { "rt",     "TDC values right side",             "fRT" },
    { "rt_c",   "Corrected times right side",        "fRT_c" },
    { "la",     "ADC values left side",              "fLA" },
    { "la_p",   "Corrected ADC values left side",    "fLA_p" },
    { "la_c",   "Corrected ADC values left side",    "fLA_c" },
    { "ra",     "ADC values right side",             "fRA" },
    { "ra_p",   "Corrected ADC values right side",   "fRA_p" },
    { "ra_c",   "Corrected ADC values right side",   "fRA_c" },
    { "nthit",  "Number of paddles with l&r TDCs",   "fNhit" },
    { "t_pads", "Paddles with l&r coincidence TDCs", "fHitPad" },
    { "y_t",    "y-position from timing (m)",        "fYt" },
    { "y_adc",  "y-position from amplitudes (m)",    "fYa" },
    { "time",   "Time of hit at plane (s)",          "fTime" },
    { "dtime",  "Est. uncertainty of time (s)",      "fdTime" },
    { "dedx",   "dEdX-like deposited in paddle",     "fAmpl" },
    { "troff",  "Trigger offset for paddles",        "fTrigOff"},
    { "trn",    "Number of tracks for hits",         "GetNTracks()" },
    { "trx",    "x-position of track in det plane",  "fTrackProj.THaTrackProj.fX" },
    { "try",    "y-position of track in det plane",  "fTrackProj.THaTrackProj.fY" },
    { "trpath", "TRCS pathlen of track to det plane","fTrackProj.THaTrackProj.fPathl" },
    { "trdx",   "track deviation in x-position (m)", "fTrackProj.THaTrackProj.fdX" },
    { "trpad",  "paddle-hit associated with track",  "fTrackProj.THaTrackProj.fChannel" },
    { 0 }
  };


THaSecondaryKine (analyzer/src/THaSecondaryKine.C)

  RVarDef vars[] = {
    { "th_xq",    "Polar angle of detected particle with q (rad)",
                  "fTheta_xq" },
    { "ph_xq",    "Azimuth of detected particle with scattering plane (rad)",
                  "fPhi_xq" },
    { "th_bq",    "Polar angle of recoil system with q (rad)", "fTheta_bq" },
    { "ph_bq",    "Azimuth of recoil system with scattering plane (rad)",
                  "fPhi_bq" },
    { "xangle",   "Angle of detected particle with scattered electron (rad)",
                  "fXangle" },
    { "pmiss",    "Missing momentum magnitude (GeV), nuclear physics "
                  "definition (-pB)", "fPmiss" },
    { "pmiss_x",  "x-component of p_miss wrt q (GeV)", "fPmiss_x" },
    { "pmiss_y",  "y-component of p_miss wrt q (GeV)", "fPmiss_y" },
    { "pmiss_z",  "z-component of p_miss, along q (GeV)", "fPmiss_z" },
    { "emiss",    "Missing energy (GeV), nuclear physics definition "
                  "omega-Tx-Tb", "fEmiss" },
    { "Mrecoil",  "Invariant mass of recoil system (GeV)", "fMrecoil" },
    { "Erecoil",  "Total energy of recoil system (GeV)", "fErecoil" },
    { "Prec_x",   "x-component of recoil system in lab (GeV/c)", "fB.X()" },
    { "Prec_y",   "y-component of recoil system in lab (GeV/c)", "fB.Y()" },
    { "Prec_z",   "z-component of recoil system in lab (GeV/c)", "fB.Z()" },
    { "tx",       "Kinetic energy of detected particle (GeV)", "fTX" },
    { "tb",       "Kinetic energy of recoil system (GeV)", "fTB" },
    { "px_cm",    "Magnitude of X momentum in CM system (GeV)", "fPX_cm" },
    { "thx_cm",   "Polar angle of X in CM system wrt q (rad)", "fTheta_x_cm" },
    { "phx_cm",   "Azimuth of X in CM system wrt q (rad)", "fPhi_x_cm" },
    { "thb_cm",   "Polar angle of recoil systm in CM wrt q (rad)",
                  "fTheta_b_cm" },
    { "phb_cm",   "Azimuth of recoil system in CM wrt q (rad)", "fPhi_b_cm" },
    { "tx_cm",    "Kinetic energy of X in CM (GeV)", "fTX_cm" },
    { "tb_cm",    "Kinetic energy of B in CM (GeV)", "fTB_cm" },
    { "t_tot_cm", "Total CM kinetic energy", "fTtot_cm" },
    { "MandelS",  "Mandelstam s for secondary vertex (GeV^2)", "fMandelS" },
    { "MandelT",  "Mandelstam t for secondary vertex (GeV^2)", "fMandelT" },
    { "MandelU",  "Mandelstam u for secondary vertex (GeV^2)", "fMandelU" },
    { 0 }
  };


THaShower (analyzer/src/THaShower.C)

  RVarDef vars[] = {
    { "nhit",   "Number of hits",                     "fNhits" },
    { "a",      "Raw ADC amplitudes",                 "fA" },
    { "a_p",    "Ped-subtracted ADC amplitudes",      "fA_p" },
    { "a_c",    "Calibrated ADC amplitudes",          "fA_c" },
    { "asum_p", "Sum of ped-subtracted ADCs",         "fAsum_p" },
    { "asum_c", "Sum of calibrated ADCs",             "fAsum_c" },
    { "nclust", "Number of clusters",                 "fNclust" },
    { "e",      "Energy (MeV) of largest cluster",    "fE" },
    { "x",      "x-position (cm) of largest cluster", "fX" },
    { "y",      "y-position (cm) of largest cluster", "fY" },
    { "mult",   "Multiplicity of largest cluster",    "fMult" },
    { "nblk",   "Numbers of blocks in main cluster",  "fNblk" },
    { "eblk",   "Energies of blocks in main cluster", "fEblk" },
    { "trx",    "track x-position in det plane",      "fTRX" },
    { "try",    "track y-position in det plane",      "fTRY" },
    { 0 }
  };


THaSpectrometer (analyzer/src/THaSpectrometer.C)

  RVarDef vars[] = {
    { "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" },
    { 0 }
  };


THaTotalShower (analyzer/src/THaTotalShower.C)

  RVarDef vars[] = {
    { "e",  "Energy (MeV) of largest cluster",    "fE" },
    { "id", "ID of Psh&Sh coincidence (1==good)", "fID" },
    { 0 }
  };


THaTriggerTime (analyzer/src/THaTriggerTime.C)

  RVarDef vars[] = {
    { "evtime",  "Time-offset for event (trg based)", "fEvtTime" },
    { "evtype",  "Earliest trg-bit for the event",    "fEvtType" },
    { "trgtimes", "Times for each trg-type",          "fTrgTimes" },
    { 0 }
  };


THaVDCPlane (analyzer/src/THaVDCPlane.C)

  RVarDef vars[] = {
    { "nhit",   "Number of hits",             "GetNHits()" },
    { "wire",   "Active wire numbers",        "fHits.THaVDCHit.GetWireNum()" },
    { "rawtime","Raw TDC values of wires",    "fHits.THaVDCHit.fRawTime" },
    { "time",   "TDC values of active wires", "fHits.THaVDCHit.fTime" },
    { "dist",   "Drift distances",            "fHits.THaVDCHit.fDist" },
    { "ddist",  "Drft dist uncertainty",      "fHits.THaVDCHit.fdDist" },
    { "trdist", "Dist. from track",           "fHits.THaVDCHit.ftrDist" },
    { "nclust", "Number of clusters",         "GetNClusters()" },
    { "clsiz",  "Cluster sizes",              "fClusters.THaVDCCluster.fSize" },
    { "clpivot","Cluster pivot wire num",     "fClusters.THaVDCCluster.GetPivotWireNum()" },
    { "clpos",  "Cluster intercepts (m)",     "fClusters.THaVDCCluster.fInt" },
    { "slope",  "Cluster best slope",         "fClusters.THaVDCCluster.fSlope" },
    { "lslope", "Cluster local (fitted) slope","fClusters.THaVDCCluster.fLocalSlope" },
    { "t0",     "Timing offset (s)",          "fClusters.THaVDCCluster.fT0" },
    { "sigsl",  "Cluster slope error",        "fClusters.THaVDCCluster.fSigmaSlope" },
    { "sigpos", "Cluster position error (m)", "fClusters.THaVDCCluster.fSigmaInt" },
    { "sigt0",  "Timing offset error (s)",    "fClusters.THaVDCCluster.fSigmaT0" },
    { "clchi2", "Cluster chi2",               "fClusters.THaVDCCluster.fChi2" },
    { "clndof", "Cluster NDoF",               "fClusters.THaVDCCluster.fNDoF" },
    { "cltcor", "Cluster Time correction",    "fClusters.THaVDCCluster.fTimeCorrection" },
    { 0 }
  };


MWDC (d2n/bigbitelib/MWDC.cxx)

  RVarDef vars[] = {
    { "fail.nhits", "Too many hits in wire plane(s)",  "fFailNhits" },
    { "fail.npat",  "Too many treesearch patterns",    "fFailNpat" },
#ifdef TESTCODE
    { "ncombos",    "Number of road combinations",     "fNcombos" },
    { "nfits",      "Number of 3D track fits done",    "fN3dFits" },
    { "t_track",    "Time in 1st stage tracking (us)", "t_track" },
    { "t_3dmatch",  "Time in MatchRoads (us)",         "t_3dmatch" },
    { "t_3dfit",    "Time fitting/selecting 3D tracks (us)", "t_3dfit" },
    { "t_coarse",   "Total time in CoarseTrack (us)",  "t_coarse" },
#endif
    { 0 }
  };


Projection (d2n/bigbitelib/Projection.cxx)

  RVarDef vars[] = {
#ifdef TESTCODE
    { "n_hits", "Number of hits used for filling hitpattern", "n_hits" },
    { "n_bins", "Number of bins set in hitpattern", "n_bins" },
    { "n_binhits", "Number of references from bins to hits","n_binhits" },
    { "n_maxhits_bin", "Max number of hits per bin", "maxhits_bin" },
    { "n_test", "Number of pattern comparisons", "n_test"  },
    { "n_pat", "Number of patterns found",   "n_pat"    },
    { "n_roads", "Number of roads before filter",   "n_roads"    },
    { "n_dupl",  "Number of duplicate roads removed",   "n_dupl"    },
    { "n_badfits", "Number of roads found",   "n_badfits"    },
    { "t_treesearch", "Time in TreeSearch (us)", "t_treesearch" },
    { "t_roads", "Time in MakeRoads (us)", "t_roads" },
    { "t_fit", "Time for fitting Roads (us)", "t_fit" },
    { "t_track", "Total time in Track (us)", "t_track" },
    { "rd.nfits", "Number of acceptable fits in road",
                                         "fRoads.TreeSearch::Road.fNfits" },
#endif
    { "nroads","Number of roads (good or bad)",        "GetNroads()"      },
    { "ngood", "Number of good roads",                 "fNgoodRoads"      },
    { "rd.pos",   "Origin of best track (m)",
                                           "fRoads.TreeSearch::Road.fPos" },
    { "rd.slope", "Slope (dx/dz) of best track",
                                         "fRoads.TreeSearch::Road.fSlope" },
    { "rd.chi2",  "Chi2 of best fit", 
                                          "fRoads.TreeSearch::Road.fChi2" },
    { "rd.dof",   "Degrees of freedom of best fit",
                                           "fRoads.TreeSearch::Road.fDof" },
    { "rd.good",  "Road has valid data",
                                          "fRoads.TreeSearch::Road.fGood" },
    { 0 }
  };


THaBBShower (d2n/bigbitelib/THaBBShower.cxx)

    RVarDef vars[] = {
        { "nhit",   "Number of hits",                     "fNhits" },
        { "a",      "Raw ADC amplitudes",                 "fA" },
        { "a_p",    "Ped-subtracted ADC amplitudes",      "fA_p" },
        { "a_c",    "Calibrated ADC amplitudes",          "fA_c" },
        { "asum_p", "Sum of ped-subtracted ADCs",         "fAsum_p" },
        { "asum_c", "Sum of calibrated ADCs",             "fAsum_c" },
        { "nclust", "Number of clusters",                 "fNclust" },
        { "e",      "Energy (MeV) of largest cluster",    "fE" },
        { "e_c",    "Corrected Energy (MeV) of largest cluster",    "fE_c" },
        { "x",      "x-position (m) of largest cluster", "fX" },
        { "y",      "y-position (m) of largest cluster", "fY" },
        //{ "targ.x", "x-position (m) of largest cluster in target coords", "fXtarg" },
        //{ "targ.y", "y-position (m) of largest cluster in target coords", "fYtarg" },
        //{ "targ.z", "z-position (m) of largest cluster in target coords", "fZtarg" },
        { "mult",   "Multiplicity of largest cluster",    "fMult" },
        { "nblk",   "Numbers of blocks in main cluster",  "fNblk" },
        { "eblk",   "Energies of blocks in main cluster", "fEblk" },
        //     { "trx",    "track x-position in det plane",      "fTRX" },
        //     { "try",    "track y-position in det plane",      "fTRY" },
        { 0 }
    };


THaBBTotalShower (d2n/bigbitelib/THaBBTotalShower.cxx)

    RVarDef vars[] = {
        { "e",  "Energy (MeV) of largest cluster",    "fE" },
        { "x",  "Energy (MeV) of largest cluster",    "fX" },
        { "y",  "Energy (MeV) of largest cluster",    "fY" },
        { "id", "ID of Psh&Sh coincidence (1==good)", "fID" },
        { 0 }
    };


THaBigBite (d2n/bigbitelib/THaBigBite.cxx)

	RVarDef vars[] = {
		{ "TriggerTimingOffset",    "Real_TDC = TDC(common-stop) - BB.TriggerTimingOffset",             "GetTriggerTimingOffset()" },
  { 0 }
	};


THaHe3Target (d2n/bigbitelib/THaHe3Target.cxx)

	RVarDef vars[] = {
		{ "pol", "He3 Polarizaion in percent", "fPolarization"},
  { "theta", "Polarizaion Direction - Theta: Diviation of spin + vector from vertical up", "fTheta"},
  { "phi", "Polarizaion Direction - Phi: Angle of spin + vector projected to horizonal plane", "fPhi"},
		{ 0 }
	};


THaMWDC (d2n/bigbitelib/THaMWDC.cxx)

    RVarDef vars[] = {
        { "trackskipped", "Tracking skipped or truncated", "fTooBusy"       },
        { "cproctime",    "Coarse Processing Time",        "fCoarseProcTime"},
        { "fproctime",    "Fine Processing Time",          "fFineProcTime"  },
        { "estngrp",      "Estimated Number of Groups",    "fEstNGroups"    },
        { "estncall",     "Estimated Number of Calls",     "fEstNCalls"     },
        { "ngrp",         "Number of Groups",              "fNGroups"       },
        { "ncall",        "Number of recursive calls",     "fNCalls"        },
        { 0 }
    };


THaMWDCPlane (d2n/bigbitelib/THaMWDCPlane.cxx)

  RVarDef vars[] = {
    { "nhit",   "Number of hits",             "GetNHits()" },
    { "wire",   "Active wire numbers",        "fHits.THaMWDCHit.GetWireNum()" },
    { "rawtime","Raw TDC values of wires",    "fHits.THaMWDCHit.fRawTime" },
    { "time",   "TDC values of active wires", "fHits.THaMWDCHit.fTime" },
    { "dist",   "Drift distances",            "fHits.THaMWDCHit.fDist" },
    { "track",  "Track number used in reconstruction", "fHits.THaMWDCHit.GetTrackNumber()" },
    { "chi2",  "Chi2 Contribution", "fHits.THaMWDCHit.GetChi2Cont()" },
    { "cchi2",  "Coarse Chi2 Contribution", "fHits.THaMWDCHit.GetCoarseChi2Cont()" },
    { "refchokay", "All relevant ref channels are okay", "AreRefChOkay()" },
    { "rawtimeof", "Raw time of particular wire", "fRawT"},
    { "cortimeof", "Corrected time of particular wire", "fCorT"},
    { "reftimeof", "Time on particular ref. channel}", "fRefT"},
    { "NumHitsof", "Number of hits of particular wire", "fTcounter"},
    { "myref", "Reference time of a channel", "fHits.THaMWDCHit.fRefTime" },
    { "offset", "TDC offset used in a calculation", "fHits.THaMWDCHit.fOffset" },
    { "showercut", "Boolean result of cut by shower clusters", "fHits.THaMWDCHit.IsValidByShowerDouble()" },
    { "verbyshower", "Boolean result of cut by shower clusters", "fHits.THaMWDCHit.VerifiedByShowerDouble()" },
    { "wirepos", "Wire position in plane coords", "fHits.THaMWDCHit.GetPos()" },
    { 0 }
  };


THaOpticsE06010 (d2n/bigbitelib/THaOpticsE06010.cxx)

  RVarDef vars[] = {
    {"n","n","GetN()"},
    {"eloss","eloss","ftroptics.theoptics.Geteloss()"},
    {"sieve_x","sievex","ftroptics.theoptics.Getsievex()"},
    {"sieve_xp","sievexp","ftroptics.theoptics.Getsievexp()"},
    {"sieve_y","sievey","ftroptics.theoptics.Getsievey()"},
    {"sieve_yp","sieveyp","ftroptics.theoptics.Getsieveyp()"},
    {"bendx","bendx","ftroptics.theoptics.Getbendx()"},
    {"bendy","bendy","ftroptics.theoptics.Getbendy()"},
    {"charge","charge","ftroptics.theoptics.Getcharge()"},
    {"vzflag","vzflag","ftroptics.theoptics.Getvzflag()"},
    {"bend_theta","bend_theta","ftroptics.theoptics.Getbend_theta()"},
    {"theta","theta","ftroptics.theoptics.Gettheta_elastic()"},
    {"sieve_flag","sieve_flag","ftroptics.theoptics.Getsieve_flag()"},
    {"sieve_flag2","sieve_flag2","ftroptics.theoptics.Getsieve_flag2()"},
    { 0 }
  };


THaScintPlane (d2n/bigbitelib/THaScintPlane.cxx)

    RVarDef vars[] = {
        { "refchokay",         "All relevant ref channels are okay",        "AreRefChOkay()" },
        //      { "nbar",              "Number of bars",                            "GetNBars()"},  
        //      { "bar_num",           "bar number of bar",                         "fBars.THaScintBar.GetBarNum()"},
        //      { "bar_xpos",          "x position of bar",                         "fBars.THaScintBar.GetXPos()"},
        //      { "bar_ypos",          "y position of bar",                         "fBars.THaScintBar.GetYPos()"},
        //      { "bar_zpos",          "z position of bar",                         "fBars.THaScintBar.GetZPos()"},
        //      { "bar_xwidth",        "width_x of bar",                            "fBars.THaScintBar.GetXWidth()"},
        //      { "bar_ywidth",        "width_y of bar",                            "fBars.THaScintBar.GetYWidth()"},
        //      { "bar_zwidth",        "width_z of bar",                            "fBars.THaScintBar.GetZWidth()"},
        //      { "bar_c",             "speed of light in bar",                     "fBars.THaScintBar.GetC()"},
        //      { "bar_att",           "Attenuation length of bar",                 "fBars.THaScintBar.GetAtt()"},
        //      { "bar_type",          "Type of bar",                               "fBars.THaScintBar.GetBarType()"},
        //      { "bar_nd",            "Type of bar",                               "fBars.THaScintBar.GetBarNum_nd()"},
        // raw-data information
        { "nrefhit",           "Number of ref hits",                        "GetNRefHits()"},
        { "ref_bar",           "bars in fRefHits",                          "fRefHits.THaTdcHit.GetBarNum()"},
        { "ref_tdc",           "raw time in fRefHits",                      "fRefHits.THaTdcHit.GetRawTime()"},
        { "ref_time",          "time in fRefHits",                          "fRefHits.THaTdcHit.GetTime()"},
        { "nlthit",            "Number of lt hits",                         "GetNLtHits()"},
        { "lthit_bar",          "bars in fLtHits",                           "fLtHits.THaTdcHit.GetBarNum()"},
        { "lthit_tdc",          "raw time in fLtHits",                       "fLtHits.THaTdcHit.GetRawTime()"},
        { "lthit_time",         "time in fLtHits",                           "fLtHits.THaTdcHit.GetTime()"},
        { "lthit_side",         "side in fLtHits",                           "fLtHits.THaTdcHit.GetSide()"},
        { "nrthit",            "Number of rt hits",                         "GetNRtHits()"},
        { "rthit_bar",          "bars in fRtHits",                           "fRtHits.THaTdcHit.GetBarNum()"},
        { "rthit_tdc",          "raw time in fRtHits",                       "fRtHits.THaTdcHit.GetRawTime()"},
        { "rthit_time",         "time in fRtHits",                           "fRtHits.THaTdcHit.GetTime()"},
        { "rthit_side",         "side in fRtHits",                           "fRtHits.THaTdcHit.GetSide()"},
        { "nlahit",            "Number of la hits",                         "GetNLaHits()"},
        { "lahit_bar",         "bars in fLaHits",                           "fLaHits.THaAdcHit.GetBarNum()"},
        { "lahit_adc",         "raw amplitude in fLaHits",                  "fLaHits.THaAdcHit.GetRawAmpl()"},
        { "lahit_ap",          "pedistal corrected ampl in fLaHits",        "fLaHits.THaAdcHit.GetAmplPedCor()"},
        { "lahit_ac",          "Amplitude in fLaHits",                      "fLaHits.THaAdcHit.GetAmpl()"}, 
        { "lahit_side",        "side of bar in fLaHits",                    "fLaHits.THaAdcHit.GetSide()"}, 
        { "nrahit",            "Number of Rahits",                          "GetNRaHits()"},
        { "rahit_bar",         "bars in fRaHits",                           "fRaHits.THaAdcHit.GetBarNum()"},
        { "rahit_adc",         "raw amplitude in fRaHits",                  "fRaHits.THaAdcHit.GetRawAmpl()"},
        { "rahit_ap",          "pedistal corrected ampl in fRaHits",        "fRaHits.THaAdcHit.GetAmplPedCor()"},
        { "rahit_ac",          "Amplitude in fRaHits",                      "fRaHits.THaAdcHit.GetAmpl()"}, 
        { "rahit_side",        "side of bar in fRaHits",                    "fRaHits.THaAdcHit.GetSide()"},
        // complete reconstructed hits
        { "nhit",              "Number of hits",                            "GetNHits()"},
        { "hit_bar",           "bars in fHits",                             "fHits.THaScintHit.GetBarNum()"},
        { "hit_xpos",          "X position in fHits",                       "fHits.THaScintHit.GetHitXPos()"},
        { "hit_ypos",          "Y position in fHits",                       "fHits.THaScintHit.GetHitYPos()"},
        { "hit_tof",           "TOF in fHits = .5*(Lt + Rt)",               "fHits.THaScintHit.GetHitTOF()"},
        { "hit_Edep",          "Edep in fHits",                             "fHits.THaScintHit.GetHitEdep()"},
        { "hit_tdiff",         "Time diff in fHits=.5*(Rt - Lt)",           "fHits.THaScintHit.GetHitTdiff()"},    
#if BUILD_PARTIAL_HIT 
        // partial hits -- probably will NOT use
        { "nparthit",          "Number of partial hits",                    "GetNPartHits()"},   
        { "phit_bar",          "bars in fPartHits",                         "fPartHits.THaPartialHit.GetBarNum()"},
        { "phit_case",         "Case number in fPartHits",                  "fPartHits.THaPartialHit.GetCaseNum()"},
        { "phit_lt",           "left tdc in fPartHits",                     "fPartHits.THaPartialHit.GetLt()"},
        { "phit_rt",           "right tdc in fPartHits",                    "fPartHits.THaPartialHit.GetRt()"},
        { "phit_la",           "left adc in fPartHits",                     "fPartHits.THaPartialHit.GetLa()"},
        { "phit_ra",           "right adc in fPartHits",                    "fPartHits.THaPartialHit.GetRa()"},
        { "phit_ltdc",         "left_raw tdc in fPartHits",                 "fPartHits.THaPartialHit.GetLt_raw()"},
        { "phit_rtdc",         "right_raw tdc in fPartHits",                "fPartHits.THaPartialHit.GetRt_raw()"},
        { "phit_ladc",         "left_raw adc in fPartHits",                 "fPartHits.THaPartialHit.GetLa_raw()"},
        { "phit_radc",         "right_raw adc in fPartHits",                "fPartHits.THaPartialHit.GetRa_raw()"},
#endif
        // Reconstructed Multi-bar hits
        //{ "ncmbhit",           "Number of combined-bar hits",               "GetNCombinedHits()"},
        //{ "cmb_nbars",         "number of bars in combined hit",            "fCombHits.THaMultiHit.GetNBarHits()"},
        //{ "cmb_bar",           "primary bar of combined hit",               "fCombHits.THaMultiHit.GetBarNum()"},
        //{ "cmb_xpos",          "weighted X-position",                       "fCombHits.THaMultiHit.GetXpos()"},
        //{ "cmb_ypos",          "weighted Y-position",                       "fCombHits.THaMultiHit.GetYpos()"},
        //{ "cmb_dx2",           "weighted dx**2 of hit",                     "fCombHits.THaMultiHit.GetdX2()"},
        //{ "cmb_dy2",           "weighted dy**2 of hit",                     "fCombHits.THaMultiHit.GetdY2()"},
        //{ "cmb_tof",           "earliest TOF of hit--best bar",             "fCombHits.THaMultiHit.GetTof()"},
        //{ "cmb_Edep",          "total energy deposited",                    "fCombHits.THaMultiHit.GetTotEdep()"},

#if SAVEFLAT
        // copies of raw information but in flat arrays
        { "LE",                "Left calibrated adc",                       "fLE"},
        { "RE",                "Right calibrated adc",                      "fRE"},
        { "LA",                "Left raw adc",                              "fLrawA"},
        { "RA",                "Right raw adc",                             "fRrawA"},
        { "LApedc",            "Left pedestal corrected adc",               "fLpedcA"},
        { "RApedc",            "Right pedestal corrected adc",              "fRpedcA"},

        { "LT",                "Left tdc value",                            "fLT"},
        { "RT",                "Right tdc value",                           "fRT"},
        { "LTcounter",         "Number of Hits on left tdc",                "fLTcounter"},
        { "RTcounter",         "Number of Hits on right tdc",               "fRTcounter"},
        { "hitcounter",        "Number of Hits",                            "hitcounter"},
        { "Energy",            "Energy in bar",                             "Energy"},
        { "Timediff",          "Time difference in bar",                    "TDIFF"},
        { "tof",               "Time of flight",                            "TOF"},
        { "Total_Time",        "Total Time",                                "T_tot"},
        { "Yt_pos",            "Yt_pos",                                    "Yt_pos"},
        { "Ya_pos",            "Ya_pos",                                    "Ya_pos"},
        { "Y_pred",            "Y position prediction",                     "Y_pred"},
        { "Y_dev",             "Deviation in Y actual and prediction",      "Y_dev"},
        { "angle",             "angle (degrees) of bar hit from the origin","fAngle"},

#endif

        { 0 }
    };


THaScintPlaneDet (d2n/bigbitelib/THaScintPlaneDet.cxx)

	RVarDef vars[] = {
		{ "refchokay",         "All relevant ref channels are okay",        "AreRefChOkay()" },
		//      { "nbar",              "Number of bars",                            "GetNBars()"},  
		//      { "bar_num",           "bar number of bar",                         "fBars.THaScintBar.GetBarNum()"},
		//      { "bar_xpos",          "x position of bar",                         "fBars.THaScintBar.GetXPos()"},
		//      { "bar_ypos",          "y position of bar",                         "fBars.THaScintBar.GetYPos()"},
		//      { "bar_zpos",          "z position of bar",                         "fBars.THaScintBar.GetZPos()"},
		//      { "bar_xwidth",        "width_x of bar",                            "fBars.THaScintBar.GetXWidth()"},
		//      { "bar_ywidth",        "width_y of bar",                            "fBars.THaScintBar.GetYWidth()"},
		//      { "bar_zwidth",        "width_z of bar",                            "fBars.THaScintBar.GetZWidth()"},
		//      { "bar_c",             "speed of light in bar",                     "fBars.THaScintBar.GetC()"},
		//      { "bar_att",           "Attenuation length of bar",                 "fBars.THaScintBar.GetAtt()"},
		//      { "bar_type",          "Type of bar",                               "fBars.THaScintBar.GetBarType()"},
		//      { "bar_nd",            "Type of bar",                               "fBars.THaScintBar.GetBarNum_nd()"},
		// raw-data information
		{ "nrefhit",           "Number of ref hits",                        "GetNRefHits()"},
		{ "ref_bar",           "bars in fRefHits",                          "fRefHits.THaTdcHit.GetBarNum()"},
		{ "ref_tdc",           "raw time in fRefHits",                      "fRefHits.THaTdcHit.GetRawTime()"},
		{ "ref_time",          "time in fRefHits",                          "fRefHits.THaTdcHit.GetTime()"},
		{ "nlthit",            "Number of lt hits",                         "GetNLtHits()"},
		{ "lthit_bar",          "bars in fLtHits",                           "fLtHits.THaTdcHit.GetBarNum()"},
		{ "lthit_tdc",          "raw time in fLtHits",                       "fLtHits.THaTdcHit.GetRawTime()"},
		{ "lthit_time",         "time in fLtHits",                           "fLtHits.THaTdcHit.GetTime()"},
		{ "lthit_side",         "side in fLtHits",                           "fLtHits.THaTdcHit.GetSide()"},
		{ "nrthit",            "Number of rt hits",                         "GetNRtHits()"},
		{ "rthit_bar",          "bars in fRtHits",                           "fRtHits.THaTdcHit.GetBarNum()"},
		{ "rthit_tdc",          "raw time in fRtHits",                       "fRtHits.THaTdcHit.GetRawTime()"},
		{ "rthit_time",         "time in fRtHits",                           "fRtHits.THaTdcHit.GetTime()"},
		{ "rthit_side",         "side in fRtHits",                           "fRtHits.THaTdcHit.GetSide()"},
		{ "nlahit",            "Number of la hits",                         "GetNLaHits()"},
		{ "lahit_bar",         "bars in fLaHits",                           "fLaHits.THaAdcHit.GetBarNum()"},
		{ "lahit_adc",         "raw amplitude in fLaHits",                  "fLaHits.THaAdcHit.GetRawAmpl()"},
		{ "lahit_ap",          "pedistal corrected ampl in fLaHits",        "fLaHits.THaAdcHit.GetAmplPedCor()"},
		{ "lahit_ac",          "Amplitude in fLaHits",                      "fLaHits.THaAdcHit.GetAmpl()"}, 
		{ "lahit_side",        "side of bar in fLaHits",                    "fLaHits.THaAdcHit.GetSide()"}, 
		{ "nrahit",            "Number of Rahits",                          "GetNRaHits()"},
		{ "rahit_bar",         "bars in fRaHits",                           "fRaHits.THaAdcHit.GetBarNum()"},
		{ "rahit_adc",         "raw amplitude in fRaHits",                  "fRaHits.THaAdcHit.GetRawAmpl()"},
		{ "rahit_ap",          "pedistal corrected ampl in fRaHits",        "fRaHits.THaAdcHit.GetAmplPedCor()"},
		{ "rahit_ac",          "Amplitude in fRaHits",                      "fRaHits.THaAdcHit.GetAmpl()"}, 
		{ "rahit_side",        "side of bar in fRaHits",                    "fRaHits.THaAdcHit.GetSide()"},
		// complete reconstructed hits
		{ "nhit",              "Number of hits",                            "GetNHits()"},
		{ "hit_bar",           "bars in fHits",                             "fHits.THaScintHit.GetBarNum()"},
		{ "hit_xpos",          "X position in fHits",                       "fHits.THaScintHit.GetHitXPos()"},
		{ "hit_ypos",          "Y position in fHits",                       "fHits.THaScintHit.GetHitYPos()"},
		{ "hit_tof",           "TOF in fHits = .5*(Lt + Rt)",               "fHits.THaScintHit.GetHitTOF()"},
		{ "hit_Edep",          "Edep in fHits",                             "fHits.THaScintHit.GetHitEdep()"},
		{ "hit_tdiff",         "Time diff in fHits=.5*(Rt - Lt)",           "fHits.THaScintHit.GetHitTdiff()"},    
#if BUILD_PARTIAL_HIT 
		// partial hits -- probably will NOT use
		{ "nparthit",          "Number of partial hits",                    "GetNPartHits()"},   
		{ "phit_bar",          "bars in fPartHits",                         "fPartHits.THaPartialHit.GetBarNum()"},
		{ "phit_case",         "Case number in fPartHits",                  "fPartHits.THaPartialHit.GetCaseNum()"},
		{ "phit_lt",           "left tdc in fPartHits",                     "fPartHits.THaPartialHit.GetLt()"},
		{ "phit_rt",           "right tdc in fPartHits",                    "fPartHits.THaPartialHit.GetRt()"},
		{ "phit_la",           "left adc in fPartHits",                     "fPartHits.THaPartialHit.GetLa()"},
		{ "phit_ra",           "right adc in fPartHits",                    "fPartHits.THaPartialHit.GetRa()"},
		{ "phit_ltdc",         "left_raw tdc in fPartHits",                 "fPartHits.THaPartialHit.GetLt_raw()"},
		{ "phit_rtdc",         "right_raw tdc in fPartHits",                "fPartHits.THaPartialHit.GetRt_raw()"},
		{ "phit_ladc",         "left_raw adc in fPartHits",                 "fPartHits.THaPartialHit.GetLa_raw()"},
		{ "phit_radc",         "right_raw adc in fPartHits",                "fPartHits.THaPartialHit.GetRa_raw()"},
#endif
		// Reconstructed Multi-bar hits
		//{ "ncmbhit",           "Number of combined-bar hits",               "GetNCombinedHits()"},
		//{ "cmb_nbars",         "number of bars in combined hit",            "fCombHits.THaMultiHit.GetNBarHits()"},
		//{ "cmb_bar",           "primary bar of combined hit",               "fCombHits.THaMultiHit.GetBarNum()"},
		//{ "cmb_xpos",          "weighted X-position",                       "fCombHits.THaMultiHit.GetXpos()"},
		//{ "cmb_ypos",          "weighted Y-position",                       "fCombHits.THaMultiHit.GetYpos()"},
		//{ "cmb_dx2",           "weighted dx**2 of hit",                     "fCombHits.THaMultiHit.GetdX2()"},
		//{ "cmb_dy2",           "weighted dy**2 of hit",                     "fCombHits.THaMultiHit.GetdY2()"},
		//{ "cmb_tof",           "earliest TOF of hit--best bar",             "fCombHits.THaMultiHit.GetTof()"},
		//{ "cmb_Edep",          "total energy deposited",                    "fCombHits.THaMultiHit.GetTotEdep()"},

#if SAVEFLAT

		//bar with largetst ADC hit
		{ "MaxADCHitBar",         "Hit Bar number with max sqrt(RApedc*LApedc)",       "fMaxADCHitBar"},
		{ "MaxEnergyHitBar",         "Hit Bar number with max sqrt(RE*LE)",       "fMaxEnergyHitBar"},
		{ "MaxADCHit",         "max sqrt(RApedc*LApedc)",       "fMaxADCHit"},
		{ "MaxEnergyHit",         "max sqrt(RE*LE)",       "fMaxEnergyHit"},
		// copies of raw information but in flat arrays
		{ "LE",                "Left calibrated adc",                       "fLE"},
		{ "RE",                "Right calibrated adc",                      "fRE"},
		{ "LA",                "Left raw adc",                              "fLrawA"},
		{ "RA",                "Right raw adc",                             "fRrawA"},
		{ "LApedc",            "Left pedestal corrected adc",               "fLpedcA"},
		{ "RApedc",            "Right pedestal corrected adc",              "fRpedcA"},

		{ "LT",                "Left tdc value",                            "fLT"},
		{ "RT",                "Right tdc value",                           "fRT"},
		{ "LTcounter",         "Number of Hits on left tdc",                "fLTcounter"},
		{ "RTcounter",         "Number of Hits on right tdc",               "fRTcounter"},
		{ "hitcounter",        "Number of Hits",                            "hitcounter"},
		{ "Energy",            "Energy in bar",                             "Energy"},
		{ "Timediff",          "Time difference in bar",                    "TDIFF"},
		{ "tof",               "Time of flight",                            "TOF"},
		{ "Total_Time",        "Total Time",                                "T_tot"},
		{ "Yt_pos",            "Yt_pos",                                    "Yt_pos"},
		{ "Ya_pos",            "Ya_pos",                                    "Ya_pos"},
		{ "Y_pred",            "Y position prediction",                     "Y_pred"},
		{ "Y_dev",             "Deviation in Y actual and prediction",      "Y_dev"},
		{ "angle",             "angle (degrees) of bar hit from the origin","fAngle"},

#endif
		//track matching
		{"MatchRatioTrack","matched Hits / num of tracks",    "GetMatchRatioTrack()"},

		{ "trx",    "x-position of track in trigger plane",  "fTrackProj.THaTrackProj.fX" },
		{ "try",    "y-position of track in trigger plane",  "fTrackProj.THaTrackProj.fY" },
		{ "trpath", "TRCS pathlen of track to trigger plane","fTrackProj.THaTrackProj.fPathl" },
		{ "trdx",   "track deviation in x-position (m)", "fTrackProj.THaTrackProj.fdX" },
		{ "trHitIndex",  "the index of THaTriggerPlaneHit associated with track, -1 means no match",  "fTrackProj.THaTrackProj.fChannel" },



		{ 0 }
	};


THaTimingPlane (d2n/bigbitelib/THaTimingPlane.cxx)

	RVarDef vars[] = {

		//end
		{0}
	};


THaTriggerPlane (d2n/bigbitelib/THaTriggerPlane.cxx)

    RVarDef vars[] = {
        // complete reconstructed hits
        { "nhit",  "Number of reconstructed hits on trigger plane",  "GetNHits()"},
        { "hit_xpos",           "X position of hit on dEplane",      "fHits.THaTriggerPlaneHit.GetHitXPos()"},
        { "hit_ypos",           "Y position of hit on dEplane",      "fHits.THaTriggerPlaneHit.GetHitYPos()"},
        { "hit_tof",            "TOF of hit on dEplane",             "fHits.THaTriggerPlaneHit.GetHitTOF()"},
        { "hit_Edep",           "Energy dep in Eplane",              "fHits.THaTriggerPlaneHit.GetHitEdep()"},
        { "hit_dEdep",          "Energy dep in dEplane",             "fHits.THaTriggerPlaneHit.GetHitdEdep()"},
        { "hit_Theta",          "polar angle of track",              "fHits.THaTriggerPlaneHit.Theta()"},
        { "hit_Phi",            "azimuth angle of track",            "fHits.THaTriggerPlaneHit.Phi()"},

#       if EXPORT_PARTIAL_HIT
        //partially reconstructed hits
        { "nparthit","Number of partially reconstructed hits on trigger plane", "GetNPartialHits()"},
        { "parthit_whichplane",     "1=dE,2=E,3=Both;other=Error",              "fPartialHits.THaTriggerPlaneHit.Status()"},
        { "parthit_xpos",           "X position of hit",                        "fPartialHits.THaTriggerPlaneHit.GetHitXPos()"},
        { "parthit_ypos",           "Y position of hit",                        "fPartialHits.THaTriggerPlaneHit.GetHitYPos()"},
        { "parthit_tof",            "TOF of hit on dEplane",                    "fPartialHits.THaTriggerPlaneHit.GetHitTOF()"},
        { "parthit_Edep",           "Energy dep in hit",                        "fPartialHits.THaTriggerPlaneHit.GetHitTotalEdep()"},
#       endif//#if PROCESS_PARTIAL_HIT
        //
        { "trx",    "x-position of track in trigger plane",  "fTrackProj.THaTrackProj.fX" },
        { "try",    "y-position of track in trigger plane",  "fTrackProj.THaTrackProj.fY" },
        { "trpath", "TRCS pathlen of track to trigger plane","fTrackProj.THaTrackProj.fPathl" },
        { "trdx",   "track deviation in x-position (m)", "fTrackProj.THaTrackProj.fdX" },
        { "trHitIndex",  "the index of THaTriggerPlaneHit associated with track, -1 means no match",  "fTrackProj.THaTrackProj.fChannel" },

        // match ratios statistic
        //# of matched THaTriggerPlaneHit / # of total THaScintHit on THaScintPlane
        {"MatchRatioE", "matched Hits / total Hits on E plane",     "GetMatchRatioE()"},
        {"MatchRatiodE","matched Hits / total Hits on dE plane",    "GetMatchRatiodE()"},
        {"MatchRatioTrack","matched Hits / num of tracks",    "GetMatchRatioTrack()"},


        //end
        {0}
    };


WirePlane (d2n/bigbitelib/WirePlane.cxx)

  RVarDef vars[] = {
    { "nhits",       "Num accepted hits",  "GetNhits()" },
    { "hit.wire",    "Hit wire number",    "fHits.TreeSearch::Hit.fWireNum" },
    { "hit.tdc",     "Hit TDC value",      "fHits.TreeSearch::Hit.fRawTDC" },
    { "hit.time",    "Hit time (s)",       "fHits.TreeSearch::Hit.fTime" },
    { "hit.dist",    "Drift distance (m)",
                                    "fHits.TreeSearch::Hit.GetDriftDist()" },
    { "ncoords",     "Num fit coords",     "GetNcoords()" },
    { "coord.rank",  "Fit rank of coord",
                                "fFitCoords.TreeSearch::FitCoord.fFitRank" },
    { "coord.wire", "Wire number of fitted hit",
                            "fFitCoords.TreeSearch::FitCoord.GetWireNum()" },
    { "coord.time", "Drift time of hit (s)",
                          "fFitCoords.TreeSearch::FitCoord.GetDriftTime()" },
    { "coord.dist", "Drift distance of hit (m)",
                          "fFitCoords.TreeSearch::FitCoord.GetDriftDist()" },
    { "coord.pos",   "Position used in fit (wirepos +/- dist) (m)",
                                    "fFitCoords.TreeSearch::FitCoord.fPos" },
    { "coord.trkpos","Track pos from projection fit (m)",
                               "fFitCoords.TreeSearch::FitCoord.fTrackPos" },
    { "coord.trkslope","Track slope from projection fit",
                             "fFitCoords.TreeSearch::FitCoord.fTrackSlope" },
    { "coord.resid", "Residual of trkpos (m)",
                           "fFitCoords.TreeSearch::FitCoord.GetResidual()" },
    { "coord.trkdist", "Distance of trkpos to wire (m)",
                          "fFitCoords.TreeSearch::FitCoord.GetTrackDist()" },
    { "coord.3Dpos",  "Crossing position of fitted 3D track (m)",
                               "fFitCoords.TreeSearch::FitCoord.f3DTrkPos" },
    { "coord.3Ddist", "Distance of 3D trkpos to wire (m)",
                          "fFitCoords.TreeSearch::FitCoord.Get3DTrkDist()" },
    { "coord.3Dresid","Residual of 3D trkpos (m)",
                         "fFitCoords.TreeSearch::FitCoord.Get3DTrkResid()" },
    { "coord.3Dslope","Slope of fitted 3D track wrt projection",
                             "fFitCoords.TreeSearch::FitCoord.f3DTrkSlope" },
#ifdef TESTCODE
    { "nmiss",       "Decoder misses",     "fNmiss" },
    { "nrej",        "Time cut nopass",    "fNrej" },
    { "sorted",      "Wires were ordered", "fWasSorted" },
    { "nwhit",       "Num wires w/hits>0", "fNhitwires" },
    { "nmulti",      "Num wires w/hits>1", "fNmultihit" },
    { "maxmul",      "Max num hits/wire",  "fNmaxmul" },
    { "ncl",         "Num clusters",       "fNcl" },
    { "ndbl",        "Num double hits ",   "fNdbl" },
    { "maxclsiz",    "Max cluster size",   "fClsiz" },
    { "hit.iscl",    "Hit has neighbor",   "fHits.TreeSearch::Hit.fCl" },
    { "hit.ismulti", "Wire has multihits", "fHits.TreeSearch::Hit.fMulti" },
    { "hit.tdiff",   "multi hits tdiff",   "fHits.TreeSearch::Hit.fTdiff" },
#endif
    { 0 }
  };