#include <Trktree.h>

Public Member Functions
const float &	bsp_sigmax ()

const float &	bsp_sigmay ()

const float &	bsp_sigmaz ()

const float &	bsp_x ()

const float &	bsp_y ()

const float &	bsp_z ()

const unsigned long long &	event ()

void	GetEntry (unsigned int idx)

void	Init (TTree *tree)

const std::vector< unsigned short > &	inv_blade ()

const std::vector< unsigned int > &	inv_detId ()

const std::vector< short > &	inv_isBarrel ()

const std::vector< unsigned short > &	inv_isLower ()

const std::vector< unsigned short > &	inv_isStack ()

const std::vector< unsigned short > &	inv_isUpper ()

const std::vector< unsigned short > &	inv_ladder ()

const std::vector< unsigned short > &	inv_layer ()

const std::vector< unsigned short > &	inv_module ()

const std::vector< unsigned short > &	inv_order ()

const std::vector< unsigned short > &	inv_panel ()

const std::vector< unsigned short > &	inv_ring ()

const std::vector< unsigned short > &	inv_rod ()

const std::vector< unsigned short > &	inv_side ()

const std::vector< unsigned short > &	inv_subdet ()

const std::vector< unsigned short > &	inv_type ()

void	LoadAllBranches ()

const unsigned int &	lumi ()

const std::vector< float > &	ph2_bbxi ()

const std::vector< unsigned int > &	ph2_detId ()

const std::vector< short > &	ph2_isBarrel ()

const std::vector< unsigned short > &	ph2_isLower ()

const std::vector< unsigned short > &	ph2_isStack ()

const std::vector< unsigned short > &	ph2_isUpper ()

const std::vector< unsigned short > &	ph2_layer ()

const std::vector< unsigned short > &	ph2_module ()

const std::vector< unsigned short > &	ph2_order ()

const std::vector< float > &	ph2_radL ()

const std::vector< unsigned short > &	ph2_ring ()

const std::vector< unsigned short > &	ph2_rod ()

const std::vector< std::vector< int > > &	ph2_seeIdx ()

const std::vector< unsigned short > &	ph2_side ()

const std::vector< std::vector< int > > &	ph2_simHitIdx ()

const std::vector< unsigned short > &	ph2_simType ()

const std::vector< unsigned short > &	ph2_subdet ()

const std::vector< std::vector< int > > &	ph2_trkIdx ()

const std::vector< float > &	ph2_x ()

const std::vector< float > &	ph2_xx ()

const std::vector< float > &	ph2_xy ()

const std::vector< std::vector< float > > &	ph2_xySignificance ()

const std::vector< float > &	ph2_y ()

const std::vector< float > &	ph2_yy ()

const std::vector< float > &	ph2_yz ()

const std::vector< float > &	ph2_z ()

const std::vector< float > &	ph2_zx ()

const std::vector< float > &	ph2_zz ()

const std::vector< float > &	pix_bbxi ()

const std::vector< unsigned short > &	pix_blade ()

const std::vector< std::vector< float > > &	pix_chargeFraction ()

const std::vector< unsigned int > &	pix_detId ()

const std::vector< short > &	pix_isBarrel ()

const std::vector< unsigned short > &	pix_ladder ()

const std::vector< unsigned short > &	pix_layer ()

const std::vector< unsigned short > &	pix_module ()

const std::vector< unsigned short > &	pix_panel ()

const std::vector< float > &	pix_radL ()

const std::vector< std::vector< int > > &	pix_seeIdx ()

const std::vector< unsigned short > &	pix_side ()

const std::vector< std::vector< int > > &	pix_simHitIdx ()

const std::vector< unsigned short > &	pix_simType ()

const std::vector< unsigned short > &	pix_subdet ()

const std::vector< std::vector< int > > &	pix_trkIdx ()

const std::vector< float > &	pix_x ()

const std::vector< float > &	pix_xx ()

const std::vector< float > &	pix_xy ()

const std::vector< std::vector< float > > &	pix_xySignificance ()

const std::vector< float > &	pix_y ()

const std::vector< float > &	pix_yy ()

const std::vector< float > &	pix_yz ()

const std::vector< float > &	pix_z ()

const std::vector< float > &	pix_zx ()

const std::vector< float > &	pix_zz ()

const unsigned int &	run ()

const std::vector< unsigned int > &	see_algo ()

const std::vector< int > &	see_bestFromFirstHitSimTrkIdx ()

const std::vector< float > &	see_bestFromFirstHitSimTrkShareFrac ()

const std::vector< int > &	see_bestSimTrkIdx ()

const std::vector< float > &	see_bestSimTrkShareFrac ()

const std::vector< float > &	see_chi2 ()

const std::vector< float > &	see_dxy ()

const std::vector< float > &	see_dxyErr ()

const std::vector< float > &	see_dz ()

const std::vector< float > &	see_dzErr ()

const std::vector< float > &	see_eta ()

const std::vector< float > &	see_etaErr ()

const std::vector< short > &	see_fitok ()

const std::vector< std::vector< int > > &	see_hitIdx ()

const std::vector< std::vector< int > > &	see_hitType ()

const std::vector< unsigned short > &	see_nCands ()

const std::vector< unsigned int > &	see_nCluster ()

const std::vector< unsigned int > &	see_nGlued ()

const std::vector< unsigned int > &	see_nPhase2OT ()

const std::vector< unsigned int > &	see_nPixel ()

const std::vector< unsigned int > &	see_nStrip ()

const std::vector< unsigned int > &	see_nValid ()

const std::vector< unsigned int > &	see_offset ()

const std::vector< float > &	see_phi ()

const std::vector< float > &	see_phiErr ()

const std::vector< float > &	see_pt ()

const std::vector< float > &	see_ptErr ()

const std::vector< float > &	see_px ()

const std::vector< float > &	see_py ()

const std::vector< float > &	see_pz ()

const std::vector< int > &	see_q ()

const std::vector< std::vector< int > > &	see_simTrkIdx ()

const std::vector< std::vector< float > > &	see_simTrkShareFrac ()

const std::vector< float > &	see_stateCcov00 ()

const std::vector< float > &	see_stateCcov01 ()

const std::vector< float > &	see_stateCcov02 ()

const std::vector< float > &	see_stateCcov03 ()

const std::vector< float > &	see_stateCcov04 ()

const std::vector< float > &	see_stateCcov05 ()

const std::vector< float > &	see_stateCcov11 ()

const std::vector< float > &	see_stateCcov12 ()

const std::vector< float > &	see_stateCcov13 ()

const std::vector< float > &	see_stateCcov14 ()

const std::vector< float > &	see_stateCcov15 ()

const std::vector< float > &	see_stateCcov22 ()

const std::vector< float > &	see_stateCcov23 ()

const std::vector< float > &	see_stateCcov24 ()

const std::vector< float > &	see_stateCcov25 ()

const std::vector< float > &	see_stateCcov33 ()

const std::vector< float > &	see_stateCcov34 ()

const std::vector< float > &	see_stateCcov35 ()

const std::vector< float > &	see_stateCcov44 ()

const std::vector< float > &	see_stateCcov45 ()

const std::vector< float > &	see_stateCcov55 ()

const std::vector< float > &	see_statePt ()

const std::vector< float > &	see_stateTrajGlbPx ()

const std::vector< float > &	see_stateTrajGlbPy ()

const std::vector< float > &	see_stateTrajGlbPz ()

const std::vector< float > &	see_stateTrajGlbX ()

const std::vector< float > &	see_stateTrajGlbY ()

const std::vector< float > &	see_stateTrajGlbZ ()

const std::vector< float > &	see_stateTrajPx ()

const std::vector< float > &	see_stateTrajPy ()

const std::vector< float > &	see_stateTrajPz ()

const std::vector< float > &	see_stateTrajX ()

const std::vector< float > &	see_stateTrajY ()

const std::vector< unsigned short > &	see_stopReason ()

const std::vector< int > &	see_trkIdx ()

const std::vector< int > &	sim_bunchCrossing ()

const std::vector< std::vector< int > > &	sim_decayVtxIdx ()

const std::vector< float > &	sim_eta ()

const std::vector< int > &	sim_event ()

const std::vector< std::vector< int > > &	sim_genPdgIds ()

const std::vector< float > &	sim_hits ()

const std::vector< int > &	sim_isFromBHadron ()

const std::vector< float > &	sim_len ()

const std::vector< float > &	sim_lengap ()

const std::vector< unsigned int > &	sim_n3DLay ()

const std::vector< unsigned int > &	sim_nLay ()

const std::vector< unsigned int > &	sim_nPixel ()

const std::vector< unsigned int > &	sim_nPixelLay ()

const std::vector< unsigned int > &	sim_nRecoClusters ()

const std::vector< unsigned int > &	sim_nStrip ()

const std::vector< unsigned int > &	sim_nTrackerHits ()

const std::vector< unsigned int > &	sim_nValid ()

const std::vector< int > &	sim_parentVtxIdx ()

const std::vector< float > &	sim_pca_cotTheta ()

const std::vector< float > &	sim_pca_dxy ()

const std::vector< float > &	sim_pca_dz ()

const std::vector< float > &	sim_pca_eta ()

const std::vector< float > &	sim_pca_lambda ()

const std::vector< float > &	sim_pca_phi ()

const std::vector< float > &	sim_pca_pt ()

const std::vector< int > &	sim_pdgId ()

const std::vector< float > &	sim_phi ()

const std::vector< float > &	sim_pt ()

const std::vector< float > &	sim_px ()

const std::vector< float > &	sim_py ()

const std::vector< float > &	sim_pz ()

const std::vector< int > &	sim_q ()

const std::vector< std::vector< int > > &	sim_seedIdx ()

const std::vector< std::vector< int > > &	sim_simHitIdx ()

const std::vector< std::vector< int > > &	sim_trkIdx ()

const std::vector< std::vector< float > > &	sim_trkShareFrac ()

const std::vector< unsigned short > &	simhit_blade ()

const std::vector< unsigned int > &	simhit_detId ()

const std::vector< float > &	simhit_eloss ()

const std::vector< std::vector< int > > &	simhit_hitIdx ()

const std::vector< std::vector< int > > &	simhit_hitType ()

const std::vector< unsigned short > &	simhit_isLower ()

const std::vector< unsigned short > &	simhit_isStack ()

const std::vector< unsigned short > &	simhit_isUpper ()

const std::vector< unsigned short > &	simhit_ladder ()

const std::vector< unsigned short > &	simhit_layer ()

const std::vector< unsigned short > &	simhit_module ()

const std::vector< unsigned short > &	simhit_order ()

const std::vector< unsigned short > &	simhit_panel ()

const std::vector< int > &	simhit_particle ()

const std::vector< short > &	simhit_process ()

const std::vector< float > &	simhit_px ()

const std::vector< float > &	simhit_py ()

const std::vector< float > &	simhit_pz ()

const std::vector< unsigned short > &	simhit_ring ()

const std::vector< unsigned short > &	simhit_rod ()

const std::vector< unsigned short > &	simhit_side ()

const std::vector< int > &	simhit_simTrkIdx ()

const std::vector< unsigned short > &	simhit_subdet ()

const std::vector< float > &	simhit_tof ()

const std::vector< float > &	simhit_x ()

const std::vector< float > &	simhit_y ()

const std::vector< float > &	simhit_z ()

const std::vector< int > &	simpv_idx ()

const std::vector< int > &	simvtx_bunchCrossing ()

const std::vector< std::vector< int > > &	simvtx_daughterSimIdx ()

const std::vector< int > &	simvtx_event ()

const std::vector< unsigned int > &	simvtx_processType ()

const std::vector< std::vector< int > > &	simvtx_sourceSimIdx ()

const std::vector< float > &	simvtx_x ()

const std::vector< float > &	simvtx_y ()

const std::vector< float > &	simvtx_z ()

const std::vector< unsigned int > &	trk_algo ()

const std::vector< ULong64_t > &	trk_algoMask ()

const std::vector< int > &	trk_bestFromFirstHitSimTrkIdx ()

const std::vector< float > &	trk_bestFromFirstHitSimTrkNChi2 ()

const std::vector< float > &	trk_bestFromFirstHitSimTrkShareFrac ()

const std::vector< float > &	trk_bestFromFirstHitSimTrkShareFracSimClusterDenom ()

const std::vector< float > &	trk_bestFromFirstHitSimTrkShareFracSimDenom ()

const std::vector< int > &	trk_bestSimTrkIdx ()

const std::vector< float > &	trk_bestSimTrkNChi2 ()

const std::vector< float > &	trk_bestSimTrkShareFrac ()

const std::vector< float > &	trk_bestSimTrkShareFracSimClusterDenom ()

const std::vector< float > &	trk_bestSimTrkShareFracSimDenom ()

const std::vector< float > &	trk_cotTheta ()

const std::vector< float > &	trk_dxy ()

const std::vector< float > &	trk_dxyClosestPV ()

const std::vector< float > &	trk_dxyErr ()

const std::vector< float > &	trk_dxyPV ()

const std::vector< float > &	trk_dz ()

const std::vector< float > &	trk_dzClosestPV ()

const std::vector< float > &	trk_dzErr ()

const std::vector< float > &	trk_dzPV ()

const std::vector< float > &	trk_eta ()

const std::vector< float > &	trk_etaErr ()

const std::vector< std::vector< int > > &	trk_hitIdx ()

const std::vector< std::vector< int > > &	trk_hitType ()

const std::vector< float > &	trk_inner_pt ()

const std::vector< float > &	trk_inner_px ()

const std::vector< float > &	trk_inner_py ()

const std::vector< float > &	trk_inner_pz ()

const std::vector< short > &	trk_isHP ()

const std::vector< float > &	trk_lambda ()

const std::vector< float > &	trk_lambdaErr ()

const std::vector< float > &	trk_mva ()

const std::vector< unsigned int > &	trk_n3DLay ()

const std::vector< float > &	trk_nChi2 ()

const std::vector< float > &	trk_nChi2_1Dmod ()

const std::vector< unsigned int > &	trk_nCluster ()

const std::vector< float > &	trk_ndof ()

const std::vector< unsigned int > &	trk_nInactive ()

const std::vector< unsigned int > &	trk_nInnerInactive ()

const std::vector< unsigned int > &	trk_nInnerLost ()

const std::vector< unsigned int > &	trk_nLost ()

const std::vector< unsigned int > &	trk_nLostLay ()

const std::vector< unsigned int > &	trk_nOuterInactive ()

const std::vector< unsigned int > &	trk_nOuterLost ()

const std::vector< unsigned int > &	trk_nPixel ()

const std::vector< unsigned int > &	trk_nPixelLay ()

const std::vector< unsigned int > &	trk_nStrip ()

const std::vector< unsigned int > &	trk_nStripLay ()

const std::vector< unsigned int > &	trk_nValid ()

const std::vector< unsigned int > &	trk_originalAlgo ()

const std::vector< float > &	trk_outer_pt ()

const std::vector< float > &	trk_outer_px ()

const std::vector< float > &	trk_outer_py ()

const std::vector< float > &	trk_outer_pz ()

const std::vector< float > &	trk_phi ()

const std::vector< float > &	trk_phiErr ()

const std::vector< float > &	trk_pt ()

const std::vector< float > &	trk_ptErr ()

const std::vector< float > &	trk_px ()

const std::vector< float > &	trk_py ()

const std::vector< float > &	trk_pz ()

const std::vector< int > &	trk_q ()

const std::vector< unsigned short > &	trk_qualityMask ()

const std::vector< float > &	trk_refpoint_x ()

const std::vector< float > &	trk_refpoint_y ()

const std::vector< float > &	trk_refpoint_z ()

const std::vector< int > &	trk_seedIdx ()

const std::vector< std::vector< int > > &	trk_simTrkIdx ()

const std::vector< std::vector< float > > &	trk_simTrkNChi2 ()

const std::vector< std::vector< float > > &	trk_simTrkShareFrac ()

const std::vector< unsigned short > &	trk_stopReason ()

const std::vector< int > &	trk_vtxIdx ()

const std::vector< float > &	vtx_chi2 ()

const std::vector< short > &	vtx_fake ()

const std::vector< float > &	vtx_ndof ()

const std::vector< std::vector< int > > &	vtx_trkIdx ()

const std::vector< short > &	vtx_valid ()

const std::vector< float > &	vtx_x ()

const std::vector< float > &	vtx_xErr ()

const std::vector< float > &	vtx_y ()

const std::vector< float > &	vtx_yErr ()

const std::vector< float > &	vtx_z ()

const std::vector< float > &	vtx_zErr ()

Static Public Member Functions
static void	progress (int nEventsTotal, int nEventsChain)

Protected Attributes
float	bsp_sigmax_

TBranch *	bsp_sigmax_branch

bool	bsp_sigmax_isLoaded

float	bsp_sigmay_

TBranch *	bsp_sigmay_branch

bool	bsp_sigmay_isLoaded

float	bsp_sigmaz_

TBranch *	bsp_sigmaz_branch

bool	bsp_sigmaz_isLoaded

float	bsp_x_

TBranch *	bsp_x_branch

bool	bsp_x_isLoaded

float	bsp_y_

TBranch *	bsp_y_branch

bool	bsp_y_isLoaded

float	bsp_z_

TBranch *	bsp_z_branch

bool	bsp_z_isLoaded

unsigned long long	event_

TBranch *	event_branch

bool	event_isLoaded

unsigned int	index

std::vector< unsigned short > *	inv_blade_

TBranch *	inv_blade_branch

bool	inv_blade_isLoaded

std::vector< unsigned int > *	inv_detId_

TBranch *	inv_detId_branch

bool	inv_detId_isLoaded

std::vector< short > *	inv_isBarrel_

TBranch *	inv_isBarrel_branch

bool	inv_isBarrel_isLoaded

std::vector< unsigned short > *	inv_isLower_

TBranch *	inv_isLower_branch

bool	inv_isLower_isLoaded

std::vector< unsigned short > *	inv_isStack_

TBranch *	inv_isStack_branch

bool	inv_isStack_isLoaded

std::vector< unsigned short > *	inv_isUpper_

TBranch *	inv_isUpper_branch

bool	inv_isUpper_isLoaded

std::vector< unsigned short > *	inv_ladder_

TBranch *	inv_ladder_branch

bool	inv_ladder_isLoaded

std::vector< unsigned short > *	inv_layer_

TBranch *	inv_layer_branch

bool	inv_layer_isLoaded

std::vector< unsigned short > *	inv_module_

TBranch *	inv_module_branch

bool	inv_module_isLoaded

std::vector< unsigned short > *	inv_order_

TBranch *	inv_order_branch

bool	inv_order_isLoaded

std::vector< unsigned short > *	inv_panel_

TBranch *	inv_panel_branch

bool	inv_panel_isLoaded

std::vector< unsigned short > *	inv_ring_

TBranch *	inv_ring_branch

bool	inv_ring_isLoaded

std::vector< unsigned short > *	inv_rod_

TBranch *	inv_rod_branch

bool	inv_rod_isLoaded

std::vector< unsigned short > *	inv_side_

TBranch *	inv_side_branch

bool	inv_side_isLoaded

std::vector< unsigned short > *	inv_subdet_

TBranch *	inv_subdet_branch

bool	inv_subdet_isLoaded

std::vector< unsigned short > *	inv_type_

TBranch *	inv_type_branch

bool	inv_type_isLoaded

unsigned int	lumi_

TBranch *	lumi_branch

bool	lumi_isLoaded

std::vector< float > *	ph2_bbxi_

TBranch *	ph2_bbxi_branch

bool	ph2_bbxi_isLoaded

std::vector< unsigned int > *	ph2_detId_

TBranch *	ph2_detId_branch

bool	ph2_detId_isLoaded

std::vector< short > *	ph2_isBarrel_

TBranch *	ph2_isBarrel_branch

bool	ph2_isBarrel_isLoaded

std::vector< unsigned short > *	ph2_isLower_

TBranch *	ph2_isLower_branch

bool	ph2_isLower_isLoaded

std::vector< unsigned short > *	ph2_isStack_

TBranch *	ph2_isStack_branch

bool	ph2_isStack_isLoaded

std::vector< unsigned short > *	ph2_isUpper_

TBranch *	ph2_isUpper_branch

bool	ph2_isUpper_isLoaded

std::vector< unsigned short > *	ph2_layer_

TBranch *	ph2_layer_branch

bool	ph2_layer_isLoaded

std::vector< unsigned short > *	ph2_module_

TBranch *	ph2_module_branch

bool	ph2_module_isLoaded

std::vector< unsigned short > *	ph2_order_

TBranch *	ph2_order_branch

bool	ph2_order_isLoaded

std::vector< float > *	ph2_radL_

TBranch *	ph2_radL_branch

bool	ph2_radL_isLoaded

std::vector< unsigned short > *	ph2_ring_

TBranch *	ph2_ring_branch

bool	ph2_ring_isLoaded

std::vector< unsigned short > *	ph2_rod_

TBranch *	ph2_rod_branch

bool	ph2_rod_isLoaded

std::vector< std::vector< int > > *	ph2_seeIdx_

TBranch *	ph2_seeIdx_branch

bool	ph2_seeIdx_isLoaded

std::vector< unsigned short > *	ph2_side_

TBranch *	ph2_side_branch

bool	ph2_side_isLoaded

std::vector< std::vector< int > > *	ph2_simHitIdx_

TBranch *	ph2_simHitIdx_branch

bool	ph2_simHitIdx_isLoaded

std::vector< unsigned short > *	ph2_simType_

TBranch *	ph2_simType_branch

bool	ph2_simType_isLoaded

std::vector< unsigned short > *	ph2_subdet_

TBranch *	ph2_subdet_branch

bool	ph2_subdet_isLoaded

std::vector< std::vector< int > > *	ph2_trkIdx_

TBranch *	ph2_trkIdx_branch

bool	ph2_trkIdx_isLoaded

std::vector< float > *	ph2_x_

TBranch *	ph2_x_branch

bool	ph2_x_isLoaded

std::vector< float > *	ph2_xx_

TBranch *	ph2_xx_branch

bool	ph2_xx_isLoaded

std::vector< float > *	ph2_xy_

TBranch *	ph2_xy_branch

bool	ph2_xy_isLoaded

std::vector< std::vector< float > > *	ph2_xySignificance_

TBranch *	ph2_xySignificance_branch

bool	ph2_xySignificance_isLoaded

std::vector< float > *	ph2_y_

TBranch *	ph2_y_branch

bool	ph2_y_isLoaded

std::vector< float > *	ph2_yy_

TBranch *	ph2_yy_branch

bool	ph2_yy_isLoaded

std::vector< float > *	ph2_yz_

TBranch *	ph2_yz_branch

bool	ph2_yz_isLoaded

std::vector< float > *	ph2_z_

TBranch *	ph2_z_branch

bool	ph2_z_isLoaded

std::vector< float > *	ph2_zx_

TBranch *	ph2_zx_branch

bool	ph2_zx_isLoaded

std::vector< float > *	ph2_zz_

TBranch *	ph2_zz_branch

bool	ph2_zz_isLoaded

std::vector< float > *	pix_bbxi_

TBranch *	pix_bbxi_branch

bool	pix_bbxi_isLoaded

std::vector< unsigned short > *	pix_blade_

TBranch *	pix_blade_branch

bool	pix_blade_isLoaded

std::vector< std::vector< float > > *	pix_chargeFraction_

TBranch *	pix_chargeFraction_branch

bool	pix_chargeFraction_isLoaded

std::vector< unsigned int > *	pix_detId_

TBranch *	pix_detId_branch

bool	pix_detId_isLoaded

std::vector< short > *	pix_isBarrel_

TBranch *	pix_isBarrel_branch

bool	pix_isBarrel_isLoaded

std::vector< unsigned short > *	pix_ladder_

TBranch *	pix_ladder_branch

bool	pix_ladder_isLoaded

std::vector< unsigned short > *	pix_layer_

TBranch *	pix_layer_branch

bool	pix_layer_isLoaded

std::vector< unsigned short > *	pix_module_

TBranch *	pix_module_branch

bool	pix_module_isLoaded

std::vector< unsigned short > *	pix_panel_

TBranch *	pix_panel_branch

bool	pix_panel_isLoaded

std::vector< float > *	pix_radL_

TBranch *	pix_radL_branch

bool	pix_radL_isLoaded

std::vector< std::vector< int > > *	pix_seeIdx_

TBranch *	pix_seeIdx_branch

bool	pix_seeIdx_isLoaded

std::vector< unsigned short > *	pix_side_

TBranch *	pix_side_branch

bool	pix_side_isLoaded

std::vector< std::vector< int > > *	pix_simHitIdx_

TBranch *	pix_simHitIdx_branch

bool	pix_simHitIdx_isLoaded

std::vector< unsigned short > *	pix_simType_

TBranch *	pix_simType_branch

bool	pix_simType_isLoaded

std::vector< unsigned short > *	pix_subdet_

TBranch *	pix_subdet_branch

bool	pix_subdet_isLoaded

std::vector< std::vector< int > > *	pix_trkIdx_

TBranch *	pix_trkIdx_branch

bool	pix_trkIdx_isLoaded

std::vector< float > *	pix_x_

TBranch *	pix_x_branch

bool	pix_x_isLoaded

std::vector< float > *	pix_xx_

TBranch *	pix_xx_branch

bool	pix_xx_isLoaded

std::vector< float > *	pix_xy_

TBranch *	pix_xy_branch

bool	pix_xy_isLoaded

std::vector< std::vector< float > > *	pix_xySignificance_

TBranch *	pix_xySignificance_branch

bool	pix_xySignificance_isLoaded

std::vector< float > *	pix_y_

TBranch *	pix_y_branch

bool	pix_y_isLoaded

std::vector< float > *	pix_yy_

TBranch *	pix_yy_branch

bool	pix_yy_isLoaded

std::vector< float > *	pix_yz_

TBranch *	pix_yz_branch

bool	pix_yz_isLoaded

std::vector< float > *	pix_z_

TBranch *	pix_z_branch

bool	pix_z_isLoaded

std::vector< float > *	pix_zx_

TBranch *	pix_zx_branch

bool	pix_zx_isLoaded

std::vector< float > *	pix_zz_

TBranch *	pix_zz_branch

bool	pix_zz_isLoaded

unsigned int	run_

TBranch *	run_branch

bool	run_isLoaded

std::vector< unsigned int > *	see_algo_

TBranch *	see_algo_branch

bool	see_algo_isLoaded

std::vector< int > *	see_bestFromFirstHitSimTrkIdx_

TBranch *	see_bestFromFirstHitSimTrkIdx_branch

bool	see_bestFromFirstHitSimTrkIdx_isLoaded

std::vector< float > *	see_bestFromFirstHitSimTrkShareFrac_

TBranch *	see_bestFromFirstHitSimTrkShareFrac_branch

bool	see_bestFromFirstHitSimTrkShareFrac_isLoaded

std::vector< int > *	see_bestSimTrkIdx_

TBranch *	see_bestSimTrkIdx_branch

bool	see_bestSimTrkIdx_isLoaded

std::vector< float > *	see_bestSimTrkShareFrac_

TBranch *	see_bestSimTrkShareFrac_branch

bool	see_bestSimTrkShareFrac_isLoaded

std::vector< float > *	see_chi2_

TBranch *	see_chi2_branch

bool	see_chi2_isLoaded

std::vector< float > *	see_dxy_

TBranch *	see_dxy_branch

bool	see_dxy_isLoaded

std::vector< float > *	see_dxyErr_

TBranch *	see_dxyErr_branch

bool	see_dxyErr_isLoaded

std::vector< float > *	see_dz_

TBranch *	see_dz_branch

bool	see_dz_isLoaded

std::vector< float > *	see_dzErr_

TBranch *	see_dzErr_branch

bool	see_dzErr_isLoaded

std::vector< float > *	see_eta_

TBranch *	see_eta_branch

bool	see_eta_isLoaded

std::vector< float > *	see_etaErr_

TBranch *	see_etaErr_branch

bool	see_etaErr_isLoaded

std::vector< short > *	see_fitok_

TBranch *	see_fitok_branch

bool	see_fitok_isLoaded

std::vector< std::vector< int > > *	see_hitIdx_

TBranch *	see_hitIdx_branch

bool	see_hitIdx_isLoaded

std::vector< std::vector< int > > *	see_hitType_

TBranch *	see_hitType_branch

bool	see_hitType_isLoaded

std::vector< unsigned short > *	see_nCands_

TBranch *	see_nCands_branch

bool	see_nCands_isLoaded

std::vector< unsigned int > *	see_nCluster_

TBranch *	see_nCluster_branch

bool	see_nCluster_isLoaded

std::vector< unsigned int > *	see_nGlued_

TBranch *	see_nGlued_branch

bool	see_nGlued_isLoaded

std::vector< unsigned int > *	see_nPhase2OT_

TBranch *	see_nPhase2OT_branch

bool	see_nPhase2OT_isLoaded

std::vector< unsigned int > *	see_nPixel_

TBranch *	see_nPixel_branch

bool	see_nPixel_isLoaded

std::vector< unsigned int > *	see_nStrip_

TBranch *	see_nStrip_branch

bool	see_nStrip_isLoaded

std::vector< unsigned int > *	see_nValid_

TBranch *	see_nValid_branch

bool	see_nValid_isLoaded

std::vector< unsigned int > *	see_offset_

TBranch *	see_offset_branch

bool	see_offset_isLoaded

std::vector< float > *	see_phi_

TBranch *	see_phi_branch

bool	see_phi_isLoaded

std::vector< float > *	see_phiErr_

TBranch *	see_phiErr_branch

bool	see_phiErr_isLoaded

std::vector< float > *	see_pt_

TBranch *	see_pt_branch

bool	see_pt_isLoaded

std::vector< float > *	see_ptErr_

TBranch *	see_ptErr_branch

bool	see_ptErr_isLoaded

std::vector< float > *	see_px_

TBranch *	see_px_branch

bool	see_px_isLoaded

std::vector< float > *	see_py_

TBranch *	see_py_branch

bool	see_py_isLoaded

std::vector< float > *	see_pz_

TBranch *	see_pz_branch

bool	see_pz_isLoaded

std::vector< int > *	see_q_

TBranch *	see_q_branch

bool	see_q_isLoaded

std::vector< std::vector< int > > *	see_simTrkIdx_

TBranch *	see_simTrkIdx_branch

bool	see_simTrkIdx_isLoaded

std::vector< std::vector< float > > *	see_simTrkShareFrac_

TBranch *	see_simTrkShareFrac_branch

bool	see_simTrkShareFrac_isLoaded

std::vector< float > *	see_stateCcov00_

TBranch *	see_stateCcov00_branch

bool	see_stateCcov00_isLoaded

std::vector< float > *	see_stateCcov01_

TBranch *	see_stateCcov01_branch

bool	see_stateCcov01_isLoaded

std::vector< float > *	see_stateCcov02_

TBranch *	see_stateCcov02_branch

bool	see_stateCcov02_isLoaded

std::vector< float > *	see_stateCcov03_

TBranch *	see_stateCcov03_branch

bool	see_stateCcov03_isLoaded

std::vector< float > *	see_stateCcov04_

TBranch *	see_stateCcov04_branch

bool	see_stateCcov04_isLoaded

std::vector< float > *	see_stateCcov05_

TBranch *	see_stateCcov05_branch

bool	see_stateCcov05_isLoaded

std::vector< float > *	see_stateCcov11_

TBranch *	see_stateCcov11_branch

bool	see_stateCcov11_isLoaded

std::vector< float > *	see_stateCcov12_

TBranch *	see_stateCcov12_branch

bool	see_stateCcov12_isLoaded

std::vector< float > *	see_stateCcov13_

TBranch *	see_stateCcov13_branch

bool	see_stateCcov13_isLoaded

std::vector< float > *	see_stateCcov14_

TBranch *	see_stateCcov14_branch

bool	see_stateCcov14_isLoaded

std::vector< float > *	see_stateCcov15_

TBranch *	see_stateCcov15_branch

bool	see_stateCcov15_isLoaded

std::vector< float > *	see_stateCcov22_

TBranch *	see_stateCcov22_branch

bool	see_stateCcov22_isLoaded

std::vector< float > *	see_stateCcov23_

TBranch *	see_stateCcov23_branch

bool	see_stateCcov23_isLoaded

std::vector< float > *	see_stateCcov24_

TBranch *	see_stateCcov24_branch

bool	see_stateCcov24_isLoaded

std::vector< float > *	see_stateCcov25_

TBranch *	see_stateCcov25_branch

bool	see_stateCcov25_isLoaded

std::vector< float > *	see_stateCcov33_

TBranch *	see_stateCcov33_branch

bool	see_stateCcov33_isLoaded

std::vector< float > *	see_stateCcov34_

TBranch *	see_stateCcov34_branch

bool	see_stateCcov34_isLoaded

std::vector< float > *	see_stateCcov35_

TBranch *	see_stateCcov35_branch

bool	see_stateCcov35_isLoaded

std::vector< float > *	see_stateCcov44_

TBranch *	see_stateCcov44_branch

bool	see_stateCcov44_isLoaded

std::vector< float > *	see_stateCcov45_

TBranch *	see_stateCcov45_branch

bool	see_stateCcov45_isLoaded

std::vector< float > *	see_stateCcov55_

TBranch *	see_stateCcov55_branch

bool	see_stateCcov55_isLoaded

std::vector< float > *	see_statePt_

TBranch *	see_statePt_branch

bool	see_statePt_isLoaded

std::vector< float > *	see_stateTrajGlbPx_

TBranch *	see_stateTrajGlbPx_branch

bool	see_stateTrajGlbPx_isLoaded

std::vector< float > *	see_stateTrajGlbPy_

TBranch *	see_stateTrajGlbPy_branch

bool	see_stateTrajGlbPy_isLoaded

std::vector< float > *	see_stateTrajGlbPz_

TBranch *	see_stateTrajGlbPz_branch

bool	see_stateTrajGlbPz_isLoaded

std::vector< float > *	see_stateTrajGlbX_

TBranch *	see_stateTrajGlbX_branch

bool	see_stateTrajGlbX_isLoaded

std::vector< float > *	see_stateTrajGlbY_

TBranch *	see_stateTrajGlbY_branch

bool	see_stateTrajGlbY_isLoaded

std::vector< float > *	see_stateTrajGlbZ_

TBranch *	see_stateTrajGlbZ_branch

bool	see_stateTrajGlbZ_isLoaded

std::vector< float > *	see_stateTrajPx_

TBranch *	see_stateTrajPx_branch

bool	see_stateTrajPx_isLoaded

std::vector< float > *	see_stateTrajPy_

TBranch *	see_stateTrajPy_branch

bool	see_stateTrajPy_isLoaded

std::vector< float > *	see_stateTrajPz_

TBranch *	see_stateTrajPz_branch

bool	see_stateTrajPz_isLoaded

std::vector< float > *	see_stateTrajX_

TBranch *	see_stateTrajX_branch

bool	see_stateTrajX_isLoaded

std::vector< float > *	see_stateTrajY_

TBranch *	see_stateTrajY_branch

bool	see_stateTrajY_isLoaded

std::vector< unsigned short > *	see_stopReason_

TBranch *	see_stopReason_branch

bool	see_stopReason_isLoaded

std::vector< int > *	see_trkIdx_

TBranch *	see_trkIdx_branch

bool	see_trkIdx_isLoaded

std::vector< int > *	sim_bunchCrossing_

TBranch *	sim_bunchCrossing_branch

bool	sim_bunchCrossing_isLoaded

std::vector< std::vector< int > > *	sim_decayVtxIdx_

TBranch *	sim_decayVtxIdx_branch

bool	sim_decayVtxIdx_isLoaded

std::vector< float > *	sim_eta_

TBranch *	sim_eta_branch

bool	sim_eta_isLoaded

std::vector< int > *	sim_event_

TBranch *	sim_event_branch

bool	sim_event_isLoaded

std::vector< std::vector< int > > *	sim_genPdgIds_

TBranch *	sim_genPdgIds_branch

bool	sim_genPdgIds_isLoaded

std::vector< float > *	sim_hits_

TBranch *	sim_hits_branch

bool	sim_hits_isLoaded

std::vector< int > *	sim_isFromBHadron_

TBranch *	sim_isFromBHadron_branch

bool	sim_isFromBHadron_isLoaded

std::vector< float > *	sim_len_

TBranch *	sim_len_branch

bool	sim_len_isLoaded

std::vector< float > *	sim_lengap_

TBranch *	sim_lengap_branch

bool	sim_lengap_isLoaded

std::vector< unsigned int > *	sim_n3DLay_

TBranch *	sim_n3DLay_branch

bool	sim_n3DLay_isLoaded

std::vector< unsigned int > *	sim_nLay_

TBranch *	sim_nLay_branch

bool	sim_nLay_isLoaded

std::vector< unsigned int > *	sim_nPixel_

TBranch *	sim_nPixel_branch

bool	sim_nPixel_isLoaded

std::vector< unsigned int > *	sim_nPixelLay_

TBranch *	sim_nPixelLay_branch

bool	sim_nPixelLay_isLoaded

std::vector< unsigned int > *	sim_nRecoClusters_

TBranch *	sim_nRecoClusters_branch

bool	sim_nRecoClusters_isLoaded

std::vector< unsigned int > *	sim_nStrip_

TBranch *	sim_nStrip_branch

bool	sim_nStrip_isLoaded

std::vector< unsigned int > *	sim_nTrackerHits_

TBranch *	sim_nTrackerHits_branch

bool	sim_nTrackerHits_isLoaded

std::vector< unsigned int > *	sim_nValid_

TBranch *	sim_nValid_branch

bool	sim_nValid_isLoaded

std::vector< int > *	sim_parentVtxIdx_

TBranch *	sim_parentVtxIdx_branch

bool	sim_parentVtxIdx_isLoaded

std::vector< float > *	sim_pca_cotTheta_

TBranch *	sim_pca_cotTheta_branch

bool	sim_pca_cotTheta_isLoaded

std::vector< float > *	sim_pca_dxy_

TBranch *	sim_pca_dxy_branch

bool	sim_pca_dxy_isLoaded

std::vector< float > *	sim_pca_dz_

TBranch *	sim_pca_dz_branch

bool	sim_pca_dz_isLoaded

std::vector< float > *	sim_pca_eta_

TBranch *	sim_pca_eta_branch

bool	sim_pca_eta_isLoaded

std::vector< float > *	sim_pca_lambda_

TBranch *	sim_pca_lambda_branch

bool	sim_pca_lambda_isLoaded

std::vector< float > *	sim_pca_phi_

TBranch *	sim_pca_phi_branch

bool	sim_pca_phi_isLoaded

std::vector< float > *	sim_pca_pt_

TBranch *	sim_pca_pt_branch

bool	sim_pca_pt_isLoaded

std::vector< int > *	sim_pdgId_

TBranch *	sim_pdgId_branch

bool	sim_pdgId_isLoaded

std::vector< float > *	sim_phi_

TBranch *	sim_phi_branch

bool	sim_phi_isLoaded

std::vector< float > *	sim_pt_

TBranch *	sim_pt_branch

bool	sim_pt_isLoaded

std::vector< float > *	sim_px_

TBranch *	sim_px_branch

bool	sim_px_isLoaded

std::vector< float > *	sim_py_

TBranch *	sim_py_branch

bool	sim_py_isLoaded

std::vector< float > *	sim_pz_

TBranch *	sim_pz_branch

bool	sim_pz_isLoaded

std::vector< int > *	sim_q_

TBranch *	sim_q_branch

bool	sim_q_isLoaded

std::vector< std::vector< int > > *	sim_seedIdx_

TBranch *	sim_seedIdx_branch

bool	sim_seedIdx_isLoaded

std::vector< std::vector< int > > *	sim_simHitIdx_

TBranch *	sim_simHitIdx_branch

bool	sim_simHitIdx_isLoaded

std::vector< std::vector< int > > *	sim_trkIdx_

TBranch *	sim_trkIdx_branch

bool	sim_trkIdx_isLoaded

std::vector< std::vector< float > > *	sim_trkShareFrac_

TBranch *	sim_trkShareFrac_branch

bool	sim_trkShareFrac_isLoaded

std::vector< unsigned short > *	simhit_blade_

TBranch *	simhit_blade_branch

bool	simhit_blade_isLoaded

std::vector< unsigned int > *	simhit_detId_

TBranch *	simhit_detId_branch

bool	simhit_detId_isLoaded

std::vector< float > *	simhit_eloss_

TBranch *	simhit_eloss_branch

bool	simhit_eloss_isLoaded

std::vector< std::vector< int > > *	simhit_hitIdx_

TBranch *	simhit_hitIdx_branch

bool	simhit_hitIdx_isLoaded

std::vector< std::vector< int > > *	simhit_hitType_

TBranch *	simhit_hitType_branch

bool	simhit_hitType_isLoaded

std::vector< unsigned short > *	simhit_isLower_

TBranch *	simhit_isLower_branch

bool	simhit_isLower_isLoaded

std::vector< unsigned short > *	simhit_isStack_

TBranch *	simhit_isStack_branch

bool	simhit_isStack_isLoaded

std::vector< unsigned short > *	simhit_isUpper_

TBranch *	simhit_isUpper_branch

bool	simhit_isUpper_isLoaded

std::vector< unsigned short > *	simhit_ladder_

TBranch *	simhit_ladder_branch

bool	simhit_ladder_isLoaded

std::vector< unsigned short > *	simhit_layer_

TBranch *	simhit_layer_branch

bool	simhit_layer_isLoaded

std::vector< unsigned short > *	simhit_module_

TBranch *	simhit_module_branch

bool	simhit_module_isLoaded

std::vector< unsigned short > *	simhit_order_

TBranch *	simhit_order_branch

bool	simhit_order_isLoaded

std::vector< unsigned short > *	simhit_panel_

TBranch *	simhit_panel_branch

bool	simhit_panel_isLoaded

std::vector< int > *	simhit_particle_

TBranch *	simhit_particle_branch

bool	simhit_particle_isLoaded

std::vector< short > *	simhit_process_

TBranch *	simhit_process_branch

bool	simhit_process_isLoaded

std::vector< float > *	simhit_px_

TBranch *	simhit_px_branch

bool	simhit_px_isLoaded

std::vector< float > *	simhit_py_

TBranch *	simhit_py_branch

bool	simhit_py_isLoaded

std::vector< float > *	simhit_pz_

TBranch *	simhit_pz_branch

bool	simhit_pz_isLoaded

std::vector< unsigned short > *	simhit_ring_

TBranch *	simhit_ring_branch

bool	simhit_ring_isLoaded

std::vector< unsigned short > *	simhit_rod_

TBranch *	simhit_rod_branch

bool	simhit_rod_isLoaded

std::vector< unsigned short > *	simhit_side_

TBranch *	simhit_side_branch

bool	simhit_side_isLoaded

std::vector< int > *	simhit_simTrkIdx_

TBranch *	simhit_simTrkIdx_branch

bool	simhit_simTrkIdx_isLoaded

std::vector< unsigned short > *	simhit_subdet_

TBranch *	simhit_subdet_branch

bool	simhit_subdet_isLoaded

std::vector< float > *	simhit_tof_

TBranch *	simhit_tof_branch

bool	simhit_tof_isLoaded

std::vector< float > *	simhit_x_

TBranch *	simhit_x_branch

bool	simhit_x_isLoaded

std::vector< float > *	simhit_y_

TBranch *	simhit_y_branch

bool	simhit_y_isLoaded

std::vector< float > *	simhit_z_

TBranch *	simhit_z_branch

bool	simhit_z_isLoaded

std::vector< int > *	simpv_idx_

TBranch *	simpv_idx_branch

bool	simpv_idx_isLoaded

std::vector< int > *	simvtx_bunchCrossing_

TBranch *	simvtx_bunchCrossing_branch

bool	simvtx_bunchCrossing_isLoaded

std::vector< std::vector< int > > *	simvtx_daughterSimIdx_

TBranch *	simvtx_daughterSimIdx_branch

bool	simvtx_daughterSimIdx_isLoaded

std::vector< int > *	simvtx_event_

TBranch *	simvtx_event_branch

bool	simvtx_event_isLoaded

std::vector< unsigned int > *	simvtx_processType_

TBranch *	simvtx_processType_branch

bool	simvtx_processType_isLoaded

std::vector< std::vector< int > > *	simvtx_sourceSimIdx_

TBranch *	simvtx_sourceSimIdx_branch

bool	simvtx_sourceSimIdx_isLoaded

std::vector< float > *	simvtx_x_

TBranch *	simvtx_x_branch

bool	simvtx_x_isLoaded

std::vector< float > *	simvtx_y_

TBranch *	simvtx_y_branch

bool	simvtx_y_isLoaded

std::vector< float > *	simvtx_z_

TBranch *	simvtx_z_branch

bool	simvtx_z_isLoaded

std::vector< unsigned int > *	trk_algo_

TBranch *	trk_algo_branch

bool	trk_algo_isLoaded

std::vector< ULong64_t > *	trk_algoMask_

TBranch *	trk_algoMask_branch

bool	trk_algoMask_isLoaded

std::vector< int > *	trk_bestFromFirstHitSimTrkIdx_

TBranch *	trk_bestFromFirstHitSimTrkIdx_branch

bool	trk_bestFromFirstHitSimTrkIdx_isLoaded

std::vector< float > *	trk_bestFromFirstHitSimTrkNChi2_

TBranch *	trk_bestFromFirstHitSimTrkNChi2_branch

bool	trk_bestFromFirstHitSimTrkNChi2_isLoaded

std::vector< float > *	trk_bestFromFirstHitSimTrkShareFrac_

TBranch *	trk_bestFromFirstHitSimTrkShareFrac_branch

bool	trk_bestFromFirstHitSimTrkShareFrac_isLoaded

std::vector< float > *	trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_

TBranch *	trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch

bool	trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_isLoaded

std::vector< float > *	trk_bestFromFirstHitSimTrkShareFracSimDenom_

TBranch *	trk_bestFromFirstHitSimTrkShareFracSimDenom_branch

bool	trk_bestFromFirstHitSimTrkShareFracSimDenom_isLoaded

std::vector< int > *	trk_bestSimTrkIdx_

TBranch *	trk_bestSimTrkIdx_branch

bool	trk_bestSimTrkIdx_isLoaded

std::vector< float > *	trk_bestSimTrkNChi2_

TBranch *	trk_bestSimTrkNChi2_branch

bool	trk_bestSimTrkNChi2_isLoaded

std::vector< float > *	trk_bestSimTrkShareFrac_

TBranch *	trk_bestSimTrkShareFrac_branch

bool	trk_bestSimTrkShareFrac_isLoaded

std::vector< float > *	trk_bestSimTrkShareFracSimClusterDenom_

TBranch *	trk_bestSimTrkShareFracSimClusterDenom_branch

bool	trk_bestSimTrkShareFracSimClusterDenom_isLoaded

std::vector< float > *	trk_bestSimTrkShareFracSimDenom_

TBranch *	trk_bestSimTrkShareFracSimDenom_branch

bool	trk_bestSimTrkShareFracSimDenom_isLoaded

std::vector< float > *	trk_cotTheta_

TBranch *	trk_cotTheta_branch

bool	trk_cotTheta_isLoaded

std::vector< float > *	trk_dxy_

TBranch *	trk_dxy_branch

bool	trk_dxy_isLoaded

std::vector< float > *	trk_dxyClosestPV_

TBranch *	trk_dxyClosestPV_branch

bool	trk_dxyClosestPV_isLoaded

std::vector< float > *	trk_dxyErr_

TBranch *	trk_dxyErr_branch

bool	trk_dxyErr_isLoaded

std::vector< float > *	trk_dxyPV_

TBranch *	trk_dxyPV_branch

bool	trk_dxyPV_isLoaded

std::vector< float > *	trk_dz_

TBranch *	trk_dz_branch

bool	trk_dz_isLoaded

std::vector< float > *	trk_dzClosestPV_

TBranch *	trk_dzClosestPV_branch

bool	trk_dzClosestPV_isLoaded

std::vector< float > *	trk_dzErr_

TBranch *	trk_dzErr_branch

bool	trk_dzErr_isLoaded

std::vector< float > *	trk_dzPV_

TBranch *	trk_dzPV_branch

bool	trk_dzPV_isLoaded

std::vector< float > *	trk_eta_

TBranch *	trk_eta_branch

bool	trk_eta_isLoaded

std::vector< float > *	trk_etaErr_

TBranch *	trk_etaErr_branch

bool	trk_etaErr_isLoaded

std::vector< std::vector< int > > *	trk_hitIdx_

TBranch *	trk_hitIdx_branch

bool	trk_hitIdx_isLoaded

std::vector< std::vector< int > > *	trk_hitType_

TBranch *	trk_hitType_branch

bool	trk_hitType_isLoaded

std::vector< float > *	trk_inner_pt_

TBranch *	trk_inner_pt_branch

bool	trk_inner_pt_isLoaded

std::vector< float > *	trk_inner_px_

TBranch *	trk_inner_px_branch

bool	trk_inner_px_isLoaded

std::vector< float > *	trk_inner_py_

TBranch *	trk_inner_py_branch

bool	trk_inner_py_isLoaded

std::vector< float > *	trk_inner_pz_

TBranch *	trk_inner_pz_branch

bool	trk_inner_pz_isLoaded

std::vector< short > *	trk_isHP_

TBranch *	trk_isHP_branch

bool	trk_isHP_isLoaded

std::vector< float > *	trk_lambda_

TBranch *	trk_lambda_branch

bool	trk_lambda_isLoaded

std::vector< float > *	trk_lambdaErr_

TBranch *	trk_lambdaErr_branch

bool	trk_lambdaErr_isLoaded

std::vector< float > *	trk_mva_

TBranch *	trk_mva_branch

bool	trk_mva_isLoaded

std::vector< unsigned int > *	trk_n3DLay_

TBranch *	trk_n3DLay_branch

bool	trk_n3DLay_isLoaded

std::vector< float > *	trk_nChi2_

std::vector< float > *	trk_nChi2_1Dmod_

TBranch *	trk_nChi2_1Dmod_branch

bool	trk_nChi2_1Dmod_isLoaded

TBranch *	trk_nChi2_branch

bool	trk_nChi2_isLoaded

std::vector< unsigned int > *	trk_nCluster_

TBranch *	trk_nCluster_branch

bool	trk_nCluster_isLoaded

std::vector< float > *	trk_ndof_

TBranch *	trk_ndof_branch

bool	trk_ndof_isLoaded

std::vector< unsigned int > *	trk_nInactive_

TBranch *	trk_nInactive_branch

bool	trk_nInactive_isLoaded

std::vector< unsigned int > *	trk_nInnerInactive_

TBranch *	trk_nInnerInactive_branch

bool	trk_nInnerInactive_isLoaded

std::vector< unsigned int > *	trk_nInnerLost_

TBranch *	trk_nInnerLost_branch

bool	trk_nInnerLost_isLoaded

std::vector< unsigned int > *	trk_nLost_

TBranch *	trk_nLost_branch

bool	trk_nLost_isLoaded

std::vector< unsigned int > *	trk_nLostLay_

TBranch *	trk_nLostLay_branch

bool	trk_nLostLay_isLoaded

std::vector< unsigned int > *	trk_nOuterInactive_

TBranch *	trk_nOuterInactive_branch

bool	trk_nOuterInactive_isLoaded

std::vector< unsigned int > *	trk_nOuterLost_

TBranch *	trk_nOuterLost_branch

bool	trk_nOuterLost_isLoaded

std::vector< unsigned int > *	trk_nPixel_

TBranch *	trk_nPixel_branch

bool	trk_nPixel_isLoaded

std::vector< unsigned int > *	trk_nPixelLay_

TBranch *	trk_nPixelLay_branch

bool	trk_nPixelLay_isLoaded

std::vector< unsigned int > *	trk_nStrip_

TBranch *	trk_nStrip_branch

bool	trk_nStrip_isLoaded

std::vector< unsigned int > *	trk_nStripLay_

TBranch *	trk_nStripLay_branch

bool	trk_nStripLay_isLoaded

std::vector< unsigned int > *	trk_nValid_

TBranch *	trk_nValid_branch

bool	trk_nValid_isLoaded

std::vector< unsigned int > *	trk_originalAlgo_

TBranch *	trk_originalAlgo_branch

bool	trk_originalAlgo_isLoaded

std::vector< float > *	trk_outer_pt_

TBranch *	trk_outer_pt_branch

bool	trk_outer_pt_isLoaded

std::vector< float > *	trk_outer_px_

TBranch *	trk_outer_px_branch

bool	trk_outer_px_isLoaded

std::vector< float > *	trk_outer_py_

TBranch *	trk_outer_py_branch

bool	trk_outer_py_isLoaded

std::vector< float > *	trk_outer_pz_

TBranch *	trk_outer_pz_branch

bool	trk_outer_pz_isLoaded

std::vector< float > *	trk_phi_

TBranch *	trk_phi_branch

bool	trk_phi_isLoaded

std::vector< float > *	trk_phiErr_

TBranch *	trk_phiErr_branch

bool	trk_phiErr_isLoaded

std::vector< float > *	trk_pt_

TBranch *	trk_pt_branch

bool	trk_pt_isLoaded

std::vector< float > *	trk_ptErr_

TBranch *	trk_ptErr_branch

bool	trk_ptErr_isLoaded

std::vector< float > *	trk_px_

TBranch *	trk_px_branch

bool	trk_px_isLoaded

std::vector< float > *	trk_py_

TBranch *	trk_py_branch

bool	trk_py_isLoaded

std::vector< float > *	trk_pz_

TBranch *	trk_pz_branch

bool	trk_pz_isLoaded

std::vector< int > *	trk_q_

TBranch *	trk_q_branch

bool	trk_q_isLoaded

std::vector< unsigned short > *	trk_qualityMask_

TBranch *	trk_qualityMask_branch

bool	trk_qualityMask_isLoaded

std::vector< float > *	trk_refpoint_x_

TBranch *	trk_refpoint_x_branch

bool	trk_refpoint_x_isLoaded

std::vector< float > *	trk_refpoint_y_

TBranch *	trk_refpoint_y_branch

bool	trk_refpoint_y_isLoaded

std::vector< float > *	trk_refpoint_z_

TBranch *	trk_refpoint_z_branch

bool	trk_refpoint_z_isLoaded

std::vector< int > *	trk_seedIdx_

TBranch *	trk_seedIdx_branch

bool	trk_seedIdx_isLoaded

std::vector< std::vector< int > > *	trk_simTrkIdx_

TBranch *	trk_simTrkIdx_branch

bool	trk_simTrkIdx_isLoaded

std::vector< std::vector< float > > *	trk_simTrkNChi2_

TBranch *	trk_simTrkNChi2_branch

bool	trk_simTrkNChi2_isLoaded

std::vector< std::vector< float > > *	trk_simTrkShareFrac_

TBranch *	trk_simTrkShareFrac_branch

bool	trk_simTrkShareFrac_isLoaded

std::vector< unsigned short > *	trk_stopReason_

TBranch *	trk_stopReason_branch

bool	trk_stopReason_isLoaded

std::vector< int > *	trk_vtxIdx_

TBranch *	trk_vtxIdx_branch

bool	trk_vtxIdx_isLoaded

std::vector< float > *	vtx_chi2_

TBranch *	vtx_chi2_branch

bool	vtx_chi2_isLoaded

std::vector< short > *	vtx_fake_

TBranch *	vtx_fake_branch

bool	vtx_fake_isLoaded

std::vector< float > *	vtx_ndof_

TBranch *	vtx_ndof_branch

bool	vtx_ndof_isLoaded

std::vector< std::vector< int > > *	vtx_trkIdx_

TBranch *	vtx_trkIdx_branch

bool	vtx_trkIdx_isLoaded

std::vector< short > *	vtx_valid_

TBranch *	vtx_valid_branch

bool	vtx_valid_isLoaded

std::vector< float > *	vtx_x_

TBranch *	vtx_x_branch

bool	vtx_x_isLoaded

std::vector< float > *	vtx_xErr_

TBranch *	vtx_xErr_branch

bool	vtx_xErr_isLoaded

std::vector< float > *	vtx_y_

TBranch *	vtx_y_branch

bool	vtx_y_isLoaded

std::vector< float > *	vtx_yErr_

TBranch *	vtx_yErr_branch

bool	vtx_yErr_isLoaded

std::vector< float > *	vtx_z_

TBranch *	vtx_z_branch

bool	vtx_z_isLoaded

std::vector< float > *	vtx_zErr_

TBranch *	vtx_zErr_branch

bool	vtx_zErr_isLoaded

Detailed Description

Definition at line 16 of file Trktree.h.

Member Function Documentation

◆ bsp_sigmax()

const float & Trktree::bsp_sigmax ( )

Definition at line 4581 of file Trktree.cc.

References bsp_sigmax_, bsp_sigmax_branch, bsp_sigmax_isLoaded, beamvalidation::exit(), and index.

Referenced by tas::bsp_sigmax(), and LoadAllBranches().

                                  {
   if (not bsp_sigmax_isLoaded) {
     if (bsp_sigmax_branch != 0) {
       bsp_sigmax_branch->GetEntry(index);
     } else {
       printf("branch bsp_sigmax_branch does not exist!\n");
       exit(1);
     }
     bsp_sigmax_isLoaded = true;
   }
   return bsp_sigmax_;
 }

◆ bsp_sigmay()

const float & Trktree::bsp_sigmay ( )

Definition at line 4569 of file Trktree.cc.

References bsp_sigmay_, bsp_sigmay_branch, bsp_sigmay_isLoaded, beamvalidation::exit(), and index.

Referenced by tas::bsp_sigmay(), and LoadAllBranches().

                                  {
   if (not bsp_sigmay_isLoaded) {
     if (bsp_sigmay_branch != 0) {
       bsp_sigmay_branch->GetEntry(index);
     } else {
       printf("branch bsp_sigmay_branch does not exist!\n");
       exit(1);
     }
     bsp_sigmay_isLoaded = true;
   }
   return bsp_sigmay_;
 }

◆ bsp_sigmaz()

const float & Trktree::bsp_sigmaz ( )

Definition at line 4557 of file Trktree.cc.

References bsp_sigmaz_, bsp_sigmaz_branch, bsp_sigmaz_isLoaded, beamvalidation::exit(), and index.

Referenced by tas::bsp_sigmaz(), and LoadAllBranches().

                                  {
   if (not bsp_sigmaz_isLoaded) {
     if (bsp_sigmaz_branch != 0) {
       bsp_sigmaz_branch->GetEntry(index);
     } else {
       printf("branch bsp_sigmaz_branch does not exist!\n");
       exit(1);
     }
     bsp_sigmaz_isLoaded = true;
   }
   return bsp_sigmaz_;
 }

◆ bsp_x()

const float & Trktree::bsp_x ( )

Definition at line 3081 of file Trktree.cc.

References bsp_x_, bsp_x_branch, bsp_x_isLoaded, beamvalidation::exit(), and index.

Referenced by tas::bsp_x(), and LoadAllBranches().

                             {
   if (not bsp_x_isLoaded) {
     if (bsp_x_branch != 0) {
       bsp_x_branch->GetEntry(index);
     } else {
       printf("branch bsp_x_branch does not exist!\n");
       exit(1);
     }
     bsp_x_isLoaded = true;
   }
   return bsp_x_;
 }

◆ bsp_y()

const float & Trktree::bsp_y ( )

Definition at line 4245 of file Trktree.cc.

References bsp_y_, bsp_y_branch, bsp_y_isLoaded, beamvalidation::exit(), and index.

Referenced by tas::bsp_y(), and LoadAllBranches().

                             {
   if (not bsp_y_isLoaded) {
     if (bsp_y_branch != 0) {
       bsp_y_branch->GetEntry(index);
     } else {
       printf("branch bsp_y_branch does not exist!\n");
       exit(1);
     }
     bsp_y_isLoaded = true;
   }
   return bsp_y_;
 }

◆ bsp_z()

const float & Trktree::bsp_z ( )

Definition at line 4233 of file Trktree.cc.

References bsp_z_, bsp_z_branch, bsp_z_isLoaded, beamvalidation::exit(), and index.

Referenced by tas::bsp_z(), and LoadAllBranches().

                             {
   if (not bsp_z_isLoaded) {
     if (bsp_z_branch != 0) {
       bsp_z_branch->GetEntry(index);
     } else {
       printf("branch bsp_z_branch does not exist!\n");
       exit(1);
     }
     bsp_z_isLoaded = true;
   }
   return bsp_z_;
 }

◆ event()

const unsigned long long & Trktree::event ( )

Definition at line 4161 of file Trktree.cc.

References event_, event_branch, event_isLoaded, beamvalidation::exit(), and index.

Referenced by tas::event(), and LoadAllBranches().

                                          {
   if (not event_isLoaded) {
     if (event_branch != 0) {
       event_branch->GetEntry(index);
     } else {
       printf("branch event_branch does not exist!\n");
       exit(1);
     }
     event_isLoaded = true;
   }
   return event_;
 }

◆ GetEntry()

void Trktree::GetEntry ( unsigned int idx )

Definition at line 2131 of file Trktree.cc.

Referenced by run_lst().

                                        {
   index = idx;
   see_stateCcov01_isLoaded = false;
   simhit_rod_isLoaded = false;
   trk_phi_isLoaded = false;
   bsp_x_isLoaded = false;
   see_stateCcov05_isLoaded = false;
   see_stateCcov04_isLoaded = false;
   trk_dxyPV_isLoaded = false;
   simhit_tof_isLoaded = false;
   sim_event_isLoaded = false;
   simhit_isStack_isLoaded = false;
   trk_dz_isLoaded = false;
   see_stateCcov03_isLoaded = false;
   sim_eta_isLoaded = false;
   simvtx_processType_isLoaded = false;
   pix_radL_isLoaded = false;
   see_stateCcov02_isLoaded = false;
   see_nGlued_isLoaded = false;
   trk_bestSimTrkIdx_isLoaded = false;
   see_stateTrajGlbPz_isLoaded = false;
   pix_yz_isLoaded = false;
   pix_yy_isLoaded = false;
   simhit_process_isLoaded = false;
   see_stateCcov34_isLoaded = false;
   trk_nInnerLost_isLoaded = false;
   see_py_isLoaded = false;
   sim_trkIdx_isLoaded = false;
   trk_nLost_isLoaded = false;
   pix_isBarrel_isLoaded = false;
   see_dxyErr_isLoaded = false;
   simhit_detId_isLoaded = false;
   simhit_subdet_isLoaded = false;
   see_hitIdx_isLoaded = false;
   see_pt_isLoaded = false;
   ph2_detId_isLoaded = false;
   trk_nStripLay_isLoaded = false;
   see_bestFromFirstHitSimTrkIdx_isLoaded = false;
   sim_pca_pt_isLoaded = false;
   see_trkIdx_isLoaded = false;
   trk_nCluster_isLoaded = false;
   trk_bestFromFirstHitSimTrkNChi2_isLoaded = false;
   trk_isHP_isLoaded = false;
   simhit_hitType_isLoaded = false;
   ph2_isUpper_isLoaded = false;
   see_nStrip_isLoaded = false;
   trk_bestSimTrkShareFracSimClusterDenom_isLoaded = false;
   simhit_side_isLoaded = false;
   simhit_x_isLoaded = false;
   see_q_isLoaded = false;
   simhit_z_isLoaded = false;
   sim_pca_lambda_isLoaded = false;
   sim_q_isLoaded = false;
   pix_bbxi_isLoaded = false;
   ph2_order_isLoaded = false;
   ph2_module_isLoaded = false;
   inv_order_isLoaded = false;
   trk_dzErr_isLoaded = false;
   trk_nInnerInactive_isLoaded = false;
   see_fitok_isLoaded = false;
   simhit_blade_isLoaded = false;
   inv_subdet_isLoaded = false;
   pix_blade_isLoaded = false;
   pix_xx_isLoaded = false;
   pix_xy_isLoaded = false;
   simhit_panel_isLoaded = false;
   sim_pz_isLoaded = false;
   trk_dxy_isLoaded = false;
   sim_px_isLoaded = false;
   trk_lambda_isLoaded = false;
   see_stateCcov12_isLoaded = false;
   sim_pt_isLoaded = false;
   sim_py_isLoaded = false;
   sim_decayVtxIdx_isLoaded = false;
   pix_detId_isLoaded = false;
   trk_eta_isLoaded = false;
   see_dxy_isLoaded = false;
   sim_isFromBHadron_isLoaded = false;
   simhit_eloss_isLoaded = false;
   see_stateCcov11_isLoaded = false;
   simhit_pz_isLoaded = false;
   sim_pdgId_isLoaded = false;
   trk_stopReason_isLoaded = false;
   sim_pca_phi_isLoaded = false;
   simhit_isLower_isLoaded = false;
   inv_ring_isLoaded = false;
   ph2_simHitIdx_isLoaded = false;
   simhit_order_isLoaded = false;
   trk_dxyClosestPV_isLoaded = false;
   pix_z_isLoaded = false;
   pix_y_isLoaded = false;
   pix_x_isLoaded = false;
   see_hitType_isLoaded = false;
   see_statePt_isLoaded = false;
   simvtx_sourceSimIdx_isLoaded = false;
   event_isLoaded = false;
   pix_module_isLoaded = false;
   ph2_side_isLoaded = false;
   trk_bestSimTrkNChi2_isLoaded = false;
   see_stateTrajPy_isLoaded = false;
   inv_type_isLoaded = false;
   bsp_z_isLoaded = false;
   bsp_y_isLoaded = false;
   simhit_py_isLoaded = false;
   see_simTrkIdx_isLoaded = false;
   see_stateTrajGlbZ_isLoaded = false;
   see_stateTrajGlbX_isLoaded = false;
   see_stateTrajGlbY_isLoaded = false;
   trk_originalAlgo_isLoaded = false;
   trk_nPixel_isLoaded = false;
   see_stateCcov14_isLoaded = false;
   see_stateCcov15_isLoaded = false;
   trk_phiErr_isLoaded = false;
   see_stateCcov13_isLoaded = false;
   pix_chargeFraction_isLoaded = false;
   trk_q_isLoaded = false;
   sim_seedIdx_isLoaded = false;
   see_dzErr_isLoaded = false;
   sim_nRecoClusters_isLoaded = false;
   run_isLoaded = false;
   ph2_xySignificance_isLoaded = false;
   trk_nChi2_isLoaded = false;
   pix_layer_isLoaded = false;
   pix_xySignificance_isLoaded = false;
   sim_pca_eta_isLoaded = false;
   see_bestSimTrkShareFrac_isLoaded = false;
   see_etaErr_isLoaded = false;
   trk_bestSimTrkShareFracSimDenom_isLoaded = false;
   bsp_sigmaz_isLoaded = false;
   bsp_sigmay_isLoaded = false;
   bsp_sigmax_isLoaded = false;
   pix_ladder_isLoaded = false;
   trk_qualityMask_isLoaded = false;
   trk_ndof_isLoaded = false;
   pix_subdet_isLoaded = false;
   ph2_seeIdx_isLoaded = false;
   inv_isUpper_isLoaded = false;
   ph2_zx_isLoaded = false;
   pix_trkIdx_isLoaded = false;
   trk_nOuterLost_isLoaded = false;
   inv_panel_isLoaded = false;
   vtx_z_isLoaded = false;
   simhit_layer_isLoaded = false;
   vtx_y_isLoaded = false;
   ph2_isBarrel_isLoaded = false;
   pix_seeIdx_isLoaded = false;
   trk_bestFromFirstHitSimTrkIdx_isLoaded = false;
   simhit_px_isLoaded = false;
   see_stateTrajX_isLoaded = false;
   see_stateTrajY_isLoaded = false;
   trk_nOuterInactive_isLoaded = false;
   sim_pca_dxy_isLoaded = false;
   trk_algo_isLoaded = false;
   trk_hitType_isLoaded = false;
   trk_bestFromFirstHitSimTrkShareFrac_isLoaded = false;
   inv_isBarrel_isLoaded = false;
   simvtx_event_isLoaded = false;
   ph2_z_isLoaded = false;
   ph2_x_isLoaded = false;
   ph2_y_isLoaded = false;
   sim_genPdgIds_isLoaded = false;
   trk_mva_isLoaded = false;
   see_stateCcov24_isLoaded = false;
   trk_dzClosestPV_isLoaded = false;
   see_nCluster_isLoaded = false;
   inv_rod_isLoaded = false;
   trk_hitIdx_isLoaded = false;
   see_stateCcov22_isLoaded = false;
   pix_simType_isLoaded = false;
   simhit_ring_isLoaded = false;
   trk_outer_px_isLoaded = false;
   trk_outer_py_isLoaded = false;
   trk_outer_pz_isLoaded = false;
   ph2_zz_isLoaded = false;
   trk_outer_pt_isLoaded = false;
   trk_n3DLay_isLoaded = false;
   trk_nValid_isLoaded = false;
   see_ptErr_isLoaded = false;
   see_stateTrajGlbPx_isLoaded = false;
   ph2_simType_isLoaded = false;
   trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_isLoaded = false;
   sim_hits_isLoaded = false;
   sim_len_isLoaded = false;
   sim_lengap_isLoaded = false;
   simvtx_x_isLoaded = false;
   trk_pz_isLoaded = false;
   see_bestFromFirstHitSimTrkShareFrac_isLoaded = false;
   trk_px_isLoaded = false;
   trk_py_isLoaded = false;
   trk_vtxIdx_isLoaded = false;
   sim_nPixel_isLoaded = false;
   vtx_chi2_isLoaded = false;
   ph2_ring_isLoaded = false;
   trk_pt_isLoaded = false;
   see_stateCcov44_isLoaded = false;
   ph2_radL_isLoaded = false;
   vtx_zErr_isLoaded = false;
   see_px_isLoaded = false;
   see_pz_isLoaded = false;
   see_eta_isLoaded = false;
   simvtx_bunchCrossing_isLoaded = false;
   sim_pca_dz_isLoaded = false;
   simvtx_y_isLoaded = false;
   inv_isStack_isLoaded = false;
   trk_nStrip_isLoaded = false;
   trk_etaErr_isLoaded = false;
   trk_simTrkNChi2_isLoaded = false;
   pix_zz_isLoaded = false;
   simhit_particle_isLoaded = false;
   see_dz_isLoaded = false;
   see_stateTrajPz_isLoaded = false;
   trk_bestSimTrkShareFrac_isLoaded = false;
   trk_lambdaErr_isLoaded = false;
   see_simTrkShareFrac_isLoaded = false;
   pix_simHitIdx_isLoaded = false;
   vtx_trkIdx_isLoaded = false;
   ph2_rod_isLoaded = false;
   vtx_ndof_isLoaded = false;
   see_nPixel_isLoaded = false;
   sim_nStrip_isLoaded = false;
   sim_bunchCrossing_isLoaded = false;
   see_stateCcov45_isLoaded = false;
   ph2_isStack_isLoaded = false;
   sim_trkShareFrac_isLoaded = false;
   trk_simTrkShareFrac_isLoaded = false;
   sim_phi_isLoaded = false;
   inv_side_isLoaded = false;
   vtx_fake_isLoaded = false;
   trk_nInactive_isLoaded = false;
   trk_nPixelLay_isLoaded = false;
   ph2_bbxi_isLoaded = false;
   vtx_xErr_isLoaded = false;
   see_stateCcov25_isLoaded = false;
   sim_parentVtxIdx_isLoaded = false;
   see_stateCcov23_isLoaded = false;
   trk_algoMask_isLoaded = false;
   trk_simTrkIdx_isLoaded = false;
   see_phiErr_isLoaded = false;
   trk_cotTheta_isLoaded = false;
   see_algo_isLoaded = false;
   simhit_module_isLoaded = false;
   simvtx_daughterSimIdx_isLoaded = false;
   vtx_x_isLoaded = false;
   trk_seedIdx_isLoaded = false;
   simhit_y_isLoaded = false;
   inv_layer_isLoaded = false;
   trk_nLostLay_isLoaded = false;
   ph2_isLower_isLoaded = false;
   pix_side_isLoaded = false;
   inv_isLower_isLoaded = false;
   ph2_trkIdx_isLoaded = false;
   sim_nValid_isLoaded = false;
   simhit_simTrkIdx_isLoaded = false;
   see_nCands_isLoaded = false;
   see_bestSimTrkIdx_isLoaded = false;
   vtx_yErr_isLoaded = false;
   trk_dzPV_isLoaded = false;
   ph2_xy_isLoaded = false;
   inv_module_isLoaded = false;
   see_stateCcov55_isLoaded = false;
   pix_panel_isLoaded = false;
   inv_ladder_isLoaded = false;
   ph2_xx_isLoaded = false;
   sim_pca_cotTheta_isLoaded = false;
   simpv_idx_isLoaded = false;
   trk_inner_pz_isLoaded = false;
   see_chi2_isLoaded = false;
   see_stateCcov35_isLoaded = false;
   see_stateCcov33_isLoaded = false;
   inv_detId_isLoaded = false;
   see_offset_isLoaded = false;
   sim_nLay_isLoaded = false;
   sim_simHitIdx_isLoaded = false;
   simhit_isUpper_isLoaded = false;
   see_stateCcov00_isLoaded = false;
   see_stopReason_isLoaded = false;
   vtx_valid_isLoaded = false;
   lumi_isLoaded = false;
   trk_refpoint_x_isLoaded = false;
   trk_refpoint_y_isLoaded = false;
   trk_refpoint_z_isLoaded = false;
   sim_n3DLay_isLoaded = false;
   see_nPhase2OT_isLoaded = false;
   trk_bestFromFirstHitSimTrkShareFracSimDenom_isLoaded = false;
   ph2_yy_isLoaded = false;
   ph2_yz_isLoaded = false;
   inv_blade_isLoaded = false;
   trk_ptErr_isLoaded = false;
   pix_zx_isLoaded = false;
   simvtx_z_isLoaded = false;
   sim_nTrackerHits_isLoaded = false;
   ph2_subdet_isLoaded = false;
   see_stateTrajPx_isLoaded = false;
   simhit_hitIdx_isLoaded = false;
   simhit_ladder_isLoaded = false;
   ph2_layer_isLoaded = false;
   see_phi_isLoaded = false;
   trk_nChi2_1Dmod_isLoaded = false;
   trk_inner_py_isLoaded = false;
   trk_inner_px_isLoaded = false;
   trk_dxyErr_isLoaded = false;
   sim_nPixelLay_isLoaded = false;
   see_nValid_isLoaded = false;
   trk_inner_pt_isLoaded = false;
   see_stateTrajGlbPy_isLoaded = false;
 }

◆ Init()

void Trktree::Init ( TTree * tree )

Definition at line 4 of file Trktree.cc.

Referenced by run_lst().

                               {
   tree->SetMakeClass(1);
   see_stateCcov01_branch = 0;
   if (tree->GetBranch("see_stateCcov01") != 0) {
     see_stateCcov01_branch = tree->GetBranch("see_stateCcov01");
     if (see_stateCcov01_branch) {
       see_stateCcov01_branch->SetAddress(&see_stateCcov01_);
     }
   }
   simhit_rod_branch = 0;
   if (tree->GetBranch("simhit_rod") != 0) {
     simhit_rod_branch = tree->GetBranch("simhit_rod");
     if (simhit_rod_branch) {
       simhit_rod_branch->SetAddress(&simhit_rod_);
     }
   }
   trk_phi_branch = 0;
   if (tree->GetBranch("trk_phi") != 0) {
     trk_phi_branch = tree->GetBranch("trk_phi");
     if (trk_phi_branch) {
       trk_phi_branch->SetAddress(&trk_phi_);
     }
   }
   bsp_x_branch = 0;
   if (tree->GetBranch("bsp_x") != 0) {
     bsp_x_branch = tree->GetBranch("bsp_x");
     if (bsp_x_branch) {
       bsp_x_branch->SetAddress(&bsp_x_);
     }
   }
   see_stateCcov05_branch = 0;
   if (tree->GetBranch("see_stateCcov05") != 0) {
     see_stateCcov05_branch = tree->GetBranch("see_stateCcov05");
     if (see_stateCcov05_branch) {
       see_stateCcov05_branch->SetAddress(&see_stateCcov05_);
     }
   }
   see_stateCcov04_branch = 0;
   if (tree->GetBranch("see_stateCcov04") != 0) {
     see_stateCcov04_branch = tree->GetBranch("see_stateCcov04");
     if (see_stateCcov04_branch) {
       see_stateCcov04_branch->SetAddress(&see_stateCcov04_);
     }
   }
   trk_dxyPV_branch = 0;
   if (tree->GetBranch("trk_dxyPV") != 0) {
     trk_dxyPV_branch = tree->GetBranch("trk_dxyPV");
     if (trk_dxyPV_branch) {
       trk_dxyPV_branch->SetAddress(&trk_dxyPV_);
     }
   }
   simhit_tof_branch = 0;
   if (tree->GetBranch("simhit_tof") != 0) {
     simhit_tof_branch = tree->GetBranch("simhit_tof");
     if (simhit_tof_branch) {
       simhit_tof_branch->SetAddress(&simhit_tof_);
     }
   }
   sim_event_branch = 0;
   if (tree->GetBranch("sim_event") != 0) {
     sim_event_branch = tree->GetBranch("sim_event");
     if (sim_event_branch) {
       sim_event_branch->SetAddress(&sim_event_);
     }
   }
   simhit_isStack_branch = 0;
   if (tree->GetBranch("simhit_isStack") != 0) {
     simhit_isStack_branch = tree->GetBranch("simhit_isStack");
     if (simhit_isStack_branch) {
       simhit_isStack_branch->SetAddress(&simhit_isStack_);
     }
   }
   trk_dz_branch = 0;
   if (tree->GetBranch("trk_dz") != 0) {
     trk_dz_branch = tree->GetBranch("trk_dz");
     if (trk_dz_branch) {
       trk_dz_branch->SetAddress(&trk_dz_);
     }
   }
   see_stateCcov03_branch = 0;
   if (tree->GetBranch("see_stateCcov03") != 0) {
     see_stateCcov03_branch = tree->GetBranch("see_stateCcov03");
     if (see_stateCcov03_branch) {
       see_stateCcov03_branch->SetAddress(&see_stateCcov03_);
     }
   }
   sim_eta_branch = 0;
   if (tree->GetBranch("sim_eta") != 0) {
     sim_eta_branch = tree->GetBranch("sim_eta");
     if (sim_eta_branch) {
       sim_eta_branch->SetAddress(&sim_eta_);
     }
   }
   simvtx_processType_branch = 0;
   if (tree->GetBranch("simvtx_processType") != 0) {
     simvtx_processType_branch = tree->GetBranch("simvtx_processType");
     if (simvtx_processType_branch) {
       simvtx_processType_branch->SetAddress(&simvtx_processType_);
     }
   }
   pix_radL_branch = 0;
   if (tree->GetBranch("pix_radL") != 0) {
     pix_radL_branch = tree->GetBranch("pix_radL");
     if (pix_radL_branch) {
       pix_radL_branch->SetAddress(&pix_radL_);
     }
   }
   see_stateCcov02_branch = 0;
   if (tree->GetBranch("see_stateCcov02") != 0) {
     see_stateCcov02_branch = tree->GetBranch("see_stateCcov02");
     if (see_stateCcov02_branch) {
       see_stateCcov02_branch->SetAddress(&see_stateCcov02_);
     }
   }
   see_nGlued_branch = 0;
   if (tree->GetBranch("see_nGlued") != 0) {
     see_nGlued_branch = tree->GetBranch("see_nGlued");
     if (see_nGlued_branch) {
       see_nGlued_branch->SetAddress(&see_nGlued_);
     }
   }
   trk_bestSimTrkIdx_branch = 0;
   if (tree->GetBranch("trk_bestSimTrkIdx") != 0) {
     trk_bestSimTrkIdx_branch = tree->GetBranch("trk_bestSimTrkIdx");
     if (trk_bestSimTrkIdx_branch) {
       trk_bestSimTrkIdx_branch->SetAddress(&trk_bestSimTrkIdx_);
     }
   }
   see_stateTrajGlbPz_branch = 0;
   if (tree->GetBranch("see_stateTrajGlbPz") != 0) {
     see_stateTrajGlbPz_branch = tree->GetBranch("see_stateTrajGlbPz");
     if (see_stateTrajGlbPz_branch) {
       see_stateTrajGlbPz_branch->SetAddress(&see_stateTrajGlbPz_);
     }
   }
   pix_yz_branch = 0;
   if (tree->GetBranch("pix_yz") != 0) {
     pix_yz_branch = tree->GetBranch("pix_yz");
     if (pix_yz_branch) {
       pix_yz_branch->SetAddress(&pix_yz_);
     }
   }
   pix_yy_branch = 0;
   if (tree->GetBranch("pix_yy") != 0) {
     pix_yy_branch = tree->GetBranch("pix_yy");
     if (pix_yy_branch) {
       pix_yy_branch->SetAddress(&pix_yy_);
     }
   }
   simhit_process_branch = 0;
   if (tree->GetBranch("simhit_process") != 0) {
     simhit_process_branch = tree->GetBranch("simhit_process");
     if (simhit_process_branch) {
       simhit_process_branch->SetAddress(&simhit_process_);
     }
   }
   see_stateCcov34_branch = 0;
   if (tree->GetBranch("see_stateCcov34") != 0) {
     see_stateCcov34_branch = tree->GetBranch("see_stateCcov34");
     if (see_stateCcov34_branch) {
       see_stateCcov34_branch->SetAddress(&see_stateCcov34_);
     }
   }
   trk_nInnerLost_branch = 0;
   if (tree->GetBranch("trk_nInnerLost") != 0) {
     trk_nInnerLost_branch = tree->GetBranch("trk_nInnerLost");
     if (trk_nInnerLost_branch) {
       trk_nInnerLost_branch->SetAddress(&trk_nInnerLost_);
     }
   }
   see_py_branch = 0;
   if (tree->GetBranch("see_py") != 0) {
     see_py_branch = tree->GetBranch("see_py");
     if (see_py_branch) {
       see_py_branch->SetAddress(&see_py_);
     }
   }
   sim_trkIdx_branch = 0;
   if (tree->GetBranch("sim_trkIdx") != 0) {
     sim_trkIdx_branch = tree->GetBranch("sim_trkIdx");
     if (sim_trkIdx_branch) {
       sim_trkIdx_branch->SetAddress(&sim_trkIdx_);
     }
   }
   trk_nLost_branch = 0;
   if (tree->GetBranch("trk_nLost") != 0) {
     trk_nLost_branch = tree->GetBranch("trk_nLost");
     if (trk_nLost_branch) {
       trk_nLost_branch->SetAddress(&trk_nLost_);
     }
   }
   pix_isBarrel_branch = 0;
   if (tree->GetBranch("pix_isBarrel") != 0) {
     pix_isBarrel_branch = tree->GetBranch("pix_isBarrel");
     if (pix_isBarrel_branch) {
       pix_isBarrel_branch->SetAddress(&pix_isBarrel_);
     }
   }
   see_dxyErr_branch = 0;
   if (tree->GetBranch("see_dxyErr") != 0) {
     see_dxyErr_branch = tree->GetBranch("see_dxyErr");
     if (see_dxyErr_branch) {
       see_dxyErr_branch->SetAddress(&see_dxyErr_);
     }
   }
   simhit_detId_branch = 0;
   if (tree->GetBranch("simhit_detId") != 0) {
     simhit_detId_branch = tree->GetBranch("simhit_detId");
     if (simhit_detId_branch) {
       simhit_detId_branch->SetAddress(&simhit_detId_);
     }
   }
   simhit_subdet_branch = 0;
   if (tree->GetBranch("simhit_subdet") != 0) {
     simhit_subdet_branch = tree->GetBranch("simhit_subdet");
     if (simhit_subdet_branch) {
       simhit_subdet_branch->SetAddress(&simhit_subdet_);
     }
   }
   see_hitIdx_branch = 0;
   if (tree->GetBranch("see_hitIdx") != 0) {
     see_hitIdx_branch = tree->GetBranch("see_hitIdx");
     if (see_hitIdx_branch) {
       see_hitIdx_branch->SetAddress(&see_hitIdx_);
     }
   }
   see_pt_branch = 0;
   if (tree->GetBranch("see_pt") != 0) {
     see_pt_branch = tree->GetBranch("see_pt");
     if (see_pt_branch) {
       see_pt_branch->SetAddress(&see_pt_);
     }
   }
   ph2_detId_branch = 0;
   if (tree->GetBranch("ph2_detId") != 0) {
     ph2_detId_branch = tree->GetBranch("ph2_detId");
     if (ph2_detId_branch) {
       ph2_detId_branch->SetAddress(&ph2_detId_);
     }
   }
   trk_nStripLay_branch = 0;
   if (tree->GetBranch("trk_nStripLay") != 0) {
     trk_nStripLay_branch = tree->GetBranch("trk_nStripLay");
     if (trk_nStripLay_branch) {
       trk_nStripLay_branch->SetAddress(&trk_nStripLay_);
     }
   }
   see_bestFromFirstHitSimTrkIdx_branch = 0;
   if (tree->GetBranch("see_bestFromFirstHitSimTrkIdx") != 0) {
     see_bestFromFirstHitSimTrkIdx_branch = tree->GetBranch("see_bestFromFirstHitSimTrkIdx");
     if (see_bestFromFirstHitSimTrkIdx_branch) {
       see_bestFromFirstHitSimTrkIdx_branch->SetAddress(&see_bestFromFirstHitSimTrkIdx_);
     }
   }
   sim_pca_pt_branch = 0;
   if (tree->GetBranch("sim_pca_pt") != 0) {
     sim_pca_pt_branch = tree->GetBranch("sim_pca_pt");
     if (sim_pca_pt_branch) {
       sim_pca_pt_branch->SetAddress(&sim_pca_pt_);
     }
   }
   see_trkIdx_branch = 0;
   if (tree->GetBranch("see_trkIdx") != 0) {
     see_trkIdx_branch = tree->GetBranch("see_trkIdx");
     if (see_trkIdx_branch) {
       see_trkIdx_branch->SetAddress(&see_trkIdx_);
     }
   }
   trk_nCluster_branch = 0;
   if (tree->GetBranch("trk_nCluster") != 0) {
     trk_nCluster_branch = tree->GetBranch("trk_nCluster");
     if (trk_nCluster_branch) {
       trk_nCluster_branch->SetAddress(&trk_nCluster_);
     }
   }
   trk_bestFromFirstHitSimTrkNChi2_branch = 0;
   if (tree->GetBranch("trk_bestFromFirstHitSimTrkNChi2") != 0) {
     trk_bestFromFirstHitSimTrkNChi2_branch = tree->GetBranch("trk_bestFromFirstHitSimTrkNChi2");
     if (trk_bestFromFirstHitSimTrkNChi2_branch) {
       trk_bestFromFirstHitSimTrkNChi2_branch->SetAddress(&trk_bestFromFirstHitSimTrkNChi2_);
     }
   }
   trk_isHP_branch = 0;
   if (tree->GetBranch("trk_isHP") != 0) {
     trk_isHP_branch = tree->GetBranch("trk_isHP");
     if (trk_isHP_branch) {
       trk_isHP_branch->SetAddress(&trk_isHP_);
     }
   }
   simhit_hitType_branch = 0;
   if (tree->GetBranch("simhit_hitType") != 0) {
     simhit_hitType_branch = tree->GetBranch("simhit_hitType");
     if (simhit_hitType_branch) {
       simhit_hitType_branch->SetAddress(&simhit_hitType_);
     }
   }
   ph2_isUpper_branch = 0;
   if (tree->GetBranch("ph2_isUpper") != 0) {
     ph2_isUpper_branch = tree->GetBranch("ph2_isUpper");
     if (ph2_isUpper_branch) {
       ph2_isUpper_branch->SetAddress(&ph2_isUpper_);
     }
   }
   see_nStrip_branch = 0;
   if (tree->GetBranch("see_nStrip") != 0) {
     see_nStrip_branch = tree->GetBranch("see_nStrip");
     if (see_nStrip_branch) {
       see_nStrip_branch->SetAddress(&see_nStrip_);
     }
   }
   trk_bestSimTrkShareFracSimClusterDenom_branch = 0;
   if (tree->GetBranch("trk_bestSimTrkShareFracSimClusterDenom") != 0) {
     trk_bestSimTrkShareFracSimClusterDenom_branch = tree->GetBranch("trk_bestSimTrkShareFracSimClusterDenom");
     if (trk_bestSimTrkShareFracSimClusterDenom_branch) {
       trk_bestSimTrkShareFracSimClusterDenom_branch->SetAddress(&trk_bestSimTrkShareFracSimClusterDenom_);
     }
   }
   simhit_side_branch = 0;
   if (tree->GetBranch("simhit_side") != 0) {
     simhit_side_branch = tree->GetBranch("simhit_side");
     if (simhit_side_branch) {
       simhit_side_branch->SetAddress(&simhit_side_);
     }
   }
   simhit_x_branch = 0;
   if (tree->GetBranch("simhit_x") != 0) {
     simhit_x_branch = tree->GetBranch("simhit_x");
     if (simhit_x_branch) {
       simhit_x_branch->SetAddress(&simhit_x_);
     }
   }
   see_q_branch = 0;
   if (tree->GetBranch("see_q") != 0) {
     see_q_branch = tree->GetBranch("see_q");
     if (see_q_branch) {
       see_q_branch->SetAddress(&see_q_);
     }
   }
   simhit_z_branch = 0;
   if (tree->GetBranch("simhit_z") != 0) {
     simhit_z_branch = tree->GetBranch("simhit_z");
     if (simhit_z_branch) {
       simhit_z_branch->SetAddress(&simhit_z_);
     }
   }
   sim_pca_lambda_branch = 0;
   if (tree->GetBranch("sim_pca_lambda") != 0) {
     sim_pca_lambda_branch = tree->GetBranch("sim_pca_lambda");
     if (sim_pca_lambda_branch) {
       sim_pca_lambda_branch->SetAddress(&sim_pca_lambda_);
     }
   }
   sim_q_branch = 0;
   if (tree->GetBranch("sim_q") != 0) {
     sim_q_branch = tree->GetBranch("sim_q");
     if (sim_q_branch) {
       sim_q_branch->SetAddress(&sim_q_);
     }
   }
   pix_bbxi_branch = 0;
   if (tree->GetBranch("pix_bbxi") != 0) {
     pix_bbxi_branch = tree->GetBranch("pix_bbxi");
     if (pix_bbxi_branch) {
       pix_bbxi_branch->SetAddress(&pix_bbxi_);
     }
   }
   ph2_order_branch = 0;
   if (tree->GetBranch("ph2_order") != 0) {
     ph2_order_branch = tree->GetBranch("ph2_order");
     if (ph2_order_branch) {
       ph2_order_branch->SetAddress(&ph2_order_);
     }
   }
   ph2_module_branch = 0;
   if (tree->GetBranch("ph2_module") != 0) {
     ph2_module_branch = tree->GetBranch("ph2_module");
     if (ph2_module_branch) {
       ph2_module_branch->SetAddress(&ph2_module_);
     }
   }
   inv_order_branch = 0;
   if (tree->GetBranch("inv_order") != 0) {
     inv_order_branch = tree->GetBranch("inv_order");
     if (inv_order_branch) {
       inv_order_branch->SetAddress(&inv_order_);
     }
   }
   trk_dzErr_branch = 0;
   if (tree->GetBranch("trk_dzErr") != 0) {
     trk_dzErr_branch = tree->GetBranch("trk_dzErr");
     if (trk_dzErr_branch) {
       trk_dzErr_branch->SetAddress(&trk_dzErr_);
     }
   }
   trk_nInnerInactive_branch = 0;
   if (tree->GetBranch("trk_nInnerInactive") != 0) {
     trk_nInnerInactive_branch = tree->GetBranch("trk_nInnerInactive");
     if (trk_nInnerInactive_branch) {
       trk_nInnerInactive_branch->SetAddress(&trk_nInnerInactive_);
     }
   }
   see_fitok_branch = 0;
   if (tree->GetBranch("see_fitok") != 0) {
     see_fitok_branch = tree->GetBranch("see_fitok");
     if (see_fitok_branch) {
       see_fitok_branch->SetAddress(&see_fitok_);
     }
   }
   simhit_blade_branch = 0;
   if (tree->GetBranch("simhit_blade") != 0) {
     simhit_blade_branch = tree->GetBranch("simhit_blade");
     if (simhit_blade_branch) {
       simhit_blade_branch->SetAddress(&simhit_blade_);
     }
   }
   inv_subdet_branch = 0;
   if (tree->GetBranch("inv_subdet") != 0) {
     inv_subdet_branch = tree->GetBranch("inv_subdet");
     if (inv_subdet_branch) {
       inv_subdet_branch->SetAddress(&inv_subdet_);
     }
   }
   pix_blade_branch = 0;
   if (tree->GetBranch("pix_blade") != 0) {
     pix_blade_branch = tree->GetBranch("pix_blade");
     if (pix_blade_branch) {
       pix_blade_branch->SetAddress(&pix_blade_);
     }
   }
   pix_xx_branch = 0;
   if (tree->GetBranch("pix_xx") != 0) {
     pix_xx_branch = tree->GetBranch("pix_xx");
     if (pix_xx_branch) {
       pix_xx_branch->SetAddress(&pix_xx_);
     }
   }
   pix_xy_branch = 0;
   if (tree->GetBranch("pix_xy") != 0) {
     pix_xy_branch = tree->GetBranch("pix_xy");
     if (pix_xy_branch) {
       pix_xy_branch->SetAddress(&pix_xy_);
     }
   }
   simhit_panel_branch = 0;
   if (tree->GetBranch("simhit_panel") != 0) {
     simhit_panel_branch = tree->GetBranch("simhit_panel");
     if (simhit_panel_branch) {
       simhit_panel_branch->SetAddress(&simhit_panel_);
     }
   }
   sim_pz_branch = 0;
   if (tree->GetBranch("sim_pz") != 0) {
     sim_pz_branch = tree->GetBranch("sim_pz");
     if (sim_pz_branch) {
       sim_pz_branch->SetAddress(&sim_pz_);
     }
   }
   trk_dxy_branch = 0;
   if (tree->GetBranch("trk_dxy") != 0) {
     trk_dxy_branch = tree->GetBranch("trk_dxy");
     if (trk_dxy_branch) {
       trk_dxy_branch->SetAddress(&trk_dxy_);
     }
   }
   sim_px_branch = 0;
   if (tree->GetBranch("sim_px") != 0) {
     sim_px_branch = tree->GetBranch("sim_px");
     if (sim_px_branch) {
       sim_px_branch->SetAddress(&sim_px_);
     }
   }
   trk_lambda_branch = 0;
   if (tree->GetBranch("trk_lambda") != 0) {
     trk_lambda_branch = tree->GetBranch("trk_lambda");
     if (trk_lambda_branch) {
       trk_lambda_branch->SetAddress(&trk_lambda_);
     }
   }
   see_stateCcov12_branch = 0;
   if (tree->GetBranch("see_stateCcov12") != 0) {
     see_stateCcov12_branch = tree->GetBranch("see_stateCcov12");
     if (see_stateCcov12_branch) {
       see_stateCcov12_branch->SetAddress(&see_stateCcov12_);
     }
   }
   sim_pt_branch = 0;
   if (tree->GetBranch("sim_pt") != 0) {
     sim_pt_branch = tree->GetBranch("sim_pt");
     if (sim_pt_branch) {
       sim_pt_branch->SetAddress(&sim_pt_);
     }
   }
   sim_py_branch = 0;
   if (tree->GetBranch("sim_py") != 0) {
     sim_py_branch = tree->GetBranch("sim_py");
     if (sim_py_branch) {
       sim_py_branch->SetAddress(&sim_py_);
     }
   }
   sim_decayVtxIdx_branch = 0;
   if (tree->GetBranch("sim_decayVtxIdx") != 0) {
     sim_decayVtxIdx_branch = tree->GetBranch("sim_decayVtxIdx");
     if (sim_decayVtxIdx_branch) {
       sim_decayVtxIdx_branch->SetAddress(&sim_decayVtxIdx_);
     }
   }
   pix_detId_branch = 0;
   if (tree->GetBranch("pix_detId") != 0) {
     pix_detId_branch = tree->GetBranch("pix_detId");
     if (pix_detId_branch) {
       pix_detId_branch->SetAddress(&pix_detId_);
     }
   }
   trk_eta_branch = 0;
   if (tree->GetBranch("trk_eta") != 0) {
     trk_eta_branch = tree->GetBranch("trk_eta");
     if (trk_eta_branch) {
       trk_eta_branch->SetAddress(&trk_eta_);
     }
   }
   see_dxy_branch = 0;
   if (tree->GetBranch("see_dxy") != 0) {
     see_dxy_branch = tree->GetBranch("see_dxy");
     if (see_dxy_branch) {
       see_dxy_branch->SetAddress(&see_dxy_);
     }
   }
   sim_isFromBHadron_branch = 0;
   if (tree->GetBranch("sim_isFromBHadron") != 0) {
     sim_isFromBHadron_branch = tree->GetBranch("sim_isFromBHadron");
     if (sim_isFromBHadron_branch) {
       sim_isFromBHadron_branch->SetAddress(&sim_isFromBHadron_);
     }
   }
   simhit_eloss_branch = 0;
   if (tree->GetBranch("simhit_eloss") != 0) {
     simhit_eloss_branch = tree->GetBranch("simhit_eloss");
     if (simhit_eloss_branch) {
       simhit_eloss_branch->SetAddress(&simhit_eloss_);
     }
   }
   see_stateCcov11_branch = 0;
   if (tree->GetBranch("see_stateCcov11") != 0) {
     see_stateCcov11_branch = tree->GetBranch("see_stateCcov11");
     if (see_stateCcov11_branch) {
       see_stateCcov11_branch->SetAddress(&see_stateCcov11_);
     }
   }
   simhit_pz_branch = 0;
   if (tree->GetBranch("simhit_pz") != 0) {
     simhit_pz_branch = tree->GetBranch("simhit_pz");
     if (simhit_pz_branch) {
       simhit_pz_branch->SetAddress(&simhit_pz_);
     }
   }
   sim_pdgId_branch = 0;
   if (tree->GetBranch("sim_pdgId") != 0) {
     sim_pdgId_branch = tree->GetBranch("sim_pdgId");
     if (sim_pdgId_branch) {
       sim_pdgId_branch->SetAddress(&sim_pdgId_);
     }
   }
   trk_stopReason_branch = 0;
   if (tree->GetBranch("trk_stopReason") != 0) {
     trk_stopReason_branch = tree->GetBranch("trk_stopReason");
     if (trk_stopReason_branch) {
       trk_stopReason_branch->SetAddress(&trk_stopReason_);
     }
   }
   sim_pca_phi_branch = 0;
   if (tree->GetBranch("sim_pca_phi") != 0) {
     sim_pca_phi_branch = tree->GetBranch("sim_pca_phi");
     if (sim_pca_phi_branch) {
       sim_pca_phi_branch->SetAddress(&sim_pca_phi_);
     }
   }
   simhit_isLower_branch = 0;
   if (tree->GetBranch("simhit_isLower") != 0) {
     simhit_isLower_branch = tree->GetBranch("simhit_isLower");
     if (simhit_isLower_branch) {
       simhit_isLower_branch->SetAddress(&simhit_isLower_);
     }
   }
   inv_ring_branch = 0;
   if (tree->GetBranch("inv_ring") != 0) {
     inv_ring_branch = tree->GetBranch("inv_ring");
     if (inv_ring_branch) {
       inv_ring_branch->SetAddress(&inv_ring_);
     }
   }
   ph2_simHitIdx_branch = 0;
   if (tree->GetBranch("ph2_simHitIdx") != 0) {
     ph2_simHitIdx_branch = tree->GetBranch("ph2_simHitIdx");
     if (ph2_simHitIdx_branch) {
       ph2_simHitIdx_branch->SetAddress(&ph2_simHitIdx_);
     }
   }
   simhit_order_branch = 0;
   if (tree->GetBranch("simhit_order") != 0) {
     simhit_order_branch = tree->GetBranch("simhit_order");
     if (simhit_order_branch) {
       simhit_order_branch->SetAddress(&simhit_order_);
     }
   }
   trk_dxyClosestPV_branch = 0;
   if (tree->GetBranch("trk_dxyClosestPV") != 0) {
     trk_dxyClosestPV_branch = tree->GetBranch("trk_dxyClosestPV");
     if (trk_dxyClosestPV_branch) {
       trk_dxyClosestPV_branch->SetAddress(&trk_dxyClosestPV_);
     }
   }
   pix_z_branch = 0;
   if (tree->GetBranch("pix_z") != 0) {
     pix_z_branch = tree->GetBranch("pix_z");
     if (pix_z_branch) {
       pix_z_branch->SetAddress(&pix_z_);
     }
   }
   pix_y_branch = 0;
   if (tree->GetBranch("pix_y") != 0) {
     pix_y_branch = tree->GetBranch("pix_y");
     if (pix_y_branch) {
       pix_y_branch->SetAddress(&pix_y_);
     }
   }
   pix_x_branch = 0;
   if (tree->GetBranch("pix_x") != 0) {
     pix_x_branch = tree->GetBranch("pix_x");
     if (pix_x_branch) {
       pix_x_branch->SetAddress(&pix_x_);
     }
   }
   see_hitType_branch = 0;
   if (tree->GetBranch("see_hitType") != 0) {
     see_hitType_branch = tree->GetBranch("see_hitType");
     if (see_hitType_branch) {
       see_hitType_branch->SetAddress(&see_hitType_);
     }
   }
   see_statePt_branch = 0;
   if (tree->GetBranch("see_statePt") != 0) {
     see_statePt_branch = tree->GetBranch("see_statePt");
     if (see_statePt_branch) {
       see_statePt_branch->SetAddress(&see_statePt_);
     }
   }
   simvtx_sourceSimIdx_branch = 0;
   if (tree->GetBranch("simvtx_sourceSimIdx") != 0) {
     simvtx_sourceSimIdx_branch = tree->GetBranch("simvtx_sourceSimIdx");
     if (simvtx_sourceSimIdx_branch) {
       simvtx_sourceSimIdx_branch->SetAddress(&simvtx_sourceSimIdx_);
     }
   }
   event_branch = 0;
   if (tree->GetBranch("event") != 0) {
     event_branch = tree->GetBranch("event");
     if (event_branch) {
       event_branch->SetAddress(&event_);
     }
   }
   pix_module_branch = 0;
   if (tree->GetBranch("pix_module") != 0) {
     pix_module_branch = tree->GetBranch("pix_module");
     if (pix_module_branch) {
       pix_module_branch->SetAddress(&pix_module_);
     }
   }
   ph2_side_branch = 0;
   if (tree->GetBranch("ph2_side") != 0) {
     ph2_side_branch = tree->GetBranch("ph2_side");
     if (ph2_side_branch) {
       ph2_side_branch->SetAddress(&ph2_side_);
     }
   }
   trk_bestSimTrkNChi2_branch = 0;
   if (tree->GetBranch("trk_bestSimTrkNChi2") != 0) {
     trk_bestSimTrkNChi2_branch = tree->GetBranch("trk_bestSimTrkNChi2");
     if (trk_bestSimTrkNChi2_branch) {
       trk_bestSimTrkNChi2_branch->SetAddress(&trk_bestSimTrkNChi2_);
     }
   }
   see_stateTrajPy_branch = 0;
   if (tree->GetBranch("see_stateTrajPy") != 0) {
     see_stateTrajPy_branch = tree->GetBranch("see_stateTrajPy");
     if (see_stateTrajPy_branch) {
       see_stateTrajPy_branch->SetAddress(&see_stateTrajPy_);
     }
   }
   inv_type_branch = 0;
   if (tree->GetBranch("inv_type") != 0) {
     inv_type_branch = tree->GetBranch("inv_type");
     if (inv_type_branch) {
       inv_type_branch->SetAddress(&inv_type_);
     }
   }
   bsp_z_branch = 0;
   if (tree->GetBranch("bsp_z") != 0) {
     bsp_z_branch = tree->GetBranch("bsp_z");
     if (bsp_z_branch) {
       bsp_z_branch->SetAddress(&bsp_z_);
     }
   }
   bsp_y_branch = 0;
   if (tree->GetBranch("bsp_y") != 0) {
     bsp_y_branch = tree->GetBranch("bsp_y");
     if (bsp_y_branch) {
       bsp_y_branch->SetAddress(&bsp_y_);
     }
   }
   simhit_py_branch = 0;
   if (tree->GetBranch("simhit_py") != 0) {
     simhit_py_branch = tree->GetBranch("simhit_py");
     if (simhit_py_branch) {
       simhit_py_branch->SetAddress(&simhit_py_);
     }
   }
   see_simTrkIdx_branch = 0;
   if (tree->GetBranch("see_simTrkIdx") != 0) {
     see_simTrkIdx_branch = tree->GetBranch("see_simTrkIdx");
     if (see_simTrkIdx_branch) {
       see_simTrkIdx_branch->SetAddress(&see_simTrkIdx_);
     }
   }
   see_stateTrajGlbZ_branch = 0;
   if (tree->GetBranch("see_stateTrajGlbZ") != 0) {
     see_stateTrajGlbZ_branch = tree->GetBranch("see_stateTrajGlbZ");
     if (see_stateTrajGlbZ_branch) {
       see_stateTrajGlbZ_branch->SetAddress(&see_stateTrajGlbZ_);
     }
   }
   see_stateTrajGlbX_branch = 0;
   if (tree->GetBranch("see_stateTrajGlbX") != 0) {
     see_stateTrajGlbX_branch = tree->GetBranch("see_stateTrajGlbX");
     if (see_stateTrajGlbX_branch) {
       see_stateTrajGlbX_branch->SetAddress(&see_stateTrajGlbX_);
     }
   }
   see_stateTrajGlbY_branch = 0;
   if (tree->GetBranch("see_stateTrajGlbY") != 0) {
     see_stateTrajGlbY_branch = tree->GetBranch("see_stateTrajGlbY");
     if (see_stateTrajGlbY_branch) {
       see_stateTrajGlbY_branch->SetAddress(&see_stateTrajGlbY_);
     }
   }
   trk_originalAlgo_branch = 0;
   if (tree->GetBranch("trk_originalAlgo") != 0) {
     trk_originalAlgo_branch = tree->GetBranch("trk_originalAlgo");
     if (trk_originalAlgo_branch) {
       trk_originalAlgo_branch->SetAddress(&trk_originalAlgo_);
     }
   }
   trk_nPixel_branch = 0;
   if (tree->GetBranch("trk_nPixel") != 0) {
     trk_nPixel_branch = tree->GetBranch("trk_nPixel");
     if (trk_nPixel_branch) {
       trk_nPixel_branch->SetAddress(&trk_nPixel_);
     }
   }
   see_stateCcov14_branch = 0;
   if (tree->GetBranch("see_stateCcov14") != 0) {
     see_stateCcov14_branch = tree->GetBranch("see_stateCcov14");
     if (see_stateCcov14_branch) {
       see_stateCcov14_branch->SetAddress(&see_stateCcov14_);
     }
   }
   see_stateCcov15_branch = 0;
   if (tree->GetBranch("see_stateCcov15") != 0) {
     see_stateCcov15_branch = tree->GetBranch("see_stateCcov15");
     if (see_stateCcov15_branch) {
       see_stateCcov15_branch->SetAddress(&see_stateCcov15_);
     }
   }
   trk_phiErr_branch = 0;
   if (tree->GetBranch("trk_phiErr") != 0) {
     trk_phiErr_branch = tree->GetBranch("trk_phiErr");
     if (trk_phiErr_branch) {
       trk_phiErr_branch->SetAddress(&trk_phiErr_);
     }
   }
   see_stateCcov13_branch = 0;
   if (tree->GetBranch("see_stateCcov13") != 0) {
     see_stateCcov13_branch = tree->GetBranch("see_stateCcov13");
     if (see_stateCcov13_branch) {
       see_stateCcov13_branch->SetAddress(&see_stateCcov13_);
     }
   }
   pix_chargeFraction_branch = 0;
   if (tree->GetBranch("pix_chargeFraction") != 0) {
     pix_chargeFraction_branch = tree->GetBranch("pix_chargeFraction");
     if (pix_chargeFraction_branch) {
       pix_chargeFraction_branch->SetAddress(&pix_chargeFraction_);
     }
   }
   trk_q_branch = 0;
   if (tree->GetBranch("trk_q") != 0) {
     trk_q_branch = tree->GetBranch("trk_q");
     if (trk_q_branch) {
       trk_q_branch->SetAddress(&trk_q_);
     }
   }
   sim_seedIdx_branch = 0;
   if (tree->GetBranch("sim_seedIdx") != 0) {
     sim_seedIdx_branch = tree->GetBranch("sim_seedIdx");
     if (sim_seedIdx_branch) {
       sim_seedIdx_branch->SetAddress(&sim_seedIdx_);
     }
   }
   see_dzErr_branch = 0;
   if (tree->GetBranch("see_dzErr") != 0) {
     see_dzErr_branch = tree->GetBranch("see_dzErr");
     if (see_dzErr_branch) {
       see_dzErr_branch->SetAddress(&see_dzErr_);
     }
   }
   sim_nRecoClusters_branch = 0;
   if (tree->GetBranch("sim_nRecoClusters") != 0) {
     sim_nRecoClusters_branch = tree->GetBranch("sim_nRecoClusters");
     if (sim_nRecoClusters_branch) {
       sim_nRecoClusters_branch->SetAddress(&sim_nRecoClusters_);
     }
   }
   run_branch = 0;
   if (tree->GetBranch("run") != 0) {
     run_branch = tree->GetBranch("run");
     if (run_branch) {
       run_branch->SetAddress(&run_);
     }
   }
   ph2_xySignificance_branch = 0;
   if (tree->GetBranch("ph2_xySignificance") != 0) {
     ph2_xySignificance_branch = tree->GetBranch("ph2_xySignificance");
     if (ph2_xySignificance_branch) {
       ph2_xySignificance_branch->SetAddress(&ph2_xySignificance_);
     }
   }
   trk_nChi2_branch = 0;
   if (tree->GetBranch("trk_nChi2") != 0) {
     trk_nChi2_branch = tree->GetBranch("trk_nChi2");
     if (trk_nChi2_branch) {
       trk_nChi2_branch->SetAddress(&trk_nChi2_);
     }
   }
   pix_layer_branch = 0;
   if (tree->GetBranch("pix_layer") != 0) {
     pix_layer_branch = tree->GetBranch("pix_layer");
     if (pix_layer_branch) {
       pix_layer_branch->SetAddress(&pix_layer_);
     }
   }
   pix_xySignificance_branch = 0;
   if (tree->GetBranch("pix_xySignificance") != 0) {
     pix_xySignificance_branch = tree->GetBranch("pix_xySignificance");
     if (pix_xySignificance_branch) {
       pix_xySignificance_branch->SetAddress(&pix_xySignificance_);
     }
   }
   sim_pca_eta_branch = 0;
   if (tree->GetBranch("sim_pca_eta") != 0) {
     sim_pca_eta_branch = tree->GetBranch("sim_pca_eta");
     if (sim_pca_eta_branch) {
       sim_pca_eta_branch->SetAddress(&sim_pca_eta_);
     }
   }
   see_bestSimTrkShareFrac_branch = 0;
   if (tree->GetBranch("see_bestSimTrkShareFrac") != 0) {
     see_bestSimTrkShareFrac_branch = tree->GetBranch("see_bestSimTrkShareFrac");
     if (see_bestSimTrkShareFrac_branch) {
       see_bestSimTrkShareFrac_branch->SetAddress(&see_bestSimTrkShareFrac_);
     }
   }
   see_etaErr_branch = 0;
   if (tree->GetBranch("see_etaErr") != 0) {
     see_etaErr_branch = tree->GetBranch("see_etaErr");
     if (see_etaErr_branch) {
       see_etaErr_branch->SetAddress(&see_etaErr_);
     }
   }
   trk_bestSimTrkShareFracSimDenom_branch = 0;
   if (tree->GetBranch("trk_bestSimTrkShareFracSimDenom") != 0) {
     trk_bestSimTrkShareFracSimDenom_branch = tree->GetBranch("trk_bestSimTrkShareFracSimDenom");
     if (trk_bestSimTrkShareFracSimDenom_branch) {
       trk_bestSimTrkShareFracSimDenom_branch->SetAddress(&trk_bestSimTrkShareFracSimDenom_);
     }
   }
   bsp_sigmaz_branch = 0;
   if (tree->GetBranch("bsp_sigmaz") != 0) {
     bsp_sigmaz_branch = tree->GetBranch("bsp_sigmaz");
     if (bsp_sigmaz_branch) {
       bsp_sigmaz_branch->SetAddress(&bsp_sigmaz_);
     }
   }
   bsp_sigmay_branch = 0;
   if (tree->GetBranch("bsp_sigmay") != 0) {
     bsp_sigmay_branch = tree->GetBranch("bsp_sigmay");
     if (bsp_sigmay_branch) {
       bsp_sigmay_branch->SetAddress(&bsp_sigmay_);
     }
   }
   bsp_sigmax_branch = 0;
   if (tree->GetBranch("bsp_sigmax") != 0) {
     bsp_sigmax_branch = tree->GetBranch("bsp_sigmax");
     if (bsp_sigmax_branch) {
       bsp_sigmax_branch->SetAddress(&bsp_sigmax_);
     }
   }
   pix_ladder_branch = 0;
   if (tree->GetBranch("pix_ladder") != 0) {
     pix_ladder_branch = tree->GetBranch("pix_ladder");
     if (pix_ladder_branch) {
       pix_ladder_branch->SetAddress(&pix_ladder_);
     }
   }
   trk_qualityMask_branch = 0;
   if (tree->GetBranch("trk_qualityMask") != 0) {
     trk_qualityMask_branch = tree->GetBranch("trk_qualityMask");
     if (trk_qualityMask_branch) {
       trk_qualityMask_branch->SetAddress(&trk_qualityMask_);
     }
   }
   trk_ndof_branch = 0;
   if (tree->GetBranch("trk_ndof") != 0) {
     trk_ndof_branch = tree->GetBranch("trk_ndof");
     if (trk_ndof_branch) {
       trk_ndof_branch->SetAddress(&trk_ndof_);
     }
   }
   pix_subdet_branch = 0;
   if (tree->GetBranch("pix_subdet") != 0) {
     pix_subdet_branch = tree->GetBranch("pix_subdet");
     if (pix_subdet_branch) {
       pix_subdet_branch->SetAddress(&pix_subdet_);
     }
   }
   ph2_seeIdx_branch = 0;
   if (tree->GetBranch("ph2_seeIdx") != 0) {
     ph2_seeIdx_branch = tree->GetBranch("ph2_seeIdx");
     if (ph2_seeIdx_branch) {
       ph2_seeIdx_branch->SetAddress(&ph2_seeIdx_);
     }
   }
   inv_isUpper_branch = 0;
   if (tree->GetBranch("inv_isUpper") != 0) {
     inv_isUpper_branch = tree->GetBranch("inv_isUpper");
     if (inv_isUpper_branch) {
       inv_isUpper_branch->SetAddress(&inv_isUpper_);
     }
   }
   ph2_zx_branch = 0;
   if (tree->GetBranch("ph2_zx") != 0) {
     ph2_zx_branch = tree->GetBranch("ph2_zx");
     if (ph2_zx_branch) {
       ph2_zx_branch->SetAddress(&ph2_zx_);
     }
   }
   pix_trkIdx_branch = 0;
   if (tree->GetBranch("pix_trkIdx") != 0) {
     pix_trkIdx_branch = tree->GetBranch("pix_trkIdx");
     if (pix_trkIdx_branch) {
       pix_trkIdx_branch->SetAddress(&pix_trkIdx_);
     }
   }
   trk_nOuterLost_branch = 0;
   if (tree->GetBranch("trk_nOuterLost") != 0) {
     trk_nOuterLost_branch = tree->GetBranch("trk_nOuterLost");
     if (trk_nOuterLost_branch) {
       trk_nOuterLost_branch->SetAddress(&trk_nOuterLost_);
     }
   }
   inv_panel_branch = 0;
   if (tree->GetBranch("inv_panel") != 0) {
     inv_panel_branch = tree->GetBranch("inv_panel");
     if (inv_panel_branch) {
       inv_panel_branch->SetAddress(&inv_panel_);
     }
   }
   vtx_z_branch = 0;
   if (tree->GetBranch("vtx_z") != 0) {
     vtx_z_branch = tree->GetBranch("vtx_z");
     if (vtx_z_branch) {
       vtx_z_branch->SetAddress(&vtx_z_);
     }
   }
   simhit_layer_branch = 0;
   if (tree->GetBranch("simhit_layer") != 0) {
     simhit_layer_branch = tree->GetBranch("simhit_layer");
     if (simhit_layer_branch) {
       simhit_layer_branch->SetAddress(&simhit_layer_);
     }
   }
   vtx_y_branch = 0;
   if (tree->GetBranch("vtx_y") != 0) {
     vtx_y_branch = tree->GetBranch("vtx_y");
     if (vtx_y_branch) {
       vtx_y_branch->SetAddress(&vtx_y_);
     }
   }
   ph2_isBarrel_branch = 0;
   if (tree->GetBranch("ph2_isBarrel") != 0) {
     ph2_isBarrel_branch = tree->GetBranch("ph2_isBarrel");
     if (ph2_isBarrel_branch) {
       ph2_isBarrel_branch->SetAddress(&ph2_isBarrel_);
     }
   }
   pix_seeIdx_branch = 0;
   if (tree->GetBranch("pix_seeIdx") != 0) {
     pix_seeIdx_branch = tree->GetBranch("pix_seeIdx");
     if (pix_seeIdx_branch) {
       pix_seeIdx_branch->SetAddress(&pix_seeIdx_);
     }
   }
   trk_bestFromFirstHitSimTrkIdx_branch = 0;
   if (tree->GetBranch("trk_bestFromFirstHitSimTrkIdx") != 0) {
     trk_bestFromFirstHitSimTrkIdx_branch = tree->GetBranch("trk_bestFromFirstHitSimTrkIdx");
     if (trk_bestFromFirstHitSimTrkIdx_branch) {
       trk_bestFromFirstHitSimTrkIdx_branch->SetAddress(&trk_bestFromFirstHitSimTrkIdx_);
     }
   }
   simhit_px_branch = 0;
   if (tree->GetBranch("simhit_px") != 0) {
     simhit_px_branch = tree->GetBranch("simhit_px");
     if (simhit_px_branch) {
       simhit_px_branch->SetAddress(&simhit_px_);
     }
   }
   see_stateTrajX_branch = 0;
   if (tree->GetBranch("see_stateTrajX") != 0) {
     see_stateTrajX_branch = tree->GetBranch("see_stateTrajX");
     if (see_stateTrajX_branch) {
       see_stateTrajX_branch->SetAddress(&see_stateTrajX_);
     }
   }
   see_stateTrajY_branch = 0;
   if (tree->GetBranch("see_stateTrajY") != 0) {
     see_stateTrajY_branch = tree->GetBranch("see_stateTrajY");
     if (see_stateTrajY_branch) {
       see_stateTrajY_branch->SetAddress(&see_stateTrajY_);
     }
   }
   trk_nOuterInactive_branch = 0;
   if (tree->GetBranch("trk_nOuterInactive") != 0) {
     trk_nOuterInactive_branch = tree->GetBranch("trk_nOuterInactive");
     if (trk_nOuterInactive_branch) {
       trk_nOuterInactive_branch->SetAddress(&trk_nOuterInactive_);
     }
   }
   sim_pca_dxy_branch = 0;
   if (tree->GetBranch("sim_pca_dxy") != 0) {
     sim_pca_dxy_branch = tree->GetBranch("sim_pca_dxy");
     if (sim_pca_dxy_branch) {
       sim_pca_dxy_branch->SetAddress(&sim_pca_dxy_);
     }
   }
   trk_algo_branch = 0;
   if (tree->GetBranch("trk_algo") != 0) {
     trk_algo_branch = tree->GetBranch("trk_algo");
     if (trk_algo_branch) {
       trk_algo_branch->SetAddress(&trk_algo_);
     }
   }
   trk_hitType_branch = 0;
   if (tree->GetBranch("trk_hitType") != 0) {
     trk_hitType_branch = tree->GetBranch("trk_hitType");
     if (trk_hitType_branch) {
       trk_hitType_branch->SetAddress(&trk_hitType_);
     }
   }
   trk_bestFromFirstHitSimTrkShareFrac_branch = 0;
   if (tree->GetBranch("trk_bestFromFirstHitSimTrkShareFrac") != 0) {
     trk_bestFromFirstHitSimTrkShareFrac_branch = tree->GetBranch("trk_bestFromFirstHitSimTrkShareFrac");
     if (trk_bestFromFirstHitSimTrkShareFrac_branch) {
       trk_bestFromFirstHitSimTrkShareFrac_branch->SetAddress(&trk_bestFromFirstHitSimTrkShareFrac_);
     }
   }
   inv_isBarrel_branch = 0;
   if (tree->GetBranch("inv_isBarrel") != 0) {
     inv_isBarrel_branch = tree->GetBranch("inv_isBarrel");
     if (inv_isBarrel_branch) {
       inv_isBarrel_branch->SetAddress(&inv_isBarrel_);
     }
   }
   simvtx_event_branch = 0;
   if (tree->GetBranch("simvtx_event") != 0) {
     simvtx_event_branch = tree->GetBranch("simvtx_event");
     if (simvtx_event_branch) {
       simvtx_event_branch->SetAddress(&simvtx_event_);
     }
   }
   ph2_z_branch = 0;
   if (tree->GetBranch("ph2_z") != 0) {
     ph2_z_branch = tree->GetBranch("ph2_z");
     if (ph2_z_branch) {
       ph2_z_branch->SetAddress(&ph2_z_);
     }
   }
   ph2_x_branch = 0;
   if (tree->GetBranch("ph2_x") != 0) {
     ph2_x_branch = tree->GetBranch("ph2_x");
     if (ph2_x_branch) {
       ph2_x_branch->SetAddress(&ph2_x_);
     }
   }
   ph2_y_branch = 0;
   if (tree->GetBranch("ph2_y") != 0) {
     ph2_y_branch = tree->GetBranch("ph2_y");
     if (ph2_y_branch) {
       ph2_y_branch->SetAddress(&ph2_y_);
     }
   }
   sim_genPdgIds_branch = 0;
   if (tree->GetBranch("sim_genPdgIds") != 0) {
     sim_genPdgIds_branch = tree->GetBranch("sim_genPdgIds");
     if (sim_genPdgIds_branch) {
       sim_genPdgIds_branch->SetAddress(&sim_genPdgIds_);
     }
   }
   trk_mva_branch = 0;
   if (tree->GetBranch("trk_mva") != 0) {
     trk_mva_branch = tree->GetBranch("trk_mva");
     if (trk_mva_branch) {
       trk_mva_branch->SetAddress(&trk_mva_);
     }
   }
   see_stateCcov24_branch = 0;
   if (tree->GetBranch("see_stateCcov24") != 0) {
     see_stateCcov24_branch = tree->GetBranch("see_stateCcov24");
     if (see_stateCcov24_branch) {
       see_stateCcov24_branch->SetAddress(&see_stateCcov24_);
     }
   }
   trk_dzClosestPV_branch = 0;
   if (tree->GetBranch("trk_dzClosestPV") != 0) {
     trk_dzClosestPV_branch = tree->GetBranch("trk_dzClosestPV");
     if (trk_dzClosestPV_branch) {
       trk_dzClosestPV_branch->SetAddress(&trk_dzClosestPV_);
     }
   }
   see_nCluster_branch = 0;
   if (tree->GetBranch("see_nCluster") != 0) {
     see_nCluster_branch = tree->GetBranch("see_nCluster");
     if (see_nCluster_branch) {
       see_nCluster_branch->SetAddress(&see_nCluster_);
     }
   }
   inv_rod_branch = 0;
   if (tree->GetBranch("inv_rod") != 0) {
     inv_rod_branch = tree->GetBranch("inv_rod");
     if (inv_rod_branch) {
       inv_rod_branch->SetAddress(&inv_rod_);
     }
   }
   trk_hitIdx_branch = 0;
   if (tree->GetBranch("trk_hitIdx") != 0) {
     trk_hitIdx_branch = tree->GetBranch("trk_hitIdx");
     if (trk_hitIdx_branch) {
       trk_hitIdx_branch->SetAddress(&trk_hitIdx_);
     }
   }
   see_stateCcov22_branch = 0;
   if (tree->GetBranch("see_stateCcov22") != 0) {
     see_stateCcov22_branch = tree->GetBranch("see_stateCcov22");
     if (see_stateCcov22_branch) {
       see_stateCcov22_branch->SetAddress(&see_stateCcov22_);
     }
   }
   pix_simType_branch = 0;
   if (tree->GetBranch("pix_simType") != 0) {
     pix_simType_branch = tree->GetBranch("pix_simType");
     if (pix_simType_branch) {
       pix_simType_branch->SetAddress(&pix_simType_);
     }
   }
   simhit_ring_branch = 0;
   if (tree->GetBranch("simhit_ring") != 0) {
     simhit_ring_branch = tree->GetBranch("simhit_ring");
     if (simhit_ring_branch) {
       simhit_ring_branch->SetAddress(&simhit_ring_);
     }
   }
   trk_outer_px_branch = 0;
   if (tree->GetBranch("trk_outer_px") != 0) {
     trk_outer_px_branch = tree->GetBranch("trk_outer_px");
     if (trk_outer_px_branch) {
       trk_outer_px_branch->SetAddress(&trk_outer_px_);
     }
   }
   trk_outer_py_branch = 0;
   if (tree->GetBranch("trk_outer_py") != 0) {
     trk_outer_py_branch = tree->GetBranch("trk_outer_py");
     if (trk_outer_py_branch) {
       trk_outer_py_branch->SetAddress(&trk_outer_py_);
     }
   }
   trk_outer_pz_branch = 0;
   if (tree->GetBranch("trk_outer_pz") != 0) {
     trk_outer_pz_branch = tree->GetBranch("trk_outer_pz");
     if (trk_outer_pz_branch) {
       trk_outer_pz_branch->SetAddress(&trk_outer_pz_);
     }
   }
   ph2_zz_branch = 0;
   if (tree->GetBranch("ph2_zz") != 0) {
     ph2_zz_branch = tree->GetBranch("ph2_zz");
     if (ph2_zz_branch) {
       ph2_zz_branch->SetAddress(&ph2_zz_);
     }
   }
   trk_outer_pt_branch = 0;
   if (tree->GetBranch("trk_outer_pt") != 0) {
     trk_outer_pt_branch = tree->GetBranch("trk_outer_pt");
     if (trk_outer_pt_branch) {
       trk_outer_pt_branch->SetAddress(&trk_outer_pt_);
     }
   }
   trk_n3DLay_branch = 0;
   if (tree->GetBranch("trk_n3DLay") != 0) {
     trk_n3DLay_branch = tree->GetBranch("trk_n3DLay");
     if (trk_n3DLay_branch) {
       trk_n3DLay_branch->SetAddress(&trk_n3DLay_);
     }
   }
   trk_nValid_branch = 0;
   if (tree->GetBranch("trk_nValid") != 0) {
     trk_nValid_branch = tree->GetBranch("trk_nValid");
     if (trk_nValid_branch) {
       trk_nValid_branch->SetAddress(&trk_nValid_);
     }
   }
   see_ptErr_branch = 0;
   if (tree->GetBranch("see_ptErr") != 0) {
     see_ptErr_branch = tree->GetBranch("see_ptErr");
     if (see_ptErr_branch) {
       see_ptErr_branch->SetAddress(&see_ptErr_);
     }
   }
   see_stateTrajGlbPx_branch = 0;
   if (tree->GetBranch("see_stateTrajGlbPx") != 0) {
     see_stateTrajGlbPx_branch = tree->GetBranch("see_stateTrajGlbPx");
     if (see_stateTrajGlbPx_branch) {
       see_stateTrajGlbPx_branch->SetAddress(&see_stateTrajGlbPx_);
     }
   }
   ph2_simType_branch = 0;
   if (tree->GetBranch("ph2_simType") != 0) {
     ph2_simType_branch = tree->GetBranch("ph2_simType");
     if (ph2_simType_branch) {
       ph2_simType_branch->SetAddress(&ph2_simType_);
     }
   }
   trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch = 0;
   if (tree->GetBranch("trk_bestFromFirstHitSimTrkShareFracSimClusterDenom") != 0) {
     trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch =
         tree->GetBranch("trk_bestFromFirstHitSimTrkShareFracSimClusterDenom");
     if (trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch) {
       trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch->SetAddress(
           &trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_);
     }
   }
   sim_hits_branch = 0;
   if (tree->GetBranch("sim_hits") != 0) {
     sim_hits_branch = tree->GetBranch("sim_hits");
     if (sim_hits_branch) {
       sim_hits_branch->SetAddress(&sim_hits_);
     }
   }
   sim_len_branch = 0;
   if (tree->GetBranch("sim_len") != 0) {
     sim_len_branch = tree->GetBranch("sim_len");
     if (sim_len_branch) {
       sim_len_branch->SetAddress(&sim_len_);
     }
   }
   sim_lengap_branch = 0;
   if (tree->GetBranch("sim_lengap") != 0) {
     sim_lengap_branch = tree->GetBranch("sim_lengap");
     if (sim_lengap_branch) {
       sim_lengap_branch->SetAddress(&sim_lengap_);
     }
   }
   simvtx_x_branch = 0;
   if (tree->GetBranch("simvtx_x") != 0) {
     simvtx_x_branch = tree->GetBranch("simvtx_x");
     if (simvtx_x_branch) {
       simvtx_x_branch->SetAddress(&simvtx_x_);
     }
   }
   trk_pz_branch = 0;
   if (tree->GetBranch("trk_pz") != 0) {
     trk_pz_branch = tree->GetBranch("trk_pz");
     if (trk_pz_branch) {
       trk_pz_branch->SetAddress(&trk_pz_);
     }
   }
   see_bestFromFirstHitSimTrkShareFrac_branch = 0;
   if (tree->GetBranch("see_bestFromFirstHitSimTrkShareFrac") != 0) {
     see_bestFromFirstHitSimTrkShareFrac_branch = tree->GetBranch("see_bestFromFirstHitSimTrkShareFrac");
     if (see_bestFromFirstHitSimTrkShareFrac_branch) {
       see_bestFromFirstHitSimTrkShareFrac_branch->SetAddress(&see_bestFromFirstHitSimTrkShareFrac_);
     }
   }
   trk_px_branch = 0;
   if (tree->GetBranch("trk_px") != 0) {
     trk_px_branch = tree->GetBranch("trk_px");
     if (trk_px_branch) {
       trk_px_branch->SetAddress(&trk_px_);
     }
   }
   trk_py_branch = 0;
   if (tree->GetBranch("trk_py") != 0) {
     trk_py_branch = tree->GetBranch("trk_py");
     if (trk_py_branch) {
       trk_py_branch->SetAddress(&trk_py_);
     }
   }
   trk_vtxIdx_branch = 0;
   if (tree->GetBranch("trk_vtxIdx") != 0) {
     trk_vtxIdx_branch = tree->GetBranch("trk_vtxIdx");
     if (trk_vtxIdx_branch) {
       trk_vtxIdx_branch->SetAddress(&trk_vtxIdx_);
     }
   }
   sim_nPixel_branch = 0;
   if (tree->GetBranch("sim_nPixel") != 0) {
     sim_nPixel_branch = tree->GetBranch("sim_nPixel");
     if (sim_nPixel_branch) {
       sim_nPixel_branch->SetAddress(&sim_nPixel_);
     }
   }
   vtx_chi2_branch = 0;
   if (tree->GetBranch("vtx_chi2") != 0) {
     vtx_chi2_branch = tree->GetBranch("vtx_chi2");
     if (vtx_chi2_branch) {
       vtx_chi2_branch->SetAddress(&vtx_chi2_);
     }
   }
   ph2_ring_branch = 0;
   if (tree->GetBranch("ph2_ring") != 0) {
     ph2_ring_branch = tree->GetBranch("ph2_ring");
     if (ph2_ring_branch) {
       ph2_ring_branch->SetAddress(&ph2_ring_);
     }
   }
   trk_pt_branch = 0;
   if (tree->GetBranch("trk_pt") != 0) {
     trk_pt_branch = tree->GetBranch("trk_pt");
     if (trk_pt_branch) {
       trk_pt_branch->SetAddress(&trk_pt_);
     }
   }
   see_stateCcov44_branch = 0;
   if (tree->GetBranch("see_stateCcov44") != 0) {
     see_stateCcov44_branch = tree->GetBranch("see_stateCcov44");
     if (see_stateCcov44_branch) {
       see_stateCcov44_branch->SetAddress(&see_stateCcov44_);
     }
   }
   ph2_radL_branch = 0;
   if (tree->GetBranch("ph2_radL") != 0) {
     ph2_radL_branch = tree->GetBranch("ph2_radL");
     if (ph2_radL_branch) {
       ph2_radL_branch->SetAddress(&ph2_radL_);
     }
   }
   vtx_zErr_branch = 0;
   if (tree->GetBranch("vtx_zErr") != 0) {
     vtx_zErr_branch = tree->GetBranch("vtx_zErr");
     if (vtx_zErr_branch) {
       vtx_zErr_branch->SetAddress(&vtx_zErr_);
     }
   }
   see_px_branch = 0;
   if (tree->GetBranch("see_px") != 0) {
     see_px_branch = tree->GetBranch("see_px");
     if (see_px_branch) {
       see_px_branch->SetAddress(&see_px_);
     }
   }
   see_pz_branch = 0;
   if (tree->GetBranch("see_pz") != 0) {
     see_pz_branch = tree->GetBranch("see_pz");
     if (see_pz_branch) {
       see_pz_branch->SetAddress(&see_pz_);
     }
   }
   see_eta_branch = 0;
   if (tree->GetBranch("see_eta") != 0) {
     see_eta_branch = tree->GetBranch("see_eta");
     if (see_eta_branch) {
       see_eta_branch->SetAddress(&see_eta_);
     }
   }
   simvtx_bunchCrossing_branch = 0;
   if (tree->GetBranch("simvtx_bunchCrossing") != 0) {
     simvtx_bunchCrossing_branch = tree->GetBranch("simvtx_bunchCrossing");
     if (simvtx_bunchCrossing_branch) {
       simvtx_bunchCrossing_branch->SetAddress(&simvtx_bunchCrossing_);
     }
   }
   sim_pca_dz_branch = 0;
   if (tree->GetBranch("sim_pca_dz") != 0) {
     sim_pca_dz_branch = tree->GetBranch("sim_pca_dz");
     if (sim_pca_dz_branch) {
       sim_pca_dz_branch->SetAddress(&sim_pca_dz_);
     }
   }
   simvtx_y_branch = 0;
   if (tree->GetBranch("simvtx_y") != 0) {
     simvtx_y_branch = tree->GetBranch("simvtx_y");
     if (simvtx_y_branch) {
       simvtx_y_branch->SetAddress(&simvtx_y_);
     }
   }
   inv_isStack_branch = 0;
   if (tree->GetBranch("inv_isStack") != 0) {
     inv_isStack_branch = tree->GetBranch("inv_isStack");
     if (inv_isStack_branch) {
       inv_isStack_branch->SetAddress(&inv_isStack_);
     }
   }
   trk_nStrip_branch = 0;
   if (tree->GetBranch("trk_nStrip") != 0) {
     trk_nStrip_branch = tree->GetBranch("trk_nStrip");
     if (trk_nStrip_branch) {
       trk_nStrip_branch->SetAddress(&trk_nStrip_);
     }
   }
   trk_etaErr_branch = 0;
   if (tree->GetBranch("trk_etaErr") != 0) {
     trk_etaErr_branch = tree->GetBranch("trk_etaErr");
     if (trk_etaErr_branch) {
       trk_etaErr_branch->SetAddress(&trk_etaErr_);
     }
   }
   trk_simTrkNChi2_branch = 0;
   if (tree->GetBranch("trk_simTrkNChi2") != 0) {
     trk_simTrkNChi2_branch = tree->GetBranch("trk_simTrkNChi2");
     if (trk_simTrkNChi2_branch) {
       trk_simTrkNChi2_branch->SetAddress(&trk_simTrkNChi2_);
     }
   }
   pix_zz_branch = 0;
   if (tree->GetBranch("pix_zz") != 0) {
     pix_zz_branch = tree->GetBranch("pix_zz");
     if (pix_zz_branch) {
       pix_zz_branch->SetAddress(&pix_zz_);
     }
   }
   simhit_particle_branch = 0;
   if (tree->GetBranch("simhit_particle") != 0) {
     simhit_particle_branch = tree->GetBranch("simhit_particle");
     if (simhit_particle_branch) {
       simhit_particle_branch->SetAddress(&simhit_particle_);
     }
   }
   see_dz_branch = 0;
   if (tree->GetBranch("see_dz") != 0) {
     see_dz_branch = tree->GetBranch("see_dz");
     if (see_dz_branch) {
       see_dz_branch->SetAddress(&see_dz_);
     }
   }
   see_stateTrajPz_branch = 0;
   if (tree->GetBranch("see_stateTrajPz") != 0) {
     see_stateTrajPz_branch = tree->GetBranch("see_stateTrajPz");
     if (see_stateTrajPz_branch) {
       see_stateTrajPz_branch->SetAddress(&see_stateTrajPz_);
     }
   }
   trk_bestSimTrkShareFrac_branch = 0;
   if (tree->GetBranch("trk_bestSimTrkShareFrac") != 0) {
     trk_bestSimTrkShareFrac_branch = tree->GetBranch("trk_bestSimTrkShareFrac");
     if (trk_bestSimTrkShareFrac_branch) {
       trk_bestSimTrkShareFrac_branch->SetAddress(&trk_bestSimTrkShareFrac_);
     }
   }
   trk_lambdaErr_branch = 0;
   if (tree->GetBranch("trk_lambdaErr") != 0) {
     trk_lambdaErr_branch = tree->GetBranch("trk_lambdaErr");
     if (trk_lambdaErr_branch) {
       trk_lambdaErr_branch->SetAddress(&trk_lambdaErr_);
     }
   }
   see_simTrkShareFrac_branch = 0;
   if (tree->GetBranch("see_simTrkShareFrac") != 0) {
     see_simTrkShareFrac_branch = tree->GetBranch("see_simTrkShareFrac");
     if (see_simTrkShareFrac_branch) {
       see_simTrkShareFrac_branch->SetAddress(&see_simTrkShareFrac_);
     }
   }
   pix_simHitIdx_branch = 0;
   if (tree->GetBranch("pix_simHitIdx") != 0) {
     pix_simHitIdx_branch = tree->GetBranch("pix_simHitIdx");
     if (pix_simHitIdx_branch) {
       pix_simHitIdx_branch->SetAddress(&pix_simHitIdx_);
     }
   }
   vtx_trkIdx_branch = 0;
   if (tree->GetBranch("vtx_trkIdx") != 0) {
     vtx_trkIdx_branch = tree->GetBranch("vtx_trkIdx");
     if (vtx_trkIdx_branch) {
       vtx_trkIdx_branch->SetAddress(&vtx_trkIdx_);
     }
   }
   ph2_rod_branch = 0;
   if (tree->GetBranch("ph2_rod") != 0) {
     ph2_rod_branch = tree->GetBranch("ph2_rod");
     if (ph2_rod_branch) {
       ph2_rod_branch->SetAddress(&ph2_rod_);
     }
   }
   vtx_ndof_branch = 0;
   if (tree->GetBranch("vtx_ndof") != 0) {
     vtx_ndof_branch = tree->GetBranch("vtx_ndof");
     if (vtx_ndof_branch) {
       vtx_ndof_branch->SetAddress(&vtx_ndof_);
     }
   }
   see_nPixel_branch = 0;
   if (tree->GetBranch("see_nPixel") != 0) {
     see_nPixel_branch = tree->GetBranch("see_nPixel");
     if (see_nPixel_branch) {
       see_nPixel_branch->SetAddress(&see_nPixel_);
     }
   }
   sim_nStrip_branch = 0;
   if (tree->GetBranch("sim_nStrip") != 0) {
     sim_nStrip_branch = tree->GetBranch("sim_nStrip");
     if (sim_nStrip_branch) {
       sim_nStrip_branch->SetAddress(&sim_nStrip_);
     }
   }
   sim_bunchCrossing_branch = 0;
   if (tree->GetBranch("sim_bunchCrossing") != 0) {
     sim_bunchCrossing_branch = tree->GetBranch("sim_bunchCrossing");
     if (sim_bunchCrossing_branch) {
       sim_bunchCrossing_branch->SetAddress(&sim_bunchCrossing_);
     }
   }
   see_stateCcov45_branch = 0;
   if (tree->GetBranch("see_stateCcov45") != 0) {
     see_stateCcov45_branch = tree->GetBranch("see_stateCcov45");
     if (see_stateCcov45_branch) {
       see_stateCcov45_branch->SetAddress(&see_stateCcov45_);
     }
   }
   ph2_isStack_branch = 0;
   if (tree->GetBranch("ph2_isStack") != 0) {
     ph2_isStack_branch = tree->GetBranch("ph2_isStack");
     if (ph2_isStack_branch) {
       ph2_isStack_branch->SetAddress(&ph2_isStack_);
     }
   }
   sim_trkShareFrac_branch = 0;
   if (tree->GetBranch("sim_trkShareFrac") != 0) {
     sim_trkShareFrac_branch = tree->GetBranch("sim_trkShareFrac");
     if (sim_trkShareFrac_branch) {
       sim_trkShareFrac_branch->SetAddress(&sim_trkShareFrac_);
     }
   }
   trk_simTrkShareFrac_branch = 0;
   if (tree->GetBranch("trk_simTrkShareFrac") != 0) {
     trk_simTrkShareFrac_branch = tree->GetBranch("trk_simTrkShareFrac");
     if (trk_simTrkShareFrac_branch) {
       trk_simTrkShareFrac_branch->SetAddress(&trk_simTrkShareFrac_);
     }
   }
   sim_phi_branch = 0;
   if (tree->GetBranch("sim_phi") != 0) {
     sim_phi_branch = tree->GetBranch("sim_phi");
     if (sim_phi_branch) {
       sim_phi_branch->SetAddress(&sim_phi_);
     }
   }
   inv_side_branch = 0;
   if (tree->GetBranch("inv_side") != 0) {
     inv_side_branch = tree->GetBranch("inv_side");
     if (inv_side_branch) {
       inv_side_branch->SetAddress(&inv_side_);
     }
   }
   vtx_fake_branch = 0;
   if (tree->GetBranch("vtx_fake") != 0) {
     vtx_fake_branch = tree->GetBranch("vtx_fake");
     if (vtx_fake_branch) {
       vtx_fake_branch->SetAddress(&vtx_fake_);
     }
   }
   trk_nInactive_branch = 0;
   if (tree->GetBranch("trk_nInactive") != 0) {
     trk_nInactive_branch = tree->GetBranch("trk_nInactive");
     if (trk_nInactive_branch) {
       trk_nInactive_branch->SetAddress(&trk_nInactive_);
     }
   }
   trk_nPixelLay_branch = 0;
   if (tree->GetBranch("trk_nPixelLay") != 0) {
     trk_nPixelLay_branch = tree->GetBranch("trk_nPixelLay");
     if (trk_nPixelLay_branch) {
       trk_nPixelLay_branch->SetAddress(&trk_nPixelLay_);
     }
   }
   ph2_bbxi_branch = 0;
   if (tree->GetBranch("ph2_bbxi") != 0) {
     ph2_bbxi_branch = tree->GetBranch("ph2_bbxi");
     if (ph2_bbxi_branch) {
       ph2_bbxi_branch->SetAddress(&ph2_bbxi_);
     }
   }
   vtx_xErr_branch = 0;
   if (tree->GetBranch("vtx_xErr") != 0) {
     vtx_xErr_branch = tree->GetBranch("vtx_xErr");
     if (vtx_xErr_branch) {
       vtx_xErr_branch->SetAddress(&vtx_xErr_);
     }
   }
   see_stateCcov25_branch = 0;
   if (tree->GetBranch("see_stateCcov25") != 0) {
     see_stateCcov25_branch = tree->GetBranch("see_stateCcov25");
     if (see_stateCcov25_branch) {
       see_stateCcov25_branch->SetAddress(&see_stateCcov25_);
     }
   }
   sim_parentVtxIdx_branch = 0;
   if (tree->GetBranch("sim_parentVtxIdx") != 0) {
     sim_parentVtxIdx_branch = tree->GetBranch("sim_parentVtxIdx");
     if (sim_parentVtxIdx_branch) {
       sim_parentVtxIdx_branch->SetAddress(&sim_parentVtxIdx_);
     }
   }
   see_stateCcov23_branch = 0;
   if (tree->GetBranch("see_stateCcov23") != 0) {
     see_stateCcov23_branch = tree->GetBranch("see_stateCcov23");
     if (see_stateCcov23_branch) {
       see_stateCcov23_branch->SetAddress(&see_stateCcov23_);
     }
   }
   trk_algoMask_branch = 0;
   if (tree->GetBranch("trk_algoMask") != 0) {
     trk_algoMask_branch = tree->GetBranch("trk_algoMask");
     if (trk_algoMask_branch) {
       trk_algoMask_branch->SetAddress(&trk_algoMask_);
     }
   }
   trk_simTrkIdx_branch = 0;
   if (tree->GetBranch("trk_simTrkIdx") != 0) {
     trk_simTrkIdx_branch = tree->GetBranch("trk_simTrkIdx");
     if (trk_simTrkIdx_branch) {
       trk_simTrkIdx_branch->SetAddress(&trk_simTrkIdx_);
     }
   }
   see_phiErr_branch = 0;
   if (tree->GetBranch("see_phiErr") != 0) {
     see_phiErr_branch = tree->GetBranch("see_phiErr");
     if (see_phiErr_branch) {
       see_phiErr_branch->SetAddress(&see_phiErr_);
     }
   }
   trk_cotTheta_branch = 0;
   if (tree->GetBranch("trk_cotTheta") != 0) {
     trk_cotTheta_branch = tree->GetBranch("trk_cotTheta");
     if (trk_cotTheta_branch) {
       trk_cotTheta_branch->SetAddress(&trk_cotTheta_);
     }
   }
   see_algo_branch = 0;
   if (tree->GetBranch("see_algo") != 0) {
     see_algo_branch = tree->GetBranch("see_algo");
     if (see_algo_branch) {
       see_algo_branch->SetAddress(&see_algo_);
     }
   }
   simhit_module_branch = 0;
   if (tree->GetBranch("simhit_module") != 0) {
     simhit_module_branch = tree->GetBranch("simhit_module");
     if (simhit_module_branch) {
       simhit_module_branch->SetAddress(&simhit_module_);
     }
   }
   simvtx_daughterSimIdx_branch = 0;
   if (tree->GetBranch("simvtx_daughterSimIdx") != 0) {
     simvtx_daughterSimIdx_branch = tree->GetBranch("simvtx_daughterSimIdx");
     if (simvtx_daughterSimIdx_branch) {
       simvtx_daughterSimIdx_branch->SetAddress(&simvtx_daughterSimIdx_);
     }
   }
   vtx_x_branch = 0;
   if (tree->GetBranch("vtx_x") != 0) {
     vtx_x_branch = tree->GetBranch("vtx_x");
     if (vtx_x_branch) {
       vtx_x_branch->SetAddress(&vtx_x_);
     }
   }
   trk_seedIdx_branch = 0;
   if (tree->GetBranch("trk_seedIdx") != 0) {
     trk_seedIdx_branch = tree->GetBranch("trk_seedIdx");
     if (trk_seedIdx_branch) {
       trk_seedIdx_branch->SetAddress(&trk_seedIdx_);
     }
   }
   simhit_y_branch = 0;
   if (tree->GetBranch("simhit_y") != 0) {
     simhit_y_branch = tree->GetBranch("simhit_y");
     if (simhit_y_branch) {
       simhit_y_branch->SetAddress(&simhit_y_);
     }
   }
   inv_layer_branch = 0;
   if (tree->GetBranch("inv_layer") != 0) {
     inv_layer_branch = tree->GetBranch("inv_layer");
     if (inv_layer_branch) {
       inv_layer_branch->SetAddress(&inv_layer_);
     }
   }
   trk_nLostLay_branch = 0;
   if (tree->GetBranch("trk_nLostLay") != 0) {
     trk_nLostLay_branch = tree->GetBranch("trk_nLostLay");
     if (trk_nLostLay_branch) {
       trk_nLostLay_branch->SetAddress(&trk_nLostLay_);
     }
   }
   ph2_isLower_branch = 0;
   if (tree->GetBranch("ph2_isLower") != 0) {
     ph2_isLower_branch = tree->GetBranch("ph2_isLower");
     if (ph2_isLower_branch) {
       ph2_isLower_branch->SetAddress(&ph2_isLower_);
     }
   }
   pix_side_branch = 0;
   if (tree->GetBranch("pix_side") != 0) {
     pix_side_branch = tree->GetBranch("pix_side");
     if (pix_side_branch) {
       pix_side_branch->SetAddress(&pix_side_);
     }
   }
   inv_isLower_branch = 0;
   if (tree->GetBranch("inv_isLower") != 0) {
     inv_isLower_branch = tree->GetBranch("inv_isLower");
     if (inv_isLower_branch) {
       inv_isLower_branch->SetAddress(&inv_isLower_);
     }
   }
   ph2_trkIdx_branch = 0;
   if (tree->GetBranch("ph2_trkIdx") != 0) {
     ph2_trkIdx_branch = tree->GetBranch("ph2_trkIdx");
     if (ph2_trkIdx_branch) {
       ph2_trkIdx_branch->SetAddress(&ph2_trkIdx_);
     }
   }
   sim_nValid_branch = 0;
   if (tree->GetBranch("sim_nValid") != 0) {
     sim_nValid_branch = tree->GetBranch("sim_nValid");
     if (sim_nValid_branch) {
       sim_nValid_branch->SetAddress(&sim_nValid_);
     }
   }
   simhit_simTrkIdx_branch = 0;
   if (tree->GetBranch("simhit_simTrkIdx") != 0) {
     simhit_simTrkIdx_branch = tree->GetBranch("simhit_simTrkIdx");
     if (simhit_simTrkIdx_branch) {
       simhit_simTrkIdx_branch->SetAddress(&simhit_simTrkIdx_);
     }
   }
   see_nCands_branch = 0;
   if (tree->GetBranch("see_nCands") != 0) {
     see_nCands_branch = tree->GetBranch("see_nCands");
     if (see_nCands_branch) {
       see_nCands_branch->SetAddress(&see_nCands_);
     }
   }
   see_bestSimTrkIdx_branch = 0;
   if (tree->GetBranch("see_bestSimTrkIdx") != 0) {
     see_bestSimTrkIdx_branch = tree->GetBranch("see_bestSimTrkIdx");
     if (see_bestSimTrkIdx_branch) {
       see_bestSimTrkIdx_branch->SetAddress(&see_bestSimTrkIdx_);
     }
   }
   vtx_yErr_branch = 0;
   if (tree->GetBranch("vtx_yErr") != 0) {
     vtx_yErr_branch = tree->GetBranch("vtx_yErr");
     if (vtx_yErr_branch) {
       vtx_yErr_branch->SetAddress(&vtx_yErr_);
     }
   }
   trk_dzPV_branch = 0;
   if (tree->GetBranch("trk_dzPV") != 0) {
     trk_dzPV_branch = tree->GetBranch("trk_dzPV");
     if (trk_dzPV_branch) {
       trk_dzPV_branch->SetAddress(&trk_dzPV_);
     }
   }
   ph2_xy_branch = 0;
   if (tree->GetBranch("ph2_xy") != 0) {
     ph2_xy_branch = tree->GetBranch("ph2_xy");
     if (ph2_xy_branch) {
       ph2_xy_branch->SetAddress(&ph2_xy_);
     }
   }
   inv_module_branch = 0;
   if (tree->GetBranch("inv_module") != 0) {
     inv_module_branch = tree->GetBranch("inv_module");
     if (inv_module_branch) {
       inv_module_branch->SetAddress(&inv_module_);
     }
   }
   see_stateCcov55_branch = 0;
   if (tree->GetBranch("see_stateCcov55") != 0) {
     see_stateCcov55_branch = tree->GetBranch("see_stateCcov55");
     if (see_stateCcov55_branch) {
       see_stateCcov55_branch->SetAddress(&see_stateCcov55_);
     }
   }
   pix_panel_branch = 0;
   if (tree->GetBranch("pix_panel") != 0) {
     pix_panel_branch = tree->GetBranch("pix_panel");
     if (pix_panel_branch) {
       pix_panel_branch->SetAddress(&pix_panel_);
     }
   }
   inv_ladder_branch = 0;
   if (tree->GetBranch("inv_ladder") != 0) {
     inv_ladder_branch = tree->GetBranch("inv_ladder");
     if (inv_ladder_branch) {
       inv_ladder_branch->SetAddress(&inv_ladder_);
     }
   }
   ph2_xx_branch = 0;
   if (tree->GetBranch("ph2_xx") != 0) {
     ph2_xx_branch = tree->GetBranch("ph2_xx");
     if (ph2_xx_branch) {
       ph2_xx_branch->SetAddress(&ph2_xx_);
     }
   }
   sim_pca_cotTheta_branch = 0;
   if (tree->GetBranch("sim_pca_cotTheta") != 0) {
     sim_pca_cotTheta_branch = tree->GetBranch("sim_pca_cotTheta");
     if (sim_pca_cotTheta_branch) {
       sim_pca_cotTheta_branch->SetAddress(&sim_pca_cotTheta_);
     }
   }
   simpv_idx_branch = 0;
   if (tree->GetBranch("simpv_idx") != 0) {
     simpv_idx_branch = tree->GetBranch("simpv_idx");
     if (simpv_idx_branch) {
       simpv_idx_branch->SetAddress(&simpv_idx_);
     }
   }
   trk_inner_pz_branch = 0;
   if (tree->GetBranch("trk_inner_pz") != 0) {
     trk_inner_pz_branch = tree->GetBranch("trk_inner_pz");
     if (trk_inner_pz_branch) {
       trk_inner_pz_branch->SetAddress(&trk_inner_pz_);
     }
   }
   see_chi2_branch = 0;
   if (tree->GetBranch("see_chi2") != 0) {
     see_chi2_branch = tree->GetBranch("see_chi2");
     if (see_chi2_branch) {
       see_chi2_branch->SetAddress(&see_chi2_);
     }
   }
   see_stateCcov35_branch = 0;
   if (tree->GetBranch("see_stateCcov35") != 0) {
     see_stateCcov35_branch = tree->GetBranch("see_stateCcov35");
     if (see_stateCcov35_branch) {
       see_stateCcov35_branch->SetAddress(&see_stateCcov35_);
     }
   }
   see_stateCcov33_branch = 0;
   if (tree->GetBranch("see_stateCcov33") != 0) {
     see_stateCcov33_branch = tree->GetBranch("see_stateCcov33");
     if (see_stateCcov33_branch) {
       see_stateCcov33_branch->SetAddress(&see_stateCcov33_);
     }
   }
   inv_detId_branch = 0;
   if (tree->GetBranch("inv_detId") != 0) {
     inv_detId_branch = tree->GetBranch("inv_detId");
     if (inv_detId_branch) {
       inv_detId_branch->SetAddress(&inv_detId_);
     }
   }
   see_offset_branch = 0;
   if (tree->GetBranch("see_offset") != 0) {
     see_offset_branch = tree->GetBranch("see_offset");
     if (see_offset_branch) {
       see_offset_branch->SetAddress(&see_offset_);
     }
   }
   sim_nLay_branch = 0;
   if (tree->GetBranch("sim_nLay") != 0) {
     sim_nLay_branch = tree->GetBranch("sim_nLay");
     if (sim_nLay_branch) {
       sim_nLay_branch->SetAddress(&sim_nLay_);
     }
   }
   sim_simHitIdx_branch = 0;
   if (tree->GetBranch("sim_simHitIdx") != 0) {
     sim_simHitIdx_branch = tree->GetBranch("sim_simHitIdx");
     if (sim_simHitIdx_branch) {
       sim_simHitIdx_branch->SetAddress(&sim_simHitIdx_);
     }
   }
   simhit_isUpper_branch = 0;
   if (tree->GetBranch("simhit_isUpper") != 0) {
     simhit_isUpper_branch = tree->GetBranch("simhit_isUpper");
     if (simhit_isUpper_branch) {
       simhit_isUpper_branch->SetAddress(&simhit_isUpper_);
     }
   }
   see_stateCcov00_branch = 0;
   if (tree->GetBranch("see_stateCcov00") != 0) {
     see_stateCcov00_branch = tree->GetBranch("see_stateCcov00");
     if (see_stateCcov00_branch) {
       see_stateCcov00_branch->SetAddress(&see_stateCcov00_);
     }
   }
   see_stopReason_branch = 0;
   if (tree->GetBranch("see_stopReason") != 0) {
     see_stopReason_branch = tree->GetBranch("see_stopReason");
     if (see_stopReason_branch) {
       see_stopReason_branch->SetAddress(&see_stopReason_);
     }
   }
   vtx_valid_branch = 0;
   if (tree->GetBranch("vtx_valid") != 0) {
     vtx_valid_branch = tree->GetBranch("vtx_valid");
     if (vtx_valid_branch) {
       vtx_valid_branch->SetAddress(&vtx_valid_);
     }
   }
   lumi_branch = 0;
   if (tree->GetBranch("lumi") != 0) {
     lumi_branch = tree->GetBranch("lumi");
     if (lumi_branch) {
       lumi_branch->SetAddress(&lumi_);
     }
   }
   trk_refpoint_x_branch = 0;
   if (tree->GetBranch("trk_refpoint_x") != 0) {
     trk_refpoint_x_branch = tree->GetBranch("trk_refpoint_x");
     if (trk_refpoint_x_branch) {
       trk_refpoint_x_branch->SetAddress(&trk_refpoint_x_);
     }
   }
   trk_refpoint_y_branch = 0;
   if (tree->GetBranch("trk_refpoint_y") != 0) {
     trk_refpoint_y_branch = tree->GetBranch("trk_refpoint_y");
     if (trk_refpoint_y_branch) {
       trk_refpoint_y_branch->SetAddress(&trk_refpoint_y_);
     }
   }
   trk_refpoint_z_branch = 0;
   if (tree->GetBranch("trk_refpoint_z") != 0) {
     trk_refpoint_z_branch = tree->GetBranch("trk_refpoint_z");
     if (trk_refpoint_z_branch) {
       trk_refpoint_z_branch->SetAddress(&trk_refpoint_z_);
     }
   }
   sim_n3DLay_branch = 0;
   if (tree->GetBranch("sim_n3DLay") != 0) {
     sim_n3DLay_branch = tree->GetBranch("sim_n3DLay");
     if (sim_n3DLay_branch) {
       sim_n3DLay_branch->SetAddress(&sim_n3DLay_);
     }
   }
   see_nPhase2OT_branch = 0;
   if (tree->GetBranch("see_nPhase2OT") != 0) {
     see_nPhase2OT_branch = tree->GetBranch("see_nPhase2OT");
     if (see_nPhase2OT_branch) {
       see_nPhase2OT_branch->SetAddress(&see_nPhase2OT_);
     }
   }
   trk_bestFromFirstHitSimTrkShareFracSimDenom_branch = 0;
   if (tree->GetBranch("trk_bestFromFirstHitSimTrkShareFracSimDenom") != 0) {
     trk_bestFromFirstHitSimTrkShareFracSimDenom_branch = tree->GetBranch("trk_bestFromFirstHitSimTrkShareFracSimDenom");
     if (trk_bestFromFirstHitSimTrkShareFracSimDenom_branch) {
       trk_bestFromFirstHitSimTrkShareFracSimDenom_branch->SetAddress(&trk_bestFromFirstHitSimTrkShareFracSimDenom_);
     }
   }
   ph2_yy_branch = 0;
   if (tree->GetBranch("ph2_yy") != 0) {
     ph2_yy_branch = tree->GetBranch("ph2_yy");
     if (ph2_yy_branch) {
       ph2_yy_branch->SetAddress(&ph2_yy_);
     }
   }
   ph2_yz_branch = 0;
   if (tree->GetBranch("ph2_yz") != 0) {
     ph2_yz_branch = tree->GetBranch("ph2_yz");
     if (ph2_yz_branch) {
       ph2_yz_branch->SetAddress(&ph2_yz_);
     }
   }
   inv_blade_branch = 0;
   if (tree->GetBranch("inv_blade") != 0) {
     inv_blade_branch = tree->GetBranch("inv_blade");
     if (inv_blade_branch) {
       inv_blade_branch->SetAddress(&inv_blade_);
     }
   }
   trk_ptErr_branch = 0;
   if (tree->GetBranch("trk_ptErr") != 0) {
     trk_ptErr_branch = tree->GetBranch("trk_ptErr");
     if (trk_ptErr_branch) {
       trk_ptErr_branch->SetAddress(&trk_ptErr_);
     }
   }
   pix_zx_branch = 0;
   if (tree->GetBranch("pix_zx") != 0) {
     pix_zx_branch = tree->GetBranch("pix_zx");
     if (pix_zx_branch) {
       pix_zx_branch->SetAddress(&pix_zx_);
     }
   }
   simvtx_z_branch = 0;
   if (tree->GetBranch("simvtx_z") != 0) {
     simvtx_z_branch = tree->GetBranch("simvtx_z");
     if (simvtx_z_branch) {
       simvtx_z_branch->SetAddress(&simvtx_z_);
     }
   }
   sim_nTrackerHits_branch = 0;
   if (tree->GetBranch("sim_nTrackerHits") != 0) {
     sim_nTrackerHits_branch = tree->GetBranch("sim_nTrackerHits");
     if (sim_nTrackerHits_branch) {
       sim_nTrackerHits_branch->SetAddress(&sim_nTrackerHits_);
     }
   }
   ph2_subdet_branch = 0;
   if (tree->GetBranch("ph2_subdet") != 0) {
     ph2_subdet_branch = tree->GetBranch("ph2_subdet");
     if (ph2_subdet_branch) {
       ph2_subdet_branch->SetAddress(&ph2_subdet_);
     }
   }
   see_stateTrajPx_branch = 0;
   if (tree->GetBranch("see_stateTrajPx") != 0) {
     see_stateTrajPx_branch = tree->GetBranch("see_stateTrajPx");
     if (see_stateTrajPx_branch) {
       see_stateTrajPx_branch->SetAddress(&see_stateTrajPx_);
     }
   }
   simhit_hitIdx_branch = 0;
   if (tree->GetBranch("simhit_hitIdx") != 0) {
     simhit_hitIdx_branch = tree->GetBranch("simhit_hitIdx");
     if (simhit_hitIdx_branch) {
       simhit_hitIdx_branch->SetAddress(&simhit_hitIdx_);
     }
   }
   simhit_ladder_branch = 0;
   if (tree->GetBranch("simhit_ladder") != 0) {
     simhit_ladder_branch = tree->GetBranch("simhit_ladder");
     if (simhit_ladder_branch) {
       simhit_ladder_branch->SetAddress(&simhit_ladder_);
     }
   }
   ph2_layer_branch = 0;
   if (tree->GetBranch("ph2_layer") != 0) {
     ph2_layer_branch = tree->GetBranch("ph2_layer");
     if (ph2_layer_branch) {
       ph2_layer_branch->SetAddress(&ph2_layer_);
     }
   }
   see_phi_branch = 0;
   if (tree->GetBranch("see_phi") != 0) {
     see_phi_branch = tree->GetBranch("see_phi");
     if (see_phi_branch) {
       see_phi_branch->SetAddress(&see_phi_);
     }
   }
   trk_nChi2_1Dmod_branch = 0;
   if (tree->GetBranch("trk_nChi2_1Dmod") != 0) {
     trk_nChi2_1Dmod_branch = tree->GetBranch("trk_nChi2_1Dmod");
     if (trk_nChi2_1Dmod_branch) {
       trk_nChi2_1Dmod_branch->SetAddress(&trk_nChi2_1Dmod_);
     }
   }
   trk_inner_py_branch = 0;
   if (tree->GetBranch("trk_inner_py") != 0) {
     trk_inner_py_branch = tree->GetBranch("trk_inner_py");
     if (trk_inner_py_branch) {
       trk_inner_py_branch->SetAddress(&trk_inner_py_);
     }
   }
   trk_inner_px_branch = 0;
   if (tree->GetBranch("trk_inner_px") != 0) {
     trk_inner_px_branch = tree->GetBranch("trk_inner_px");
     if (trk_inner_px_branch) {
       trk_inner_px_branch->SetAddress(&trk_inner_px_);
     }
   }
   trk_dxyErr_branch = 0;
   if (tree->GetBranch("trk_dxyErr") != 0) {
     trk_dxyErr_branch = tree->GetBranch("trk_dxyErr");
     if (trk_dxyErr_branch) {
       trk_dxyErr_branch->SetAddress(&trk_dxyErr_);
     }
   }
   sim_nPixelLay_branch = 0;
   if (tree->GetBranch("sim_nPixelLay") != 0) {
     sim_nPixelLay_branch = tree->GetBranch("sim_nPixelLay");
     if (sim_nPixelLay_branch) {
       sim_nPixelLay_branch->SetAddress(&sim_nPixelLay_);
     }
   }
   see_nValid_branch = 0;
   if (tree->GetBranch("see_nValid") != 0) {
     see_nValid_branch = tree->GetBranch("see_nValid");
     if (see_nValid_branch) {
       see_nValid_branch->SetAddress(&see_nValid_);
     }
   }
   trk_inner_pt_branch = 0;
   if (tree->GetBranch("trk_inner_pt") != 0) {
     trk_inner_pt_branch = tree->GetBranch("trk_inner_pt");
     if (trk_inner_pt_branch) {
       trk_inner_pt_branch->SetAddress(&trk_inner_pt_);
     }
   }
   see_stateTrajGlbPy_branch = 0;
   if (tree->GetBranch("see_stateTrajGlbPy") != 0) {
     see_stateTrajGlbPy_branch = tree->GetBranch("see_stateTrajGlbPy");
     if (see_stateTrajGlbPy_branch) {
       see_stateTrajGlbPy_branch->SetAddress(&see_stateTrajGlbPy_);
     }
   }
   tree->SetMakeClass(0);
 }

◆ inv_blade()

const std::vector< unsigned short > & Trktree::inv_blade ( )

Definition at line 6453 of file Trktree.cc.

References beamvalidation::exit(), index, inv_blade_, inv_blade_branch, and inv_blade_isLoaded.

Referenced by tas::inv_blade(), and LoadAllBranches().

                                                     {
   if (not inv_blade_isLoaded) {
     if (inv_blade_branch != 0) {
       inv_blade_branch->GetEntry(index);
     } else {
       printf("branch inv_blade_branch does not exist!\n");
       exit(1);
     }
     inv_blade_isLoaded = true;
   }
   return *inv_blade_;
 }

◆ inv_detId()

const std::vector< unsigned int > & Trktree::inv_detId ( )

Definition at line 6249 of file Trktree.cc.

References beamvalidation::exit(), index, inv_detId_, inv_detId_branch, and inv_detId_isLoaded.

Referenced by tas::inv_detId(), and LoadAllBranches().

                                                   {
   if (not inv_detId_isLoaded) {
     if (inv_detId_branch != 0) {
       inv_detId_branch->GetEntry(index);
     } else {
       printf("branch inv_detId_branch does not exist!\n");
       exit(1);
     }
     inv_detId_isLoaded = true;
   }
   return *inv_detId_;
 }

◆ inv_isBarrel()

const std::vector< short > & Trktree::inv_isBarrel ( )

Definition at line 4881 of file Trktree.cc.

References beamvalidation::exit(), index, inv_isBarrel_, inv_isBarrel_branch, and inv_isBarrel_isLoaded.

Referenced by tas::inv_isBarrel(), and LoadAllBranches().

                                               {
   if (not inv_isBarrel_isLoaded) {
     if (inv_isBarrel_branch != 0) {
       inv_isBarrel_branch->GetEntry(index);
     } else {
       printf("branch inv_isBarrel_branch does not exist!\n");
       exit(1);
     }
     inv_isBarrel_isLoaded = true;
   }
   return *inv_isBarrel_;
 }

◆ inv_isLower()

const std::vector< unsigned short > & Trktree::inv_isLower ( )

Definition at line 6009 of file Trktree.cc.

References beamvalidation::exit(), index, inv_isLower_, inv_isLower_branch, and inv_isLower_isLoaded.

Referenced by tas::inv_isLower(), and LoadAllBranches().

                                                       {
   if (not inv_isLower_isLoaded) {
     if (inv_isLower_branch != 0) {
       inv_isLower_branch->GetEntry(index);
     } else {
       printf("branch inv_isLower_branch does not exist!\n");
       exit(1);
     }
     inv_isLower_isLoaded = true;
   }
   return *inv_isLower_;
 }

◆ inv_isStack()

const std::vector< unsigned short > & Trktree::inv_isStack ( )

Definition at line 5457 of file Trktree.cc.

References beamvalidation::exit(), index, inv_isStack_, inv_isStack_branch, and inv_isStack_isLoaded.

Referenced by tas::inv_isStack(), and LoadAllBranches().

                                                       {
   if (not inv_isStack_isLoaded) {
     if (inv_isStack_branch != 0) {
       inv_isStack_branch->GetEntry(index);
     } else {
       printf("branch inv_isStack_branch does not exist!\n");
       exit(1);
     }
     inv_isStack_isLoaded = true;
   }
   return *inv_isStack_;
 }

◆ inv_isUpper()

const std::vector< unsigned short > & Trktree::inv_isUpper ( )

Definition at line 4653 of file Trktree.cc.

References beamvalidation::exit(), index, inv_isUpper_, inv_isUpper_branch, and inv_isUpper_isLoaded.

Referenced by tas::inv_isUpper(), and LoadAllBranches().

                                                       {
   if (not inv_isUpper_isLoaded) {
     if (inv_isUpper_branch != 0) {
       inv_isUpper_branch->GetEntry(index);
     } else {
       printf("branch inv_isUpper_branch does not exist!\n");
       exit(1);
     }
     inv_isUpper_isLoaded = true;
   }
   return *inv_isUpper_;
 }

◆ inv_ladder()

const std::vector< unsigned short > & Trktree::inv_ladder ( )

Definition at line 6153 of file Trktree.cc.

References beamvalidation::exit(), index, inv_ladder_, inv_ladder_branch, and inv_ladder_isLoaded.

Referenced by tas::inv_ladder(), and LoadAllBranches().

                                                      {
   if (not inv_ladder_isLoaded) {
     if (inv_ladder_branch != 0) {
       inv_ladder_branch->GetEntry(index);
     } else {
       printf("branch inv_ladder_branch does not exist!\n");
       exit(1);
     }
     inv_ladder_isLoaded = true;
   }
   return *inv_ladder_;
 }

◆ inv_layer()

const std::vector< unsigned short > & Trktree::inv_layer ( )

Definition at line 5961 of file Trktree.cc.

References beamvalidation::exit(), index, inv_layer_, inv_layer_branch, and inv_layer_isLoaded.

Referenced by tas::inv_layer(), and LoadAllBranches().

                                                     {
   if (not inv_layer_isLoaded) {
     if (inv_layer_branch != 0) {
       inv_layer_branch->GetEntry(index);
     } else {
       printf("branch inv_layer_branch does not exist!\n");
       exit(1);
     }
     inv_layer_isLoaded = true;
   }
   return *inv_layer_;
 }

◆ inv_module()

const std::vector< unsigned short > & Trktree::inv_module ( )

Definition at line 6117 of file Trktree.cc.

References beamvalidation::exit(), index, inv_module_, inv_module_branch, and inv_module_isLoaded.

Referenced by tas::inv_module(), and LoadAllBranches().

                                                      {
   if (not inv_module_isLoaded) {
     if (inv_module_branch != 0) {
       inv_module_branch->GetEntry(index);
     } else {
       printf("branch inv_module_branch does not exist!\n");
       exit(1);
     }
     inv_module_isLoaded = true;
   }
   return *inv_module_;
 }

◆ inv_order()

const std::vector< unsigned short > & Trktree::inv_order ( )

Definition at line 3693 of file Trktree.cc.

References beamvalidation::exit(), index, inv_order_, inv_order_branch, and inv_order_isLoaded.

Referenced by tas::inv_order(), and LoadAllBranches().

                                                     {
   if (not inv_order_isLoaded) {
     if (inv_order_branch != 0) {
       inv_order_branch->GetEntry(index);
     } else {
       printf("branch inv_order_branch does not exist!\n");
       exit(1);
     }
     inv_order_isLoaded = true;
   }
   return *inv_order_;
 }

◆ inv_panel()

const std::vector< unsigned short > & Trktree::inv_panel ( )

Definition at line 4701 of file Trktree.cc.

References beamvalidation::exit(), index, inv_panel_, inv_panel_branch, and inv_panel_isLoaded.

Referenced by tas::inv_panel(), and LoadAllBranches().

                                                     {
   if (not inv_panel_isLoaded) {
     if (inv_panel_branch != 0) {
       inv_panel_branch->GetEntry(index);
     } else {
       printf("branch inv_panel_branch does not exist!\n");
       exit(1);
     }
     inv_panel_isLoaded = true;
   }
   return *inv_panel_;
 }

◆ inv_ring()

const std::vector< unsigned short > & Trktree::inv_ring ( )

Definition at line 4041 of file Trktree.cc.

References beamvalidation::exit(), index, inv_ring_, inv_ring_branch, and inv_ring_isLoaded.

Referenced by tas::inv_ring(), and LoadAllBranches().

                                                    {
   if (not inv_ring_isLoaded) {
     if (inv_ring_branch != 0) {
       inv_ring_branch->GetEntry(index);
     } else {
       printf("branch inv_ring_branch does not exist!\n");
       exit(1);
     }
     inv_ring_isLoaded = true;
   }
   return *inv_ring_;
 }

◆ inv_rod()

const std::vector< unsigned short > & Trktree::inv_rod ( )

Definition at line 5001 of file Trktree.cc.

References beamvalidation::exit(), index, inv_rod_, inv_rod_branch, and inv_rod_isLoaded.

Referenced by tas::inv_rod(), and LoadAllBranches().

                                                   {
   if (not inv_rod_isLoaded) {
     if (inv_rod_branch != 0) {
       inv_rod_branch->GetEntry(index);
     } else {
       printf("branch inv_rod_branch does not exist!\n");
       exit(1);
     }
     inv_rod_isLoaded = true;
   }
   return *inv_rod_;
 }

◆ inv_side()

const std::vector< unsigned short > & Trktree::inv_side ( )

Definition at line 5733 of file Trktree.cc.

References beamvalidation::exit(), index, inv_side_, inv_side_branch, and inv_side_isLoaded.

Referenced by tas::inv_side(), and LoadAllBranches().

                                                    {
   if (not inv_side_isLoaded) {
     if (inv_side_branch != 0) {
       inv_side_branch->GetEntry(index);
     } else {
       printf("branch inv_side_branch does not exist!\n");
       exit(1);
     }
     inv_side_isLoaded = true;
   }
   return *inv_side_;
 }

◆ inv_subdet()

const std::vector< unsigned short > & Trktree::inv_subdet ( )

Definition at line 3753 of file Trktree.cc.

References beamvalidation::exit(), index, inv_subdet_, inv_subdet_branch, and inv_subdet_isLoaded.

Referenced by tas::inv_subdet(), and LoadAllBranches().

                                                      {
   if (not inv_subdet_isLoaded) {
     if (inv_subdet_branch != 0) {
       inv_subdet_branch->GetEntry(index);
     } else {
       printf("branch inv_subdet_branch does not exist!\n");
       exit(1);
     }
     inv_subdet_isLoaded = true;
   }
   return *inv_subdet_;
 }

◆ inv_type()

const std::vector< unsigned short > & Trktree::inv_type ( )

Definition at line 4221 of file Trktree.cc.

References beamvalidation::exit(), index, inv_type_, inv_type_branch, and inv_type_isLoaded.

Referenced by tas::inv_type(), and LoadAllBranches().

                                                    {
   if (not inv_type_isLoaded) {
     if (inv_type_branch != 0) {
       inv_type_branch->GetEntry(index);
     } else {
       printf("branch inv_type_branch does not exist!\n");
       exit(1);
     }
     inv_type_isLoaded = true;
   }
   return *inv_type_;
 }

◆ LoadAllBranches()

void Trktree::LoadAllBranches ( )

Definition at line 2437 of file Trktree.cc.

                               {
   if (see_stateCcov01_branch != 0)
     see_stateCcov01();
   if (simhit_rod_branch != 0)
     simhit_rod();
   if (trk_phi_branch != 0)
     trk_phi();
   if (bsp_x_branch != 0)
     bsp_x();
   if (see_stateCcov05_branch != 0)
     see_stateCcov05();
   if (see_stateCcov04_branch != 0)
     see_stateCcov04();
   if (trk_dxyPV_branch != 0)
     trk_dxyPV();
   if (simhit_tof_branch != 0)
     simhit_tof();
   if (sim_event_branch != 0)
     sim_event();
   if (simhit_isStack_branch != 0)
     simhit_isStack();
   if (trk_dz_branch != 0)
     trk_dz();
   if (see_stateCcov03_branch != 0)
     see_stateCcov03();
   if (sim_eta_branch != 0)
     sim_eta();
   if (simvtx_processType_branch != 0)
     simvtx_processType();
   if (pix_radL_branch != 0)
     pix_radL();
   if (see_stateCcov02_branch != 0)
     see_stateCcov02();
   if (see_nGlued_branch != 0)
     see_nGlued();
   if (trk_bestSimTrkIdx_branch != 0)
     trk_bestSimTrkIdx();
   if (see_stateTrajGlbPz_branch != 0)
     see_stateTrajGlbPz();
   if (pix_yz_branch != 0)
     pix_yz();
   if (pix_yy_branch != 0)
     pix_yy();
   if (simhit_process_branch != 0)
     simhit_process();
   if (see_stateCcov34_branch != 0)
     see_stateCcov34();
   if (trk_nInnerLost_branch != 0)
     trk_nInnerLost();
   if (see_py_branch != 0)
     see_py();
   if (sim_trkIdx_branch != 0)
     sim_trkIdx();
   if (trk_nLost_branch != 0)
     trk_nLost();
   if (pix_isBarrel_branch != 0)
     pix_isBarrel();
   if (see_dxyErr_branch != 0)
     see_dxyErr();
   if (simhit_detId_branch != 0)
     simhit_detId();
   if (simhit_subdet_branch != 0)
     simhit_subdet();
   if (see_hitIdx_branch != 0)
     see_hitIdx();
   if (see_pt_branch != 0)
     see_pt();
   if (ph2_detId_branch != 0)
     ph2_detId();
   if (trk_nStripLay_branch != 0)
     trk_nStripLay();
   if (see_bestFromFirstHitSimTrkIdx_branch != 0)
     see_bestFromFirstHitSimTrkIdx();
   if (sim_pca_pt_branch != 0)
     sim_pca_pt();
   if (see_trkIdx_branch != 0)
     see_trkIdx();
   if (trk_nCluster_branch != 0)
     trk_nCluster();
   if (trk_bestFromFirstHitSimTrkNChi2_branch != 0)
     trk_bestFromFirstHitSimTrkNChi2();
   if (trk_isHP_branch != 0)
     trk_isHP();
   if (simhit_hitType_branch != 0)
     simhit_hitType();
   if (ph2_isUpper_branch != 0)
     ph2_isUpper();
   if (see_nStrip_branch != 0)
     see_nStrip();
   if (trk_bestSimTrkShareFracSimClusterDenom_branch != 0)
     trk_bestSimTrkShareFracSimClusterDenom();
   if (simhit_side_branch != 0)
     simhit_side();
   if (simhit_x_branch != 0)
     simhit_x();
   if (see_q_branch != 0)
     see_q();
   if (simhit_z_branch != 0)
     simhit_z();
   if (sim_pca_lambda_branch != 0)
     sim_pca_lambda();
   if (sim_q_branch != 0)
     sim_q();
   if (pix_bbxi_branch != 0)
     pix_bbxi();
   if (ph2_order_branch != 0)
     ph2_order();
   if (ph2_module_branch != 0)
     ph2_module();
   if (inv_order_branch != 0)
     inv_order();
   if (trk_dzErr_branch != 0)
     trk_dzErr();
   if (trk_nInnerInactive_branch != 0)
     trk_nInnerInactive();
   if (see_fitok_branch != 0)
     see_fitok();
   if (simhit_blade_branch != 0)
     simhit_blade();
   if (inv_subdet_branch != 0)
     inv_subdet();
   if (pix_blade_branch != 0)
     pix_blade();
   if (pix_xx_branch != 0)
     pix_xx();
   if (pix_xy_branch != 0)
     pix_xy();
   if (simhit_panel_branch != 0)
     simhit_panel();
   if (sim_pz_branch != 0)
     sim_pz();
   if (trk_dxy_branch != 0)
     trk_dxy();
   if (sim_px_branch != 0)
     sim_px();
   if (trk_lambda_branch != 0)
     trk_lambda();
   if (see_stateCcov12_branch != 0)
     see_stateCcov12();
   if (sim_pt_branch != 0)
     sim_pt();
   if (sim_py_branch != 0)
     sim_py();
   if (sim_decayVtxIdx_branch != 0)
     sim_decayVtxIdx();
   if (pix_detId_branch != 0)
     pix_detId();
   if (trk_eta_branch != 0)
     trk_eta();
   if (see_dxy_branch != 0)
     see_dxy();
   if (sim_isFromBHadron_branch != 0)
     sim_isFromBHadron();
   if (simhit_eloss_branch != 0)
     simhit_eloss();
   if (see_stateCcov11_branch != 0)
     see_stateCcov11();
   if (simhit_pz_branch != 0)
     simhit_pz();
   if (sim_pdgId_branch != 0)
     sim_pdgId();
   if (trk_stopReason_branch != 0)
     trk_stopReason();
   if (sim_pca_phi_branch != 0)
     sim_pca_phi();
   if (simhit_isLower_branch != 0)
     simhit_isLower();
   if (inv_ring_branch != 0)
     inv_ring();
   if (ph2_simHitIdx_branch != 0)
     ph2_simHitIdx();
   if (simhit_order_branch != 0)
     simhit_order();
   if (trk_dxyClosestPV_branch != 0)
     trk_dxyClosestPV();
   if (pix_z_branch != 0)
     pix_z();
   if (pix_y_branch != 0)
     pix_y();
   if (pix_x_branch != 0)
     pix_x();
   if (see_hitType_branch != 0)
     see_hitType();
   if (see_statePt_branch != 0)
     see_statePt();
   if (simvtx_sourceSimIdx_branch != 0)
     simvtx_sourceSimIdx();
   if (event_branch != 0)
     event();
   if (pix_module_branch != 0)
     pix_module();
   if (ph2_side_branch != 0)
     ph2_side();
   if (trk_bestSimTrkNChi2_branch != 0)
     trk_bestSimTrkNChi2();
   if (see_stateTrajPy_branch != 0)
     see_stateTrajPy();
   if (inv_type_branch != 0)
     inv_type();
   if (bsp_z_branch != 0)
     bsp_z();
   if (bsp_y_branch != 0)
     bsp_y();
   if (simhit_py_branch != 0)
     simhit_py();
   if (see_simTrkIdx_branch != 0)
     see_simTrkIdx();
   if (see_stateTrajGlbZ_branch != 0)
     see_stateTrajGlbZ();
   if (see_stateTrajGlbX_branch != 0)
     see_stateTrajGlbX();
   if (see_stateTrajGlbY_branch != 0)
     see_stateTrajGlbY();
   if (trk_originalAlgo_branch != 0)
     trk_originalAlgo();
   if (trk_nPixel_branch != 0)
     trk_nPixel();
   if (see_stateCcov14_branch != 0)
     see_stateCcov14();
   if (see_stateCcov15_branch != 0)
     see_stateCcov15();
   if (trk_phiErr_branch != 0)
     trk_phiErr();
   if (see_stateCcov13_branch != 0)
     see_stateCcov13();
   if (pix_chargeFraction_branch != 0)
     pix_chargeFraction();
   if (trk_q_branch != 0)
     trk_q();
   if (sim_seedIdx_branch != 0)
     sim_seedIdx();
   if (see_dzErr_branch != 0)
     see_dzErr();
   if (sim_nRecoClusters_branch != 0)
     sim_nRecoClusters();
   if (run_branch != 0)
     run();
   if (ph2_xySignificance_branch != 0)
     ph2_xySignificance();
   if (trk_nChi2_branch != 0)
     trk_nChi2();
   if (pix_layer_branch != 0)
     pix_layer();
   if (pix_xySignificance_branch != 0)
     pix_xySignificance();
   if (sim_pca_eta_branch != 0)
     sim_pca_eta();
   if (see_bestSimTrkShareFrac_branch != 0)
     see_bestSimTrkShareFrac();
   if (see_etaErr_branch != 0)
     see_etaErr();
   if (trk_bestSimTrkShareFracSimDenom_branch != 0)
     trk_bestSimTrkShareFracSimDenom();
   if (bsp_sigmaz_branch != 0)
     bsp_sigmaz();
   if (bsp_sigmay_branch != 0)
     bsp_sigmay();
   if (bsp_sigmax_branch != 0)
     bsp_sigmax();
   if (pix_ladder_branch != 0)
     pix_ladder();
   if (trk_qualityMask_branch != 0)
     trk_qualityMask();
   if (trk_ndof_branch != 0)
     trk_ndof();
   if (pix_subdet_branch != 0)
     pix_subdet();
   if (ph2_seeIdx_branch != 0)
     ph2_seeIdx();
   if (inv_isUpper_branch != 0)
     inv_isUpper();
   if (ph2_zx_branch != 0)
     ph2_zx();
   if (pix_trkIdx_branch != 0)
     pix_trkIdx();
   if (trk_nOuterLost_branch != 0)
     trk_nOuterLost();
   if (inv_panel_branch != 0)
     inv_panel();
   if (vtx_z_branch != 0)
     vtx_z();
   if (simhit_layer_branch != 0)
     simhit_layer();
   if (vtx_y_branch != 0)
     vtx_y();
   if (ph2_isBarrel_branch != 0)
     ph2_isBarrel();
   if (pix_seeIdx_branch != 0)
     pix_seeIdx();
   if (trk_bestFromFirstHitSimTrkIdx_branch != 0)
     trk_bestFromFirstHitSimTrkIdx();
   if (simhit_px_branch != 0)
     simhit_px();
   if (see_stateTrajX_branch != 0)
     see_stateTrajX();
   if (see_stateTrajY_branch != 0)
     see_stateTrajY();
   if (trk_nOuterInactive_branch != 0)
     trk_nOuterInactive();
   if (sim_pca_dxy_branch != 0)
     sim_pca_dxy();
   if (trk_algo_branch != 0)
     trk_algo();
   if (trk_hitType_branch != 0)
     trk_hitType();
   if (trk_bestFromFirstHitSimTrkShareFrac_branch != 0)
     trk_bestFromFirstHitSimTrkShareFrac();
   if (inv_isBarrel_branch != 0)
     inv_isBarrel();
   if (simvtx_event_branch != 0)
     simvtx_event();
   if (ph2_z_branch != 0)
     ph2_z();
   if (ph2_x_branch != 0)
     ph2_x();
   if (ph2_y_branch != 0)
     ph2_y();
   if (sim_genPdgIds_branch != 0)
     sim_genPdgIds();
   if (trk_mva_branch != 0)
     trk_mva();
   if (see_stateCcov24_branch != 0)
     see_stateCcov24();
   if (trk_dzClosestPV_branch != 0)
     trk_dzClosestPV();
   if (see_nCluster_branch != 0)
     see_nCluster();
   if (inv_rod_branch != 0)
     inv_rod();
   if (trk_hitIdx_branch != 0)
     trk_hitIdx();
   if (see_stateCcov22_branch != 0)
     see_stateCcov22();
   if (pix_simType_branch != 0)
     pix_simType();
   if (simhit_ring_branch != 0)
     simhit_ring();
   if (trk_outer_px_branch != 0)
     trk_outer_px();
   if (trk_outer_py_branch != 0)
     trk_outer_py();
   if (trk_outer_pz_branch != 0)
     trk_outer_pz();
   if (ph2_zz_branch != 0)
     ph2_zz();
   if (trk_outer_pt_branch != 0)
     trk_outer_pt();
   if (trk_n3DLay_branch != 0)
     trk_n3DLay();
   if (trk_nValid_branch != 0)
     trk_nValid();
   if (see_ptErr_branch != 0)
     see_ptErr();
   if (see_stateTrajGlbPx_branch != 0)
     see_stateTrajGlbPx();
   if (ph2_simType_branch != 0)
     ph2_simType();
   if (trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch != 0)
     trk_bestFromFirstHitSimTrkShareFracSimClusterDenom();
   if (sim_hits_branch != 0)
     sim_hits();
   if (sim_len_branch != 0)
     sim_len();
   if (sim_lengap_branch != 0)
     sim_lengap();
   if (simvtx_x_branch != 0)
     simvtx_x();
   if (trk_pz_branch != 0)
     trk_pz();
   if (see_bestFromFirstHitSimTrkShareFrac_branch != 0)
     see_bestFromFirstHitSimTrkShareFrac();
   if (trk_px_branch != 0)
     trk_px();
   if (trk_py_branch != 0)
     trk_py();
   if (trk_vtxIdx_branch != 0)
     trk_vtxIdx();
   if (sim_nPixel_branch != 0)
     sim_nPixel();
   if (vtx_chi2_branch != 0)
     vtx_chi2();
   if (ph2_ring_branch != 0)
     ph2_ring();
   if (trk_pt_branch != 0)
     trk_pt();
   if (see_stateCcov44_branch != 0)
     see_stateCcov44();
   if (ph2_radL_branch != 0)
     ph2_radL();
   if (vtx_zErr_branch != 0)
     vtx_zErr();
   if (see_px_branch != 0)
     see_px();
   if (see_pz_branch != 0)
     see_pz();
   if (see_eta_branch != 0)
     see_eta();
   if (simvtx_bunchCrossing_branch != 0)
     simvtx_bunchCrossing();
   if (sim_pca_dz_branch != 0)
     sim_pca_dz();
   if (simvtx_y_branch != 0)
     simvtx_y();
   if (inv_isStack_branch != 0)
     inv_isStack();
   if (trk_nStrip_branch != 0)
     trk_nStrip();
   if (trk_etaErr_branch != 0)
     trk_etaErr();
   if (trk_simTrkNChi2_branch != 0)
     trk_simTrkNChi2();
   if (pix_zz_branch != 0)
     pix_zz();
   if (simhit_particle_branch != 0)
     simhit_particle();
   if (see_dz_branch != 0)
     see_dz();
   if (see_stateTrajPz_branch != 0)
     see_stateTrajPz();
   if (trk_bestSimTrkShareFrac_branch != 0)
     trk_bestSimTrkShareFrac();
   if (trk_lambdaErr_branch != 0)
     trk_lambdaErr();
   if (see_simTrkShareFrac_branch != 0)
     see_simTrkShareFrac();
   if (pix_simHitIdx_branch != 0)
     pix_simHitIdx();
   if (vtx_trkIdx_branch != 0)
     vtx_trkIdx();
   if (ph2_rod_branch != 0)
     ph2_rod();
   if (vtx_ndof_branch != 0)
     vtx_ndof();
   if (see_nPixel_branch != 0)
     see_nPixel();
   if (sim_nStrip_branch != 0)
     sim_nStrip();
   if (sim_bunchCrossing_branch != 0)
     sim_bunchCrossing();
   if (see_stateCcov45_branch != 0)
     see_stateCcov45();
   if (ph2_isStack_branch != 0)
     ph2_isStack();
   if (sim_trkShareFrac_branch != 0)
     sim_trkShareFrac();
   if (trk_simTrkShareFrac_branch != 0)
     trk_simTrkShareFrac();
   if (sim_phi_branch != 0)
     sim_phi();
   if (inv_side_branch != 0)
     inv_side();
   if (vtx_fake_branch != 0)
     vtx_fake();
   if (trk_nInactive_branch != 0)
     trk_nInactive();
   if (trk_nPixelLay_branch != 0)
     trk_nPixelLay();
   if (ph2_bbxi_branch != 0)
     ph2_bbxi();
   if (vtx_xErr_branch != 0)
     vtx_xErr();
   if (see_stateCcov25_branch != 0)
     see_stateCcov25();
   if (sim_parentVtxIdx_branch != 0)
     sim_parentVtxIdx();
   if (see_stateCcov23_branch != 0)
     see_stateCcov23();
   if (trk_algoMask_branch != 0)
     trk_algoMask();
   if (trk_simTrkIdx_branch != 0)
     trk_simTrkIdx();
   if (see_phiErr_branch != 0)
     see_phiErr();
   if (trk_cotTheta_branch != 0)
     trk_cotTheta();
   if (see_algo_branch != 0)
     see_algo();
   if (simhit_module_branch != 0)
     simhit_module();
   if (simvtx_daughterSimIdx_branch != 0)
     simvtx_daughterSimIdx();
   if (vtx_x_branch != 0)
     vtx_x();
   if (trk_seedIdx_branch != 0)
     trk_seedIdx();
   if (simhit_y_branch != 0)
     simhit_y();
   if (inv_layer_branch != 0)
     inv_layer();
   if (trk_nLostLay_branch != 0)
     trk_nLostLay();
   if (ph2_isLower_branch != 0)
     ph2_isLower();
   if (pix_side_branch != 0)
     pix_side();
   if (inv_isLower_branch != 0)
     inv_isLower();
   if (ph2_trkIdx_branch != 0)
     ph2_trkIdx();
   if (sim_nValid_branch != 0)
     sim_nValid();
   if (simhit_simTrkIdx_branch != 0)
     simhit_simTrkIdx();
   if (see_nCands_branch != 0)
     see_nCands();
   if (see_bestSimTrkIdx_branch != 0)
     see_bestSimTrkIdx();
   if (vtx_yErr_branch != 0)
     vtx_yErr();
   if (trk_dzPV_branch != 0)
     trk_dzPV();
   if (ph2_xy_branch != 0)
     ph2_xy();
   if (inv_module_branch != 0)
     inv_module();
   if (see_stateCcov55_branch != 0)
     see_stateCcov55();
   if (pix_panel_branch != 0)
     pix_panel();
   if (inv_ladder_branch != 0)
     inv_ladder();
   if (ph2_xx_branch != 0)
     ph2_xx();
   if (sim_pca_cotTheta_branch != 0)
     sim_pca_cotTheta();
   if (simpv_idx_branch != 0)
     simpv_idx();
   if (trk_inner_pz_branch != 0)
     trk_inner_pz();
   if (see_chi2_branch != 0)
     see_chi2();
   if (see_stateCcov35_branch != 0)
     see_stateCcov35();
   if (see_stateCcov33_branch != 0)
     see_stateCcov33();
   if (inv_detId_branch != 0)
     inv_detId();
   if (see_offset_branch != 0)
     see_offset();
   if (sim_nLay_branch != 0)
     sim_nLay();
   if (sim_simHitIdx_branch != 0)
     sim_simHitIdx();
   if (simhit_isUpper_branch != 0)
     simhit_isUpper();
   if (see_stateCcov00_branch != 0)
     see_stateCcov00();
   if (see_stopReason_branch != 0)
     see_stopReason();
   if (vtx_valid_branch != 0)
     vtx_valid();
   if (lumi_branch != 0)
     lumi();
   if (trk_refpoint_x_branch != 0)
     trk_refpoint_x();
   if (trk_refpoint_y_branch != 0)
     trk_refpoint_y();
   if (trk_refpoint_z_branch != 0)
     trk_refpoint_z();
   if (sim_n3DLay_branch != 0)
     sim_n3DLay();
   if (see_nPhase2OT_branch != 0)
     see_nPhase2OT();
   if (trk_bestFromFirstHitSimTrkShareFracSimDenom_branch != 0)
     trk_bestFromFirstHitSimTrkShareFracSimDenom();
   if (ph2_yy_branch != 0)
     ph2_yy();
   if (ph2_yz_branch != 0)
     ph2_yz();
   if (inv_blade_branch != 0)
     inv_blade();
   if (trk_ptErr_branch != 0)
     trk_ptErr();
   if (pix_zx_branch != 0)
     pix_zx();
   if (simvtx_z_branch != 0)
     simvtx_z();
   if (sim_nTrackerHits_branch != 0)
     sim_nTrackerHits();
   if (ph2_subdet_branch != 0)
     ph2_subdet();
   if (see_stateTrajPx_branch != 0)
     see_stateTrajPx();
   if (simhit_hitIdx_branch != 0)
     simhit_hitIdx();
   if (simhit_ladder_branch != 0)
     simhit_ladder();
   if (ph2_layer_branch != 0)
     ph2_layer();
   if (see_phi_branch != 0)
     see_phi();
   if (trk_nChi2_1Dmod_branch != 0)
     trk_nChi2_1Dmod();
   if (trk_inner_py_branch != 0)
     trk_inner_py();
   if (trk_inner_px_branch != 0)
     trk_inner_px();
   if (trk_dxyErr_branch != 0)
     trk_dxyErr();
   if (sim_nPixelLay_branch != 0)
     sim_nPixelLay();
   if (see_nValid_branch != 0)
     see_nValid();
   if (trk_inner_pt_branch != 0)
     trk_inner_pt();
   if (see_stateTrajGlbPy_branch != 0)
     see_stateTrajGlbPy();
 }

◆ lumi()

const unsigned int & Trktree::lumi ( )

Definition at line 6345 of file Trktree.cc.

References beamvalidation::exit(), index, lumi_, lumi_branch, and lumi_isLoaded.

Referenced by LoadAllBranches(), and tas::lumi().

                                   {
   if (not lumi_isLoaded) {
     if (lumi_branch != 0) {
       lumi_branch->GetEntry(index);
     } else {
       printf("branch lumi_branch does not exist!\n");
       exit(1);
     }
     lumi_isLoaded = true;
   }
   return lumi_;
 }

◆ ph2_bbxi()

const std::vector< float > & Trktree::ph2_bbxi ( )

Definition at line 5781 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_bbxi_, ph2_bbxi_branch, and ph2_bbxi_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_bbxi().

                                           {
   if (not ph2_bbxi_isLoaded) {
     if (ph2_bbxi_branch != 0) {
       ph2_bbxi_branch->GetEntry(index);
     } else {
       printf("branch ph2_bbxi_branch does not exist!\n");
       exit(1);
     }
     ph2_bbxi_isLoaded = true;
   }
   return *ph2_bbxi_;
 }

◆ ph2_detId()

const std::vector< unsigned int > & Trktree::ph2_detId ( )

Definition at line 3441 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_detId_, ph2_detId_branch, and ph2_detId_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), tas::ph2_detId(), and setGnnNtupleMiniDoublet().

                                                   {
   if (not ph2_detId_isLoaded) {
     if (ph2_detId_branch != 0) {
       ph2_detId_branch->GetEntry(index);
     } else {
       printf("branch ph2_detId_branch does not exist!\n");
       exit(1);
     }
     ph2_detId_isLoaded = true;
   }
   return *ph2_detId_;
 }

◆ ph2_isBarrel()

const std::vector< short > & Trktree::ph2_isBarrel ( )

Definition at line 4749 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_isBarrel_, ph2_isBarrel_branch, and ph2_isBarrel_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_isBarrel().

                                               {
   if (not ph2_isBarrel_isLoaded) {
     if (ph2_isBarrel_branch != 0) {
       ph2_isBarrel_branch->GetEntry(index);
     } else {
       printf("branch ph2_isBarrel_branch does not exist!\n");
       exit(1);
     }
     ph2_isBarrel_isLoaded = true;
   }
   return *ph2_isBarrel_;
 }

◆ ph2_isLower()

const std::vector< unsigned short > & Trktree::ph2_isLower ( )

Definition at line 5985 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_isLower_, ph2_isLower_branch, and ph2_isLower_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_isLower().

                                                       {
   if (not ph2_isLower_isLoaded) {
     if (ph2_isLower_branch != 0) {
       ph2_isLower_branch->GetEntry(index);
     } else {
       printf("branch ph2_isLower_branch does not exist!\n");
       exit(1);
     }
     ph2_isLower_isLoaded = true;
   }
   return *ph2_isLower_;
 }

◆ ph2_isStack()

const std::vector< unsigned short > & Trktree::ph2_isStack ( )

Definition at line 5685 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_isStack_, ph2_isStack_branch, and ph2_isStack_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_isStack().

                                                       {
   if (not ph2_isStack_isLoaded) {
     if (ph2_isStack_branch != 0) {
       ph2_isStack_branch->GetEntry(index);
     } else {
       printf("branch ph2_isStack_branch does not exist!\n");
       exit(1);
     }
     ph2_isStack_isLoaded = true;
   }
   return *ph2_isStack_;
 }

◆ ph2_isUpper()

const std::vector< unsigned short > & Trktree::ph2_isUpper ( )

Definition at line 3549 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_isUpper_, ph2_isUpper_branch, and ph2_isUpper_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_isUpper().

                                                       {
   if (not ph2_isUpper_isLoaded) {
     if (ph2_isUpper_branch != 0) {
       ph2_isUpper_branch->GetEntry(index);
     } else {
       printf("branch ph2_isUpper_branch does not exist!\n");
       exit(1);
     }
     ph2_isUpper_isLoaded = true;
   }
   return *ph2_isUpper_;
 }

◆ ph2_layer()

const std::vector< unsigned short > & Trktree::ph2_layer ( )

Definition at line 6561 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_layer_, ph2_layer_branch, and ph2_layer_isLoaded.

Referenced by LoadAllBranches(), tas::ph2_layer(), and setGnnNtupleMiniDoublet().

                                                     {
   if (not ph2_layer_isLoaded) {
     if (ph2_layer_branch != 0) {
       ph2_layer_branch->GetEntry(index);
     } else {
       printf("branch ph2_layer_branch does not exist!\n");
       exit(1);
     }
     ph2_layer_isLoaded = true;
   }
   return *ph2_layer_;
 }

◆ ph2_module()

const std::vector< unsigned short > & Trktree::ph2_module ( )

Definition at line 3681 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_module_, ph2_module_branch, and ph2_module_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_module().

                                                      {
   if (not ph2_module_isLoaded) {
     if (ph2_module_branch != 0) {
       ph2_module_branch->GetEntry(index);
     } else {
       printf("branch ph2_module_branch does not exist!\n");
       exit(1);
     }
     ph2_module_isLoaded = true;
   }
   return *ph2_module_;
 }

◆ ph2_order()

const std::vector< unsigned short > & Trktree::ph2_order ( )

Definition at line 3669 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_order_, ph2_order_branch, and ph2_order_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_order().

                                                     {
   if (not ph2_order_isLoaded) {
     if (ph2_order_branch != 0) {
       ph2_order_branch->GetEntry(index);
     } else {
       printf("branch ph2_order_branch does not exist!\n");
       exit(1);
     }
     ph2_order_isLoaded = true;
   }
   return *ph2_order_;
 }

◆ ph2_radL()

const std::vector< float > & Trktree::ph2_radL ( )

Definition at line 5361 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_radL_, ph2_radL_branch, and ph2_radL_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_radL().

                                           {
   if (not ph2_radL_isLoaded) {
     if (ph2_radL_branch != 0) {
       ph2_radL_branch->GetEntry(index);
     } else {
       printf("branch ph2_radL_branch does not exist!\n");
       exit(1);
     }
     ph2_radL_isLoaded = true;
   }
   return *ph2_radL_;
 }

◆ ph2_ring()

const std::vector< unsigned short > & Trktree::ph2_ring ( )

Definition at line 5325 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_ring_, ph2_ring_branch, and ph2_ring_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_ring().

                                                    {
   if (not ph2_ring_isLoaded) {
     if (ph2_ring_branch != 0) {
       ph2_ring_branch->GetEntry(index);
     } else {
       printf("branch ph2_ring_branch does not exist!\n");
       exit(1);
     }
     ph2_ring_isLoaded = true;
   }
   return *ph2_ring_;
 }

◆ ph2_rod()

const std::vector< unsigned short > & Trktree::ph2_rod ( )

Definition at line 5613 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_rod_, ph2_rod_branch, and ph2_rod_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_rod().

                                                   {
   if (not ph2_rod_isLoaded) {
     if (ph2_rod_branch != 0) {
       ph2_rod_branch->GetEntry(index);
     } else {
       printf("branch ph2_rod_branch does not exist!\n");
       exit(1);
     }
     ph2_rod_isLoaded = true;
   }
   return *ph2_rod_;
 }

◆ ph2_seeIdx()

const std::vector< std::vector< int > > & Trktree::ph2_seeIdx ( )

Definition at line 4641 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_seeIdx_, ph2_seeIdx_branch, and ph2_seeIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_seeIdx().

                                                       {
   if (not ph2_seeIdx_isLoaded) {
     if (ph2_seeIdx_branch != 0) {
       ph2_seeIdx_branch->GetEntry(index);
     } else {
       printf("branch ph2_seeIdx_branch does not exist!\n");
       exit(1);
     }
     ph2_seeIdx_isLoaded = true;
   }
   return *ph2_seeIdx_;
 }

◆ ph2_side()

const std::vector< unsigned short > & Trktree::ph2_side ( )

Definition at line 4185 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_side_, ph2_side_branch, and ph2_side_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_side().

                                                    {
   if (not ph2_side_isLoaded) {
     if (ph2_side_branch != 0) {
       ph2_side_branch->GetEntry(index);
     } else {
       printf("branch ph2_side_branch does not exist!\n");
       exit(1);
     }
     ph2_side_isLoaded = true;
   }
   return *ph2_side_;
 }

◆ ph2_simHitIdx()

const std::vector< std::vector< int > > & Trktree::ph2_simHitIdx ( )

Definition at line 4053 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_simHitIdx_, ph2_simHitIdx_branch, and ph2_simHitIdx_isLoaded.

Referenced by LoadAllBranches(), matchedSimTrkIdxs(), and tas::ph2_simHitIdx().

                                                          {
   if (not ph2_simHitIdx_isLoaded) {
     if (ph2_simHitIdx_branch != 0) {
       ph2_simHitIdx_branch->GetEntry(index);
     } else {
       printf("branch ph2_simHitIdx_branch does not exist!\n");
       exit(1);
     }
     ph2_simHitIdx_isLoaded = true;
   }
   return *ph2_simHitIdx_;
 }

◆ ph2_simType()

const std::vector< unsigned short > & Trktree::ph2_simType ( )

Definition at line 5169 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_simType_, ph2_simType_branch, and ph2_simType_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_simType().

                                                       {
   if (not ph2_simType_isLoaded) {
     if (ph2_simType_branch != 0) {
       ph2_simType_branch->GetEntry(index);
     } else {
       printf("branch ph2_simType_branch does not exist!\n");
       exit(1);
     }
     ph2_simType_isLoaded = true;
   }
   return *ph2_simType_;
 }

◆ ph2_subdet()

const std::vector< unsigned short > & Trktree::ph2_subdet ( )

Definition at line 6513 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_subdet_, ph2_subdet_branch, and ph2_subdet_isLoaded.

Referenced by LoadAllBranches(), tas::ph2_subdet(), and setGnnNtupleMiniDoublet().

                                                      {
   if (not ph2_subdet_isLoaded) {
     if (ph2_subdet_branch != 0) {
       ph2_subdet_branch->GetEntry(index);
     } else {
       printf("branch ph2_subdet_branch does not exist!\n");
       exit(1);
     }
     ph2_subdet_isLoaded = true;
   }
   return *ph2_subdet_;
 }

◆ ph2_trkIdx()

const std::vector< std::vector< int > > & Trktree::ph2_trkIdx ( )

Definition at line 6021 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_trkIdx_, ph2_trkIdx_branch, and ph2_trkIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_trkIdx().

                                                       {
   if (not ph2_trkIdx_isLoaded) {
     if (ph2_trkIdx_branch != 0) {
       ph2_trkIdx_branch->GetEntry(index);
     } else {
       printf("branch ph2_trkIdx_branch does not exist!\n");
       exit(1);
     }
     ph2_trkIdx_isLoaded = true;
   }
   return *ph2_trkIdx_;
 }

◆ ph2_x()

const std::vector< float > & Trktree::ph2_x ( )

Definition at line 4917 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_x_, ph2_x_branch, and ph2_x_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), parseT5(), tas::ph2_x(), and setGnnNtupleMiniDoublet().

                                        {
   if (not ph2_x_isLoaded) {
     if (ph2_x_branch != 0) {
       ph2_x_branch->GetEntry(index);
     } else {
       printf("branch ph2_x_branch does not exist!\n");
       exit(1);
     }
     ph2_x_isLoaded = true;
   }
   return *ph2_x_;
 }

◆ ph2_xx()

const std::vector< float > & Trktree::ph2_xx ( )

Definition at line 6165 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_xx_, ph2_xx_branch, and ph2_xx_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_xx().

                                         {
   if (not ph2_xx_isLoaded) {
     if (ph2_xx_branch != 0) {
       ph2_xx_branch->GetEntry(index);
     } else {
       printf("branch ph2_xx_branch does not exist!\n");
       exit(1);
     }
     ph2_xx_isLoaded = true;
   }
   return *ph2_xx_;
 }

◆ ph2_xy()

const std::vector< float > & Trktree::ph2_xy ( )

Definition at line 6105 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_xy_, ph2_xy_branch, and ph2_xy_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_xy().

                                         {
   if (not ph2_xy_isLoaded) {
     if (ph2_xy_branch != 0) {
       ph2_xy_branch->GetEntry(index);
     } else {
       printf("branch ph2_xy_branch does not exist!\n");
       exit(1);
     }
     ph2_xy_isLoaded = true;
   }
   return *ph2_xy_;
 }

◆ ph2_xySignificance()

const std::vector< std::vector< float > > & Trktree::ph2_xySignificance ( )

Definition at line 4461 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_xySignificance_, ph2_xySignificance_branch, and ph2_xySignificance_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_xySignificance().

                                                                 {
   if (not ph2_xySignificance_isLoaded) {
     if (ph2_xySignificance_branch != 0) {
       ph2_xySignificance_branch->GetEntry(index);
     } else {
       printf("branch ph2_xySignificance_branch does not exist!\n");
       exit(1);
     }
     ph2_xySignificance_isLoaded = true;
   }
   return *ph2_xySignificance_;
 }

◆ ph2_y()

const std::vector< float > & Trktree::ph2_y ( )

Definition at line 4929 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_y_, ph2_y_branch, and ph2_y_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), parseT5(), tas::ph2_y(), and setGnnNtupleMiniDoublet().

                                        {
   if (not ph2_y_isLoaded) {
     if (ph2_y_branch != 0) {
       ph2_y_branch->GetEntry(index);
     } else {
       printf("branch ph2_y_branch does not exist!\n");
       exit(1);
     }
     ph2_y_isLoaded = true;
   }
   return *ph2_y_;
 }

◆ ph2_yy()

const std::vector< float > & Trktree::ph2_yy ( )

Definition at line 6429 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_yy_, ph2_yy_branch, and ph2_yy_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_yy().

                                         {
   if (not ph2_yy_isLoaded) {
     if (ph2_yy_branch != 0) {
       ph2_yy_branch->GetEntry(index);
     } else {
       printf("branch ph2_yy_branch does not exist!\n");
       exit(1);
     }
     ph2_yy_isLoaded = true;
   }
   return *ph2_yy_;
 }

◆ ph2_yz()

const std::vector< float > & Trktree::ph2_yz ( )

Definition at line 6441 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_yz_, ph2_yz_branch, and ph2_yz_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_yz().

                                         {
   if (not ph2_yz_isLoaded) {
     if (ph2_yz_branch != 0) {
       ph2_yz_branch->GetEntry(index);
     } else {
       printf("branch ph2_yz_branch does not exist!\n");
       exit(1);
     }
     ph2_yz_isLoaded = true;
   }
   return *ph2_yz_;
 }

◆ ph2_z()

const std::vector< float > & Trktree::ph2_z ( )

Definition at line 4905 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_z_, ph2_z_branch, and ph2_z_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), parseT5(), tas::ph2_z(), and setGnnNtupleMiniDoublet().

                                        {
   if (not ph2_z_isLoaded) {
     if (ph2_z_branch != 0) {
       ph2_z_branch->GetEntry(index);
     } else {
       printf("branch ph2_z_branch does not exist!\n");
       exit(1);
     }
     ph2_z_isLoaded = true;
   }
   return *ph2_z_;
 }

◆ ph2_zx()

const std::vector< float > & Trktree::ph2_zx ( )

Definition at line 4665 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_zx_, ph2_zx_branch, and ph2_zx_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_zx().

                                         {
   if (not ph2_zx_isLoaded) {
     if (ph2_zx_branch != 0) {
       ph2_zx_branch->GetEntry(index);
     } else {
       printf("branch ph2_zx_branch does not exist!\n");
       exit(1);
     }
     ph2_zx_isLoaded = true;
   }
   return *ph2_zx_;
 }

◆ ph2_zz()

const std::vector< float > & Trktree::ph2_zz ( )

Definition at line 5097 of file Trktree.cc.

References beamvalidation::exit(), index, ph2_zz_, ph2_zz_branch, and ph2_zz_isLoaded.

Referenced by LoadAllBranches(), and tas::ph2_zz().

                                         {
   if (not ph2_zz_isLoaded) {
     if (ph2_zz_branch != 0) {
       ph2_zz_branch->GetEntry(index);
     } else {
       printf("branch ph2_zz_branch does not exist!\n");
       exit(1);
     }
     ph2_zz_isLoaded = true;
   }
   return *ph2_zz_;
 }

◆ pix_bbxi()

const std::vector< float > & Trktree::pix_bbxi ( )

Definition at line 3657 of file Trktree.cc.

References beamvalidation::exit(), index, pix_bbxi_, pix_bbxi_branch, and pix_bbxi_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_bbxi().

                                           {
   if (not pix_bbxi_isLoaded) {
     if (pix_bbxi_branch != 0) {
       pix_bbxi_branch->GetEntry(index);
     } else {
       printf("branch pix_bbxi_branch does not exist!\n");
       exit(1);
     }
     pix_bbxi_isLoaded = true;
   }
   return *pix_bbxi_;
 }

◆ pix_blade()

const std::vector< unsigned short > & Trktree::pix_blade ( )

Definition at line 3765 of file Trktree.cc.

References beamvalidation::exit(), index, pix_blade_, pix_blade_branch, and pix_blade_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_blade().

                                                     {
   if (not pix_blade_isLoaded) {
     if (pix_blade_branch != 0) {
       pix_blade_branch->GetEntry(index);
     } else {
       printf("branch pix_blade_branch does not exist!\n");
       exit(1);
     }
     pix_blade_isLoaded = true;
   }
   return *pix_blade_;
 }

◆ pix_chargeFraction()

const std::vector< std::vector< float > > & Trktree::pix_chargeFraction ( )

Definition at line 4389 of file Trktree.cc.

References beamvalidation::exit(), index, pix_chargeFraction_, pix_chargeFraction_branch, and pix_chargeFraction_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_chargeFraction().

                                                                 {
   if (not pix_chargeFraction_isLoaded) {
     if (pix_chargeFraction_branch != 0) {
       pix_chargeFraction_branch->GetEntry(index);
     } else {
       printf("branch pix_chargeFraction_branch does not exist!\n");
       exit(1);
     }
     pix_chargeFraction_isLoaded = true;
   }
   return *pix_chargeFraction_;
 }

◆ pix_detId()

const std::vector< unsigned int > & Trktree::pix_detId ( )

Definition at line 3909 of file Trktree.cc.

References beamvalidation::exit(), index, pix_detId_, pix_detId_branch, and pix_detId_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_detId().

                                                   {
   if (not pix_detId_isLoaded) {
     if (pix_detId_branch != 0) {
       pix_detId_branch->GetEntry(index);
     } else {
       printf("branch pix_detId_branch does not exist!\n");
       exit(1);
     }
     pix_detId_isLoaded = true;
   }
   return *pix_detId_;
 }

◆ pix_isBarrel()

const std::vector< short > & Trktree::pix_isBarrel ( )

Definition at line 3369 of file Trktree.cc.

References beamvalidation::exit(), index, pix_isBarrel_, pix_isBarrel_branch, and pix_isBarrel_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_isBarrel().

                                               {
   if (not pix_isBarrel_isLoaded) {
     if (pix_isBarrel_branch != 0) {
       pix_isBarrel_branch->GetEntry(index);
     } else {
       printf("branch pix_isBarrel_branch does not exist!\n");
       exit(1);
     }
     pix_isBarrel_isLoaded = true;
   }
   return *pix_isBarrel_;
 }

◆ pix_ladder()

const std::vector< unsigned short > & Trktree::pix_ladder ( )

Definition at line 4593 of file Trktree.cc.

References beamvalidation::exit(), index, pix_ladder_, pix_ladder_branch, and pix_ladder_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_ladder().

                                                      {
   if (not pix_ladder_isLoaded) {
     if (pix_ladder_branch != 0) {
       pix_ladder_branch->GetEntry(index);
     } else {
       printf("branch pix_ladder_branch does not exist!\n");
       exit(1);
     }
     pix_ladder_isLoaded = true;
   }
   return *pix_ladder_;
 }

◆ pix_layer()

const std::vector< unsigned short > & Trktree::pix_layer ( )

Definition at line 4485 of file Trktree.cc.

References beamvalidation::exit(), index, pix_layer_, pix_layer_branch, and pix_layer_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_layer().

                                                     {
   if (not pix_layer_isLoaded) {
     if (pix_layer_branch != 0) {
       pix_layer_branch->GetEntry(index);
     } else {
       printf("branch pix_layer_branch does not exist!\n");
       exit(1);
     }
     pix_layer_isLoaded = true;
   }
   return *pix_layer_;
 }

◆ pix_module()

const std::vector< unsigned short > & Trktree::pix_module ( )

Definition at line 4173 of file Trktree.cc.

References beamvalidation::exit(), index, pix_module_, pix_module_branch, and pix_module_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_module().

                                                      {
   if (not pix_module_isLoaded) {
     if (pix_module_branch != 0) {
       pix_module_branch->GetEntry(index);
     } else {
       printf("branch pix_module_branch does not exist!\n");
       exit(1);
     }
     pix_module_isLoaded = true;
   }
   return *pix_module_;
 }

◆ pix_panel()

const std::vector< unsigned short > & Trktree::pix_panel ( )

Definition at line 6141 of file Trktree.cc.

References beamvalidation::exit(), index, pix_panel_, pix_panel_branch, and pix_panel_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_panel().

                                                     {
   if (not pix_panel_isLoaded) {
     if (pix_panel_branch != 0) {
       pix_panel_branch->GetEntry(index);
     } else {
       printf("branch pix_panel_branch does not exist!\n");
       exit(1);
     }
     pix_panel_isLoaded = true;
   }
   return *pix_panel_;
 }

◆ pix_radL()

const std::vector< float > & Trktree::pix_radL ( )

Definition at line 3213 of file Trktree.cc.

References beamvalidation::exit(), index, pix_radL_, pix_radL_branch, and pix_radL_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_radL().

                                           {
   if (not pix_radL_isLoaded) {
     if (pix_radL_branch != 0) {
       pix_radL_branch->GetEntry(index);
     } else {
       printf("branch pix_radL_branch does not exist!\n");
       exit(1);
     }
     pix_radL_isLoaded = true;
   }
   return *pix_radL_;
 }

◆ pix_seeIdx()

const std::vector< std::vector< int > > & Trktree::pix_seeIdx ( )

Definition at line 4761 of file Trktree.cc.

References beamvalidation::exit(), index, pix_seeIdx_, pix_seeIdx_branch, and pix_seeIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_seeIdx().

                                                       {
   if (not pix_seeIdx_isLoaded) {
     if (pix_seeIdx_branch != 0) {
       pix_seeIdx_branch->GetEntry(index);
     } else {
       printf("branch pix_seeIdx_branch does not exist!\n");
       exit(1);
     }
     pix_seeIdx_isLoaded = true;
   }
   return *pix_seeIdx_;
 }

◆ pix_side()

const std::vector< unsigned short > & Trktree::pix_side ( )

Definition at line 5997 of file Trktree.cc.

References beamvalidation::exit(), index, pix_side_, pix_side_branch, and pix_side_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_side().

                                                    {
   if (not pix_side_isLoaded) {
     if (pix_side_branch != 0) {
       pix_side_branch->GetEntry(index);
     } else {
       printf("branch pix_side_branch does not exist!\n");
       exit(1);
     }
     pix_side_isLoaded = true;
   }
   return *pix_side_;
 }

◆ pix_simHitIdx()

const std::vector< std::vector< int > > & Trktree::pix_simHitIdx ( )

Definition at line 5589 of file Trktree.cc.

References beamvalidation::exit(), index, pix_simHitIdx_, pix_simHitIdx_branch, and pix_simHitIdx_isLoaded.

Referenced by LoadAllBranches(), matchedSimTrkIdxs(), and tas::pix_simHitIdx().

                                                          {
   if (not pix_simHitIdx_isLoaded) {
     if (pix_simHitIdx_branch != 0) {
       pix_simHitIdx_branch->GetEntry(index);
     } else {
       printf("branch pix_simHitIdx_branch does not exist!\n");
       exit(1);
     }
     pix_simHitIdx_isLoaded = true;
   }
   return *pix_simHitIdx_;
 }

◆ pix_simType()

const std::vector< unsigned short > & Trktree::pix_simType ( )

Definition at line 5037 of file Trktree.cc.

References beamvalidation::exit(), index, pix_simType_, pix_simType_branch, and pix_simType_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_simType().

                                                       {
   if (not pix_simType_isLoaded) {
     if (pix_simType_branch != 0) {
       pix_simType_branch->GetEntry(index);
     } else {
       printf("branch pix_simType_branch does not exist!\n");
       exit(1);
     }
     pix_simType_isLoaded = true;
   }
   return *pix_simType_;
 }

◆ pix_subdet()

const std::vector< unsigned short > & Trktree::pix_subdet ( )

Definition at line 4629 of file Trktree.cc.

References beamvalidation::exit(), index, pix_subdet_, pix_subdet_branch, and pix_subdet_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_subdet().

                                                      {
   if (not pix_subdet_isLoaded) {
     if (pix_subdet_branch != 0) {
       pix_subdet_branch->GetEntry(index);
     } else {
       printf("branch pix_subdet_branch does not exist!\n");
       exit(1);
     }
     pix_subdet_isLoaded = true;
   }
   return *pix_subdet_;
 }

◆ pix_trkIdx()

const std::vector< std::vector< int > > & Trktree::pix_trkIdx ( )

Definition at line 4677 of file Trktree.cc.

References beamvalidation::exit(), index, pix_trkIdx_, pix_trkIdx_branch, and pix_trkIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_trkIdx().

                                                       {
   if (not pix_trkIdx_isLoaded) {
     if (pix_trkIdx_branch != 0) {
       pix_trkIdx_branch->GetEntry(index);
     } else {
       printf("branch pix_trkIdx_branch does not exist!\n");
       exit(1);
     }
     pix_trkIdx_isLoaded = true;
   }
   return *pix_trkIdx_;
 }

◆ pix_x()

const std::vector< float > & Trktree::pix_x ( )

Definition at line 4113 of file Trktree.cc.

References beamvalidation::exit(), index, pix_x_, pix_x_branch, and pix_x_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_x().

                                        {
   if (not pix_x_isLoaded) {
     if (pix_x_branch != 0) {
       pix_x_branch->GetEntry(index);
     } else {
       printf("branch pix_x_branch does not exist!\n");
       exit(1);
     }
     pix_x_isLoaded = true;
   }
   return *pix_x_;
 }

◆ pix_xx()

const std::vector< float > & Trktree::pix_xx ( )

Definition at line 3777 of file Trktree.cc.

References beamvalidation::exit(), index, pix_xx_, pix_xx_branch, and pix_xx_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_xx().

                                         {
   if (not pix_xx_isLoaded) {
     if (pix_xx_branch != 0) {
       pix_xx_branch->GetEntry(index);
     } else {
       printf("branch pix_xx_branch does not exist!\n");
       exit(1);
     }
     pix_xx_isLoaded = true;
   }
   return *pix_xx_;
 }

◆ pix_xy()

const std::vector< float > & Trktree::pix_xy ( )

Definition at line 3789 of file Trktree.cc.

References beamvalidation::exit(), index, pix_xy_, pix_xy_branch, and pix_xy_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_xy().

                                         {
   if (not pix_xy_isLoaded) {
     if (pix_xy_branch != 0) {
       pix_xy_branch->GetEntry(index);
     } else {
       printf("branch pix_xy_branch does not exist!\n");
       exit(1);
     }
     pix_xy_isLoaded = true;
   }
   return *pix_xy_;
 }

◆ pix_xySignificance()

const std::vector< std::vector< float > > & Trktree::pix_xySignificance ( )

Definition at line 4497 of file Trktree.cc.

References beamvalidation::exit(), index, pix_xySignificance_, pix_xySignificance_branch, and pix_xySignificance_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_xySignificance().

                                                                 {
   if (not pix_xySignificance_isLoaded) {
     if (pix_xySignificance_branch != 0) {
       pix_xySignificance_branch->GetEntry(index);
     } else {
       printf("branch pix_xySignificance_branch does not exist!\n");
       exit(1);
     }
     pix_xySignificance_isLoaded = true;
   }
   return *pix_xySignificance_;
 }

◆ pix_y()

const std::vector< float > & Trktree::pix_y ( )

Definition at line 4101 of file Trktree.cc.

References beamvalidation::exit(), index, pix_y_, pix_y_branch, and pix_y_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_y().

                                        {
   if (not pix_y_isLoaded) {
     if (pix_y_branch != 0) {
       pix_y_branch->GetEntry(index);
     } else {
       printf("branch pix_y_branch does not exist!\n");
       exit(1);
     }
     pix_y_isLoaded = true;
   }
   return *pix_y_;
 }

◆ pix_yy()

const std::vector< float > & Trktree::pix_yy ( )

Definition at line 3285 of file Trktree.cc.

References beamvalidation::exit(), index, pix_yy_, pix_yy_branch, and pix_yy_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_yy().

                                         {
   if (not pix_yy_isLoaded) {
     if (pix_yy_branch != 0) {
       pix_yy_branch->GetEntry(index);
     } else {
       printf("branch pix_yy_branch does not exist!\n");
       exit(1);
     }
     pix_yy_isLoaded = true;
   }
   return *pix_yy_;
 }

◆ pix_yz()

const std::vector< float > & Trktree::pix_yz ( )

Definition at line 3273 of file Trktree.cc.

References beamvalidation::exit(), index, pix_yz_, pix_yz_branch, and pix_yz_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_yz().

                                         {
   if (not pix_yz_isLoaded) {
     if (pix_yz_branch != 0) {
       pix_yz_branch->GetEntry(index);
     } else {
       printf("branch pix_yz_branch does not exist!\n");
       exit(1);
     }
     pix_yz_isLoaded = true;
   }
   return *pix_yz_;
 }

◆ pix_z()

const std::vector< float > & Trktree::pix_z ( )

Definition at line 4089 of file Trktree.cc.

References beamvalidation::exit(), index, pix_z_, pix_z_branch, and pix_z_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_z().

                                        {
   if (not pix_z_isLoaded) {
     if (pix_z_branch != 0) {
       pix_z_branch->GetEntry(index);
     } else {
       printf("branch pix_z_branch does not exist!\n");
       exit(1);
     }
     pix_z_isLoaded = true;
   }
   return *pix_z_;
 }

◆ pix_zx()

const std::vector< float > & Trktree::pix_zx ( )

Definition at line 6477 of file Trktree.cc.

References beamvalidation::exit(), index, pix_zx_, pix_zx_branch, and pix_zx_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_zx().

                                         {
   if (not pix_zx_isLoaded) {
     if (pix_zx_branch != 0) {
       pix_zx_branch->GetEntry(index);
     } else {
       printf("branch pix_zx_branch does not exist!\n");
       exit(1);
     }
     pix_zx_isLoaded = true;
   }
   return *pix_zx_;
 }

◆ pix_zz()

const std::vector< float > & Trktree::pix_zz ( )

Definition at line 5505 of file Trktree.cc.

References beamvalidation::exit(), index, pix_zz_, pix_zz_branch, and pix_zz_isLoaded.

Referenced by LoadAllBranches(), and tas::pix_zz().

                                         {
   if (not pix_zz_isLoaded) {
     if (pix_zz_branch != 0) {
       pix_zz_branch->GetEntry(index);
     } else {
       printf("branch pix_zz_branch does not exist!\n");
       exit(1);
     }
     pix_zz_isLoaded = true;
   }
   return *pix_zz_;
 }

◆ progress()

void Trktree::progress	(	int	nEventsTotal,
		int	nEventsChain
	)

static

Definition at line 6681 of file Trktree.cc.

References gather_cfg::cout, ALCARECOEcalPhiSym_cff::float, DivergingColor::frac, l1tstage2_dqm_sourceclient-live_cfg::period, and mps_setup::stdout.

                                                          {
   int period = 1000;
   if (nEventsTotal % 1000 == 0) {
     if (isatty(1)) {
       if ((nEventsChain - nEventsTotal) > period) {
         float frac = (float)nEventsTotal / (nEventsChain * 0.01);
         printf(
             "\015\033[32m ---> \033[1m\033[31m%4.1f%%"
             "\033[0m\033[32m <---\033[0m\015",
             frac);
         fflush(stdout);
       } else {
         printf(
             "\015\033[32m ---> \033[1m\033[31m%4.1f%%"
             "\033[0m\033[32m <---\033[0m\015",
             100.);
         std::cout << std::endl;
       }
     }
   }
 }

◆ run()

const unsigned int & Trktree::run ( )

Definition at line 4449 of file Trktree.cc.

References beamvalidation::exit(), index, run_, run_branch, and run_isLoaded.

Referenced by LoadAllBranches(), and tas::run().

                                  {
   if (not run_isLoaded) {
     if (run_branch != 0) {
       run_branch->GetEntry(index);
     } else {
       printf("branch run_branch does not exist!\n");
       exit(1);
     }
     run_isLoaded = true;
   }
   return run_;
 }

◆ see_algo()

const std::vector< unsigned int > & Trktree::see_algo ( )

Definition at line 5889 of file Trktree.cc.

References beamvalidation::exit(), index, see_algo_, see_algo_branch, and see_algo_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_algo().

                                                  {
   if (not see_algo_isLoaded) {
     if (see_algo_branch != 0) {
       see_algo_branch->GetEntry(index);
     } else {
       printf("branch see_algo_branch does not exist!\n");
       exit(1);
     }
     see_algo_isLoaded = true;
   }
   return *see_algo_;
 }

◆ see_bestFromFirstHitSimTrkIdx()

const std::vector< int > & Trktree::see_bestFromFirstHitSimTrkIdx ( )

Definition at line 3465 of file Trktree.cc.

References beamvalidation::exit(), index, see_bestFromFirstHitSimTrkIdx_, see_bestFromFirstHitSimTrkIdx_branch, and see_bestFromFirstHitSimTrkIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::see_bestFromFirstHitSimTrkIdx().

                                                              {
   if (not see_bestFromFirstHitSimTrkIdx_isLoaded) {
     if (see_bestFromFirstHitSimTrkIdx_branch != 0) {
       see_bestFromFirstHitSimTrkIdx_branch->GetEntry(index);
     } else {
       printf("branch see_bestFromFirstHitSimTrkIdx_branch does not exist!\n");
       exit(1);
     }
     see_bestFromFirstHitSimTrkIdx_isLoaded = true;
   }
   return *see_bestFromFirstHitSimTrkIdx_;
 }

◆ see_bestFromFirstHitSimTrkShareFrac()

const std::vector< float > & Trktree::see_bestFromFirstHitSimTrkShareFrac ( )

Definition at line 5253 of file Trktree.cc.

References beamvalidation::exit(), index, see_bestFromFirstHitSimTrkShareFrac_, see_bestFromFirstHitSimTrkShareFrac_branch, and see_bestFromFirstHitSimTrkShareFrac_isLoaded.

Referenced by LoadAllBranches(), and tas::see_bestFromFirstHitSimTrkShareFrac().

                                                                      {
   if (not see_bestFromFirstHitSimTrkShareFrac_isLoaded) {
     if (see_bestFromFirstHitSimTrkShareFrac_branch != 0) {
       see_bestFromFirstHitSimTrkShareFrac_branch->GetEntry(index);
     } else {
       printf("branch see_bestFromFirstHitSimTrkShareFrac_branch does not exist!\n");
       exit(1);
     }
     see_bestFromFirstHitSimTrkShareFrac_isLoaded = true;
   }
   return *see_bestFromFirstHitSimTrkShareFrac_;
 }

◆ see_bestSimTrkIdx()

const std::vector< int > & Trktree::see_bestSimTrkIdx ( )

Definition at line 6069 of file Trktree.cc.

References beamvalidation::exit(), index, see_bestSimTrkIdx_, see_bestSimTrkIdx_branch, and see_bestSimTrkIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::see_bestSimTrkIdx().

                                                  {
   if (not see_bestSimTrkIdx_isLoaded) {
     if (see_bestSimTrkIdx_branch != 0) {
       see_bestSimTrkIdx_branch->GetEntry(index);
     } else {
       printf("branch see_bestSimTrkIdx_branch does not exist!\n");
       exit(1);
     }
     see_bestSimTrkIdx_isLoaded = true;
   }
   return *see_bestSimTrkIdx_;
 }

◆ see_bestSimTrkShareFrac()

const std::vector< float > & Trktree::see_bestSimTrkShareFrac ( )

Definition at line 4521 of file Trktree.cc.

References beamvalidation::exit(), index, see_bestSimTrkShareFrac_, see_bestSimTrkShareFrac_branch, and see_bestSimTrkShareFrac_isLoaded.

Referenced by LoadAllBranches(), and tas::see_bestSimTrkShareFrac().

                                                          {
   if (not see_bestSimTrkShareFrac_isLoaded) {
     if (see_bestSimTrkShareFrac_branch != 0) {
       see_bestSimTrkShareFrac_branch->GetEntry(index);
     } else {
       printf("branch see_bestSimTrkShareFrac_branch does not exist!\n");
       exit(1);
     }
     see_bestSimTrkShareFrac_isLoaded = true;
   }
   return *see_bestSimTrkShareFrac_;
 }

◆ see_chi2()

const std::vector< float > & Trktree::see_chi2 ( )

Definition at line 6213 of file Trktree.cc.

References beamvalidation::exit(), index, see_chi2_, see_chi2_branch, and see_chi2_isLoaded.

Referenced by LoadAllBranches(), and tas::see_chi2().

                                           {
   if (not see_chi2_isLoaded) {
     if (see_chi2_branch != 0) {
       see_chi2_branch->GetEntry(index);
     } else {
       printf("branch see_chi2_branch does not exist!\n");
       exit(1);
     }
     see_chi2_isLoaded = true;
   }
   return *see_chi2_;
 }

◆ see_dxy()

const std::vector< float > & Trktree::see_dxy ( )

Definition at line 3933 of file Trktree.cc.

References beamvalidation::exit(), index, see_dxy_, see_dxy_branch, and see_dxy_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_dxy().

                                          {
   if (not see_dxy_isLoaded) {
     if (see_dxy_branch != 0) {
       see_dxy_branch->GetEntry(index);
     } else {
       printf("branch see_dxy_branch does not exist!\n");
       exit(1);
     }
     see_dxy_isLoaded = true;
   }
   return *see_dxy_;
 }

◆ see_dxyErr()

const std::vector< float > & Trktree::see_dxyErr ( )

Definition at line 3381 of file Trktree.cc.

References beamvalidation::exit(), index, see_dxyErr_, see_dxyErr_branch, and see_dxyErr_isLoaded.

Referenced by LoadAllBranches(), and tas::see_dxyErr().

                                             {
   if (not see_dxyErr_isLoaded) {
     if (see_dxyErr_branch != 0) {
       see_dxyErr_branch->GetEntry(index);
     } else {
       printf("branch see_dxyErr_branch does not exist!\n");
       exit(1);
     }
     see_dxyErr_isLoaded = true;
   }
   return *see_dxyErr_;
 }

◆ see_dz()

const std::vector< float > & Trktree::see_dz ( )

Definition at line 5529 of file Trktree.cc.

References beamvalidation::exit(), index, see_dz_, see_dz_branch, and see_dz_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_dz().

                                         {
   if (not see_dz_isLoaded) {
     if (see_dz_branch != 0) {
       see_dz_branch->GetEntry(index);
     } else {
       printf("branch see_dz_branch does not exist!\n");
       exit(1);
     }
     see_dz_isLoaded = true;
   }
   return *see_dz_;
 }

◆ see_dzErr()

const std::vector< float > & Trktree::see_dzErr ( )

Definition at line 4425 of file Trktree.cc.

References beamvalidation::exit(), index, see_dzErr_, see_dzErr_branch, and see_dzErr_isLoaded.

Referenced by LoadAllBranches(), and tas::see_dzErr().

                                            {
   if (not see_dzErr_isLoaded) {
     if (see_dzErr_branch != 0) {
       see_dzErr_branch->GetEntry(index);
     } else {
       printf("branch see_dzErr_branch does not exist!\n");
       exit(1);
     }
     see_dzErr_isLoaded = true;
   }
   return *see_dzErr_;
 }

◆ see_eta()

const std::vector< float > & Trktree::see_eta ( )

Definition at line 5409 of file Trktree.cc.

References beamvalidation::exit(), index, see_eta_, see_eta_branch, and see_eta_isLoaded.

Referenced by LoadAllBranches(), and tas::see_eta().

                                          {
   if (not see_eta_isLoaded) {
     if (see_eta_branch != 0) {
       see_eta_branch->GetEntry(index);
     } else {
       printf("branch see_eta_branch does not exist!\n");
       exit(1);
     }
     see_eta_isLoaded = true;
   }
   return *see_eta_;
 }

◆ see_etaErr()

const std::vector< float > & Trktree::see_etaErr ( )

Definition at line 4533 of file Trktree.cc.

References beamvalidation::exit(), index, see_etaErr_, see_etaErr_branch, and see_etaErr_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_etaErr().

                                             {
   if (not see_etaErr_isLoaded) {
     if (see_etaErr_branch != 0) {
       see_etaErr_branch->GetEntry(index);
     } else {
       printf("branch see_etaErr_branch does not exist!\n");
       exit(1);
     }
     see_etaErr_isLoaded = true;
   }
   return *see_etaErr_;
 }

◆ see_fitok()

const std::vector< short > & Trktree::see_fitok ( )

Definition at line 3729 of file Trktree.cc.

References beamvalidation::exit(), index, see_fitok_, see_fitok_branch, and see_fitok_isLoaded.

Referenced by LoadAllBranches(), and tas::see_fitok().

                                            {
   if (not see_fitok_isLoaded) {
     if (see_fitok_branch != 0) {
       see_fitok_branch->GetEntry(index);
     } else {
       printf("branch see_fitok_branch does not exist!\n");
       exit(1);
     }
     see_fitok_isLoaded = true;
   }
   return *see_fitok_;
 }

◆ see_hitIdx()

const std::vector< std::vector< int > > & Trktree::see_hitIdx ( )

Definition at line 3417 of file Trktree.cc.

References beamvalidation::exit(), index, see_hitIdx_, see_hitIdx_branch, and see_hitIdx_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_hitIdx().

                                                       {
   if (not see_hitIdx_isLoaded) {
     if (see_hitIdx_branch != 0) {
       see_hitIdx_branch->GetEntry(index);
     } else {
       printf("branch see_hitIdx_branch does not exist!\n");
       exit(1);
     }
     see_hitIdx_isLoaded = true;
   }
   return *see_hitIdx_;
 }

◆ see_hitType()

const std::vector< std::vector< int > > & Trktree::see_hitType ( )

Definition at line 4125 of file Trktree.cc.

References beamvalidation::exit(), index, see_hitType_, see_hitType_branch, and see_hitType_isLoaded.

Referenced by LoadAllBranches(), and tas::see_hitType().

                                                        {
   if (not see_hitType_isLoaded) {
     if (see_hitType_branch != 0) {
       see_hitType_branch->GetEntry(index);
     } else {
       printf("branch see_hitType_branch does not exist!\n");
       exit(1);
     }
     see_hitType_isLoaded = true;
   }
   return *see_hitType_;
 }

◆ see_nCands()

const std::vector< unsigned short > & Trktree::see_nCands ( )

Definition at line 6057 of file Trktree.cc.

References beamvalidation::exit(), index, see_nCands_, see_nCands_branch, and see_nCands_isLoaded.

Referenced by LoadAllBranches(), and tas::see_nCands().

                                                      {
   if (not see_nCands_isLoaded) {
     if (see_nCands_branch != 0) {
       see_nCands_branch->GetEntry(index);
     } else {
       printf("branch see_nCands_branch does not exist!\n");
       exit(1);
     }
     see_nCands_isLoaded = true;
   }
   return *see_nCands_;
 }

◆ see_nCluster()

const std::vector< unsigned int > & Trktree::see_nCluster ( )

Definition at line 4989 of file Trktree.cc.

References beamvalidation::exit(), index, see_nCluster_, see_nCluster_branch, and see_nCluster_isLoaded.

Referenced by LoadAllBranches(), and tas::see_nCluster().

                                                      {
   if (not see_nCluster_isLoaded) {
     if (see_nCluster_branch != 0) {
       see_nCluster_branch->GetEntry(index);
     } else {
       printf("branch see_nCluster_branch does not exist!\n");
       exit(1);
     }
     see_nCluster_isLoaded = true;
   }
   return *see_nCluster_;
 }

◆ see_nGlued()

const std::vector< unsigned int > & Trktree::see_nGlued ( )

Definition at line 3237 of file Trktree.cc.

References beamvalidation::exit(), index, see_nGlued_, see_nGlued_branch, and see_nGlued_isLoaded.

Referenced by LoadAllBranches(), and tas::see_nGlued().

                                                    {
   if (not see_nGlued_isLoaded) {
     if (see_nGlued_branch != 0) {
       see_nGlued_branch->GetEntry(index);
     } else {
       printf("branch see_nGlued_branch does not exist!\n");
       exit(1);
     }
     see_nGlued_isLoaded = true;
   }
   return *see_nGlued_;
 }

◆ see_nPhase2OT()

const std::vector< unsigned int > & Trktree::see_nPhase2OT ( )

Definition at line 6405 of file Trktree.cc.

References beamvalidation::exit(), index, see_nPhase2OT_, see_nPhase2OT_branch, and see_nPhase2OT_isLoaded.

Referenced by LoadAllBranches(), and tas::see_nPhase2OT().

                                                       {
   if (not see_nPhase2OT_isLoaded) {
     if (see_nPhase2OT_branch != 0) {
       see_nPhase2OT_branch->GetEntry(index);
     } else {
       printf("branch see_nPhase2OT_branch does not exist!\n");
       exit(1);
     }
     see_nPhase2OT_isLoaded = true;
   }
   return *see_nPhase2OT_;
 }

◆ see_nPixel()

const std::vector< unsigned int > & Trktree::see_nPixel ( )

Definition at line 5637 of file Trktree.cc.

References beamvalidation::exit(), index, see_nPixel_, see_nPixel_branch, and see_nPixel_isLoaded.

Referenced by LoadAllBranches(), and tas::see_nPixel().

                                                    {
   if (not see_nPixel_isLoaded) {
     if (see_nPixel_branch != 0) {
       see_nPixel_branch->GetEntry(index);
     } else {
       printf("branch see_nPixel_branch does not exist!\n");
       exit(1);
     }
     see_nPixel_isLoaded = true;
   }
   return *see_nPixel_;
 }

◆ see_nStrip()

const std::vector< unsigned int > & Trktree::see_nStrip ( )

Definition at line 3561 of file Trktree.cc.

References beamvalidation::exit(), index, see_nStrip_, see_nStrip_branch, and see_nStrip_isLoaded.

Referenced by LoadAllBranches(), and tas::see_nStrip().

                                                    {
   if (not see_nStrip_isLoaded) {
     if (see_nStrip_branch != 0) {
       see_nStrip_branch->GetEntry(index);
     } else {
       printf("branch see_nStrip_branch does not exist!\n");
       exit(1);
     }
     see_nStrip_isLoaded = true;
   }
   return *see_nStrip_;
 }

◆ see_nValid()

const std::vector< unsigned int > & Trktree::see_nValid ( )

Definition at line 6645 of file Trktree.cc.

References beamvalidation::exit(), index, see_nValid_, see_nValid_branch, and see_nValid_isLoaded.

Referenced by LoadAllBranches(), and tas::see_nValid().

                                                    {
   if (not see_nValid_isLoaded) {
     if (see_nValid_branch != 0) {
       see_nValid_branch->GetEntry(index);
     } else {
       printf("branch see_nValid_branch does not exist!\n");
       exit(1);
     }
     see_nValid_isLoaded = true;
   }
   return *see_nValid_;
 }

◆ see_offset()

const std::vector< unsigned int > & Trktree::see_offset ( )

Definition at line 6261 of file Trktree.cc.

References beamvalidation::exit(), index, see_offset_, see_offset_branch, and see_offset_isLoaded.

Referenced by LoadAllBranches(), and tas::see_offset().

                                                    {
   if (not see_offset_isLoaded) {
     if (see_offset_branch != 0) {
       see_offset_branch->GetEntry(index);
     } else {
       printf("branch see_offset_branch does not exist!\n");
       exit(1);
     }
     see_offset_isLoaded = true;
   }
   return *see_offset_;
 }

◆ see_phi()

const std::vector< float > & Trktree::see_phi ( )

Definition at line 6573 of file Trktree.cc.

References beamvalidation::exit(), index, see_phi_, see_phi_branch, and see_phi_isLoaded.

Referenced by LoadAllBranches(), and tas::see_phi().

                                          {
   if (not see_phi_isLoaded) {
     if (see_phi_branch != 0) {
       see_phi_branch->GetEntry(index);
     } else {
       printf("branch see_phi_branch does not exist!\n");
       exit(1);
     }
     see_phi_isLoaded = true;
   }
   return *see_phi_;
 }

◆ see_phiErr()

const std::vector< float > & Trktree::see_phiErr ( )

Definition at line 5865 of file Trktree.cc.

References beamvalidation::exit(), index, see_phiErr_, see_phiErr_branch, and see_phiErr_isLoaded.

Referenced by LoadAllBranches(), and tas::see_phiErr().

                                             {
   if (not see_phiErr_isLoaded) {
     if (see_phiErr_branch != 0) {
       see_phiErr_branch->GetEntry(index);
     } else {
       printf("branch see_phiErr_branch does not exist!\n");
       exit(1);
     }
     see_phiErr_isLoaded = true;
   }
   return *see_phiErr_;
 }

◆ see_pt()

const std::vector< float > & Trktree::see_pt ( )

Definition at line 3429 of file Trktree.cc.

References beamvalidation::exit(), index, see_pt_, see_pt_branch, and see_pt_isLoaded.

Referenced by LoadAllBranches(), and tas::see_pt().

                                         {
   if (not see_pt_isLoaded) {
     if (see_pt_branch != 0) {
       see_pt_branch->GetEntry(index);
     } else {
       printf("branch see_pt_branch does not exist!\n");
       exit(1);
     }
     see_pt_isLoaded = true;
   }
   return *see_pt_;
 }

◆ see_ptErr()

const std::vector< float > & Trktree::see_ptErr ( )

Definition at line 5145 of file Trktree.cc.

References beamvalidation::exit(), index, see_ptErr_, see_ptErr_branch, and see_ptErr_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_ptErr().

                                            {
   if (not see_ptErr_isLoaded) {
     if (see_ptErr_branch != 0) {
       see_ptErr_branch->GetEntry(index);
     } else {
       printf("branch see_ptErr_branch does not exist!\n");
       exit(1);
     }
     see_ptErr_isLoaded = true;
   }
   return *see_ptErr_;
 }

◆ see_px()

const std::vector< float > & Trktree::see_px ( )

Definition at line 5385 of file Trktree.cc.

References beamvalidation::exit(), index, see_px_, see_px_branch, and see_px_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_px().

                                         {
   if (not see_px_isLoaded) {
     if (see_px_branch != 0) {
       see_px_branch->GetEntry(index);
     } else {
       printf("branch see_px_branch does not exist!\n");
       exit(1);
     }
     see_px_isLoaded = true;
   }
   return *see_px_;
 }

◆ see_py()

const std::vector< float > & Trktree::see_py ( )

Definition at line 3333 of file Trktree.cc.

References beamvalidation::exit(), index, see_py_, see_py_branch, and see_py_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_py().

                                         {
   if (not see_py_isLoaded) {
     if (see_py_branch != 0) {
       see_py_branch->GetEntry(index);
     } else {
       printf("branch see_py_branch does not exist!\n");
       exit(1);
     }
     see_py_isLoaded = true;
   }
   return *see_py_;
 }

◆ see_pz()

const std::vector< float > & Trktree::see_pz ( )

Definition at line 5397 of file Trktree.cc.

References beamvalidation::exit(), index, see_pz_, see_pz_branch, and see_pz_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_pz().

                                         {
   if (not see_pz_isLoaded) {
     if (see_pz_branch != 0) {
       see_pz_branch->GetEntry(index);
     } else {
       printf("branch see_pz_branch does not exist!\n");
       exit(1);
     }
     see_pz_isLoaded = true;
   }
   return *see_pz_;
 }

◆ see_q()

const std::vector< int > & Trktree::see_q ( )

Definition at line 3609 of file Trktree.cc.

References beamvalidation::exit(), index, see_q_, see_q_branch, and see_q_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_q().

                                      {
   if (not see_q_isLoaded) {
     if (see_q_branch != 0) {
       see_q_branch->GetEntry(index);
     } else {
       printf("branch see_q_branch does not exist!\n");
       exit(1);
     }
     see_q_isLoaded = true;
   }
   return *see_q_;
 }

◆ see_simTrkIdx()

const std::vector< std::vector< int > > & Trktree::see_simTrkIdx ( )

Definition at line 4269 of file Trktree.cc.

References beamvalidation::exit(), index, see_simTrkIdx_, see_simTrkIdx_branch, and see_simTrkIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::see_simTrkIdx().

                                                          {
   if (not see_simTrkIdx_isLoaded) {
     if (see_simTrkIdx_branch != 0) {
       see_simTrkIdx_branch->GetEntry(index);
     } else {
       printf("branch see_simTrkIdx_branch does not exist!\n");
       exit(1);
     }
     see_simTrkIdx_isLoaded = true;
   }
   return *see_simTrkIdx_;
 }

◆ see_simTrkShareFrac()

const std::vector< std::vector< float > > & Trktree::see_simTrkShareFrac ( )

Definition at line 5577 of file Trktree.cc.

References beamvalidation::exit(), index, see_simTrkShareFrac_, see_simTrkShareFrac_branch, and see_simTrkShareFrac_isLoaded.

Referenced by LoadAllBranches(), and tas::see_simTrkShareFrac().

                                                                  {
   if (not see_simTrkShareFrac_isLoaded) {
     if (see_simTrkShareFrac_branch != 0) {
       see_simTrkShareFrac_branch->GetEntry(index);
     } else {
       printf("branch see_simTrkShareFrac_branch does not exist!\n");
       exit(1);
     }
     see_simTrkShareFrac_isLoaded = true;
   }
   return *see_simTrkShareFrac_;
 }

◆ see_stateCcov00()

const std::vector< float > & Trktree::see_stateCcov00 ( )

Definition at line 6309 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov00_, see_stateCcov00_branch, and see_stateCcov00_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov00().

                                                  {
   if (not see_stateCcov00_isLoaded) {
     if (see_stateCcov00_branch != 0) {
       see_stateCcov00_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov00_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov00_isLoaded = true;
   }
   return *see_stateCcov00_;
 }

◆ see_stateCcov01()

const std::vector< float > & Trktree::see_stateCcov01 ( )

Definition at line 3045 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov01_, see_stateCcov01_branch, and see_stateCcov01_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov01().

                                                  {
   if (not see_stateCcov01_isLoaded) {
     if (see_stateCcov01_branch != 0) {
       see_stateCcov01_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov01_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov01_isLoaded = true;
   }
   return *see_stateCcov01_;
 }

◆ see_stateCcov02()

const std::vector< float > & Trktree::see_stateCcov02 ( )

Definition at line 3225 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov02_, see_stateCcov02_branch, and see_stateCcov02_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov02().

                                                  {
   if (not see_stateCcov02_isLoaded) {
     if (see_stateCcov02_branch != 0) {
       see_stateCcov02_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov02_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov02_isLoaded = true;
   }
   return *see_stateCcov02_;
 }

◆ see_stateCcov03()

const std::vector< float > & Trktree::see_stateCcov03 ( )

Definition at line 3177 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov03_, see_stateCcov03_branch, and see_stateCcov03_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov03().

                                                  {
   if (not see_stateCcov03_isLoaded) {
     if (see_stateCcov03_branch != 0) {
       see_stateCcov03_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov03_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov03_isLoaded = true;
   }
   return *see_stateCcov03_;
 }

◆ see_stateCcov04()

const std::vector< float > & Trktree::see_stateCcov04 ( )

Definition at line 3105 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov04_, see_stateCcov04_branch, and see_stateCcov04_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov04().

                                                  {
   if (not see_stateCcov04_isLoaded) {
     if (see_stateCcov04_branch != 0) {
       see_stateCcov04_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov04_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov04_isLoaded = true;
   }
   return *see_stateCcov04_;
 }

◆ see_stateCcov05()

const std::vector< float > & Trktree::see_stateCcov05 ( )

Definition at line 3093 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov05_, see_stateCcov05_branch, and see_stateCcov05_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov05().

                                                  {
   if (not see_stateCcov05_isLoaded) {
     if (see_stateCcov05_branch != 0) {
       see_stateCcov05_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov05_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov05_isLoaded = true;
   }
   return *see_stateCcov05_;
 }

◆ see_stateCcov11()

const std::vector< float > & Trktree::see_stateCcov11 ( )

Definition at line 3969 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov11_, see_stateCcov11_branch, and see_stateCcov11_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov11().

                                                  {
   if (not see_stateCcov11_isLoaded) {
     if (see_stateCcov11_branch != 0) {
       see_stateCcov11_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov11_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov11_isLoaded = true;
   }
   return *see_stateCcov11_;
 }

◆ see_stateCcov12()

const std::vector< float > & Trktree::see_stateCcov12 ( )

Definition at line 3861 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov12_, see_stateCcov12_branch, and see_stateCcov12_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov12().

                                                  {
   if (not see_stateCcov12_isLoaded) {
     if (see_stateCcov12_branch != 0) {
       see_stateCcov12_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov12_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov12_isLoaded = true;
   }
   return *see_stateCcov12_;
 }

◆ see_stateCcov13()

const std::vector< float > & Trktree::see_stateCcov13 ( )

Definition at line 4377 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov13_, see_stateCcov13_branch, and see_stateCcov13_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov13().

                                                  {
   if (not see_stateCcov13_isLoaded) {
     if (see_stateCcov13_branch != 0) {
       see_stateCcov13_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov13_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov13_isLoaded = true;
   }
   return *see_stateCcov13_;
 }

◆ see_stateCcov14()

const std::vector< float > & Trktree::see_stateCcov14 ( )

Definition at line 4341 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov14_, see_stateCcov14_branch, and see_stateCcov14_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov14().

                                                  {
   if (not see_stateCcov14_isLoaded) {
     if (see_stateCcov14_branch != 0) {
       see_stateCcov14_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov14_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov14_isLoaded = true;
   }
   return *see_stateCcov14_;
 }

◆ see_stateCcov15()

const std::vector< float > & Trktree::see_stateCcov15 ( )

Definition at line 4353 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov15_, see_stateCcov15_branch, and see_stateCcov15_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov15().

                                                  {
   if (not see_stateCcov15_isLoaded) {
     if (see_stateCcov15_branch != 0) {
       see_stateCcov15_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov15_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov15_isLoaded = true;
   }
   return *see_stateCcov15_;
 }

◆ see_stateCcov22()

const std::vector< float > & Trktree::see_stateCcov22 ( )

Definition at line 5025 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov22_, see_stateCcov22_branch, and see_stateCcov22_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov22().

                                                  {
   if (not see_stateCcov22_isLoaded) {
     if (see_stateCcov22_branch != 0) {
       see_stateCcov22_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov22_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov22_isLoaded = true;
   }
   return *see_stateCcov22_;
 }

◆ see_stateCcov23()

const std::vector< float > & Trktree::see_stateCcov23 ( )

Definition at line 5829 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov23_, see_stateCcov23_branch, and see_stateCcov23_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov23().

                                                  {
   if (not see_stateCcov23_isLoaded) {
     if (see_stateCcov23_branch != 0) {
       see_stateCcov23_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov23_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov23_isLoaded = true;
   }
   return *see_stateCcov23_;
 }

◆ see_stateCcov24()

const std::vector< float > & Trktree::see_stateCcov24 ( )

Definition at line 4965 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov24_, see_stateCcov24_branch, and see_stateCcov24_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov24().

                                                  {
   if (not see_stateCcov24_isLoaded) {
     if (see_stateCcov24_branch != 0) {
       see_stateCcov24_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov24_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov24_isLoaded = true;
   }
   return *see_stateCcov24_;
 }

◆ see_stateCcov25()

const std::vector< float > & Trktree::see_stateCcov25 ( )

Definition at line 5805 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov25_, see_stateCcov25_branch, and see_stateCcov25_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov25().

                                                  {
   if (not see_stateCcov25_isLoaded) {
     if (see_stateCcov25_branch != 0) {
       see_stateCcov25_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov25_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov25_isLoaded = true;
   }
   return *see_stateCcov25_;
 }

◆ see_stateCcov33()

const std::vector< float > & Trktree::see_stateCcov33 ( )

Definition at line 6237 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov33_, see_stateCcov33_branch, and see_stateCcov33_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov33().

                                                  {
   if (not see_stateCcov33_isLoaded) {
     if (see_stateCcov33_branch != 0) {
       see_stateCcov33_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov33_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov33_isLoaded = true;
   }
   return *see_stateCcov33_;
 }

◆ see_stateCcov34()

const std::vector< float > & Trktree::see_stateCcov34 ( )

Definition at line 3309 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov34_, see_stateCcov34_branch, and see_stateCcov34_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov34().

                                                  {
   if (not see_stateCcov34_isLoaded) {
     if (see_stateCcov34_branch != 0) {
       see_stateCcov34_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov34_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov34_isLoaded = true;
   }
   return *see_stateCcov34_;
 }

◆ see_stateCcov35()

const std::vector< float > & Trktree::see_stateCcov35 ( )

Definition at line 6225 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov35_, see_stateCcov35_branch, and see_stateCcov35_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov35().

                                                  {
   if (not see_stateCcov35_isLoaded) {
     if (see_stateCcov35_branch != 0) {
       see_stateCcov35_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov35_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov35_isLoaded = true;
   }
   return *see_stateCcov35_;
 }

◆ see_stateCcov44()

const std::vector< float > & Trktree::see_stateCcov44 ( )

Definition at line 5349 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov44_, see_stateCcov44_branch, and see_stateCcov44_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov44().

                                                  {
   if (not see_stateCcov44_isLoaded) {
     if (see_stateCcov44_branch != 0) {
       see_stateCcov44_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov44_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov44_isLoaded = true;
   }
   return *see_stateCcov44_;
 }

◆ see_stateCcov45()

const std::vector< float > & Trktree::see_stateCcov45 ( )

Definition at line 5673 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov45_, see_stateCcov45_branch, and see_stateCcov45_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov45().

                                                  {
   if (not see_stateCcov45_isLoaded) {
     if (see_stateCcov45_branch != 0) {
       see_stateCcov45_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov45_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov45_isLoaded = true;
   }
   return *see_stateCcov45_;
 }

◆ see_stateCcov55()

const std::vector< float > & Trktree::see_stateCcov55 ( )

Definition at line 6129 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateCcov55_, see_stateCcov55_branch, and see_stateCcov55_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateCcov55().

                                                  {
   if (not see_stateCcov55_isLoaded) {
     if (see_stateCcov55_branch != 0) {
       see_stateCcov55_branch->GetEntry(index);
     } else {
       printf("branch see_stateCcov55_branch does not exist!\n");
       exit(1);
     }
     see_stateCcov55_isLoaded = true;
   }
   return *see_stateCcov55_;
 }

◆ see_statePt()

const std::vector< float > & Trktree::see_statePt ( )

Definition at line 4137 of file Trktree.cc.

References beamvalidation::exit(), index, see_statePt_, see_statePt_branch, and see_statePt_isLoaded.

Referenced by LoadAllBranches(), and tas::see_statePt().

                                              {
   if (not see_statePt_isLoaded) {
     if (see_statePt_branch != 0) {
       see_statePt_branch->GetEntry(index);
     } else {
       printf("branch see_statePt_branch does not exist!\n");
       exit(1);
     }
     see_statePt_isLoaded = true;
   }
   return *see_statePt_;
 }

◆ see_stateTrajGlbPx()

const std::vector< float > & Trktree::see_stateTrajGlbPx ( )

Definition at line 5157 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateTrajGlbPx_, see_stateTrajGlbPx_branch, and see_stateTrajGlbPx_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_stateTrajGlbPx().

                                                     {
   if (not see_stateTrajGlbPx_isLoaded) {
     if (see_stateTrajGlbPx_branch != 0) {
       see_stateTrajGlbPx_branch->GetEntry(index);
     } else {
       printf("branch see_stateTrajGlbPx_branch does not exist!\n");
       exit(1);
     }
     see_stateTrajGlbPx_isLoaded = true;
   }
   return *see_stateTrajGlbPx_;
 }

◆ see_stateTrajGlbPy()

const std::vector< float > & Trktree::see_stateTrajGlbPy ( )

Definition at line 6669 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateTrajGlbPy_, see_stateTrajGlbPy_branch, and see_stateTrajGlbPy_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_stateTrajGlbPy().

                                                     {
   if (not see_stateTrajGlbPy_isLoaded) {
     if (see_stateTrajGlbPy_branch != 0) {
       see_stateTrajGlbPy_branch->GetEntry(index);
     } else {
       printf("branch see_stateTrajGlbPy_branch does not exist!\n");
       exit(1);
     }
     see_stateTrajGlbPy_isLoaded = true;
   }
   return *see_stateTrajGlbPy_;
 }

◆ see_stateTrajGlbPz()

const std::vector< float > & Trktree::see_stateTrajGlbPz ( )

Definition at line 3261 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateTrajGlbPz_, see_stateTrajGlbPz_branch, and see_stateTrajGlbPz_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_stateTrajGlbPz().

                                                     {
   if (not see_stateTrajGlbPz_isLoaded) {
     if (see_stateTrajGlbPz_branch != 0) {
       see_stateTrajGlbPz_branch->GetEntry(index);
     } else {
       printf("branch see_stateTrajGlbPz_branch does not exist!\n");
       exit(1);
     }
     see_stateTrajGlbPz_isLoaded = true;
   }
   return *see_stateTrajGlbPz_;
 }

◆ see_stateTrajGlbX()

const std::vector< float > & Trktree::see_stateTrajGlbX ( )

Definition at line 4293 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateTrajGlbX_, see_stateTrajGlbX_branch, and see_stateTrajGlbX_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_stateTrajGlbX().

                                                    {
   if (not see_stateTrajGlbX_isLoaded) {
     if (see_stateTrajGlbX_branch != 0) {
       see_stateTrajGlbX_branch->GetEntry(index);
     } else {
       printf("branch see_stateTrajGlbX_branch does not exist!\n");
       exit(1);
     }
     see_stateTrajGlbX_isLoaded = true;
   }
   return *see_stateTrajGlbX_;
 }

◆ see_stateTrajGlbY()

const std::vector< float > & Trktree::see_stateTrajGlbY ( )

Definition at line 4305 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateTrajGlbY_, see_stateTrajGlbY_branch, and see_stateTrajGlbY_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_stateTrajGlbY().

                                                    {
   if (not see_stateTrajGlbY_isLoaded) {
     if (see_stateTrajGlbY_branch != 0) {
       see_stateTrajGlbY_branch->GetEntry(index);
     } else {
       printf("branch see_stateTrajGlbY_branch does not exist!\n");
       exit(1);
     }
     see_stateTrajGlbY_isLoaded = true;
   }
   return *see_stateTrajGlbY_;
 }

◆ see_stateTrajGlbZ()

const std::vector< float > & Trktree::see_stateTrajGlbZ ( )

Definition at line 4281 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateTrajGlbZ_, see_stateTrajGlbZ_branch, and see_stateTrajGlbZ_isLoaded.

Referenced by addInputsToLineSegmentTrackingPreLoad(), LoadAllBranches(), and tas::see_stateTrajGlbZ().

                                                    {
   if (not see_stateTrajGlbZ_isLoaded) {
     if (see_stateTrajGlbZ_branch != 0) {
       see_stateTrajGlbZ_branch->GetEntry(index);
     } else {
       printf("branch see_stateTrajGlbZ_branch does not exist!\n");
       exit(1);
     }
     see_stateTrajGlbZ_isLoaded = true;
   }
   return *see_stateTrajGlbZ_;
 }

◆ see_stateTrajPx()

const std::vector< float > & Trktree::see_stateTrajPx ( )

Definition at line 6525 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateTrajPx_, see_stateTrajPx_branch, and see_stateTrajPx_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateTrajPx().

                                                  {
   if (not see_stateTrajPx_isLoaded) {
     if (see_stateTrajPx_branch != 0) {
       see_stateTrajPx_branch->GetEntry(index);
     } else {
       printf("branch see_stateTrajPx_branch does not exist!\n");
       exit(1);
     }
     see_stateTrajPx_isLoaded = true;
   }
   return *see_stateTrajPx_;
 }

◆ see_stateTrajPy()

const std::vector< float > & Trktree::see_stateTrajPy ( )

Definition at line 4209 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateTrajPy_, see_stateTrajPy_branch, and see_stateTrajPy_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateTrajPy().

                                                  {
   if (not see_stateTrajPy_isLoaded) {
     if (see_stateTrajPy_branch != 0) {
       see_stateTrajPy_branch->GetEntry(index);
     } else {
       printf("branch see_stateTrajPy_branch does not exist!\n");
       exit(1);
     }
     see_stateTrajPy_isLoaded = true;
   }
   return *see_stateTrajPy_;
 }

◆ see_stateTrajPz()

const std::vector< float > & Trktree::see_stateTrajPz ( )

Definition at line 5541 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateTrajPz_, see_stateTrajPz_branch, and see_stateTrajPz_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateTrajPz().

                                                  {
   if (not see_stateTrajPz_isLoaded) {
     if (see_stateTrajPz_branch != 0) {
       see_stateTrajPz_branch->GetEntry(index);
     } else {
       printf("branch see_stateTrajPz_branch does not exist!\n");
       exit(1);
     }
     see_stateTrajPz_isLoaded = true;
   }
   return *see_stateTrajPz_;
 }

◆ see_stateTrajX()

const std::vector< float > & Trktree::see_stateTrajX ( )

Definition at line 4797 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateTrajX_, see_stateTrajX_branch, and see_stateTrajX_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateTrajX().

                                                 {
   if (not see_stateTrajX_isLoaded) {
     if (see_stateTrajX_branch != 0) {
       see_stateTrajX_branch->GetEntry(index);
     } else {
       printf("branch see_stateTrajX_branch does not exist!\n");
       exit(1);
     }
     see_stateTrajX_isLoaded = true;
   }
   return *see_stateTrajX_;
 }

◆ see_stateTrajY()

const std::vector< float > & Trktree::see_stateTrajY ( )

Definition at line 4809 of file Trktree.cc.

References beamvalidation::exit(), index, see_stateTrajY_, see_stateTrajY_branch, and see_stateTrajY_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stateTrajY().

                                                 {
   if (not see_stateTrajY_isLoaded) {
     if (see_stateTrajY_branch != 0) {
       see_stateTrajY_branch->GetEntry(index);
     } else {
       printf("branch see_stateTrajY_branch does not exist!\n");
       exit(1);
     }
     see_stateTrajY_isLoaded = true;
   }
   return *see_stateTrajY_;
 }

◆ see_stopReason()

const std::vector< unsigned short > & Trktree::see_stopReason ( )

Definition at line 6321 of file Trktree.cc.

References beamvalidation::exit(), index, see_stopReason_, see_stopReason_branch, and see_stopReason_isLoaded.

Referenced by LoadAllBranches(), and tas::see_stopReason().

                                                          {
   if (not see_stopReason_isLoaded) {
     if (see_stopReason_branch != 0) {
       see_stopReason_branch->GetEntry(index);
     } else {
       printf("branch see_stopReason_branch does not exist!\n");
       exit(1);
     }
     see_stopReason_isLoaded = true;
   }
   return *see_stopReason_;
 }

◆ see_trkIdx()

const std::vector< int > & Trktree::see_trkIdx ( )

Definition at line 3489 of file Trktree.cc.

References beamvalidation::exit(), index, see_trkIdx_, see_trkIdx_branch, and see_trkIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::see_trkIdx().

                                           {
   if (not see_trkIdx_isLoaded) {
     if (see_trkIdx_branch != 0) {
       see_trkIdx_branch->GetEntry(index);
     } else {
       printf("branch see_trkIdx_branch does not exist!\n");
       exit(1);
     }
     see_trkIdx_isLoaded = true;
   }
   return *see_trkIdx_;
 }

◆ sim_bunchCrossing()

const std::vector< int > & Trktree::sim_bunchCrossing ( )

Definition at line 5661 of file Trktree.cc.

References beamvalidation::exit(), index, sim_bunchCrossing_, sim_bunchCrossing_branch, and sim_bunchCrossing_isLoaded.

Referenced by getDenomSimTrkType(), LoadAllBranches(), setGnnNtupleBranches(), setOutputBranches(), and tas::sim_bunchCrossing().

                                                  {
   if (not sim_bunchCrossing_isLoaded) {
     if (sim_bunchCrossing_branch != 0) {
       sim_bunchCrossing_branch->GetEntry(index);
     } else {
       printf("branch sim_bunchCrossing_branch does not exist!\n");
       exit(1);
     }
     sim_bunchCrossing_isLoaded = true;
   }
   return *sim_bunchCrossing_;
 }

◆ sim_decayVtxIdx()

const std::vector< std::vector< int > > & Trktree::sim_decayVtxIdx ( )

Definition at line 3897 of file Trktree.cc.

References beamvalidation::exit(), index, sim_decayVtxIdx_, sim_decayVtxIdx_branch, and sim_decayVtxIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_decayVtxIdx().

                                                            {
   if (not sim_decayVtxIdx_isLoaded) {
     if (sim_decayVtxIdx_branch != 0) {
       sim_decayVtxIdx_branch->GetEntry(index);
     } else {
       printf("branch sim_decayVtxIdx_branch does not exist!\n");
       exit(1);
     }
     sim_decayVtxIdx_isLoaded = true;
   }
   return *sim_decayVtxIdx_;
 }

◆ sim_eta()

const std::vector< float > & Trktree::sim_eta ( )

Definition at line 3189 of file Trktree.cc.

References beamvalidation::exit(), index, sim_eta_, sim_eta_branch, and sim_eta_isLoaded.

Referenced by distxySimHitConsistentWithHelix(), drfracSimHitConsistentWithHelix(), getDenomSimTrkType(), LoadAllBranches(), setGnnNtupleBranches(), setOutputBranches(), and tas::sim_eta().

                                          {
   if (not sim_eta_isLoaded) {
     if (sim_eta_branch != 0) {
       sim_eta_branch->GetEntry(index);
     } else {
       printf("branch sim_eta_branch does not exist!\n");
       exit(1);
     }
     sim_eta_isLoaded = true;
   }
   return *sim_eta_;
 }

◆ sim_event()

const std::vector< int > & Trktree::sim_event ( )

Definition at line 3141 of file Trktree.cc.

References beamvalidation::exit(), index, sim_event_, sim_event_branch, and sim_event_isLoaded.

Referenced by getDenomSimTrkType(), LoadAllBranches(), setGnnNtupleBranches(), setOutputBranches(), and tas::sim_event().

                                          {
   if (not sim_event_isLoaded) {
     if (sim_event_branch != 0) {
       sim_event_branch->GetEntry(index);
     } else {
       printf("branch sim_event_branch does not exist!\n");
       exit(1);
     }
     sim_event_isLoaded = true;
   }
   return *sim_event_;
 }

◆ sim_genPdgIds()

const std::vector< std::vector< int > > & Trktree::sim_genPdgIds ( )

Definition at line 4941 of file Trktree.cc.

References beamvalidation::exit(), index, sim_genPdgIds_, sim_genPdgIds_branch, and sim_genPdgIds_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_genPdgIds().

                                                          {
   if (not sim_genPdgIds_isLoaded) {
     if (sim_genPdgIds_branch != 0) {
       sim_genPdgIds_branch->GetEntry(index);
     } else {
       printf("branch sim_genPdgIds_branch does not exist!\n");
       exit(1);
     }
     sim_genPdgIds_isLoaded = true;
   }
   return *sim_genPdgIds_;
 }

◆ sim_hits()

const std::vector< float > & Trktree::sim_hits ( )

Definition at line 5193 of file Trktree.cc.

References beamvalidation::exit(), index, sim_hits_, sim_hits_branch, and sim_hits_isLoaded.

Referenced by LoadAllBranches().

                                           {
   if (not sim_hits_isLoaded) {
     if (sim_hits_branch != 0) {
       sim_hits_branch->GetEntry(index);
     } else {
       printf("branch sim_hits_branch does not exist!\n");
       exit(1);
     }
     sim_hits_isLoaded = true;
   }
   return *sim_hits_;
 }

◆ sim_isFromBHadron()

const std::vector< int > & Trktree::sim_isFromBHadron ( )

Definition at line 3945 of file Trktree.cc.

References beamvalidation::exit(), index, sim_isFromBHadron_, sim_isFromBHadron_branch, and sim_isFromBHadron_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_isFromBHadron().

                                                  {
   if (not sim_isFromBHadron_isLoaded) {
     if (sim_isFromBHadron_branch != 0) {
       sim_isFromBHadron_branch->GetEntry(index);
     } else {
       printf("branch sim_isFromBHadron_branch does not exist!\n");
       exit(1);
     }
     sim_isFromBHadron_isLoaded = true;
   }
   return *sim_isFromBHadron_;
 }

◆ sim_len()

const std::vector< float > & Trktree::sim_len ( )

Definition at line 5205 of file Trktree.cc.

References beamvalidation::exit(), index, sim_len_, sim_len_branch, and sim_len_isLoaded.

Referenced by LoadAllBranches().

                                          {
   if (not sim_len_isLoaded) {
     if (sim_len_branch != 0) {
       sim_len_branch->GetEntry(index);
     } else {
       printf("branch sim_len_branch does not exist!\n");
       exit(1);
     }
     sim_len_isLoaded = true;
   }
   return *sim_len_;
 }

◆ sim_lengap()

const std::vector< float > & Trktree::sim_lengap ( )

Definition at line 5217 of file Trktree.cc.

References beamvalidation::exit(), index, sim_lengap_, sim_lengap_branch, and sim_lengap_isLoaded.

Referenced by LoadAllBranches().

                                             {
   if (not sim_lengap_isLoaded) {
     if (sim_lengap_branch != 0) {
       sim_lengap_branch->GetEntry(index);
     } else {
       printf("branch sim_lengap_branch does not exist!\n");
       exit(1);
     }
     sim_lengap_isLoaded = true;
   }
   return *sim_lengap_;
 }

◆ sim_n3DLay()

const std::vector< unsigned int > & Trktree::sim_n3DLay ( )

Definition at line 6393 of file Trktree.cc.

References beamvalidation::exit(), index, sim_n3DLay_, sim_n3DLay_branch, and sim_n3DLay_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_n3DLay().

                                                    {
   if (not sim_n3DLay_isLoaded) {
     if (sim_n3DLay_branch != 0) {
       sim_n3DLay_branch->GetEntry(index);
     } else {
       printf("branch sim_n3DLay_branch does not exist!\n");
       exit(1);
     }
     sim_n3DLay_isLoaded = true;
   }
   return *sim_n3DLay_;
 }

◆ sim_nLay()

const std::vector< unsigned int > & Trktree::sim_nLay ( )

Definition at line 6273 of file Trktree.cc.

References beamvalidation::exit(), index, sim_nLay_, sim_nLay_branch, and sim_nLay_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_nLay().

                                                  {
   if (not sim_nLay_isLoaded) {
     if (sim_nLay_branch != 0) {
       sim_nLay_branch->GetEntry(index);
     } else {
       printf("branch sim_nLay_branch does not exist!\n");
       exit(1);
     }
     sim_nLay_isLoaded = true;
   }
   return *sim_nLay_;
 }

◆ sim_nPixel()

const std::vector< unsigned int > & Trktree::sim_nPixel ( )

Definition at line 5301 of file Trktree.cc.

References beamvalidation::exit(), index, sim_nPixel_, sim_nPixel_branch, and sim_nPixel_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_nPixel().

                                                    {
   if (not sim_nPixel_isLoaded) {
     if (sim_nPixel_branch != 0) {
       sim_nPixel_branch->GetEntry(index);
     } else {
       printf("branch sim_nPixel_branch does not exist!\n");
       exit(1);
     }
     sim_nPixel_isLoaded = true;
   }
   return *sim_nPixel_;
 }

◆ sim_nPixelLay()

const std::vector< unsigned int > & Trktree::sim_nPixelLay ( )

Definition at line 6633 of file Trktree.cc.

References beamvalidation::exit(), index, sim_nPixelLay_, sim_nPixelLay_branch, and sim_nPixelLay_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_nPixelLay().

                                                       {
   if (not sim_nPixelLay_isLoaded) {
     if (sim_nPixelLay_branch != 0) {
       sim_nPixelLay_branch->GetEntry(index);
     } else {
       printf("branch sim_nPixelLay_branch does not exist!\n");
       exit(1);
     }
     sim_nPixelLay_isLoaded = true;
   }
   return *sim_nPixelLay_;
 }

◆ sim_nRecoClusters()

const std::vector< unsigned int > & Trktree::sim_nRecoClusters ( )

Definition at line 4437 of file Trktree.cc.

References beamvalidation::exit(), index, sim_nRecoClusters_, sim_nRecoClusters_branch, and sim_nRecoClusters_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_nRecoClusters().

                                                           {
   if (not sim_nRecoClusters_isLoaded) {
     if (sim_nRecoClusters_branch != 0) {
       sim_nRecoClusters_branch->GetEntry(index);
     } else {
       printf("branch sim_nRecoClusters_branch does not exist!\n");
       exit(1);
     }
     sim_nRecoClusters_isLoaded = true;
   }
   return *sim_nRecoClusters_;
 }

◆ sim_nStrip()

const std::vector< unsigned int > & Trktree::sim_nStrip ( )

Definition at line 5649 of file Trktree.cc.

References beamvalidation::exit(), index, sim_nStrip_, sim_nStrip_branch, and sim_nStrip_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_nStrip().

                                                    {
   if (not sim_nStrip_isLoaded) {
     if (sim_nStrip_branch != 0) {
       sim_nStrip_branch->GetEntry(index);
     } else {
       printf("branch sim_nStrip_branch does not exist!\n");
       exit(1);
     }
     sim_nStrip_isLoaded = true;
   }
   return *sim_nStrip_;
 }

◆ sim_nTrackerHits()

const std::vector< unsigned int > & Trktree::sim_nTrackerHits ( )

Definition at line 6501 of file Trktree.cc.

References beamvalidation::exit(), index, sim_nTrackerHits_, sim_nTrackerHits_branch, and sim_nTrackerHits_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_nTrackerHits().

                                                          {
   if (not sim_nTrackerHits_isLoaded) {
     if (sim_nTrackerHits_branch != 0) {
       sim_nTrackerHits_branch->GetEntry(index);
     } else {
       printf("branch sim_nTrackerHits_branch does not exist!\n");
       exit(1);
     }
     sim_nTrackerHits_isLoaded = true;
   }
   return *sim_nTrackerHits_;
 }

◆ sim_nValid()

const std::vector< unsigned int > & Trktree::sim_nValid ( )

Definition at line 6033 of file Trktree.cc.

References beamvalidation::exit(), index, sim_nValid_, sim_nValid_branch, and sim_nValid_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_nValid().

                                                    {
   if (not sim_nValid_isLoaded) {
     if (sim_nValid_branch != 0) {
       sim_nValid_branch->GetEntry(index);
     } else {
       printf("branch sim_nValid_branch does not exist!\n");
       exit(1);
     }
     sim_nValid_isLoaded = true;
   }
   return *sim_nValid_;
 }

◆ sim_parentVtxIdx()

const std::vector< int > & Trktree::sim_parentVtxIdx ( )

Definition at line 5817 of file Trktree.cc.

References beamvalidation::exit(), index, sim_parentVtxIdx_, sim_parentVtxIdx_branch, and sim_parentVtxIdx_isLoaded.

Referenced by getDenomSimTrkType(), LoadAllBranches(), setGnnNtupleBranches(), setOutputBranches(), and tas::sim_parentVtxIdx().

                                                 {
   if (not sim_parentVtxIdx_isLoaded) {
     if (sim_parentVtxIdx_branch != 0) {
       sim_parentVtxIdx_branch->GetEntry(index);
     } else {
       printf("branch sim_parentVtxIdx_branch does not exist!\n");
       exit(1);
     }
     sim_parentVtxIdx_isLoaded = true;
   }
   return *sim_parentVtxIdx_;
 }

◆ sim_pca_cotTheta()

const std::vector< float > & Trktree::sim_pca_cotTheta ( )

Definition at line 6177 of file Trktree.cc.

References beamvalidation::exit(), index, sim_pca_cotTheta_, sim_pca_cotTheta_branch, and sim_pca_cotTheta_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_pca_cotTheta().

                                                   {
   if (not sim_pca_cotTheta_isLoaded) {
     if (sim_pca_cotTheta_branch != 0) {
       sim_pca_cotTheta_branch->GetEntry(index);
     } else {
       printf("branch sim_pca_cotTheta_branch does not exist!\n");
       exit(1);
     }
     sim_pca_cotTheta_isLoaded = true;
   }
   return *sim_pca_cotTheta_;
 }

◆ sim_pca_dxy()

const std::vector< float > & Trktree::sim_pca_dxy ( )

Definition at line 4833 of file Trktree.cc.

References beamvalidation::exit(), index, sim_pca_dxy_, sim_pca_dxy_branch, and sim_pca_dxy_isLoaded.

Referenced by LoadAllBranches(), setGnnNtupleBranches(), setOutputBranches(), and tas::sim_pca_dxy().

                                              {
   if (not sim_pca_dxy_isLoaded) {
     if (sim_pca_dxy_branch != 0) {
       sim_pca_dxy_branch->GetEntry(index);
     } else {
       printf("branch sim_pca_dxy_branch does not exist!\n");
       exit(1);
     }
     sim_pca_dxy_isLoaded = true;
   }
   return *sim_pca_dxy_;
 }

◆ sim_pca_dz()

const std::vector< float > & Trktree::sim_pca_dz ( )

Definition at line 5433 of file Trktree.cc.

References beamvalidation::exit(), index, sim_pca_dz_, sim_pca_dz_branch, and sim_pca_dz_isLoaded.

Referenced by LoadAllBranches(), setGnnNtupleBranches(), setOutputBranches(), and tas::sim_pca_dz().

                                             {
   if (not sim_pca_dz_isLoaded) {
     if (sim_pca_dz_branch != 0) {
       sim_pca_dz_branch->GetEntry(index);
     } else {
       printf("branch sim_pca_dz_branch does not exist!\n");
       exit(1);
     }
     sim_pca_dz_isLoaded = true;
   }
   return *sim_pca_dz_;
 }

◆ sim_pca_eta()

const std::vector< float > & Trktree::sim_pca_eta ( )

Definition at line 4509 of file Trktree.cc.

References beamvalidation::exit(), index, sim_pca_eta_, sim_pca_eta_branch, and sim_pca_eta_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_pca_eta().

                                              {
   if (not sim_pca_eta_isLoaded) {
     if (sim_pca_eta_branch != 0) {
       sim_pca_eta_branch->GetEntry(index);
     } else {
       printf("branch sim_pca_eta_branch does not exist!\n");
       exit(1);
     }
     sim_pca_eta_isLoaded = true;
   }
   return *sim_pca_eta_;
 }

◆ sim_pca_lambda()

const std::vector< float > & Trktree::sim_pca_lambda ( )

Definition at line 3633 of file Trktree.cc.

References beamvalidation::exit(), index, sim_pca_lambda_, sim_pca_lambda_branch, and sim_pca_lambda_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_pca_lambda().

                                                 {
   if (not sim_pca_lambda_isLoaded) {
     if (sim_pca_lambda_branch != 0) {
       sim_pca_lambda_branch->GetEntry(index);
     } else {
       printf("branch sim_pca_lambda_branch does not exist!\n");
       exit(1);
     }
     sim_pca_lambda_isLoaded = true;
   }
   return *sim_pca_lambda_;
 }

◆ sim_pca_phi()

const std::vector< float > & Trktree::sim_pca_phi ( )

Definition at line 4017 of file Trktree.cc.

References beamvalidation::exit(), index, sim_pca_phi_, sim_pca_phi_branch, and sim_pca_phi_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_pca_phi().

                                              {
   if (not sim_pca_phi_isLoaded) {
     if (sim_pca_phi_branch != 0) {
       sim_pca_phi_branch->GetEntry(index);
     } else {
       printf("branch sim_pca_phi_branch does not exist!\n");
       exit(1);
     }
     sim_pca_phi_isLoaded = true;
   }
   return *sim_pca_phi_;
 }

◆ sim_pca_pt()

const std::vector< float > & Trktree::sim_pca_pt ( )

Definition at line 3477 of file Trktree.cc.

References beamvalidation::exit(), index, sim_pca_pt_, sim_pca_pt_branch, and sim_pca_pt_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_pca_pt().

                                             {
   if (not sim_pca_pt_isLoaded) {
     if (sim_pca_pt_branch != 0) {
       sim_pca_pt_branch->GetEntry(index);
     } else {
       printf("branch sim_pca_pt_branch does not exist!\n");
       exit(1);
     }
     sim_pca_pt_isLoaded = true;
   }
   return *sim_pca_pt_;
 }

◆ sim_pdgId()

const std::vector< int > & Trktree::sim_pdgId ( )

Definition at line 3993 of file Trktree.cc.

References beamvalidation::exit(), index, sim_pdgId_, sim_pdgId_branch, and sim_pdgId_isLoaded.

Referenced by LoadAllBranches(), setGnnNtupleBranches(), setOutputBranches(), and tas::sim_pdgId().

                                          {
   if (not sim_pdgId_isLoaded) {
     if (sim_pdgId_branch != 0) {
       sim_pdgId_branch->GetEntry(index);
     } else {
       printf("branch sim_pdgId_branch does not exist!\n");
       exit(1);
     }
     sim_pdgId_isLoaded = true;
   }
   return *sim_pdgId_;
 }

◆ sim_phi()

const std::vector< float > & Trktree::sim_phi ( )

Definition at line 5721 of file Trktree.cc.

References beamvalidation::exit(), index, sim_phi_, sim_phi_branch, and sim_phi_isLoaded.

Referenced by distxySimHitConsistentWithHelix(), drfracSimHitConsistentWithHelix(), LoadAllBranches(), setGnnNtupleBranches(), setOutputBranches(), and tas::sim_phi().

                                          {
   if (not sim_phi_isLoaded) {
     if (sim_phi_branch != 0) {
       sim_phi_branch->GetEntry(index);
     } else {
       printf("branch sim_phi_branch does not exist!\n");
       exit(1);
     }
     sim_phi_isLoaded = true;
   }
   return *sim_phi_;
 }

◆ sim_pt()

const std::vector< float > & Trktree::sim_pt ( )

Definition at line 3873 of file Trktree.cc.

References beamvalidation::exit(), index, sim_pt_, sim_pt_branch, and sim_pt_isLoaded.

Referenced by distxySimHitConsistentWithHelix(), drfracSimHitConsistentWithHelix(), getDenomSimTrkType(), LoadAllBranches(), setGnnNtupleBranches(), setOutputBranches(), and tas::sim_pt().

                                         {
   if (not sim_pt_isLoaded) {
     if (sim_pt_branch != 0) {
       sim_pt_branch->GetEntry(index);
     } else {
       printf("branch sim_pt_branch does not exist!\n");
       exit(1);
     }
     sim_pt_isLoaded = true;
   }
   return *sim_pt_;
 }

◆ sim_px()

const std::vector< float > & Trktree::sim_px ( )

Definition at line 3837 of file Trktree.cc.

References beamvalidation::exit(), index, sim_px_, sim_px_branch, and sim_px_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_px().

                                         {
   if (not sim_px_isLoaded) {
     if (sim_px_branch != 0) {
       sim_px_branch->GetEntry(index);
     } else {
       printf("branch sim_px_branch does not exist!\n");
       exit(1);
     }
     sim_px_isLoaded = true;
   }
   return *sim_px_;
 }

◆ sim_py()

const std::vector< float > & Trktree::sim_py ( )

Definition at line 3885 of file Trktree.cc.

References beamvalidation::exit(), index, sim_py_, sim_py_branch, and sim_py_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_py().

                                         {
   if (not sim_py_isLoaded) {
     if (sim_py_branch != 0) {
       sim_py_branch->GetEntry(index);
     } else {
       printf("branch sim_py_branch does not exist!\n");
       exit(1);
     }
     sim_py_isLoaded = true;
   }
   return *sim_py_;
 }

◆ sim_pz()

const std::vector< float > & Trktree::sim_pz ( )

Definition at line 3813 of file Trktree.cc.

References beamvalidation::exit(), index, sim_pz_, sim_pz_branch, and sim_pz_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_pz().

                                         {
   if (not sim_pz_isLoaded) {
     if (sim_pz_branch != 0) {
       sim_pz_branch->GetEntry(index);
     } else {
       printf("branch sim_pz_branch does not exist!\n");
       exit(1);
     }
     sim_pz_isLoaded = true;
   }
   return *sim_pz_;
 }

◆ sim_q()

const std::vector< int > & Trktree::sim_q ( )

Definition at line 3645 of file Trktree.cc.

References beamvalidation::exit(), index, sim_q_, sim_q_branch, and sim_q_isLoaded.

Referenced by distxySimHitConsistentWithHelix(), drfracSimHitConsistentWithHelix(), getDenomSimTrkType(), LoadAllBranches(), setGnnNtupleBranches(), setOutputBranches(), and tas::sim_q().

                                      {
   if (not sim_q_isLoaded) {
     if (sim_q_branch != 0) {
       sim_q_branch->GetEntry(index);
     } else {
       printf("branch sim_q_branch does not exist!\n");
       exit(1);
     }
     sim_q_isLoaded = true;
   }
   return *sim_q_;
 }

◆ sim_seedIdx()

const std::vector< std::vector< int > > & Trktree::sim_seedIdx ( )

Definition at line 4413 of file Trktree.cc.

References beamvalidation::exit(), index, sim_seedIdx_, sim_seedIdx_branch, and sim_seedIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_seedIdx().

                                                        {
   if (not sim_seedIdx_isLoaded) {
     if (sim_seedIdx_branch != 0) {
       sim_seedIdx_branch->GetEntry(index);
     } else {
       printf("branch sim_seedIdx_branch does not exist!\n");
       exit(1);
     }
     sim_seedIdx_isLoaded = true;
   }
   return *sim_seedIdx_;
 }

◆ sim_simHitIdx()

const std::vector< std::vector< int > > & Trktree::sim_simHitIdx ( )

Definition at line 6285 of file Trktree.cc.

References beamvalidation::exit(), index, sim_simHitIdx_, sim_simHitIdx_branch, and sim_simHitIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_simHitIdx().

                                                          {
   if (not sim_simHitIdx_isLoaded) {
     if (sim_simHitIdx_branch != 0) {
       sim_simHitIdx_branch->GetEntry(index);
     } else {
       printf("branch sim_simHitIdx_branch does not exist!\n");
       exit(1);
     }
     sim_simHitIdx_isLoaded = true;
   }
   return *sim_simHitIdx_;
 }

◆ sim_trkIdx()

const std::vector< std::vector< int > > & Trktree::sim_trkIdx ( )

Definition at line 3345 of file Trktree.cc.

References beamvalidation::exit(), index, sim_trkIdx_, sim_trkIdx_branch, and sim_trkIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_trkIdx().

                                                       {
   if (not sim_trkIdx_isLoaded) {
     if (sim_trkIdx_branch != 0) {
       sim_trkIdx_branch->GetEntry(index);
     } else {
       printf("branch sim_trkIdx_branch does not exist!\n");
       exit(1);
     }
     sim_trkIdx_isLoaded = true;
   }
   return *sim_trkIdx_;
 }

◆ sim_trkShareFrac()

const std::vector< std::vector< float > > & Trktree::sim_trkShareFrac ( )

Definition at line 5697 of file Trktree.cc.

References beamvalidation::exit(), index, sim_trkShareFrac_, sim_trkShareFrac_branch, and sim_trkShareFrac_isLoaded.

Referenced by LoadAllBranches(), and tas::sim_trkShareFrac().

                                                               {
   if (not sim_trkShareFrac_isLoaded) {
     if (sim_trkShareFrac_branch != 0) {
       sim_trkShareFrac_branch->GetEntry(index);
     } else {
       printf("branch sim_trkShareFrac_branch does not exist!\n");
       exit(1);
     }
     sim_trkShareFrac_isLoaded = true;
   }
   return *sim_trkShareFrac_;
 }

◆ simhit_blade()

const std::vector< unsigned short > & Trktree::simhit_blade ( )

Definition at line 3741 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_blade_, simhit_blade_branch, and simhit_blade_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_blade().

                                                        {
   if (not simhit_blade_isLoaded) {
     if (simhit_blade_branch != 0) {
       simhit_blade_branch->GetEntry(index);
     } else {
       printf("branch simhit_blade_branch does not exist!\n");
       exit(1);
     }
     simhit_blade_isLoaded = true;
   }
   return *simhit_blade_;
 }

◆ simhit_detId()

const std::vector< unsigned int > & Trktree::simhit_detId ( )

Definition at line 3393 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_detId_, simhit_detId_branch, and simhit_detId_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_detId().

                                                      {
   if (not simhit_detId_isLoaded) {
     if (simhit_detId_branch != 0) {
       simhit_detId_branch->GetEntry(index);
     } else {
       printf("branch simhit_detId_branch does not exist!\n");
       exit(1);
     }
     simhit_detId_isLoaded = true;
   }
   return *simhit_detId_;
 }

◆ simhit_eloss()

const std::vector< float > & Trktree::simhit_eloss ( )

Definition at line 3957 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_eloss_, simhit_eloss_branch, and simhit_eloss_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_eloss().

                                               {
   if (not simhit_eloss_isLoaded) {
     if (simhit_eloss_branch != 0) {
       simhit_eloss_branch->GetEntry(index);
     } else {
       printf("branch simhit_eloss_branch does not exist!\n");
       exit(1);
     }
     simhit_eloss_isLoaded = true;
   }
   return *simhit_eloss_;
 }

◆ simhit_hitIdx()

const std::vector< std::vector< int > > & Trktree::simhit_hitIdx ( )

Definition at line 6537 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_hitIdx_, simhit_hitIdx_branch, and simhit_hitIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_hitIdx().

                                                          {
   if (not simhit_hitIdx_isLoaded) {
     if (simhit_hitIdx_branch != 0) {
       simhit_hitIdx_branch->GetEntry(index);
     } else {
       printf("branch simhit_hitIdx_branch does not exist!\n");
       exit(1);
     }
     simhit_hitIdx_isLoaded = true;
   }
   return *simhit_hitIdx_;
 }

◆ simhit_hitType()

const std::vector< std::vector< int > > & Trktree::simhit_hitType ( )

Definition at line 3537 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_hitType_, simhit_hitType_branch, and simhit_hitType_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_hitType().

                                                           {
   if (not simhit_hitType_isLoaded) {
     if (simhit_hitType_branch != 0) {
       simhit_hitType_branch->GetEntry(index);
     } else {
       printf("branch simhit_hitType_branch does not exist!\n");
       exit(1);
     }
     simhit_hitType_isLoaded = true;
   }
   return *simhit_hitType_;
 }

◆ simhit_isLower()

const std::vector< unsigned short > & Trktree::simhit_isLower ( )

Definition at line 4029 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_isLower_, simhit_isLower_branch, and simhit_isLower_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_isLower().

                                                          {
   if (not simhit_isLower_isLoaded) {
     if (simhit_isLower_branch != 0) {
       simhit_isLower_branch->GetEntry(index);
     } else {
       printf("branch simhit_isLower_branch does not exist!\n");
       exit(1);
     }
     simhit_isLower_isLoaded = true;
   }
   return *simhit_isLower_;
 }

◆ simhit_isStack()

const std::vector< unsigned short > & Trktree::simhit_isStack ( )

Definition at line 3153 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_isStack_, simhit_isStack_branch, and simhit_isStack_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_isStack().

                                                          {
   if (not simhit_isStack_isLoaded) {
     if (simhit_isStack_branch != 0) {
       simhit_isStack_branch->GetEntry(index);
     } else {
       printf("branch simhit_isStack_branch does not exist!\n");
       exit(1);
     }
     simhit_isStack_isLoaded = true;
   }
   return *simhit_isStack_;
 }

◆ simhit_isUpper()

const std::vector< unsigned short > & Trktree::simhit_isUpper ( )

Definition at line 6297 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_isUpper_, simhit_isUpper_branch, and simhit_isUpper_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_isUpper().

                                                          {
   if (not simhit_isUpper_isLoaded) {
     if (simhit_isUpper_branch != 0) {
       simhit_isUpper_branch->GetEntry(index);
     } else {
       printf("branch simhit_isUpper_branch does not exist!\n");
       exit(1);
     }
     simhit_isUpper_isLoaded = true;
   }
   return *simhit_isUpper_;
 }

◆ simhit_ladder()

const std::vector< unsigned short > & Trktree::simhit_ladder ( )

Definition at line 6549 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_ladder_, simhit_ladder_branch, and simhit_ladder_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_ladder().

                                                         {
   if (not simhit_ladder_isLoaded) {
     if (simhit_ladder_branch != 0) {
       simhit_ladder_branch->GetEntry(index);
     } else {
       printf("branch simhit_ladder_branch does not exist!\n");
       exit(1);
     }
     simhit_ladder_isLoaded = true;
   }
   return *simhit_ladder_;
 }

◆ simhit_layer()

const std::vector< unsigned short > & Trktree::simhit_layer ( )

Definition at line 4725 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_layer_, simhit_layer_branch, and simhit_layer_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_layer().

                                                        {
   if (not simhit_layer_isLoaded) {
     if (simhit_layer_branch != 0) {
       simhit_layer_branch->GetEntry(index);
     } else {
       printf("branch simhit_layer_branch does not exist!\n");
       exit(1);
     }
     simhit_layer_isLoaded = true;
   }
   return *simhit_layer_;
 }

◆ simhit_module()

const std::vector< unsigned short > & Trktree::simhit_module ( )

Definition at line 5901 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_module_, simhit_module_branch, and simhit_module_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_module().

                                                         {
   if (not simhit_module_isLoaded) {
     if (simhit_module_branch != 0) {
       simhit_module_branch->GetEntry(index);
     } else {
       printf("branch simhit_module_branch does not exist!\n");
       exit(1);
     }
     simhit_module_isLoaded = true;
   }
   return *simhit_module_;
 }

◆ simhit_order()

const std::vector< unsigned short > & Trktree::simhit_order ( )

Definition at line 4065 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_order_, simhit_order_branch, and simhit_order_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_order().

                                                        {
   if (not simhit_order_isLoaded) {
     if (simhit_order_branch != 0) {
       simhit_order_branch->GetEntry(index);
     } else {
       printf("branch simhit_order_branch does not exist!\n");
       exit(1);
     }
     simhit_order_isLoaded = true;
   }
   return *simhit_order_;
 }

◆ simhit_panel()

const std::vector< unsigned short > & Trktree::simhit_panel ( )

Definition at line 3801 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_panel_, simhit_panel_branch, and simhit_panel_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_panel().

                                                        {
   if (not simhit_panel_isLoaded) {
     if (simhit_panel_branch != 0) {
       simhit_panel_branch->GetEntry(index);
     } else {
       printf("branch simhit_panel_branch does not exist!\n");
       exit(1);
     }
     simhit_panel_isLoaded = true;
   }
   return *simhit_panel_;
 }

◆ simhit_particle()

const std::vector< int > & Trktree::simhit_particle ( )

Definition at line 5517 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_particle_, simhit_particle_branch, and simhit_particle_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_particle().

                                                {
   if (not simhit_particle_isLoaded) {
     if (simhit_particle_branch != 0) {
       simhit_particle_branch->GetEntry(index);
     } else {
       printf("branch simhit_particle_branch does not exist!\n");
       exit(1);
     }
     simhit_particle_isLoaded = true;
   }
   return *simhit_particle_;
 }

◆ simhit_process()

const std::vector< short > & Trktree::simhit_process ( )

Definition at line 3297 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_process_, simhit_process_branch, and simhit_process_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_process().

                                                 {
   if (not simhit_process_isLoaded) {
     if (simhit_process_branch != 0) {
       simhit_process_branch->GetEntry(index);
     } else {
       printf("branch simhit_process_branch does not exist!\n");
       exit(1);
     }
     simhit_process_isLoaded = true;
   }
   return *simhit_process_;
 }

◆ simhit_px()

const std::vector< float > & Trktree::simhit_px ( )

Definition at line 4785 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_px_, simhit_px_branch, and simhit_px_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_px().

                                            {
   if (not simhit_px_isLoaded) {
     if (simhit_px_branch != 0) {
       simhit_px_branch->GetEntry(index);
     } else {
       printf("branch simhit_px_branch does not exist!\n");
       exit(1);
     }
     simhit_px_isLoaded = true;
   }
   return *simhit_px_;
 }

◆ simhit_py()

const std::vector< float > & Trktree::simhit_py ( )

Definition at line 4257 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_py_, simhit_py_branch, and simhit_py_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_py().

                                            {
   if (not simhit_py_isLoaded) {
     if (simhit_py_branch != 0) {
       simhit_py_branch->GetEntry(index);
     } else {
       printf("branch simhit_py_branch does not exist!\n");
       exit(1);
     }
     simhit_py_isLoaded = true;
   }
   return *simhit_py_;
 }

◆ simhit_pz()

const std::vector< float > & Trktree::simhit_pz ( )

Definition at line 3981 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_pz_, simhit_pz_branch, and simhit_pz_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_pz().

                                            {
   if (not simhit_pz_isLoaded) {
     if (simhit_pz_branch != 0) {
       simhit_pz_branch->GetEntry(index);
     } else {
       printf("branch simhit_pz_branch does not exist!\n");
       exit(1);
     }
     simhit_pz_isLoaded = true;
   }
   return *simhit_pz_;
 }

◆ simhit_ring()

const std::vector< unsigned short > & Trktree::simhit_ring ( )

Definition at line 5049 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_ring_, simhit_ring_branch, and simhit_ring_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_ring().

                                                       {
   if (not simhit_ring_isLoaded) {
     if (simhit_ring_branch != 0) {
       simhit_ring_branch->GetEntry(index);
     } else {
       printf("branch simhit_ring_branch does not exist!\n");
       exit(1);
     }
     simhit_ring_isLoaded = true;
   }
   return *simhit_ring_;
 }

◆ simhit_rod()

const std::vector< unsigned short > & Trktree::simhit_rod ( )

Definition at line 3057 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_rod_, simhit_rod_branch, and simhit_rod_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_rod().

                                                      {
   if (not simhit_rod_isLoaded) {
     if (simhit_rod_branch != 0) {
       simhit_rod_branch->GetEntry(index);
     } else {
       printf("branch simhit_rod_branch does not exist!\n");
       exit(1);
     }
     simhit_rod_isLoaded = true;
   }
   return *simhit_rod_;
 }

◆ simhit_side()

const std::vector< unsigned short > & Trktree::simhit_side ( )

Definition at line 3585 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_side_, simhit_side_branch, and simhit_side_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_side().

                                                       {
   if (not simhit_side_isLoaded) {
     if (simhit_side_branch != 0) {
       simhit_side_branch->GetEntry(index);
     } else {
       printf("branch simhit_side_branch does not exist!\n");
       exit(1);
     }
     simhit_side_isLoaded = true;
   }
   return *simhit_side_;
 }

◆ simhit_simTrkIdx()

const std::vector< int > & Trktree::simhit_simTrkIdx ( )

Definition at line 6045 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_simTrkIdx_, simhit_simTrkIdx_branch, and simhit_simTrkIdx_isLoaded.

Referenced by LoadAllBranches(), matchedSimTrkIdxs(), and tas::simhit_simTrkIdx().

                                                 {
   if (not simhit_simTrkIdx_isLoaded) {
     if (simhit_simTrkIdx_branch != 0) {
       simhit_simTrkIdx_branch->GetEntry(index);
     } else {
       printf("branch simhit_simTrkIdx_branch does not exist!\n");
       exit(1);
     }
     simhit_simTrkIdx_isLoaded = true;
   }
   return *simhit_simTrkIdx_;
 }

◆ simhit_subdet()

const std::vector< unsigned short > & Trktree::simhit_subdet ( )

Definition at line 3405 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_subdet_, simhit_subdet_branch, and simhit_subdet_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_subdet().

                                                         {
   if (not simhit_subdet_isLoaded) {
     if (simhit_subdet_branch != 0) {
       simhit_subdet_branch->GetEntry(index);
     } else {
       printf("branch simhit_subdet_branch does not exist!\n");
       exit(1);
     }
     simhit_subdet_isLoaded = true;
   }
   return *simhit_subdet_;
 }

◆ simhit_tof()

const std::vector< float > & Trktree::simhit_tof ( )

Definition at line 3129 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_tof_, simhit_tof_branch, and simhit_tof_isLoaded.

Referenced by LoadAllBranches(), and tas::simhit_tof().

                                             {
   if (not simhit_tof_isLoaded) {
     if (simhit_tof_branch != 0) {
       simhit_tof_branch->GetEntry(index);
     } else {
       printf("branch simhit_tof_branch does not exist!\n");
       exit(1);
     }
     simhit_tof_isLoaded = true;
   }
   return *simhit_tof_;
 }

◆ simhit_x()

const std::vector< float > & Trktree::simhit_x ( )

Definition at line 3597 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_x_, simhit_x_branch, and simhit_x_isLoaded.

Referenced by distxySimHitConsistentWithHelix(), drfracSimHitConsistentWithHelix(), LoadAllBranches(), and tas::simhit_x().

                                           {
   if (not simhit_x_isLoaded) {
     if (simhit_x_branch != 0) {
       simhit_x_branch->GetEntry(index);
     } else {
       printf("branch simhit_x_branch does not exist!\n");
       exit(1);
     }
     simhit_x_isLoaded = true;
   }
   return *simhit_x_;
 }

◆ simhit_y()

const std::vector< float > & Trktree::simhit_y ( )

Definition at line 5949 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_y_, simhit_y_branch, and simhit_y_isLoaded.

Referenced by distxySimHitConsistentWithHelix(), drfracSimHitConsistentWithHelix(), LoadAllBranches(), and tas::simhit_y().

                                           {
   if (not simhit_y_isLoaded) {
     if (simhit_y_branch != 0) {
       simhit_y_branch->GetEntry(index);
     } else {
       printf("branch simhit_y_branch does not exist!\n");
       exit(1);
     }
     simhit_y_isLoaded = true;
   }
   return *simhit_y_;
 }

◆ simhit_z()

const std::vector< float > & Trktree::simhit_z ( )

Definition at line 3621 of file Trktree.cc.

References beamvalidation::exit(), index, simhit_z_, simhit_z_branch, and simhit_z_isLoaded.

Referenced by distxySimHitConsistentWithHelix(), drfracSimHitConsistentWithHelix(), LoadAllBranches(), and tas::simhit_z().

                                           {
   if (not simhit_z_isLoaded) {
     if (simhit_z_branch != 0) {
       simhit_z_branch->GetEntry(index);
     } else {
       printf("branch simhit_z_branch does not exist!\n");
       exit(1);
     }
     simhit_z_isLoaded = true;
   }
   return *simhit_z_;
 }

◆ simpv_idx()

const std::vector< int > & Trktree::simpv_idx ( )

Definition at line 6189 of file Trktree.cc.

References beamvalidation::exit(), index, simpv_idx_, simpv_idx_branch, and simpv_idx_isLoaded.

Referenced by LoadAllBranches(), and tas::simpv_idx().

                                          {
   if (not simpv_idx_isLoaded) {
     if (simpv_idx_branch != 0) {
       simpv_idx_branch->GetEntry(index);
     } else {
       printf("branch simpv_idx_branch does not exist!\n");
       exit(1);
     }
     simpv_idx_isLoaded = true;
   }
   return *simpv_idx_;
 }

◆ simvtx_bunchCrossing()

const std::vector< int > & Trktree::simvtx_bunchCrossing ( )

Definition at line 5421 of file Trktree.cc.

References beamvalidation::exit(), index, simvtx_bunchCrossing_, simvtx_bunchCrossing_branch, and simvtx_bunchCrossing_isLoaded.

Referenced by LoadAllBranches(), and tas::simvtx_bunchCrossing().

                                                     {
   if (not simvtx_bunchCrossing_isLoaded) {
     if (simvtx_bunchCrossing_branch != 0) {
       simvtx_bunchCrossing_branch->GetEntry(index);
     } else {
       printf("branch simvtx_bunchCrossing_branch does not exist!\n");
       exit(1);
     }
     simvtx_bunchCrossing_isLoaded = true;
   }
   return *simvtx_bunchCrossing_;
 }

◆ simvtx_daughterSimIdx()

const std::vector< std::vector< int > > & Trktree::simvtx_daughterSimIdx ( )

Definition at line 5913 of file Trktree.cc.

References beamvalidation::exit(), index, simvtx_daughterSimIdx_, simvtx_daughterSimIdx_branch, and simvtx_daughterSimIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::simvtx_daughterSimIdx().

                                                                  {
   if (not simvtx_daughterSimIdx_isLoaded) {
     if (simvtx_daughterSimIdx_branch != 0) {
       simvtx_daughterSimIdx_branch->GetEntry(index);
     } else {
       printf("branch simvtx_daughterSimIdx_branch does not exist!\n");
       exit(1);
     }
     simvtx_daughterSimIdx_isLoaded = true;
   }
   return *simvtx_daughterSimIdx_;
 }

◆ simvtx_event()

const std::vector< int > & Trktree::simvtx_event ( )

Definition at line 4893 of file Trktree.cc.

References beamvalidation::exit(), index, simvtx_event_, simvtx_event_branch, and simvtx_event_isLoaded.

Referenced by LoadAllBranches(), and tas::simvtx_event().

                                             {
   if (not simvtx_event_isLoaded) {
     if (simvtx_event_branch != 0) {
       simvtx_event_branch->GetEntry(index);
     } else {
       printf("branch simvtx_event_branch does not exist!\n");
       exit(1);
     }
     simvtx_event_isLoaded = true;
   }
   return *simvtx_event_;
 }

◆ simvtx_processType()

const std::vector< unsigned int > & Trktree::simvtx_processType ( )

Definition at line 3201 of file Trktree.cc.

References beamvalidation::exit(), index, simvtx_processType_, simvtx_processType_branch, and simvtx_processType_isLoaded.

Referenced by LoadAllBranches(), and tas::simvtx_processType().

                                                            {
   if (not simvtx_processType_isLoaded) {
     if (simvtx_processType_branch != 0) {
       simvtx_processType_branch->GetEntry(index);
     } else {
       printf("branch simvtx_processType_branch does not exist!\n");
       exit(1);
     }
     simvtx_processType_isLoaded = true;
   }
   return *simvtx_processType_;
 }

◆ simvtx_sourceSimIdx()

const std::vector< std::vector< int > > & Trktree::simvtx_sourceSimIdx ( )

Definition at line 4149 of file Trktree.cc.

References beamvalidation::exit(), index, simvtx_sourceSimIdx_, simvtx_sourceSimIdx_branch, and simvtx_sourceSimIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::simvtx_sourceSimIdx().

                                                                {
   if (not simvtx_sourceSimIdx_isLoaded) {
     if (simvtx_sourceSimIdx_branch != 0) {
       simvtx_sourceSimIdx_branch->GetEntry(index);
     } else {
       printf("branch simvtx_sourceSimIdx_branch does not exist!\n");
       exit(1);
     }
     simvtx_sourceSimIdx_isLoaded = true;
   }
   return *simvtx_sourceSimIdx_;
 }

◆ simvtx_x()

const std::vector< float > & Trktree::simvtx_x ( )

Definition at line 5229 of file Trktree.cc.

References beamvalidation::exit(), index, simvtx_x_, simvtx_x_branch, and simvtx_x_isLoaded.

Referenced by distxySimHitConsistentWithHelix(), drfracSimHitConsistentWithHelix(), getDenomSimTrkType(), LoadAllBranches(), setGnnNtupleBranches(), setOutputBranches(), and tas::simvtx_x().

                                           {
   if (not simvtx_x_isLoaded) {
     if (simvtx_x_branch != 0) {
       simvtx_x_branch->GetEntry(index);
     } else {
       printf("branch simvtx_x_branch does not exist!\n");
       exit(1);
     }
     simvtx_x_isLoaded = true;
   }
   return *simvtx_x_;
 }

◆ simvtx_y()

const std::vector< float > & Trktree::simvtx_y ( )

Definition at line 5445 of file Trktree.cc.

References beamvalidation::exit(), index, simvtx_y_, simvtx_y_branch, and simvtx_y_isLoaded.

Referenced by distxySimHitConsistentWithHelix(), drfracSimHitConsistentWithHelix(), getDenomSimTrkType(), LoadAllBranches(), setGnnNtupleBranches(), setOutputBranches(), and tas::simvtx_y().

                                           {
   if (not simvtx_y_isLoaded) {
     if (simvtx_y_branch != 0) {
       simvtx_y_branch->GetEntry(index);
     } else {
       printf("branch simvtx_y_branch does not exist!\n");
       exit(1);
     }
     simvtx_y_isLoaded = true;
   }
   return *simvtx_y_;
 }

◆ simvtx_z()

const std::vector< float > & Trktree::simvtx_z ( )

Definition at line 6489 of file Trktree.cc.

References beamvalidation::exit(), index, simvtx_z_, simvtx_z_branch, and simvtx_z_isLoaded.

Referenced by distxySimHitConsistentWithHelix(), drfracSimHitConsistentWithHelix(), getDenomSimTrkType(), LoadAllBranches(), setGnnNtupleBranches(), setOutputBranches(), and tas::simvtx_z().

                                           {
   if (not simvtx_z_isLoaded) {
     if (simvtx_z_branch != 0) {
       simvtx_z_branch->GetEntry(index);
     } else {
       printf("branch simvtx_z_branch does not exist!\n");
       exit(1);
     }
     simvtx_z_isLoaded = true;
   }
   return *simvtx_z_;
 }

◆ trk_algo()

const std::vector< unsigned int > & Trktree::trk_algo ( )

Definition at line 4845 of file Trktree.cc.

References beamvalidation::exit(), index, trk_algo_, trk_algo_branch, and trk_algo_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_algo().

                                                  {
   if (not trk_algo_isLoaded) {
     if (trk_algo_branch != 0) {
       trk_algo_branch->GetEntry(index);
     } else {
       printf("branch trk_algo_branch does not exist!\n");
       exit(1);
     }
     trk_algo_isLoaded = true;
   }
   return *trk_algo_;
 }

◆ trk_algoMask()

const std::vector< ULong64_t > & Trktree::trk_algoMask ( )

Definition at line 5841 of file Trktree.cc.

References beamvalidation::exit(), index, trk_algoMask_, trk_algoMask_branch, and trk_algoMask_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_algoMask().

                                                   {
   if (not trk_algoMask_isLoaded) {
     if (trk_algoMask_branch != 0) {
       trk_algoMask_branch->GetEntry(index);
     } else {
       printf("branch trk_algoMask_branch does not exist!\n");
       exit(1);
     }
     trk_algoMask_isLoaded = true;
   }
   return *trk_algoMask_;
 }

◆ trk_bestFromFirstHitSimTrkIdx()

const std::vector< int > & Trktree::trk_bestFromFirstHitSimTrkIdx ( )

Definition at line 4773 of file Trktree.cc.

References beamvalidation::exit(), index, trk_bestFromFirstHitSimTrkIdx_, trk_bestFromFirstHitSimTrkIdx_branch, and trk_bestFromFirstHitSimTrkIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_bestFromFirstHitSimTrkIdx().

                                                              {
   if (not trk_bestFromFirstHitSimTrkIdx_isLoaded) {
     if (trk_bestFromFirstHitSimTrkIdx_branch != 0) {
       trk_bestFromFirstHitSimTrkIdx_branch->GetEntry(index);
     } else {
       printf("branch trk_bestFromFirstHitSimTrkIdx_branch does not exist!\n");
       exit(1);
     }
     trk_bestFromFirstHitSimTrkIdx_isLoaded = true;
   }
   return *trk_bestFromFirstHitSimTrkIdx_;
 }

◆ trk_bestFromFirstHitSimTrkNChi2()

const std::vector< float > & Trktree::trk_bestFromFirstHitSimTrkNChi2 ( )

Definition at line 3513 of file Trktree.cc.

References beamvalidation::exit(), index, trk_bestFromFirstHitSimTrkNChi2_, trk_bestFromFirstHitSimTrkNChi2_branch, and trk_bestFromFirstHitSimTrkNChi2_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_bestFromFirstHitSimTrkNChi2().

                                                                  {
   if (not trk_bestFromFirstHitSimTrkNChi2_isLoaded) {
     if (trk_bestFromFirstHitSimTrkNChi2_branch != 0) {
       trk_bestFromFirstHitSimTrkNChi2_branch->GetEntry(index);
     } else {
       printf("branch trk_bestFromFirstHitSimTrkNChi2_branch does not exist!\n");
       exit(1);
     }
     trk_bestFromFirstHitSimTrkNChi2_isLoaded = true;
   }
   return *trk_bestFromFirstHitSimTrkNChi2_;
 }

◆ trk_bestFromFirstHitSimTrkShareFrac()

const std::vector< float > & Trktree::trk_bestFromFirstHitSimTrkShareFrac ( )

Definition at line 4869 of file Trktree.cc.

References beamvalidation::exit(), index, trk_bestFromFirstHitSimTrkShareFrac_, trk_bestFromFirstHitSimTrkShareFrac_branch, and trk_bestFromFirstHitSimTrkShareFrac_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_bestFromFirstHitSimTrkShareFrac().

                                                                      {
   if (not trk_bestFromFirstHitSimTrkShareFrac_isLoaded) {
     if (trk_bestFromFirstHitSimTrkShareFrac_branch != 0) {
       trk_bestFromFirstHitSimTrkShareFrac_branch->GetEntry(index);
     } else {
       printf("branch trk_bestFromFirstHitSimTrkShareFrac_branch does not exist!\n");
       exit(1);
     }
     trk_bestFromFirstHitSimTrkShareFrac_isLoaded = true;
   }
   return *trk_bestFromFirstHitSimTrkShareFrac_;
 }

◆ trk_bestFromFirstHitSimTrkShareFracSimClusterDenom()

const std::vector< float > & Trktree::trk_bestFromFirstHitSimTrkShareFracSimClusterDenom ( )

Definition at line 5181 of file Trktree.cc.

References beamvalidation::exit(), index, trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_, trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch, and trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_bestFromFirstHitSimTrkShareFracSimClusterDenom().

                                                                                     {
   if (not trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_isLoaded) {
     if (trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch != 0) {
       trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch->GetEntry(index);
     } else {
       printf("branch trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch does not exist!\n");
       exit(1);
     }
     trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_isLoaded = true;
   }
   return *trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_;
 }

◆ trk_bestFromFirstHitSimTrkShareFracSimDenom()

const std::vector< float > & Trktree::trk_bestFromFirstHitSimTrkShareFracSimDenom ( )

Definition at line 6417 of file Trktree.cc.

References beamvalidation::exit(), index, trk_bestFromFirstHitSimTrkShareFracSimDenom_, trk_bestFromFirstHitSimTrkShareFracSimDenom_branch, and trk_bestFromFirstHitSimTrkShareFracSimDenom_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_bestFromFirstHitSimTrkShareFracSimDenom().

                                                                              {
   if (not trk_bestFromFirstHitSimTrkShareFracSimDenom_isLoaded) {
     if (trk_bestFromFirstHitSimTrkShareFracSimDenom_branch != 0) {
       trk_bestFromFirstHitSimTrkShareFracSimDenom_branch->GetEntry(index);
     } else {
       printf("branch trk_bestFromFirstHitSimTrkShareFracSimDenom_branch does not exist!\n");
       exit(1);
     }
     trk_bestFromFirstHitSimTrkShareFracSimDenom_isLoaded = true;
   }
   return *trk_bestFromFirstHitSimTrkShareFracSimDenom_;
 }

◆ trk_bestSimTrkIdx()

const std::vector< int > & Trktree::trk_bestSimTrkIdx ( )

Definition at line 3249 of file Trktree.cc.

References beamvalidation::exit(), index, trk_bestSimTrkIdx_, trk_bestSimTrkIdx_branch, and trk_bestSimTrkIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_bestSimTrkIdx().

                                                  {
   if (not trk_bestSimTrkIdx_isLoaded) {
     if (trk_bestSimTrkIdx_branch != 0) {
       trk_bestSimTrkIdx_branch->GetEntry(index);
     } else {
       printf("branch trk_bestSimTrkIdx_branch does not exist!\n");
       exit(1);
     }
     trk_bestSimTrkIdx_isLoaded = true;
   }
   return *trk_bestSimTrkIdx_;
 }

◆ trk_bestSimTrkNChi2()

const std::vector< float > & Trktree::trk_bestSimTrkNChi2 ( )

Definition at line 4197 of file Trktree.cc.

References beamvalidation::exit(), index, trk_bestSimTrkNChi2_, trk_bestSimTrkNChi2_branch, and trk_bestSimTrkNChi2_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_bestSimTrkNChi2().

                                                      {
   if (not trk_bestSimTrkNChi2_isLoaded) {
     if (trk_bestSimTrkNChi2_branch != 0) {
       trk_bestSimTrkNChi2_branch->GetEntry(index);
     } else {
       printf("branch trk_bestSimTrkNChi2_branch does not exist!\n");
       exit(1);
     }
     trk_bestSimTrkNChi2_isLoaded = true;
   }
   return *trk_bestSimTrkNChi2_;
 }

◆ trk_bestSimTrkShareFrac()

const std::vector< float > & Trktree::trk_bestSimTrkShareFrac ( )

Definition at line 5553 of file Trktree.cc.

References beamvalidation::exit(), index, trk_bestSimTrkShareFrac_, trk_bestSimTrkShareFrac_branch, and trk_bestSimTrkShareFrac_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_bestSimTrkShareFrac().

                                                          {
   if (not trk_bestSimTrkShareFrac_isLoaded) {
     if (trk_bestSimTrkShareFrac_branch != 0) {
       trk_bestSimTrkShareFrac_branch->GetEntry(index);
     } else {
       printf("branch trk_bestSimTrkShareFrac_branch does not exist!\n");
       exit(1);
     }
     trk_bestSimTrkShareFrac_isLoaded = true;
   }
   return *trk_bestSimTrkShareFrac_;
 }

◆ trk_bestSimTrkShareFracSimClusterDenom()

const std::vector< float > & Trktree::trk_bestSimTrkShareFracSimClusterDenom ( )

Definition at line 3573 of file Trktree.cc.

References beamvalidation::exit(), index, trk_bestSimTrkShareFracSimClusterDenom_, trk_bestSimTrkShareFracSimClusterDenom_branch, and trk_bestSimTrkShareFracSimClusterDenom_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_bestSimTrkShareFracSimClusterDenom().

                                                                         {
   if (not trk_bestSimTrkShareFracSimClusterDenom_isLoaded) {
     if (trk_bestSimTrkShareFracSimClusterDenom_branch != 0) {
       trk_bestSimTrkShareFracSimClusterDenom_branch->GetEntry(index);
     } else {
       printf("branch trk_bestSimTrkShareFracSimClusterDenom_branch does not exist!\n");
       exit(1);
     }
     trk_bestSimTrkShareFracSimClusterDenom_isLoaded = true;
   }
   return *trk_bestSimTrkShareFracSimClusterDenom_;
 }

◆ trk_bestSimTrkShareFracSimDenom()

const std::vector< float > & Trktree::trk_bestSimTrkShareFracSimDenom ( )

Definition at line 4545 of file Trktree.cc.

References beamvalidation::exit(), index, trk_bestSimTrkShareFracSimDenom_, trk_bestSimTrkShareFracSimDenom_branch, and trk_bestSimTrkShareFracSimDenom_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_bestSimTrkShareFracSimDenom().

                                                                  {
   if (not trk_bestSimTrkShareFracSimDenom_isLoaded) {
     if (trk_bestSimTrkShareFracSimDenom_branch != 0) {
       trk_bestSimTrkShareFracSimDenom_branch->GetEntry(index);
     } else {
       printf("branch trk_bestSimTrkShareFracSimDenom_branch does not exist!\n");
       exit(1);
     }
     trk_bestSimTrkShareFracSimDenom_isLoaded = true;
   }
   return *trk_bestSimTrkShareFracSimDenom_;
 }

◆ trk_cotTheta()

const std::vector< float > & Trktree::trk_cotTheta ( )

Definition at line 5877 of file Trktree.cc.

References beamvalidation::exit(), index, trk_cotTheta_, trk_cotTheta_branch, and trk_cotTheta_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_cotTheta().

                                               {
   if (not trk_cotTheta_isLoaded) {
     if (trk_cotTheta_branch != 0) {
       trk_cotTheta_branch->GetEntry(index);
     } else {
       printf("branch trk_cotTheta_branch does not exist!\n");
       exit(1);
     }
     trk_cotTheta_isLoaded = true;
   }
   return *trk_cotTheta_;
 }

◆ trk_dxy()

const std::vector< float > & Trktree::trk_dxy ( )

Definition at line 3825 of file Trktree.cc.

References beamvalidation::exit(), index, trk_dxy_, trk_dxy_branch, and trk_dxy_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_dxy().

                                          {
   if (not trk_dxy_isLoaded) {
     if (trk_dxy_branch != 0) {
       trk_dxy_branch->GetEntry(index);
     } else {
       printf("branch trk_dxy_branch does not exist!\n");
       exit(1);
     }
     trk_dxy_isLoaded = true;
   }
   return *trk_dxy_;
 }

◆ trk_dxyClosestPV()

const std::vector< float > & Trktree::trk_dxyClosestPV ( )

Definition at line 4077 of file Trktree.cc.

References beamvalidation::exit(), index, trk_dxyClosestPV_, trk_dxyClosestPV_branch, and trk_dxyClosestPV_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_dxyClosestPV().

                                                   {
   if (not trk_dxyClosestPV_isLoaded) {
     if (trk_dxyClosestPV_branch != 0) {
       trk_dxyClosestPV_branch->GetEntry(index);
     } else {
       printf("branch trk_dxyClosestPV_branch does not exist!\n");
       exit(1);
     }
     trk_dxyClosestPV_isLoaded = true;
   }
   return *trk_dxyClosestPV_;
 }

◆ trk_dxyErr()

const std::vector< float > & Trktree::trk_dxyErr ( )

Definition at line 6621 of file Trktree.cc.

References beamvalidation::exit(), index, trk_dxyErr_, trk_dxyErr_branch, and trk_dxyErr_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_dxyErr().

                                             {
   if (not trk_dxyErr_isLoaded) {
     if (trk_dxyErr_branch != 0) {
       trk_dxyErr_branch->GetEntry(index);
     } else {
       printf("branch trk_dxyErr_branch does not exist!\n");
       exit(1);
     }
     trk_dxyErr_isLoaded = true;
   }
   return *trk_dxyErr_;
 }

◆ trk_dxyPV()

const std::vector< float > & Trktree::trk_dxyPV ( )

Definition at line 3117 of file Trktree.cc.

References beamvalidation::exit(), index, trk_dxyPV_, trk_dxyPV_branch, and trk_dxyPV_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_dxyPV().

                                            {
   if (not trk_dxyPV_isLoaded) {
     if (trk_dxyPV_branch != 0) {
       trk_dxyPV_branch->GetEntry(index);
     } else {
       printf("branch trk_dxyPV_branch does not exist!\n");
       exit(1);
     }
     trk_dxyPV_isLoaded = true;
   }
   return *trk_dxyPV_;
 }

◆ trk_dz()

const std::vector< float > & Trktree::trk_dz ( )

Definition at line 3165 of file Trktree.cc.

References beamvalidation::exit(), index, trk_dz_, trk_dz_branch, and trk_dz_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_dz().

                                         {
   if (not trk_dz_isLoaded) {
     if (trk_dz_branch != 0) {
       trk_dz_branch->GetEntry(index);
     } else {
       printf("branch trk_dz_branch does not exist!\n");
       exit(1);
     }
     trk_dz_isLoaded = true;
   }
   return *trk_dz_;
 }

◆ trk_dzClosestPV()

const std::vector< float > & Trktree::trk_dzClosestPV ( )

Definition at line 4977 of file Trktree.cc.

References beamvalidation::exit(), index, trk_dzClosestPV_, trk_dzClosestPV_branch, and trk_dzClosestPV_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_dzClosestPV().

                                                  {
   if (not trk_dzClosestPV_isLoaded) {
     if (trk_dzClosestPV_branch != 0) {
       trk_dzClosestPV_branch->GetEntry(index);
     } else {
       printf("branch trk_dzClosestPV_branch does not exist!\n");
       exit(1);
     }
     trk_dzClosestPV_isLoaded = true;
   }
   return *trk_dzClosestPV_;
 }

◆ trk_dzErr()

const std::vector< float > & Trktree::trk_dzErr ( )

Definition at line 3705 of file Trktree.cc.

References beamvalidation::exit(), index, trk_dzErr_, trk_dzErr_branch, and trk_dzErr_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_dzErr().

                                            {
   if (not trk_dzErr_isLoaded) {
     if (trk_dzErr_branch != 0) {
       trk_dzErr_branch->GetEntry(index);
     } else {
       printf("branch trk_dzErr_branch does not exist!\n");
       exit(1);
     }
     trk_dzErr_isLoaded = true;
   }
   return *trk_dzErr_;
 }

◆ trk_dzPV()

const std::vector< float > & Trktree::trk_dzPV ( )

Definition at line 6093 of file Trktree.cc.

References beamvalidation::exit(), index, trk_dzPV_, trk_dzPV_branch, and trk_dzPV_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_dzPV().

                                           {
   if (not trk_dzPV_isLoaded) {
     if (trk_dzPV_branch != 0) {
       trk_dzPV_branch->GetEntry(index);
     } else {
       printf("branch trk_dzPV_branch does not exist!\n");
       exit(1);
     }
     trk_dzPV_isLoaded = true;
   }
   return *trk_dzPV_;
 }

◆ trk_eta()

const std::vector< float > & Trktree::trk_eta ( )

Definition at line 3921 of file Trktree.cc.

References beamvalidation::exit(), index, trk_eta_, trk_eta_branch, and trk_eta_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_eta().

                                          {
   if (not trk_eta_isLoaded) {
     if (trk_eta_branch != 0) {
       trk_eta_branch->GetEntry(index);
     } else {
       printf("branch trk_eta_branch does not exist!\n");
       exit(1);
     }
     trk_eta_isLoaded = true;
   }
   return *trk_eta_;
 }

◆ trk_etaErr()

const std::vector< float > & Trktree::trk_etaErr ( )

Definition at line 5481 of file Trktree.cc.

References beamvalidation::exit(), index, trk_etaErr_, trk_etaErr_branch, and trk_etaErr_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_etaErr().

                                             {
   if (not trk_etaErr_isLoaded) {
     if (trk_etaErr_branch != 0) {
       trk_etaErr_branch->GetEntry(index);
     } else {
       printf("branch trk_etaErr_branch does not exist!\n");
       exit(1);
     }
     trk_etaErr_isLoaded = true;
   }
   return *trk_etaErr_;
 }

◆ trk_hitIdx()

const std::vector< std::vector< int > > & Trktree::trk_hitIdx ( )

Definition at line 5013 of file Trktree.cc.

References beamvalidation::exit(), index, trk_hitIdx_, trk_hitIdx_branch, and trk_hitIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_hitIdx().

                                                       {
   if (not trk_hitIdx_isLoaded) {
     if (trk_hitIdx_branch != 0) {
       trk_hitIdx_branch->GetEntry(index);
     } else {
       printf("branch trk_hitIdx_branch does not exist!\n");
       exit(1);
     }
     trk_hitIdx_isLoaded = true;
   }
   return *trk_hitIdx_;
 }

◆ trk_hitType()

const std::vector< std::vector< int > > & Trktree::trk_hitType ( )

Definition at line 4857 of file Trktree.cc.

References beamvalidation::exit(), index, trk_hitType_, trk_hitType_branch, and trk_hitType_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_hitType().

                                                        {
   if (not trk_hitType_isLoaded) {
     if (trk_hitType_branch != 0) {
       trk_hitType_branch->GetEntry(index);
     } else {
       printf("branch trk_hitType_branch does not exist!\n");
       exit(1);
     }
     trk_hitType_isLoaded = true;
   }
   return *trk_hitType_;
 }

◆ trk_inner_pt()

const std::vector< float > & Trktree::trk_inner_pt ( )

Definition at line 6657 of file Trktree.cc.

References beamvalidation::exit(), index, trk_inner_pt_, trk_inner_pt_branch, and trk_inner_pt_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_inner_pt().

                                               {
   if (not trk_inner_pt_isLoaded) {
     if (trk_inner_pt_branch != 0) {
       trk_inner_pt_branch->GetEntry(index);
     } else {
       printf("branch trk_inner_pt_branch does not exist!\n");
       exit(1);
     }
     trk_inner_pt_isLoaded = true;
   }
   return *trk_inner_pt_;
 }

◆ trk_inner_px()

const std::vector< float > & Trktree::trk_inner_px ( )

Definition at line 6609 of file Trktree.cc.

References beamvalidation::exit(), index, trk_inner_px_, trk_inner_px_branch, and trk_inner_px_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_inner_px().

                                               {
   if (not trk_inner_px_isLoaded) {
     if (trk_inner_px_branch != 0) {
       trk_inner_px_branch->GetEntry(index);
     } else {
       printf("branch trk_inner_px_branch does not exist!\n");
       exit(1);
     }
     trk_inner_px_isLoaded = true;
   }
   return *trk_inner_px_;
 }

◆ trk_inner_py()

const std::vector< float > & Trktree::trk_inner_py ( )

Definition at line 6597 of file Trktree.cc.

References beamvalidation::exit(), index, trk_inner_py_, trk_inner_py_branch, and trk_inner_py_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_inner_py().

                                               {
   if (not trk_inner_py_isLoaded) {
     if (trk_inner_py_branch != 0) {
       trk_inner_py_branch->GetEntry(index);
     } else {
       printf("branch trk_inner_py_branch does not exist!\n");
       exit(1);
     }
     trk_inner_py_isLoaded = true;
   }
   return *trk_inner_py_;
 }

◆ trk_inner_pz()

const std::vector< float > & Trktree::trk_inner_pz ( )

Definition at line 6201 of file Trktree.cc.

References beamvalidation::exit(), index, trk_inner_pz_, trk_inner_pz_branch, and trk_inner_pz_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_inner_pz().

                                               {
   if (not trk_inner_pz_isLoaded) {
     if (trk_inner_pz_branch != 0) {
       trk_inner_pz_branch->GetEntry(index);
     } else {
       printf("branch trk_inner_pz_branch does not exist!\n");
       exit(1);
     }
     trk_inner_pz_isLoaded = true;
   }
   return *trk_inner_pz_;
 }

◆ trk_isHP()

const std::vector< short > & Trktree::trk_isHP ( )

Definition at line 3525 of file Trktree.cc.

References beamvalidation::exit(), index, trk_isHP_, trk_isHP_branch, and trk_isHP_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_isHP().

                                           {
   if (not trk_isHP_isLoaded) {
     if (trk_isHP_branch != 0) {
       trk_isHP_branch->GetEntry(index);
     } else {
       printf("branch trk_isHP_branch does not exist!\n");
       exit(1);
     }
     trk_isHP_isLoaded = true;
   }
   return *trk_isHP_;
 }

◆ trk_lambda()

const std::vector< float > & Trktree::trk_lambda ( )

Definition at line 3849 of file Trktree.cc.

References beamvalidation::exit(), index, trk_lambda_, trk_lambda_branch, and trk_lambda_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_lambda().

                                             {
   if (not trk_lambda_isLoaded) {
     if (trk_lambda_branch != 0) {
       trk_lambda_branch->GetEntry(index);
     } else {
       printf("branch trk_lambda_branch does not exist!\n");
       exit(1);
     }
     trk_lambda_isLoaded = true;
   }
   return *trk_lambda_;
 }

◆ trk_lambdaErr()

const std::vector< float > & Trktree::trk_lambdaErr ( )

Definition at line 5565 of file Trktree.cc.

References beamvalidation::exit(), index, trk_lambdaErr_, trk_lambdaErr_branch, and trk_lambdaErr_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_lambdaErr().

                                                {
   if (not trk_lambdaErr_isLoaded) {
     if (trk_lambdaErr_branch != 0) {
       trk_lambdaErr_branch->GetEntry(index);
     } else {
       printf("branch trk_lambdaErr_branch does not exist!\n");
       exit(1);
     }
     trk_lambdaErr_isLoaded = true;
   }
   return *trk_lambdaErr_;
 }

◆ trk_mva()

const std::vector< float > & Trktree::trk_mva ( )

Definition at line 4953 of file Trktree.cc.

References beamvalidation::exit(), index, trk_mva_, trk_mva_branch, and trk_mva_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_mva().

                                          {
   if (not trk_mva_isLoaded) {
     if (trk_mva_branch != 0) {
       trk_mva_branch->GetEntry(index);
     } else {
       printf("branch trk_mva_branch does not exist!\n");
       exit(1);
     }
     trk_mva_isLoaded = true;
   }
   return *trk_mva_;
 }

◆ trk_n3DLay()

const std::vector< unsigned int > & Trktree::trk_n3DLay ( )

Definition at line 5121 of file Trktree.cc.

References beamvalidation::exit(), index, trk_n3DLay_, trk_n3DLay_branch, and trk_n3DLay_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_n3DLay().

                                                    {
   if (not trk_n3DLay_isLoaded) {
     if (trk_n3DLay_branch != 0) {
       trk_n3DLay_branch->GetEntry(index);
     } else {
       printf("branch trk_n3DLay_branch does not exist!\n");
       exit(1);
     }
     trk_n3DLay_isLoaded = true;
   }
   return *trk_n3DLay_;
 }

◆ trk_nChi2()

const std::vector< float > & Trktree::trk_nChi2 ( )

Definition at line 4473 of file Trktree.cc.

References beamvalidation::exit(), index, trk_nChi2_, trk_nChi2_branch, and trk_nChi2_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_nChi2().

                                            {
   if (not trk_nChi2_isLoaded) {
     if (trk_nChi2_branch != 0) {
       trk_nChi2_branch->GetEntry(index);
     } else {
       printf("branch trk_nChi2_branch does not exist!\n");
       exit(1);
     }
     trk_nChi2_isLoaded = true;
   }
   return *trk_nChi2_;
 }

◆ trk_nChi2_1Dmod()

const std::vector< float > & Trktree::trk_nChi2_1Dmod ( )

Definition at line 6585 of file Trktree.cc.

References beamvalidation::exit(), index, trk_nChi2_1Dmod_, trk_nChi2_1Dmod_branch, and trk_nChi2_1Dmod_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_nChi2_1Dmod().

                                                  {
   if (not trk_nChi2_1Dmod_isLoaded) {
     if (trk_nChi2_1Dmod_branch != 0) {
       trk_nChi2_1Dmod_branch->GetEntry(index);
     } else {
       printf("branch trk_nChi2_1Dmod_branch does not exist!\n");
       exit(1);
     }
     trk_nChi2_1Dmod_isLoaded = true;
   }
   return *trk_nChi2_1Dmod_;
 }

◆ trk_nCluster()

const std::vector< unsigned int > & Trktree::trk_nCluster ( )

Definition at line 3501 of file Trktree.cc.

References beamvalidation::exit(), index, trk_nCluster_, trk_nCluster_branch, and trk_nCluster_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_nCluster().

                                                      {
   if (not trk_nCluster_isLoaded) {
     if (trk_nCluster_branch != 0) {
       trk_nCluster_branch->GetEntry(index);
     } else {
       printf("branch trk_nCluster_branch does not exist!\n");
       exit(1);
     }
     trk_nCluster_isLoaded = true;
   }
   return *trk_nCluster_;
 }

◆ trk_ndof()

const std::vector< float > & Trktree::trk_ndof ( )

Definition at line 4617 of file Trktree.cc.

References beamvalidation::exit(), index, trk_ndof_, trk_ndof_branch, and trk_ndof_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_ndof().

                                           {
   if (not trk_ndof_isLoaded) {
     if (trk_ndof_branch != 0) {
       trk_ndof_branch->GetEntry(index);
     } else {
       printf("branch trk_ndof_branch does not exist!\n");
       exit(1);
     }
     trk_ndof_isLoaded = true;
   }
   return *trk_ndof_;
 }

◆ trk_nInactive()

const std::vector< unsigned int > & Trktree::trk_nInactive ( )

Definition at line 5757 of file Trktree.cc.

References beamvalidation::exit(), index, trk_nInactive_, trk_nInactive_branch, and trk_nInactive_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_nInactive().

                                                       {
   if (not trk_nInactive_isLoaded) {
     if (trk_nInactive_branch != 0) {
       trk_nInactive_branch->GetEntry(index);
     } else {
       printf("branch trk_nInactive_branch does not exist!\n");
       exit(1);
     }
     trk_nInactive_isLoaded = true;
   }
   return *trk_nInactive_;
 }

◆ trk_nInnerInactive()

const std::vector< unsigned int > & Trktree::trk_nInnerInactive ( )

Definition at line 3717 of file Trktree.cc.

References beamvalidation::exit(), index, trk_nInnerInactive_, trk_nInnerInactive_branch, and trk_nInnerInactive_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_nInnerInactive().

                                                            {
   if (not trk_nInnerInactive_isLoaded) {
     if (trk_nInnerInactive_branch != 0) {
       trk_nInnerInactive_branch->GetEntry(index);
     } else {
       printf("branch trk_nInnerInactive_branch does not exist!\n");
       exit(1);
     }
     trk_nInnerInactive_isLoaded = true;
   }
   return *trk_nInnerInactive_;
 }

◆ trk_nInnerLost()

const std::vector< unsigned int > & Trktree::trk_nInnerLost ( )

Definition at line 3321 of file Trktree.cc.

References beamvalidation::exit(), index, trk_nInnerLost_, trk_nInnerLost_branch, and trk_nInnerLost_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_nInnerLost().

                                                        {
   if (not trk_nInnerLost_isLoaded) {
     if (trk_nInnerLost_branch != 0) {
       trk_nInnerLost_branch->GetEntry(index);
     } else {
       printf("branch trk_nInnerLost_branch does not exist!\n");
       exit(1);
     }
     trk_nInnerLost_isLoaded = true;
   }
   return *trk_nInnerLost_;
 }

◆ trk_nLost()

const std::vector< unsigned int > & Trktree::trk_nLost ( )

Definition at line 3357 of file Trktree.cc.

References beamvalidation::exit(), index, trk_nLost_, trk_nLost_branch, and trk_nLost_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_nLost().

                                                   {
   if (not trk_nLost_isLoaded) {
     if (trk_nLost_branch != 0) {
       trk_nLost_branch->GetEntry(index);
     } else {
       printf("branch trk_nLost_branch does not exist!\n");
       exit(1);
     }
     trk_nLost_isLoaded = true;
   }
   return *trk_nLost_;
 }

◆ trk_nLostLay()

const std::vector< unsigned int > & Trktree::trk_nLostLay ( )

Definition at line 5973 of file Trktree.cc.

References beamvalidation::exit(), index, trk_nLostLay_, trk_nLostLay_branch, and trk_nLostLay_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_nLostLay().

                                                      {
   if (not trk_nLostLay_isLoaded) {
     if (trk_nLostLay_branch != 0) {
       trk_nLostLay_branch->GetEntry(index);
     } else {
       printf("branch trk_nLostLay_branch does not exist!\n");
       exit(1);
     }
     trk_nLostLay_isLoaded = true;
   }
   return *trk_nLostLay_;
 }

◆ trk_nOuterInactive()

const std::vector< unsigned int > & Trktree::trk_nOuterInactive ( )

Definition at line 4821 of file Trktree.cc.

References beamvalidation::exit(), index, trk_nOuterInactive_, trk_nOuterInactive_branch, and trk_nOuterInactive_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_nOuterInactive().

                                                            {
   if (not trk_nOuterInactive_isLoaded) {
     if (trk_nOuterInactive_branch != 0) {
       trk_nOuterInactive_branch->GetEntry(index);
     } else {
       printf("branch trk_nOuterInactive_branch does not exist!\n");
       exit(1);
     }
     trk_nOuterInactive_isLoaded = true;
   }
   return *trk_nOuterInactive_;
 }

◆ trk_nOuterLost()

const std::vector< unsigned int > & Trktree::trk_nOuterLost ( )

Definition at line 4689 of file Trktree.cc.

References beamvalidation::exit(), index, trk_nOuterLost_, trk_nOuterLost_branch, and trk_nOuterLost_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_nOuterLost().

                                                        {
   if (not trk_nOuterLost_isLoaded) {
     if (trk_nOuterLost_branch != 0) {
       trk_nOuterLost_branch->GetEntry(index);
     } else {
       printf("branch trk_nOuterLost_branch does not exist!\n");
       exit(1);
     }
     trk_nOuterLost_isLoaded = true;
   }
   return *trk_nOuterLost_;
 }

◆ trk_nPixel()

const std::vector< unsigned int > & Trktree::trk_nPixel ( )

Definition at line 4329 of file Trktree.cc.

References beamvalidation::exit(), index, trk_nPixel_, trk_nPixel_branch, and trk_nPixel_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_nPixel().

                                                    {
   if (not trk_nPixel_isLoaded) {
     if (trk_nPixel_branch != 0) {
       trk_nPixel_branch->GetEntry(index);
     } else {
       printf("branch trk_nPixel_branch does not exist!\n");
       exit(1);
     }
     trk_nPixel_isLoaded = true;
   }
   return *trk_nPixel_;
 }

◆ trk_nPixelLay()

const std::vector< unsigned int > & Trktree::trk_nPixelLay ( )

Definition at line 5769 of file Trktree.cc.

References beamvalidation::exit(), index, trk_nPixelLay_, trk_nPixelLay_branch, and trk_nPixelLay_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_nPixelLay().

                                                       {
   if (not trk_nPixelLay_isLoaded) {
     if (trk_nPixelLay_branch != 0) {
       trk_nPixelLay_branch->GetEntry(index);
     } else {
       printf("branch trk_nPixelLay_branch does not exist!\n");
       exit(1);
     }
     trk_nPixelLay_isLoaded = true;
   }
   return *trk_nPixelLay_;
 }

◆ trk_nStrip()

const std::vector< unsigned int > & Trktree::trk_nStrip ( )

Definition at line 5469 of file Trktree.cc.

References beamvalidation::exit(), index, trk_nStrip_, trk_nStrip_branch, and trk_nStrip_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_nStrip().

                                                    {
   if (not trk_nStrip_isLoaded) {
     if (trk_nStrip_branch != 0) {
       trk_nStrip_branch->GetEntry(index);
     } else {
       printf("branch trk_nStrip_branch does not exist!\n");
       exit(1);
     }
     trk_nStrip_isLoaded = true;
   }
   return *trk_nStrip_;
 }

◆ trk_nStripLay()

const std::vector< unsigned int > & Trktree::trk_nStripLay ( )

Definition at line 3453 of file Trktree.cc.

References beamvalidation::exit(), index, trk_nStripLay_, trk_nStripLay_branch, and trk_nStripLay_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_nStripLay().

                                                       {
   if (not trk_nStripLay_isLoaded) {
     if (trk_nStripLay_branch != 0) {
       trk_nStripLay_branch->GetEntry(index);
     } else {
       printf("branch trk_nStripLay_branch does not exist!\n");
       exit(1);
     }
     trk_nStripLay_isLoaded = true;
   }
   return *trk_nStripLay_;
 }

◆ trk_nValid()

const std::vector< unsigned int > & Trktree::trk_nValid ( )

Definition at line 5133 of file Trktree.cc.

References beamvalidation::exit(), index, trk_nValid_, trk_nValid_branch, and trk_nValid_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_nValid().

                                                    {
   if (not trk_nValid_isLoaded) {
     if (trk_nValid_branch != 0) {
       trk_nValid_branch->GetEntry(index);
     } else {
       printf("branch trk_nValid_branch does not exist!\n");
       exit(1);
     }
     trk_nValid_isLoaded = true;
   }
   return *trk_nValid_;
 }

◆ trk_originalAlgo()

const std::vector< unsigned int > & Trktree::trk_originalAlgo ( )

Definition at line 4317 of file Trktree.cc.

References beamvalidation::exit(), index, trk_originalAlgo_, trk_originalAlgo_branch, and trk_originalAlgo_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_originalAlgo().

                                                          {
   if (not trk_originalAlgo_isLoaded) {
     if (trk_originalAlgo_branch != 0) {
       trk_originalAlgo_branch->GetEntry(index);
     } else {
       printf("branch trk_originalAlgo_branch does not exist!\n");
       exit(1);
     }
     trk_originalAlgo_isLoaded = true;
   }
   return *trk_originalAlgo_;
 }

◆ trk_outer_pt()

const std::vector< float > & Trktree::trk_outer_pt ( )

Definition at line 5109 of file Trktree.cc.

References beamvalidation::exit(), index, trk_outer_pt_, trk_outer_pt_branch, and trk_outer_pt_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_outer_pt().

                                               {
   if (not trk_outer_pt_isLoaded) {
     if (trk_outer_pt_branch != 0) {
       trk_outer_pt_branch->GetEntry(index);
     } else {
       printf("branch trk_outer_pt_branch does not exist!\n");
       exit(1);
     }
     trk_outer_pt_isLoaded = true;
   }
   return *trk_outer_pt_;
 }

◆ trk_outer_px()

const std::vector< float > & Trktree::trk_outer_px ( )

Definition at line 5061 of file Trktree.cc.

References beamvalidation::exit(), index, trk_outer_px_, trk_outer_px_branch, and trk_outer_px_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_outer_px().

                                               {
   if (not trk_outer_px_isLoaded) {
     if (trk_outer_px_branch != 0) {
       trk_outer_px_branch->GetEntry(index);
     } else {
       printf("branch trk_outer_px_branch does not exist!\n");
       exit(1);
     }
     trk_outer_px_isLoaded = true;
   }
   return *trk_outer_px_;
 }

◆ trk_outer_py()

const std::vector< float > & Trktree::trk_outer_py ( )

Definition at line 5073 of file Trktree.cc.

References beamvalidation::exit(), index, trk_outer_py_, trk_outer_py_branch, and trk_outer_py_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_outer_py().

                                               {
   if (not trk_outer_py_isLoaded) {
     if (trk_outer_py_branch != 0) {
       trk_outer_py_branch->GetEntry(index);
     } else {
       printf("branch trk_outer_py_branch does not exist!\n");
       exit(1);
     }
     trk_outer_py_isLoaded = true;
   }
   return *trk_outer_py_;
 }

◆ trk_outer_pz()

const std::vector< float > & Trktree::trk_outer_pz ( )

Definition at line 5085 of file Trktree.cc.

References beamvalidation::exit(), index, trk_outer_pz_, trk_outer_pz_branch, and trk_outer_pz_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_outer_pz().

                                               {
   if (not trk_outer_pz_isLoaded) {
     if (trk_outer_pz_branch != 0) {
       trk_outer_pz_branch->GetEntry(index);
     } else {
       printf("branch trk_outer_pz_branch does not exist!\n");
       exit(1);
     }
     trk_outer_pz_isLoaded = true;
   }
   return *trk_outer_pz_;
 }

◆ trk_phi()

const std::vector< float > & Trktree::trk_phi ( )

Definition at line 3069 of file Trktree.cc.

References beamvalidation::exit(), index, trk_phi_, trk_phi_branch, and trk_phi_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_phi().

                                          {
   if (not trk_phi_isLoaded) {
     if (trk_phi_branch != 0) {
       trk_phi_branch->GetEntry(index);
     } else {
       printf("branch trk_phi_branch does not exist!\n");
       exit(1);
     }
     trk_phi_isLoaded = true;
   }
   return *trk_phi_;
 }

◆ trk_phiErr()

const std::vector< float > & Trktree::trk_phiErr ( )

Definition at line 4365 of file Trktree.cc.

References beamvalidation::exit(), index, trk_phiErr_, trk_phiErr_branch, and trk_phiErr_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_phiErr().

                                             {
   if (not trk_phiErr_isLoaded) {
     if (trk_phiErr_branch != 0) {
       trk_phiErr_branch->GetEntry(index);
     } else {
       printf("branch trk_phiErr_branch does not exist!\n");
       exit(1);
     }
     trk_phiErr_isLoaded = true;
   }
   return *trk_phiErr_;
 }

◆ trk_pt()

const std::vector< float > & Trktree::trk_pt ( )

Definition at line 5337 of file Trktree.cc.

References beamvalidation::exit(), index, trk_pt_, trk_pt_branch, and trk_pt_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_pt().

                                         {
   if (not trk_pt_isLoaded) {
     if (trk_pt_branch != 0) {
       trk_pt_branch->GetEntry(index);
     } else {
       printf("branch trk_pt_branch does not exist!\n");
       exit(1);
     }
     trk_pt_isLoaded = true;
   }
   return *trk_pt_;
 }

◆ trk_ptErr()

const std::vector< float > & Trktree::trk_ptErr ( )

Definition at line 6465 of file Trktree.cc.

References beamvalidation::exit(), index, trk_ptErr_, trk_ptErr_branch, and trk_ptErr_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_ptErr().

                                            {
   if (not trk_ptErr_isLoaded) {
     if (trk_ptErr_branch != 0) {
       trk_ptErr_branch->GetEntry(index);
     } else {
       printf("branch trk_ptErr_branch does not exist!\n");
       exit(1);
     }
     trk_ptErr_isLoaded = true;
   }
   return *trk_ptErr_;
 }

◆ trk_px()

const std::vector< float > & Trktree::trk_px ( )

Definition at line 5265 of file Trktree.cc.

References beamvalidation::exit(), index, trk_px_, trk_px_branch, and trk_px_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_px().

                                         {
   if (not trk_px_isLoaded) {
     if (trk_px_branch != 0) {
       trk_px_branch->GetEntry(index);
     } else {
       printf("branch trk_px_branch does not exist!\n");
       exit(1);
     }
     trk_px_isLoaded = true;
   }
   return *trk_px_;
 }

◆ trk_py()

const std::vector< float > & Trktree::trk_py ( )

Definition at line 5277 of file Trktree.cc.

References beamvalidation::exit(), index, trk_py_, trk_py_branch, and trk_py_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_py().

                                         {
   if (not trk_py_isLoaded) {
     if (trk_py_branch != 0) {
       trk_py_branch->GetEntry(index);
     } else {
       printf("branch trk_py_branch does not exist!\n");
       exit(1);
     }
     trk_py_isLoaded = true;
   }
   return *trk_py_;
 }

◆ trk_pz()

const std::vector< float > & Trktree::trk_pz ( )

Definition at line 5241 of file Trktree.cc.

References beamvalidation::exit(), index, trk_pz_, trk_pz_branch, and trk_pz_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_pz().

                                         {
   if (not trk_pz_isLoaded) {
     if (trk_pz_branch != 0) {
       trk_pz_branch->GetEntry(index);
     } else {
       printf("branch trk_pz_branch does not exist!\n");
       exit(1);
     }
     trk_pz_isLoaded = true;
   }
   return *trk_pz_;
 }

◆ trk_q()

const std::vector< int > & Trktree::trk_q ( )

Definition at line 4401 of file Trktree.cc.

References beamvalidation::exit(), index, trk_q_, trk_q_branch, and trk_q_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_q().

                                      {
   if (not trk_q_isLoaded) {
     if (trk_q_branch != 0) {
       trk_q_branch->GetEntry(index);
     } else {
       printf("branch trk_q_branch does not exist!\n");
       exit(1);
     }
     trk_q_isLoaded = true;
   }
   return *trk_q_;
 }

◆ trk_qualityMask()

const std::vector< unsigned short > & Trktree::trk_qualityMask ( )

Definition at line 4605 of file Trktree.cc.

References beamvalidation::exit(), index, trk_qualityMask_, trk_qualityMask_branch, and trk_qualityMask_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_qualityMask().

                                                           {
   if (not trk_qualityMask_isLoaded) {
     if (trk_qualityMask_branch != 0) {
       trk_qualityMask_branch->GetEntry(index);
     } else {
       printf("branch trk_qualityMask_branch does not exist!\n");
       exit(1);
     }
     trk_qualityMask_isLoaded = true;
   }
   return *trk_qualityMask_;
 }

◆ trk_refpoint_x()

const std::vector< float > & Trktree::trk_refpoint_x ( )

Definition at line 6357 of file Trktree.cc.

References beamvalidation::exit(), index, trk_refpoint_x_, trk_refpoint_x_branch, and trk_refpoint_x_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_refpoint_x().

                                                 {
   if (not trk_refpoint_x_isLoaded) {
     if (trk_refpoint_x_branch != 0) {
       trk_refpoint_x_branch->GetEntry(index);
     } else {
       printf("branch trk_refpoint_x_branch does not exist!\n");
       exit(1);
     }
     trk_refpoint_x_isLoaded = true;
   }
   return *trk_refpoint_x_;
 }

◆ trk_refpoint_y()

const std::vector< float > & Trktree::trk_refpoint_y ( )

Definition at line 6369 of file Trktree.cc.

References beamvalidation::exit(), index, trk_refpoint_y_, trk_refpoint_y_branch, and trk_refpoint_y_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_refpoint_y().

                                                 {
   if (not trk_refpoint_y_isLoaded) {
     if (trk_refpoint_y_branch != 0) {
       trk_refpoint_y_branch->GetEntry(index);
     } else {
       printf("branch trk_refpoint_y_branch does not exist!\n");
       exit(1);
     }
     trk_refpoint_y_isLoaded = true;
   }
   return *trk_refpoint_y_;
 }

◆ trk_refpoint_z()

const std::vector< float > & Trktree::trk_refpoint_z ( )

Definition at line 6381 of file Trktree.cc.

References beamvalidation::exit(), index, trk_refpoint_z_, trk_refpoint_z_branch, and trk_refpoint_z_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_refpoint_z().

                                                 {
   if (not trk_refpoint_z_isLoaded) {
     if (trk_refpoint_z_branch != 0) {
       trk_refpoint_z_branch->GetEntry(index);
     } else {
       printf("branch trk_refpoint_z_branch does not exist!\n");
       exit(1);
     }
     trk_refpoint_z_isLoaded = true;
   }
   return *trk_refpoint_z_;
 }

◆ trk_seedIdx()

const std::vector< int > & Trktree::trk_seedIdx ( )

Definition at line 5937 of file Trktree.cc.

References beamvalidation::exit(), index, trk_seedIdx_, trk_seedIdx_branch, and trk_seedIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_seedIdx().

                                            {
   if (not trk_seedIdx_isLoaded) {
     if (trk_seedIdx_branch != 0) {
       trk_seedIdx_branch->GetEntry(index);
     } else {
       printf("branch trk_seedIdx_branch does not exist!\n");
       exit(1);
     }
     trk_seedIdx_isLoaded = true;
   }
   return *trk_seedIdx_;
 }

◆ trk_simTrkIdx()

const std::vector< std::vector< int > > & Trktree::trk_simTrkIdx ( )

Definition at line 5853 of file Trktree.cc.

References beamvalidation::exit(), index, trk_simTrkIdx_, trk_simTrkIdx_branch, and trk_simTrkIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_simTrkIdx().

                                                          {
   if (not trk_simTrkIdx_isLoaded) {
     if (trk_simTrkIdx_branch != 0) {
       trk_simTrkIdx_branch->GetEntry(index);
     } else {
       printf("branch trk_simTrkIdx_branch does not exist!\n");
       exit(1);
     }
     trk_simTrkIdx_isLoaded = true;
   }
   return *trk_simTrkIdx_;
 }

◆ trk_simTrkNChi2()

const std::vector< std::vector< float > > & Trktree::trk_simTrkNChi2 ( )

Definition at line 5493 of file Trktree.cc.

References beamvalidation::exit(), index, trk_simTrkNChi2_, trk_simTrkNChi2_branch, and trk_simTrkNChi2_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_simTrkNChi2().

                                                              {
   if (not trk_simTrkNChi2_isLoaded) {
     if (trk_simTrkNChi2_branch != 0) {
       trk_simTrkNChi2_branch->GetEntry(index);
     } else {
       printf("branch trk_simTrkNChi2_branch does not exist!\n");
       exit(1);
     }
     trk_simTrkNChi2_isLoaded = true;
   }
   return *trk_simTrkNChi2_;
 }

◆ trk_simTrkShareFrac()

const std::vector< std::vector< float > > & Trktree::trk_simTrkShareFrac ( )

Definition at line 5709 of file Trktree.cc.

References beamvalidation::exit(), index, trk_simTrkShareFrac_, trk_simTrkShareFrac_branch, and trk_simTrkShareFrac_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_simTrkShareFrac().

                                                                  {
   if (not trk_simTrkShareFrac_isLoaded) {
     if (trk_simTrkShareFrac_branch != 0) {
       trk_simTrkShareFrac_branch->GetEntry(index);
     } else {
       printf("branch trk_simTrkShareFrac_branch does not exist!\n");
       exit(1);
     }
     trk_simTrkShareFrac_isLoaded = true;
   }
   return *trk_simTrkShareFrac_;
 }

◆ trk_stopReason()

const std::vector< unsigned short > & Trktree::trk_stopReason ( )

Definition at line 4005 of file Trktree.cc.

References beamvalidation::exit(), index, trk_stopReason_, trk_stopReason_branch, and trk_stopReason_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_stopReason().

                                                          {
   if (not trk_stopReason_isLoaded) {
     if (trk_stopReason_branch != 0) {
       trk_stopReason_branch->GetEntry(index);
     } else {
       printf("branch trk_stopReason_branch does not exist!\n");
       exit(1);
     }
     trk_stopReason_isLoaded = true;
   }
   return *trk_stopReason_;
 }

◆ trk_vtxIdx()

const std::vector< int > & Trktree::trk_vtxIdx ( )

Definition at line 5289 of file Trktree.cc.

References beamvalidation::exit(), index, trk_vtxIdx_, trk_vtxIdx_branch, and trk_vtxIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::trk_vtxIdx().

                                           {
   if (not trk_vtxIdx_isLoaded) {
     if (trk_vtxIdx_branch != 0) {
       trk_vtxIdx_branch->GetEntry(index);
     } else {
       printf("branch trk_vtxIdx_branch does not exist!\n");
       exit(1);
     }
     trk_vtxIdx_isLoaded = true;
   }
   return *trk_vtxIdx_;
 }

◆ vtx_chi2()

const std::vector< float > & Trktree::vtx_chi2 ( )

Definition at line 5313 of file Trktree.cc.

References beamvalidation::exit(), index, vtx_chi2_, vtx_chi2_branch, and vtx_chi2_isLoaded.

Referenced by LoadAllBranches(), and tas::vtx_chi2().

                                           {
   if (not vtx_chi2_isLoaded) {
     if (vtx_chi2_branch != 0) {
       vtx_chi2_branch->GetEntry(index);
     } else {
       printf("branch vtx_chi2_branch does not exist!\n");
       exit(1);
     }
     vtx_chi2_isLoaded = true;
   }
   return *vtx_chi2_;
 }

◆ vtx_fake()

const std::vector< short > & Trktree::vtx_fake ( )

Definition at line 5745 of file Trktree.cc.

References beamvalidation::exit(), index, vtx_fake_, vtx_fake_branch, and vtx_fake_isLoaded.

Referenced by LoadAllBranches(), and tas::vtx_fake().

                                           {
   if (not vtx_fake_isLoaded) {
     if (vtx_fake_branch != 0) {
       vtx_fake_branch->GetEntry(index);
     } else {
       printf("branch vtx_fake_branch does not exist!\n");
       exit(1);
     }
     vtx_fake_isLoaded = true;
   }
   return *vtx_fake_;
 }

◆ vtx_ndof()

const std::vector< float > & Trktree::vtx_ndof ( )

Definition at line 5625 of file Trktree.cc.

References beamvalidation::exit(), index, vtx_ndof_, vtx_ndof_branch, and vtx_ndof_isLoaded.

Referenced by LoadAllBranches(), and tas::vtx_ndof().

                                           {
   if (not vtx_ndof_isLoaded) {
     if (vtx_ndof_branch != 0) {
       vtx_ndof_branch->GetEntry(index);
     } else {
       printf("branch vtx_ndof_branch does not exist!\n");
       exit(1);
     }
     vtx_ndof_isLoaded = true;
   }
   return *vtx_ndof_;
 }

◆ vtx_trkIdx()

const std::vector< std::vector< int > > & Trktree::vtx_trkIdx ( )

Definition at line 5601 of file Trktree.cc.

References beamvalidation::exit(), index, vtx_trkIdx_, vtx_trkIdx_branch, and vtx_trkIdx_isLoaded.

Referenced by LoadAllBranches(), and tas::vtx_trkIdx().

                                                       {
   if (not vtx_trkIdx_isLoaded) {
     if (vtx_trkIdx_branch != 0) {
       vtx_trkIdx_branch->GetEntry(index);
     } else {
       printf("branch vtx_trkIdx_branch does not exist!\n");
       exit(1);
     }
     vtx_trkIdx_isLoaded = true;
   }
   return *vtx_trkIdx_;
 }

◆ vtx_valid()

const std::vector< short > & Trktree::vtx_valid ( )

Definition at line 6333 of file Trktree.cc.

References beamvalidation::exit(), index, vtx_valid_, vtx_valid_branch, and vtx_valid_isLoaded.

Referenced by LoadAllBranches(), and tas::vtx_valid().

                                            {
   if (not vtx_valid_isLoaded) {
     if (vtx_valid_branch != 0) {
       vtx_valid_branch->GetEntry(index);
     } else {
       printf("branch vtx_valid_branch does not exist!\n");
       exit(1);
     }
     vtx_valid_isLoaded = true;
   }
   return *vtx_valid_;
 }

◆ vtx_x()

const std::vector< float > & Trktree::vtx_x ( )

Definition at line 5925 of file Trktree.cc.

References beamvalidation::exit(), index, vtx_x_, vtx_x_branch, and vtx_x_isLoaded.

Referenced by LoadAllBranches(), and tas::vtx_x().

                                        {
   if (not vtx_x_isLoaded) {
     if (vtx_x_branch != 0) {
       vtx_x_branch->GetEntry(index);
     } else {
       printf("branch vtx_x_branch does not exist!\n");
       exit(1);
     }
     vtx_x_isLoaded = true;
   }
   return *vtx_x_;
 }

◆ vtx_xErr()

const std::vector< float > & Trktree::vtx_xErr ( )

Definition at line 5793 of file Trktree.cc.

References beamvalidation::exit(), index, vtx_xErr_, vtx_xErr_branch, and vtx_xErr_isLoaded.

Referenced by LoadAllBranches(), and tas::vtx_xErr().

                                           {
   if (not vtx_xErr_isLoaded) {
     if (vtx_xErr_branch != 0) {
       vtx_xErr_branch->GetEntry(index);
     } else {
       printf("branch vtx_xErr_branch does not exist!\n");
       exit(1);
     }
     vtx_xErr_isLoaded = true;
   }
   return *vtx_xErr_;
 }

◆ vtx_y()

const std::vector< float > & Trktree::vtx_y ( )

Definition at line 4737 of file Trktree.cc.

References beamvalidation::exit(), index, vtx_y_, vtx_y_branch, and vtx_y_isLoaded.

Referenced by LoadAllBranches(), and tas::vtx_y().

                                        {
   if (not vtx_y_isLoaded) {
     if (vtx_y_branch != 0) {
       vtx_y_branch->GetEntry(index);
     } else {
       printf("branch vtx_y_branch does not exist!\n");
       exit(1);
     }
     vtx_y_isLoaded = true;
   }
   return *vtx_y_;
 }

◆ vtx_yErr()

const std::vector< float > & Trktree::vtx_yErr ( )

Definition at line 6081 of file Trktree.cc.

References beamvalidation::exit(), index, vtx_yErr_, vtx_yErr_branch, and vtx_yErr_isLoaded.

Referenced by LoadAllBranches(), and tas::vtx_yErr().

                                           {
   if (not vtx_yErr_isLoaded) {
     if (vtx_yErr_branch != 0) {
       vtx_yErr_branch->GetEntry(index);
     } else {
       printf("branch vtx_yErr_branch does not exist!\n");
       exit(1);
     }
     vtx_yErr_isLoaded = true;
   }
   return *vtx_yErr_;
 }

◆ vtx_z()

const std::vector< float > & Trktree::vtx_z ( )

Definition at line 4713 of file Trktree.cc.

References beamvalidation::exit(), index, vtx_z_, vtx_z_branch, and vtx_z_isLoaded.

Referenced by LoadAllBranches(), and tas::vtx_z().

                                        {
   if (not vtx_z_isLoaded) {
     if (vtx_z_branch != 0) {
       vtx_z_branch->GetEntry(index);
     } else {
       printf("branch vtx_z_branch does not exist!\n");
       exit(1);
     }
     vtx_z_isLoaded = true;
   }
   return *vtx_z_;
 }

◆ vtx_zErr()

const std::vector< float > & Trktree::vtx_zErr ( )

Definition at line 5373 of file Trktree.cc.

References beamvalidation::exit(), index, vtx_zErr_, vtx_zErr_branch, and vtx_zErr_isLoaded.

Referenced by LoadAllBranches(), and tas::vtx_zErr().

                                           {
   if (not vtx_zErr_isLoaded) {
     if (vtx_zErr_branch != 0) {
       vtx_zErr_branch->GetEntry(index);
     } else {
       printf("branch vtx_zErr_branch does not exist!\n");
       exit(1);
     }
     vtx_zErr_isLoaded = true;
   }
   return *vtx_zErr_;
 }

Member Data Documentation

◆ bsp_sigmax_

float Trktree::bsp_sigmax_

protected

Definition at line 404 of file Trktree.h.

Referenced by bsp_sigmax(), and Init().

◆ bsp_sigmax_branch

TBranch* Trktree::bsp_sigmax_branch

protected

Definition at line 405 of file Trktree.h.

Referenced by bsp_sigmax(), Init(), and LoadAllBranches().

◆ bsp_sigmax_isLoaded

bool Trktree::bsp_sigmax_isLoaded

protected

Definition at line 406 of file Trktree.h.

Referenced by bsp_sigmax(), and GetEntry().

◆ bsp_sigmay_

float Trktree::bsp_sigmay_

protected

Definition at line 401 of file Trktree.h.

Referenced by bsp_sigmay(), and Init().

◆ bsp_sigmay_branch

TBranch* Trktree::bsp_sigmay_branch

protected

Definition at line 402 of file Trktree.h.

Referenced by bsp_sigmay(), Init(), and LoadAllBranches().

◆ bsp_sigmay_isLoaded

bool Trktree::bsp_sigmay_isLoaded

protected

Definition at line 403 of file Trktree.h.

Referenced by bsp_sigmay(), and GetEntry().

◆ bsp_sigmaz_

float Trktree::bsp_sigmaz_

protected

Definition at line 398 of file Trktree.h.

Referenced by bsp_sigmaz(), and Init().

◆ bsp_sigmaz_branch

TBranch* Trktree::bsp_sigmaz_branch

protected

Definition at line 399 of file Trktree.h.

Referenced by bsp_sigmaz(), Init(), and LoadAllBranches().

◆ bsp_sigmaz_isLoaded

bool Trktree::bsp_sigmaz_isLoaded

protected

Definition at line 400 of file Trktree.h.

Referenced by bsp_sigmaz(), and GetEntry().

◆ bsp_x_

float Trktree::bsp_x_

protected

Definition at line 29 of file Trktree.h.

Referenced by bsp_x(), and Init().

◆ bsp_x_branch

TBranch* Trktree::bsp_x_branch

protected

Definition at line 30 of file Trktree.h.

Referenced by bsp_x(), Init(), and LoadAllBranches().

◆ bsp_x_isLoaded

bool Trktree::bsp_x_isLoaded

protected

Definition at line 31 of file Trktree.h.

Referenced by bsp_x(), and GetEntry().

◆ bsp_y_

float Trktree::bsp_y_

protected

Definition at line 320 of file Trktree.h.

Referenced by bsp_y(), and Init().

◆ bsp_y_branch

TBranch* Trktree::bsp_y_branch

protected

Definition at line 321 of file Trktree.h.

Referenced by bsp_y(), Init(), and LoadAllBranches().

◆ bsp_y_isLoaded

bool Trktree::bsp_y_isLoaded

protected

Definition at line 322 of file Trktree.h.

Referenced by bsp_y(), and GetEntry().

◆ bsp_z_

float Trktree::bsp_z_

protected

Definition at line 317 of file Trktree.h.

Referenced by bsp_z(), and Init().

◆ bsp_z_branch

TBranch* Trktree::bsp_z_branch

protected

Definition at line 318 of file Trktree.h.

Referenced by bsp_z(), Init(), and LoadAllBranches().

◆ bsp_z_isLoaded

bool Trktree::bsp_z_isLoaded

protected

Definition at line 319 of file Trktree.h.

Referenced by bsp_z(), and GetEntry().

◆ event_

unsigned long long Trktree::event_

protected

Definition at line 299 of file Trktree.h.

Referenced by event(), and Init().

◆ event_branch

TBranch* Trktree::event_branch

protected

Definition at line 300 of file Trktree.h.

Referenced by event(), Init(), and LoadAllBranches().

◆ event_isLoaded

bool Trktree::event_isLoaded

protected

Definition at line 301 of file Trktree.h.

Referenced by event(), and GetEntry().

◆ index

unsigned int Trktree::index

protected

Definition at line 19 of file Trktree.h.

Referenced by tmtt::HTbase::assocTrackCands2D(), tmtt::Make3Dtracks::assocTrackCands3D(), bsp_sigmax(), bsp_sigmay(), bsp_sigmaz(), bsp_x(), bsp_y(), bsp_z(), event(), GetEntry(), inv_blade(), inv_detId(), inv_isBarrel(), inv_isLower(), inv_isStack(), inv_isUpper(), inv_ladder(), inv_layer(), inv_module(), inv_order(), inv_panel(), inv_ring(), inv_rod(), inv_side(), inv_subdet(), inv_type(), lumi(), ph2_bbxi(), ph2_detId(), ph2_isBarrel(), ph2_isLower(), ph2_isStack(), ph2_isUpper(), ph2_layer(), ph2_module(), ph2_order(), ph2_radL(), ph2_ring(), ph2_rod(), ph2_seeIdx(), ph2_side(), ph2_simHitIdx(), ph2_simType(), ph2_subdet(), ph2_trkIdx(), ph2_x(), ph2_xx(), ph2_xy(), ph2_xySignificance(), ph2_y(), ph2_yy(), ph2_yz(), ph2_z(), ph2_zx(), ph2_zz(), pix_bbxi(), pix_blade(), pix_chargeFraction(), pix_detId(), pix_isBarrel(), pix_ladder(), pix_layer(), pix_module(), pix_panel(), pix_radL(), pix_seeIdx(), pix_side(), pix_simHitIdx(), pix_simType(), pix_subdet(), pix_trkIdx(), pix_x(), pix_xx(), pix_xy(), pix_xySignificance(), pix_y(), pix_yy(), pix_yz(), pix_z(), pix_zx(), pix_zz(), LowPtGSFToTrackLinker::produce(), run(), see_algo(), see_bestFromFirstHitSimTrkIdx(), see_bestFromFirstHitSimTrkShareFrac(), see_bestSimTrkIdx(), see_bestSimTrkShareFrac(), see_chi2(), see_dxy(), see_dxyErr(), see_dz(), see_dzErr(), see_eta(), see_etaErr(), see_fitok(), see_hitIdx(), see_hitType(), see_nCands(), see_nCluster(), see_nGlued(), see_nPhase2OT(), see_nPixel(), see_nStrip(), see_nValid(), see_offset(), see_phi(), see_phiErr(), see_pt(), see_ptErr(), see_px(), see_py(), see_pz(), see_q(), see_simTrkIdx(), see_simTrkShareFrac(), see_stateCcov00(), see_stateCcov01(), see_stateCcov02(), see_stateCcov03(), see_stateCcov04(), see_stateCcov05(), see_stateCcov11(), see_stateCcov12(), see_stateCcov13(), see_stateCcov14(), see_stateCcov15(), see_stateCcov22(), see_stateCcov23(), see_stateCcov24(), see_stateCcov25(), see_stateCcov33(), see_stateCcov34(), see_stateCcov35(), see_stateCcov44(), see_stateCcov45(), see_stateCcov55(), see_statePt(), see_stateTrajGlbPx(), see_stateTrajGlbPy(), see_stateTrajGlbPz(), see_stateTrajGlbX(), see_stateTrajGlbY(), see_stateTrajGlbZ(), see_stateTrajPx(), see_stateTrajPy(), see_stateTrajPz(), see_stateTrajX(), see_stateTrajY(), see_stopReason(), see_trkIdx(), sim_bunchCrossing(), sim_decayVtxIdx(), sim_eta(), sim_event(), sim_genPdgIds(), sim_hits(), sim_isFromBHadron(), sim_len(), sim_lengap(), sim_n3DLay(), sim_nLay(), sim_nPixel(), sim_nPixelLay(), sim_nRecoClusters(), sim_nStrip(), sim_nTrackerHits(), sim_nValid(), sim_parentVtxIdx(), sim_pca_cotTheta(), sim_pca_dxy(), sim_pca_dz(), sim_pca_eta(), sim_pca_lambda(), sim_pca_phi(), sim_pca_pt(), sim_pdgId(), sim_phi(), sim_pt(), sim_px(), sim_py(), sim_pz(), sim_q(), sim_seedIdx(), sim_simHitIdx(), sim_trkIdx(), sim_trkShareFrac(), simhit_blade(), simhit_detId(), simhit_eloss(), simhit_hitIdx(), simhit_hitType(), simhit_isLower(), simhit_isStack(), simhit_isUpper(), simhit_ladder(), simhit_layer(), simhit_module(), simhit_order(), simhit_panel(), simhit_particle(), simhit_process(), simhit_px(), simhit_py(), simhit_pz(), simhit_ring(), simhit_rod(), simhit_side(), simhit_simTrkIdx(), simhit_subdet(), simhit_tof(), simhit_x(), simhit_y(), simhit_z(), simpv_idx(), simvtx_bunchCrossing(), simvtx_daughterSimIdx(), simvtx_event(), simvtx_processType(), simvtx_sourceSimIdx(), simvtx_x(), simvtx_y(), simvtx_z(), trk_algo(), trk_algoMask(), trk_bestFromFirstHitSimTrkIdx(), trk_bestFromFirstHitSimTrkNChi2(), trk_bestFromFirstHitSimTrkShareFrac(), trk_bestFromFirstHitSimTrkShareFracSimClusterDenom(), trk_bestFromFirstHitSimTrkShareFracSimDenom(), trk_bestSimTrkIdx(), trk_bestSimTrkNChi2(), trk_bestSimTrkShareFrac(), trk_bestSimTrkShareFracSimClusterDenom(), trk_bestSimTrkShareFracSimDenom(), trk_cotTheta(), trk_dxy(), trk_dxyClosestPV(), trk_dxyErr(), trk_dxyPV(), trk_dz(), trk_dzClosestPV(), trk_dzErr(), trk_dzPV(), trk_eta(), trk_etaErr(), trk_hitIdx(), trk_hitType(), trk_inner_pt(), trk_inner_px(), trk_inner_py(), trk_inner_pz(), trk_isHP(), trk_lambda(), trk_lambdaErr(), trk_mva(), trk_n3DLay(), trk_nChi2(), trk_nChi2_1Dmod(), trk_nCluster(), trk_ndof(), trk_nInactive(), trk_nInnerInactive(), trk_nInnerLost(), trk_nLost(), trk_nLostLay(), trk_nOuterInactive(), trk_nOuterLost(), trk_nPixel(), trk_nPixelLay(), trk_nStrip(), trk_nStripLay(), trk_nValid(), trk_originalAlgo(), trk_outer_pt(), trk_outer_px(), trk_outer_py(), trk_outer_pz(), trk_phi(), trk_phiErr(), trk_pt(), trk_ptErr(), trk_px(), trk_py(), trk_pz(), trk_q(), trk_qualityMask(), trk_refpoint_x(), trk_refpoint_y(), trk_refpoint_z(), trk_seedIdx(), trk_simTrkIdx(), trk_simTrkNChi2(), trk_simTrkShareFrac(), trk_stopReason(), trk_vtxIdx(), vtx_chi2(), vtx_fake(), vtx_ndof(), vtx_trkIdx(), vtx_valid(), vtx_x(), vtx_xErr(), vtx_y(), vtx_yErr(), vtx_z(), and vtx_zErr().

◆ inv_blade_

std::vector<unsigned short>* Trktree::inv_blade_

protected

Definition at line 872 of file Trktree.h.

Referenced by Init(), and inv_blade().

◆ inv_blade_branch

TBranch* Trktree::inv_blade_branch

protected

Definition at line 873 of file Trktree.h.

Referenced by Init(), inv_blade(), and LoadAllBranches().

◆ inv_blade_isLoaded

bool Trktree::inv_blade_isLoaded

protected

Definition at line 874 of file Trktree.h.

Referenced by GetEntry(), and inv_blade().

◆ inv_detId_

std::vector<unsigned int>* Trktree::inv_detId_

protected

Definition at line 821 of file Trktree.h.

Referenced by Init(), and inv_detId().

◆ inv_detId_branch

TBranch* Trktree::inv_detId_branch

protected

Definition at line 822 of file Trktree.h.

Referenced by Init(), inv_detId(), and LoadAllBranches().

◆ inv_detId_isLoaded

bool Trktree::inv_detId_isLoaded

protected

Definition at line 823 of file Trktree.h.

Referenced by GetEntry(), and inv_detId().

◆ inv_isBarrel_

std::vector<short>* Trktree::inv_isBarrel_

protected

Definition at line 479 of file Trktree.h.

Referenced by Init(), and inv_isBarrel().

◆ inv_isBarrel_branch

TBranch* Trktree::inv_isBarrel_branch

protected

Definition at line 480 of file Trktree.h.

Referenced by Init(), inv_isBarrel(), and LoadAllBranches().

◆ inv_isBarrel_isLoaded

bool Trktree::inv_isBarrel_isLoaded

protected

Definition at line 481 of file Trktree.h.

Referenced by GetEntry(), and inv_isBarrel().

◆ inv_isLower_

std::vector<unsigned short>* Trktree::inv_isLower_

protected

Definition at line 761 of file Trktree.h.

Referenced by Init(), and inv_isLower().

◆ inv_isLower_branch

TBranch* Trktree::inv_isLower_branch

protected

Definition at line 762 of file Trktree.h.

Referenced by Init(), inv_isLower(), and LoadAllBranches().

◆ inv_isLower_isLoaded

bool Trktree::inv_isLower_isLoaded

protected

Definition at line 763 of file Trktree.h.

Referenced by GetEntry(), and inv_isLower().

◆ inv_isStack_

std::vector<unsigned short>* Trktree::inv_isStack_

protected

Definition at line 623 of file Trktree.h.

Referenced by Init(), and inv_isStack().

◆ inv_isStack_branch

TBranch* Trktree::inv_isStack_branch

protected

Definition at line 624 of file Trktree.h.

Referenced by Init(), inv_isStack(), and LoadAllBranches().

◆ inv_isStack_isLoaded

bool Trktree::inv_isStack_isLoaded

protected

Definition at line 625 of file Trktree.h.

Referenced by GetEntry(), and inv_isStack().

◆ inv_isUpper_

std::vector<unsigned short>* Trktree::inv_isUpper_

protected

Definition at line 422 of file Trktree.h.

Referenced by Init(), and inv_isUpper().

◆ inv_isUpper_branch

TBranch* Trktree::inv_isUpper_branch

protected

Definition at line 423 of file Trktree.h.

Referenced by Init(), inv_isUpper(), and LoadAllBranches().

◆ inv_isUpper_isLoaded

bool Trktree::inv_isUpper_isLoaded

protected

Definition at line 424 of file Trktree.h.

Referenced by GetEntry(), and inv_isUpper().

◆ inv_ladder_

std::vector<unsigned short>* Trktree::inv_ladder_

protected

Definition at line 797 of file Trktree.h.

Referenced by Init(), and inv_ladder().

◆ inv_ladder_branch

TBranch* Trktree::inv_ladder_branch

protected

Definition at line 798 of file Trktree.h.

Referenced by Init(), inv_ladder(), and LoadAllBranches().

◆ inv_ladder_isLoaded

bool Trktree::inv_ladder_isLoaded

protected

Definition at line 799 of file Trktree.h.

Referenced by GetEntry(), and inv_ladder().

◆ inv_layer_

std::vector<unsigned short>* Trktree::inv_layer_

protected

Definition at line 749 of file Trktree.h.

Referenced by Init(), and inv_layer().

◆ inv_layer_branch

TBranch* Trktree::inv_layer_branch

protected

Definition at line 750 of file Trktree.h.

Referenced by Init(), inv_layer(), and LoadAllBranches().

◆ inv_layer_isLoaded

bool Trktree::inv_layer_isLoaded

protected

Definition at line 751 of file Trktree.h.

Referenced by GetEntry(), and inv_layer().

◆ inv_module_

std::vector<unsigned short>* Trktree::inv_module_

protected

Definition at line 788 of file Trktree.h.

Referenced by Init(), and inv_module().

◆ inv_module_branch

TBranch* Trktree::inv_module_branch

protected

Definition at line 789 of file Trktree.h.

Referenced by Init(), inv_module(), and LoadAllBranches().

◆ inv_module_isLoaded

bool Trktree::inv_module_isLoaded

protected

Definition at line 790 of file Trktree.h.

Referenced by GetEntry(), and inv_module().

◆ inv_order_

std::vector<unsigned short>* Trktree::inv_order_

protected

Definition at line 182 of file Trktree.h.

Referenced by Init(), and inv_order().

◆ inv_order_branch

TBranch* Trktree::inv_order_branch

protected

Definition at line 183 of file Trktree.h.

Referenced by Init(), inv_order(), and LoadAllBranches().

◆ inv_order_isLoaded

bool Trktree::inv_order_isLoaded

protected

Definition at line 184 of file Trktree.h.

Referenced by GetEntry(), and inv_order().

◆ inv_panel_

std::vector<unsigned short>* Trktree::inv_panel_

protected

Definition at line 434 of file Trktree.h.

Referenced by Init(), and inv_panel().

◆ inv_panel_branch

TBranch* Trktree::inv_panel_branch

protected

Definition at line 435 of file Trktree.h.

Referenced by Init(), inv_panel(), and LoadAllBranches().

◆ inv_panel_isLoaded

bool Trktree::inv_panel_isLoaded

protected

Definition at line 436 of file Trktree.h.

Referenced by GetEntry(), and inv_panel().

◆ inv_ring_

std::vector<unsigned short>* Trktree::inv_ring_

protected

Definition at line 269 of file Trktree.h.

Referenced by Init(), and inv_ring().

◆ inv_ring_branch

TBranch* Trktree::inv_ring_branch

protected

Definition at line 270 of file Trktree.h.

Referenced by Init(), inv_ring(), and LoadAllBranches().

◆ inv_ring_isLoaded

bool Trktree::inv_ring_isLoaded

protected

Definition at line 271 of file Trktree.h.

Referenced by GetEntry(), and inv_ring().

◆ inv_rod_

std::vector<unsigned short>* Trktree::inv_rod_

protected

Definition at line 509 of file Trktree.h.

Referenced by Init(), and inv_rod().

◆ inv_rod_branch

TBranch* Trktree::inv_rod_branch

protected

Definition at line 510 of file Trktree.h.

Referenced by Init(), inv_rod(), and LoadAllBranches().

◆ inv_rod_isLoaded

bool Trktree::inv_rod_isLoaded

protected

Definition at line 511 of file Trktree.h.

Referenced by GetEntry(), and inv_rod().

◆ inv_side_

std::vector<unsigned short>* Trktree::inv_side_

protected

Definition at line 692 of file Trktree.h.

Referenced by Init(), and inv_side().

◆ inv_side_branch

TBranch* Trktree::inv_side_branch

protected

Definition at line 693 of file Trktree.h.

Referenced by Init(), inv_side(), and LoadAllBranches().

◆ inv_side_isLoaded

bool Trktree::inv_side_isLoaded

protected

Definition at line 694 of file Trktree.h.

Referenced by GetEntry(), and inv_side().

◆ inv_subdet_

std::vector<unsigned short>* Trktree::inv_subdet_

protected

Definition at line 197 of file Trktree.h.

Referenced by Init(), and inv_subdet().

◆ inv_subdet_branch

TBranch* Trktree::inv_subdet_branch

protected

Definition at line 198 of file Trktree.h.

Referenced by Init(), inv_subdet(), and LoadAllBranches().

◆ inv_subdet_isLoaded

bool Trktree::inv_subdet_isLoaded

protected

Definition at line 199 of file Trktree.h.

Referenced by GetEntry(), and inv_subdet().

◆ inv_type_

std::vector<unsigned short>* Trktree::inv_type_

protected

Definition at line 314 of file Trktree.h.

Referenced by Init(), and inv_type().

◆ inv_type_branch

TBranch* Trktree::inv_type_branch

protected

Definition at line 315 of file Trktree.h.

Referenced by Init(), inv_type(), and LoadAllBranches().

◆ inv_type_isLoaded

bool Trktree::inv_type_isLoaded

protected

Definition at line 316 of file Trktree.h.

Referenced by GetEntry(), and inv_type().

◆ lumi_

unsigned int Trktree::lumi_

protected

Definition at line 845 of file Trktree.h.

Referenced by Init(), and lumi().

◆ lumi_branch

TBranch* Trktree::lumi_branch

protected

Definition at line 846 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and lumi().

◆ lumi_isLoaded

bool Trktree::lumi_isLoaded

protected

Definition at line 847 of file Trktree.h.

Referenced by GetEntry(), and lumi().

◆ ph2_bbxi_

std::vector<float>* Trktree::ph2_bbxi_

protected

Definition at line 704 of file Trktree.h.

Referenced by Init(), and ph2_bbxi().

◆ ph2_bbxi_branch

TBranch* Trktree::ph2_bbxi_branch

protected

Definition at line 705 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_bbxi().

◆ ph2_bbxi_isLoaded

bool Trktree::ph2_bbxi_isLoaded

protected

Definition at line 706 of file Trktree.h.

Referenced by GetEntry(), and ph2_bbxi().

◆ ph2_detId_

std::vector<unsigned int>* Trktree::ph2_detId_

protected

Definition at line 119 of file Trktree.h.

Referenced by Init(), and ph2_detId().

◆ ph2_detId_branch

TBranch* Trktree::ph2_detId_branch

protected

Definition at line 120 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_detId().

◆ ph2_detId_isLoaded

bool Trktree::ph2_detId_isLoaded

protected

Definition at line 121 of file Trktree.h.

Referenced by GetEntry(), and ph2_detId().

◆ ph2_isBarrel_

std::vector<short>* Trktree::ph2_isBarrel_

protected

Definition at line 446 of file Trktree.h.

Referenced by Init(), and ph2_isBarrel().

◆ ph2_isBarrel_branch

TBranch* Trktree::ph2_isBarrel_branch

protected

Definition at line 447 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_isBarrel().

◆ ph2_isBarrel_isLoaded

bool Trktree::ph2_isBarrel_isLoaded

protected

Definition at line 448 of file Trktree.h.

Referenced by GetEntry(), and ph2_isBarrel().

◆ ph2_isLower_

std::vector<unsigned short>* Trktree::ph2_isLower_

protected

Definition at line 755 of file Trktree.h.

Referenced by Init(), and ph2_isLower().

◆ ph2_isLower_branch

TBranch* Trktree::ph2_isLower_branch

protected

Definition at line 756 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_isLower().

◆ ph2_isLower_isLoaded

bool Trktree::ph2_isLower_isLoaded

protected

Definition at line 757 of file Trktree.h.

Referenced by GetEntry(), and ph2_isLower().

◆ ph2_isStack_

std::vector<unsigned short>* Trktree::ph2_isStack_

protected

Definition at line 680 of file Trktree.h.

Referenced by Init(), and ph2_isStack().

◆ ph2_isStack_branch

TBranch* Trktree::ph2_isStack_branch

protected

Definition at line 681 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_isStack().

◆ ph2_isStack_isLoaded

bool Trktree::ph2_isStack_isLoaded

protected

Definition at line 682 of file Trktree.h.

Referenced by GetEntry(), and ph2_isStack().

◆ ph2_isUpper_

std::vector<unsigned short>* Trktree::ph2_isUpper_

protected

Definition at line 146 of file Trktree.h.

Referenced by Init(), and ph2_isUpper().

◆ ph2_isUpper_branch

TBranch* Trktree::ph2_isUpper_branch

protected

Definition at line 147 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_isUpper().

◆ ph2_isUpper_isLoaded

bool Trktree::ph2_isUpper_isLoaded

protected

Definition at line 148 of file Trktree.h.

Referenced by GetEntry(), and ph2_isUpper().

◆ ph2_layer_

std::vector<unsigned short>* Trktree::ph2_layer_

protected

Definition at line 899 of file Trktree.h.

Referenced by Init(), and ph2_layer().

◆ ph2_layer_branch

TBranch* Trktree::ph2_layer_branch

protected

Definition at line 900 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_layer().

◆ ph2_layer_isLoaded

bool Trktree::ph2_layer_isLoaded

protected

Definition at line 901 of file Trktree.h.

Referenced by GetEntry(), and ph2_layer().

◆ ph2_module_

std::vector<unsigned short>* Trktree::ph2_module_

protected

Definition at line 179 of file Trktree.h.

Referenced by Init(), and ph2_module().

◆ ph2_module_branch

TBranch* Trktree::ph2_module_branch

protected

Definition at line 180 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_module().

◆ ph2_module_isLoaded

bool Trktree::ph2_module_isLoaded

protected

Definition at line 181 of file Trktree.h.

Referenced by GetEntry(), and ph2_module().

◆ ph2_order_

std::vector<unsigned short>* Trktree::ph2_order_

protected

Definition at line 176 of file Trktree.h.

Referenced by Init(), and ph2_order().

◆ ph2_order_branch

TBranch* Trktree::ph2_order_branch

protected

Definition at line 177 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_order().

◆ ph2_order_isLoaded

bool Trktree::ph2_order_isLoaded

protected

Definition at line 178 of file Trktree.h.

Referenced by GetEntry(), and ph2_order().

◆ ph2_radL_

std::vector<float>* Trktree::ph2_radL_

protected

Definition at line 599 of file Trktree.h.

Referenced by Init(), and ph2_radL().

◆ ph2_radL_branch

TBranch* Trktree::ph2_radL_branch

protected

Definition at line 600 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_radL().

◆ ph2_radL_isLoaded

bool Trktree::ph2_radL_isLoaded

protected

Definition at line 601 of file Trktree.h.

Referenced by GetEntry(), and ph2_radL().

◆ ph2_ring_

std::vector<unsigned short>* Trktree::ph2_ring_

protected

Definition at line 590 of file Trktree.h.

Referenced by Init(), and ph2_ring().

◆ ph2_ring_branch

TBranch* Trktree::ph2_ring_branch

protected

Definition at line 591 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_ring().

◆ ph2_ring_isLoaded

bool Trktree::ph2_ring_isLoaded

protected

Definition at line 592 of file Trktree.h.

Referenced by GetEntry(), and ph2_ring().

◆ ph2_rod_

std::vector<unsigned short>* Trktree::ph2_rod_

protected

Definition at line 662 of file Trktree.h.

Referenced by Init(), and ph2_rod().

◆ ph2_rod_branch

TBranch* Trktree::ph2_rod_branch

protected

Definition at line 663 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_rod().

◆ ph2_rod_isLoaded

bool Trktree::ph2_rod_isLoaded

protected

Definition at line 664 of file Trktree.h.

Referenced by GetEntry(), and ph2_rod().

◆ ph2_seeIdx_

std::vector<std::vector<int> >* Trktree::ph2_seeIdx_

protected

Definition at line 419 of file Trktree.h.

Referenced by Init(), and ph2_seeIdx().

◆ ph2_seeIdx_branch

TBranch* Trktree::ph2_seeIdx_branch

protected

Definition at line 420 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_seeIdx().

◆ ph2_seeIdx_isLoaded

bool Trktree::ph2_seeIdx_isLoaded

protected

Definition at line 421 of file Trktree.h.

Referenced by GetEntry(), and ph2_seeIdx().

◆ ph2_side_

std::vector<unsigned short>* Trktree::ph2_side_

protected

Definition at line 305 of file Trktree.h.

Referenced by Init(), and ph2_side().

◆ ph2_side_branch

TBranch* Trktree::ph2_side_branch

protected

Definition at line 306 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_side().

◆ ph2_side_isLoaded

bool Trktree::ph2_side_isLoaded

protected

Definition at line 307 of file Trktree.h.

Referenced by GetEntry(), and ph2_side().

◆ ph2_simHitIdx_

std::vector<std::vector<int> >* Trktree::ph2_simHitIdx_

protected

Definition at line 272 of file Trktree.h.

Referenced by Init(), and ph2_simHitIdx().

◆ ph2_simHitIdx_branch

TBranch* Trktree::ph2_simHitIdx_branch

protected

Definition at line 273 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_simHitIdx().

◆ ph2_simHitIdx_isLoaded

bool Trktree::ph2_simHitIdx_isLoaded

protected

Definition at line 274 of file Trktree.h.

Referenced by GetEntry(), and ph2_simHitIdx().

◆ ph2_simType_

std::vector<unsigned short>* Trktree::ph2_simType_

protected

Definition at line 551 of file Trktree.h.

Referenced by Init(), and ph2_simType().

◆ ph2_simType_branch

TBranch* Trktree::ph2_simType_branch

protected

Definition at line 552 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_simType().

◆ ph2_simType_isLoaded

bool Trktree::ph2_simType_isLoaded

protected

Definition at line 553 of file Trktree.h.

Referenced by GetEntry(), and ph2_simType().

◆ ph2_subdet_

std::vector<unsigned short>* Trktree::ph2_subdet_

protected

Definition at line 887 of file Trktree.h.

Referenced by Init(), and ph2_subdet().

◆ ph2_subdet_branch

TBranch* Trktree::ph2_subdet_branch

protected

Definition at line 888 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_subdet().

◆ ph2_subdet_isLoaded

bool Trktree::ph2_subdet_isLoaded

protected

Definition at line 889 of file Trktree.h.

Referenced by GetEntry(), and ph2_subdet().

◆ ph2_trkIdx_

std::vector<std::vector<int> >* Trktree::ph2_trkIdx_

protected

Definition at line 764 of file Trktree.h.

Referenced by Init(), and ph2_trkIdx().

◆ ph2_trkIdx_branch

TBranch* Trktree::ph2_trkIdx_branch

protected

Definition at line 765 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_trkIdx().

◆ ph2_trkIdx_isLoaded

bool Trktree::ph2_trkIdx_isLoaded

protected

Definition at line 766 of file Trktree.h.

Referenced by GetEntry(), and ph2_trkIdx().

◆ ph2_x_

std::vector<float>* Trktree::ph2_x_

protected

Definition at line 488 of file Trktree.h.

Referenced by Init(), and ph2_x().

◆ ph2_x_branch

TBranch* Trktree::ph2_x_branch

protected

Definition at line 489 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_x().

◆ ph2_x_isLoaded

bool Trktree::ph2_x_isLoaded

protected

Definition at line 490 of file Trktree.h.

Referenced by GetEntry(), and ph2_x().

◆ ph2_xx_

std::vector<float>* Trktree::ph2_xx_

protected

Definition at line 800 of file Trktree.h.

Referenced by Init(), and ph2_xx().

◆ ph2_xx_branch

TBranch* Trktree::ph2_xx_branch

protected

Definition at line 801 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_xx().

◆ ph2_xx_isLoaded

bool Trktree::ph2_xx_isLoaded

protected

Definition at line 802 of file Trktree.h.

Referenced by GetEntry(), and ph2_xx().

◆ ph2_xy_

std::vector<float>* Trktree::ph2_xy_

protected

Definition at line 785 of file Trktree.h.

Referenced by Init(), and ph2_xy().

◆ ph2_xy_branch

TBranch* Trktree::ph2_xy_branch

protected

Definition at line 786 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_xy().

◆ ph2_xy_isLoaded

bool Trktree::ph2_xy_isLoaded

protected

Definition at line 787 of file Trktree.h.

Referenced by GetEntry(), and ph2_xy().

◆ ph2_xySignificance_

std::vector<std::vector<float> >* Trktree::ph2_xySignificance_

protected

Definition at line 374 of file Trktree.h.

Referenced by Init(), and ph2_xySignificance().

◆ ph2_xySignificance_branch

TBranch* Trktree::ph2_xySignificance_branch

protected

Definition at line 375 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_xySignificance().

◆ ph2_xySignificance_isLoaded

bool Trktree::ph2_xySignificance_isLoaded

protected

Definition at line 376 of file Trktree.h.

Referenced by GetEntry(), and ph2_xySignificance().

◆ ph2_y_

std::vector<float>* Trktree::ph2_y_

protected

Definition at line 491 of file Trktree.h.

Referenced by Init(), and ph2_y().

◆ ph2_y_branch

TBranch* Trktree::ph2_y_branch

protected

Definition at line 492 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_y().

◆ ph2_y_isLoaded

bool Trktree::ph2_y_isLoaded

protected

Definition at line 493 of file Trktree.h.

Referenced by GetEntry(), and ph2_y().

◆ ph2_yy_

std::vector<float>* Trktree::ph2_yy_

protected

Definition at line 866 of file Trktree.h.

Referenced by Init(), and ph2_yy().

◆ ph2_yy_branch

TBranch* Trktree::ph2_yy_branch

protected

Definition at line 867 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_yy().

◆ ph2_yy_isLoaded

bool Trktree::ph2_yy_isLoaded

protected

Definition at line 868 of file Trktree.h.

Referenced by GetEntry(), and ph2_yy().

◆ ph2_yz_

std::vector<float>* Trktree::ph2_yz_

protected

Definition at line 869 of file Trktree.h.

Referenced by Init(), and ph2_yz().

◆ ph2_yz_branch

TBranch* Trktree::ph2_yz_branch

protected

Definition at line 870 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_yz().

◆ ph2_yz_isLoaded

bool Trktree::ph2_yz_isLoaded

protected

Definition at line 871 of file Trktree.h.

Referenced by GetEntry(), and ph2_yz().

◆ ph2_z_

std::vector<float>* Trktree::ph2_z_

protected

Definition at line 485 of file Trktree.h.

Referenced by Init(), and ph2_z().

◆ ph2_z_branch

TBranch* Trktree::ph2_z_branch

protected

Definition at line 486 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_z().

◆ ph2_z_isLoaded

bool Trktree::ph2_z_isLoaded

protected

Definition at line 487 of file Trktree.h.

Referenced by GetEntry(), and ph2_z().

◆ ph2_zx_

std::vector<float>* Trktree::ph2_zx_

protected

Definition at line 425 of file Trktree.h.

Referenced by Init(), and ph2_zx().

◆ ph2_zx_branch

TBranch* Trktree::ph2_zx_branch

protected

Definition at line 426 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_zx().

◆ ph2_zx_isLoaded

bool Trktree::ph2_zx_isLoaded

protected

Definition at line 427 of file Trktree.h.

Referenced by GetEntry(), and ph2_zx().

◆ ph2_zz_

std::vector<float>* Trktree::ph2_zz_

protected

Definition at line 533 of file Trktree.h.

Referenced by Init(), and ph2_zz().

◆ ph2_zz_branch

TBranch* Trktree::ph2_zz_branch

protected

Definition at line 534 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and ph2_zz().

◆ ph2_zz_isLoaded

bool Trktree::ph2_zz_isLoaded

protected

Definition at line 535 of file Trktree.h.

Referenced by GetEntry(), and ph2_zz().

◆ pix_bbxi_

std::vector<float>* Trktree::pix_bbxi_

protected

Definition at line 173 of file Trktree.h.

Referenced by Init(), and pix_bbxi().

◆ pix_bbxi_branch

TBranch* Trktree::pix_bbxi_branch

protected

Definition at line 174 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_bbxi().

◆ pix_bbxi_isLoaded

bool Trktree::pix_bbxi_isLoaded

protected

Definition at line 175 of file Trktree.h.

Referenced by GetEntry(), and pix_bbxi().

◆ pix_blade_

std::vector<unsigned short>* Trktree::pix_blade_

protected

Definition at line 200 of file Trktree.h.

Referenced by Init(), and pix_blade().

◆ pix_blade_branch

TBranch* Trktree::pix_blade_branch

protected

Definition at line 201 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_blade().

◆ pix_blade_isLoaded

bool Trktree::pix_blade_isLoaded

protected

Definition at line 202 of file Trktree.h.

Referenced by GetEntry(), and pix_blade().

◆ pix_chargeFraction_

std::vector<std::vector<float> >* Trktree::pix_chargeFraction_

protected

Definition at line 356 of file Trktree.h.

Referenced by Init(), and pix_chargeFraction().

◆ pix_chargeFraction_branch

TBranch* Trktree::pix_chargeFraction_branch

protected

Definition at line 357 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_chargeFraction().

◆ pix_chargeFraction_isLoaded

bool Trktree::pix_chargeFraction_isLoaded

protected

Definition at line 358 of file Trktree.h.

Referenced by GetEntry(), and pix_chargeFraction().

◆ pix_detId_

std::vector<unsigned int>* Trktree::pix_detId_

protected

Definition at line 236 of file Trktree.h.

Referenced by Init(), and pix_detId().

◆ pix_detId_branch

TBranch* Trktree::pix_detId_branch

protected

Definition at line 237 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_detId().

◆ pix_detId_isLoaded

bool Trktree::pix_detId_isLoaded

protected

Definition at line 238 of file Trktree.h.

Referenced by GetEntry(), and pix_detId().

◆ pix_isBarrel_

std::vector<short>* Trktree::pix_isBarrel_

protected

Definition at line 101 of file Trktree.h.

Referenced by Init(), and pix_isBarrel().

◆ pix_isBarrel_branch

TBranch* Trktree::pix_isBarrel_branch

protected

Definition at line 102 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_isBarrel().

◆ pix_isBarrel_isLoaded

bool Trktree::pix_isBarrel_isLoaded

protected

Definition at line 103 of file Trktree.h.

Referenced by GetEntry(), and pix_isBarrel().

◆ pix_ladder_

std::vector<unsigned short>* Trktree::pix_ladder_

protected

Definition at line 407 of file Trktree.h.

Referenced by Init(), and pix_ladder().

◆ pix_ladder_branch

TBranch* Trktree::pix_ladder_branch

protected

Definition at line 408 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_ladder().

◆ pix_ladder_isLoaded

bool Trktree::pix_ladder_isLoaded

protected

Definition at line 409 of file Trktree.h.

Referenced by GetEntry(), and pix_ladder().

◆ pix_layer_

std::vector<unsigned short>* Trktree::pix_layer_

protected

Definition at line 380 of file Trktree.h.

Referenced by Init(), and pix_layer().

◆ pix_layer_branch

TBranch* Trktree::pix_layer_branch

protected

Definition at line 381 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_layer().

◆ pix_layer_isLoaded

bool Trktree::pix_layer_isLoaded

protected

Definition at line 382 of file Trktree.h.

Referenced by GetEntry(), and pix_layer().

◆ pix_module_

std::vector<unsigned short>* Trktree::pix_module_

protected

Definition at line 302 of file Trktree.h.

Referenced by Init(), and pix_module().

◆ pix_module_branch

TBranch* Trktree::pix_module_branch

protected

Definition at line 303 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_module().

◆ pix_module_isLoaded

bool Trktree::pix_module_isLoaded

protected

Definition at line 304 of file Trktree.h.

Referenced by GetEntry(), and pix_module().

◆ pix_panel_

std::vector<unsigned short>* Trktree::pix_panel_

protected

Definition at line 794 of file Trktree.h.

Referenced by Init(), and pix_panel().

◆ pix_panel_branch

TBranch* Trktree::pix_panel_branch

protected

Definition at line 795 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_panel().

◆ pix_panel_isLoaded

bool Trktree::pix_panel_isLoaded

protected

Definition at line 796 of file Trktree.h.

Referenced by GetEntry(), and pix_panel().

◆ pix_radL_

std::vector<float>* Trktree::pix_radL_

protected

Definition at line 62 of file Trktree.h.

Referenced by Init(), and pix_radL().

◆ pix_radL_branch

TBranch* Trktree::pix_radL_branch

protected

Definition at line 63 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_radL().

◆ pix_radL_isLoaded

bool Trktree::pix_radL_isLoaded

protected

Definition at line 64 of file Trktree.h.

Referenced by GetEntry(), and pix_radL().

◆ pix_seeIdx_

std::vector<std::vector<int> >* Trktree::pix_seeIdx_

protected

Definition at line 449 of file Trktree.h.

Referenced by Init(), and pix_seeIdx().

◆ pix_seeIdx_branch

TBranch* Trktree::pix_seeIdx_branch

protected

Definition at line 450 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_seeIdx().

◆ pix_seeIdx_isLoaded

bool Trktree::pix_seeIdx_isLoaded

protected

Definition at line 451 of file Trktree.h.

Referenced by GetEntry(), and pix_seeIdx().

◆ pix_side_

std::vector<unsigned short>* Trktree::pix_side_

protected

Definition at line 758 of file Trktree.h.

Referenced by Init(), and pix_side().

◆ pix_side_branch

TBranch* Trktree::pix_side_branch

protected

Definition at line 759 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_side().

◆ pix_side_isLoaded

bool Trktree::pix_side_isLoaded

protected

Definition at line 760 of file Trktree.h.

Referenced by GetEntry(), and pix_side().

◆ pix_simHitIdx_

std::vector<std::vector<int> >* Trktree::pix_simHitIdx_

protected

Definition at line 656 of file Trktree.h.

Referenced by Init(), and pix_simHitIdx().

◆ pix_simHitIdx_branch

TBranch* Trktree::pix_simHitIdx_branch

protected

Definition at line 657 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_simHitIdx().

◆ pix_simHitIdx_isLoaded

bool Trktree::pix_simHitIdx_isLoaded

protected

Definition at line 658 of file Trktree.h.

Referenced by GetEntry(), and pix_simHitIdx().

◆ pix_simType_

std::vector<unsigned short>* Trktree::pix_simType_

protected

Definition at line 518 of file Trktree.h.

Referenced by Init(), and pix_simType().

◆ pix_simType_branch

TBranch* Trktree::pix_simType_branch

protected

Definition at line 519 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_simType().

◆ pix_simType_isLoaded

bool Trktree::pix_simType_isLoaded

protected

Definition at line 520 of file Trktree.h.

Referenced by GetEntry(), and pix_simType().

◆ pix_subdet_

std::vector<unsigned short>* Trktree::pix_subdet_

protected

Definition at line 416 of file Trktree.h.

Referenced by Init(), and pix_subdet().

◆ pix_subdet_branch

TBranch* Trktree::pix_subdet_branch

protected

Definition at line 417 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_subdet().

◆ pix_subdet_isLoaded

bool Trktree::pix_subdet_isLoaded

protected

Definition at line 418 of file Trktree.h.

Referenced by GetEntry(), and pix_subdet().

◆ pix_trkIdx_

std::vector<std::vector<int> >* Trktree::pix_trkIdx_

protected

Definition at line 428 of file Trktree.h.

Referenced by Init(), and pix_trkIdx().

◆ pix_trkIdx_branch

TBranch* Trktree::pix_trkIdx_branch

protected

Definition at line 429 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_trkIdx().

◆ pix_trkIdx_isLoaded

bool Trktree::pix_trkIdx_isLoaded

protected

Definition at line 430 of file Trktree.h.

Referenced by GetEntry(), and pix_trkIdx().

◆ pix_x_

std::vector<float>* Trktree::pix_x_

protected

Definition at line 287 of file Trktree.h.

Referenced by Init(), and pix_x().

◆ pix_x_branch

TBranch* Trktree::pix_x_branch

protected

Definition at line 288 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_x().

◆ pix_x_isLoaded

bool Trktree::pix_x_isLoaded

protected

Definition at line 289 of file Trktree.h.

Referenced by GetEntry(), and pix_x().

◆ pix_xx_

std::vector<float>* Trktree::pix_xx_

protected

Definition at line 203 of file Trktree.h.

Referenced by Init(), and pix_xx().

◆ pix_xx_branch

TBranch* Trktree::pix_xx_branch

protected

Definition at line 204 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_xx().

◆ pix_xx_isLoaded

bool Trktree::pix_xx_isLoaded

protected

Definition at line 205 of file Trktree.h.

Referenced by GetEntry(), and pix_xx().

◆ pix_xy_

std::vector<float>* Trktree::pix_xy_

protected

Definition at line 206 of file Trktree.h.

Referenced by Init(), and pix_xy().

◆ pix_xy_branch

TBranch* Trktree::pix_xy_branch

protected

Definition at line 207 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_xy().

◆ pix_xy_isLoaded

bool Trktree::pix_xy_isLoaded

protected

Definition at line 208 of file Trktree.h.

Referenced by GetEntry(), and pix_xy().

◆ pix_xySignificance_

std::vector<std::vector<float> >* Trktree::pix_xySignificance_

protected

Definition at line 383 of file Trktree.h.

Referenced by Init(), and pix_xySignificance().

◆ pix_xySignificance_branch

TBranch* Trktree::pix_xySignificance_branch

protected

Definition at line 384 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_xySignificance().

◆ pix_xySignificance_isLoaded

bool Trktree::pix_xySignificance_isLoaded

protected

Definition at line 385 of file Trktree.h.

Referenced by GetEntry(), and pix_xySignificance().

◆ pix_y_

std::vector<float>* Trktree::pix_y_

protected

Definition at line 284 of file Trktree.h.

Referenced by Init(), and pix_y().

◆ pix_y_branch

TBranch* Trktree::pix_y_branch

protected

Definition at line 285 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_y().

◆ pix_y_isLoaded

bool Trktree::pix_y_isLoaded

protected

Definition at line 286 of file Trktree.h.

Referenced by GetEntry(), and pix_y().

◆ pix_yy_

std::vector<float>* Trktree::pix_yy_

protected

Definition at line 80 of file Trktree.h.

Referenced by Init(), and pix_yy().

◆ pix_yy_branch

TBranch* Trktree::pix_yy_branch

protected

Definition at line 81 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_yy().

◆ pix_yy_isLoaded

bool Trktree::pix_yy_isLoaded

protected

Definition at line 82 of file Trktree.h.

Referenced by GetEntry(), and pix_yy().

◆ pix_yz_

std::vector<float>* Trktree::pix_yz_

protected

Definition at line 77 of file Trktree.h.

Referenced by Init(), and pix_yz().

◆ pix_yz_branch

TBranch* Trktree::pix_yz_branch

protected

Definition at line 78 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_yz().

◆ pix_yz_isLoaded

bool Trktree::pix_yz_isLoaded

protected

Definition at line 79 of file Trktree.h.

Referenced by GetEntry(), and pix_yz().

◆ pix_z_

std::vector<float>* Trktree::pix_z_

protected

Definition at line 281 of file Trktree.h.

Referenced by Init(), and pix_z().

◆ pix_z_branch

TBranch* Trktree::pix_z_branch

protected

Definition at line 282 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_z().

◆ pix_z_isLoaded

bool Trktree::pix_z_isLoaded

protected

Definition at line 283 of file Trktree.h.

Referenced by GetEntry(), and pix_z().

◆ pix_zx_

std::vector<float>* Trktree::pix_zx_

protected

Definition at line 878 of file Trktree.h.

Referenced by Init(), and pix_zx().

◆ pix_zx_branch

TBranch* Trktree::pix_zx_branch

protected

Definition at line 879 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_zx().

◆ pix_zx_isLoaded

bool Trktree::pix_zx_isLoaded

protected

Definition at line 880 of file Trktree.h.

Referenced by GetEntry(), and pix_zx().

◆ pix_zz_

std::vector<float>* Trktree::pix_zz_

protected

Definition at line 635 of file Trktree.h.

Referenced by Init(), and pix_zz().

◆ pix_zz_branch

TBranch* Trktree::pix_zz_branch

protected

Definition at line 636 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and pix_zz().

◆ pix_zz_isLoaded

bool Trktree::pix_zz_isLoaded

protected

Definition at line 637 of file Trktree.h.

Referenced by GetEntry(), and pix_zz().

◆ run_

unsigned int Trktree::run_

protected

Definition at line 371 of file Trktree.h.

Referenced by Init(), and run().

◆ run_branch

TBranch* Trktree::run_branch

protected

Definition at line 372 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and run().

◆ run_isLoaded

bool Trktree::run_isLoaded

protected

Definition at line 373 of file Trktree.h.

Referenced by GetEntry(), and run().

◆ see_algo_

std::vector<unsigned int>* Trktree::see_algo_

protected

Definition at line 731 of file Trktree.h.

Referenced by Init(), and see_algo().

◆ see_algo_branch

TBranch* Trktree::see_algo_branch

protected

Definition at line 732 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_algo().

◆ see_algo_isLoaded

bool Trktree::see_algo_isLoaded

protected

Definition at line 733 of file Trktree.h.

Referenced by GetEntry(), and see_algo().

◆ see_bestFromFirstHitSimTrkIdx_

std::vector<int>* Trktree::see_bestFromFirstHitSimTrkIdx_

protected

Definition at line 125 of file Trktree.h.

Referenced by Init(), and see_bestFromFirstHitSimTrkIdx().

◆ see_bestFromFirstHitSimTrkIdx_branch

TBranch* Trktree::see_bestFromFirstHitSimTrkIdx_branch

protected

Definition at line 126 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_bestFromFirstHitSimTrkIdx().

◆ see_bestFromFirstHitSimTrkIdx_isLoaded

bool Trktree::see_bestFromFirstHitSimTrkIdx_isLoaded

protected

Definition at line 127 of file Trktree.h.

Referenced by GetEntry(), and see_bestFromFirstHitSimTrkIdx().

◆ see_bestFromFirstHitSimTrkShareFrac_

std::vector<float>* Trktree::see_bestFromFirstHitSimTrkShareFrac_

protected

Definition at line 572 of file Trktree.h.

Referenced by Init(), and see_bestFromFirstHitSimTrkShareFrac().

◆ see_bestFromFirstHitSimTrkShareFrac_branch

TBranch* Trktree::see_bestFromFirstHitSimTrkShareFrac_branch

protected

Definition at line 573 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_bestFromFirstHitSimTrkShareFrac().

◆ see_bestFromFirstHitSimTrkShareFrac_isLoaded

bool Trktree::see_bestFromFirstHitSimTrkShareFrac_isLoaded

protected

Definition at line 574 of file Trktree.h.

Referenced by GetEntry(), and see_bestFromFirstHitSimTrkShareFrac().

◆ see_bestSimTrkIdx_

std::vector<int>* Trktree::see_bestSimTrkIdx_

protected

Definition at line 776 of file Trktree.h.

Referenced by Init(), and see_bestSimTrkIdx().

◆ see_bestSimTrkIdx_branch

TBranch* Trktree::see_bestSimTrkIdx_branch

protected

Definition at line 777 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_bestSimTrkIdx().

◆ see_bestSimTrkIdx_isLoaded

bool Trktree::see_bestSimTrkIdx_isLoaded

protected

Definition at line 778 of file Trktree.h.

Referenced by GetEntry(), and see_bestSimTrkIdx().

◆ see_bestSimTrkShareFrac_

std::vector<float>* Trktree::see_bestSimTrkShareFrac_

protected

Definition at line 389 of file Trktree.h.

Referenced by Init(), and see_bestSimTrkShareFrac().

◆ see_bestSimTrkShareFrac_branch

TBranch* Trktree::see_bestSimTrkShareFrac_branch

protected

Definition at line 390 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_bestSimTrkShareFrac().

◆ see_bestSimTrkShareFrac_isLoaded

bool Trktree::see_bestSimTrkShareFrac_isLoaded

protected

Definition at line 391 of file Trktree.h.

Referenced by GetEntry(), and see_bestSimTrkShareFrac().

◆ see_chi2_

std::vector<float>* Trktree::see_chi2_

protected

Definition at line 812 of file Trktree.h.

Referenced by Init(), and see_chi2().

◆ see_chi2_branch

TBranch* Trktree::see_chi2_branch

protected

Definition at line 813 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_chi2().

◆ see_chi2_isLoaded

bool Trktree::see_chi2_isLoaded

protected

Definition at line 814 of file Trktree.h.

Referenced by GetEntry(), and see_chi2().

◆ see_dxy_

std::vector<float>* Trktree::see_dxy_

protected

Definition at line 242 of file Trktree.h.

Referenced by Init(), and see_dxy().

◆ see_dxy_branch

TBranch* Trktree::see_dxy_branch

protected

Definition at line 243 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_dxy().

◆ see_dxy_isLoaded

bool Trktree::see_dxy_isLoaded

protected

Definition at line 244 of file Trktree.h.

Referenced by GetEntry(), and see_dxy().

◆ see_dxyErr_

std::vector<float>* Trktree::see_dxyErr_

protected

Definition at line 104 of file Trktree.h.

Referenced by Init(), and see_dxyErr().

◆ see_dxyErr_branch

TBranch* Trktree::see_dxyErr_branch

protected

Definition at line 105 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_dxyErr().

◆ see_dxyErr_isLoaded

bool Trktree::see_dxyErr_isLoaded

protected

Definition at line 106 of file Trktree.h.

Referenced by GetEntry(), and see_dxyErr().

◆ see_dz_

std::vector<float>* Trktree::see_dz_

protected

Definition at line 641 of file Trktree.h.

Referenced by Init(), and see_dz().

◆ see_dz_branch

TBranch* Trktree::see_dz_branch

protected

Definition at line 642 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_dz().

◆ see_dz_isLoaded

bool Trktree::see_dz_isLoaded

protected

Definition at line 643 of file Trktree.h.

Referenced by GetEntry(), and see_dz().

◆ see_dzErr_

std::vector<float>* Trktree::see_dzErr_

protected

Definition at line 365 of file Trktree.h.

Referenced by Init(), and see_dzErr().

◆ see_dzErr_branch

TBranch* Trktree::see_dzErr_branch

protected

Definition at line 366 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_dzErr().

◆ see_dzErr_isLoaded

bool Trktree::see_dzErr_isLoaded

protected

Definition at line 367 of file Trktree.h.

Referenced by GetEntry(), and see_dzErr().

◆ see_eta_

std::vector<float>* Trktree::see_eta_

protected

Definition at line 611 of file Trktree.h.

Referenced by Init(), and see_eta().

◆ see_eta_branch

TBranch* Trktree::see_eta_branch

protected

Definition at line 612 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_eta().

◆ see_eta_isLoaded

bool Trktree::see_eta_isLoaded

protected

Definition at line 613 of file Trktree.h.

Referenced by GetEntry(), and see_eta().

◆ see_etaErr_

std::vector<float>* Trktree::see_etaErr_

protected

Definition at line 392 of file Trktree.h.

Referenced by Init(), and see_etaErr().

◆ see_etaErr_branch

TBranch* Trktree::see_etaErr_branch

protected

Definition at line 393 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_etaErr().

◆ see_etaErr_isLoaded

bool Trktree::see_etaErr_isLoaded

protected

Definition at line 394 of file Trktree.h.

Referenced by GetEntry(), and see_etaErr().

◆ see_fitok_

std::vector<short>* Trktree::see_fitok_

protected

Definition at line 191 of file Trktree.h.

Referenced by Init(), and see_fitok().

◆ see_fitok_branch

TBranch* Trktree::see_fitok_branch

protected

Definition at line 192 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_fitok().

◆ see_fitok_isLoaded

bool Trktree::see_fitok_isLoaded

protected

Definition at line 193 of file Trktree.h.

Referenced by GetEntry(), and see_fitok().

◆ see_hitIdx_

std::vector<std::vector<int> >* Trktree::see_hitIdx_

protected

Definition at line 113 of file Trktree.h.

Referenced by Init(), and see_hitIdx().

◆ see_hitIdx_branch

TBranch* Trktree::see_hitIdx_branch

protected

Definition at line 114 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_hitIdx().

◆ see_hitIdx_isLoaded

bool Trktree::see_hitIdx_isLoaded

protected

Definition at line 115 of file Trktree.h.

Referenced by GetEntry(), and see_hitIdx().

◆ see_hitType_

std::vector<std::vector<int> >* Trktree::see_hitType_

protected

Definition at line 290 of file Trktree.h.

Referenced by Init(), and see_hitType().

◆ see_hitType_branch

TBranch* Trktree::see_hitType_branch

protected

Definition at line 291 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_hitType().

◆ see_hitType_isLoaded

bool Trktree::see_hitType_isLoaded

protected

Definition at line 292 of file Trktree.h.

Referenced by GetEntry(), and see_hitType().

◆ see_nCands_

std::vector<unsigned short>* Trktree::see_nCands_

protected

Definition at line 773 of file Trktree.h.

Referenced by Init(), and see_nCands().

◆ see_nCands_branch

TBranch* Trktree::see_nCands_branch

protected

Definition at line 774 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_nCands().

◆ see_nCands_isLoaded

bool Trktree::see_nCands_isLoaded

protected

Definition at line 775 of file Trktree.h.

Referenced by GetEntry(), and see_nCands().

◆ see_nCluster_

std::vector<unsigned int>* Trktree::see_nCluster_

protected

Definition at line 506 of file Trktree.h.

Referenced by Init(), and see_nCluster().

◆ see_nCluster_branch

TBranch* Trktree::see_nCluster_branch

protected

Definition at line 507 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_nCluster().

◆ see_nCluster_isLoaded

bool Trktree::see_nCluster_isLoaded

protected

Definition at line 508 of file Trktree.h.

Referenced by GetEntry(), and see_nCluster().

◆ see_nGlued_

std::vector<unsigned int>* Trktree::see_nGlued_

protected

Definition at line 68 of file Trktree.h.

Referenced by Init(), and see_nGlued().

◆ see_nGlued_branch

TBranch* Trktree::see_nGlued_branch

protected

Definition at line 69 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_nGlued().

◆ see_nGlued_isLoaded

bool Trktree::see_nGlued_isLoaded

protected

Definition at line 70 of file Trktree.h.

Referenced by GetEntry(), and see_nGlued().

◆ see_nPhase2OT_

std::vector<unsigned int>* Trktree::see_nPhase2OT_

protected

Definition at line 860 of file Trktree.h.

Referenced by Init(), and see_nPhase2OT().

◆ see_nPhase2OT_branch

TBranch* Trktree::see_nPhase2OT_branch

protected

Definition at line 861 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_nPhase2OT().

◆ see_nPhase2OT_isLoaded

bool Trktree::see_nPhase2OT_isLoaded

protected

Definition at line 862 of file Trktree.h.

Referenced by GetEntry(), and see_nPhase2OT().

◆ see_nPixel_

std::vector<unsigned int>* Trktree::see_nPixel_

protected

Definition at line 668 of file Trktree.h.

Referenced by Init(), and see_nPixel().

◆ see_nPixel_branch

TBranch* Trktree::see_nPixel_branch

protected

Definition at line 669 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_nPixel().

◆ see_nPixel_isLoaded

bool Trktree::see_nPixel_isLoaded

protected

Definition at line 670 of file Trktree.h.

Referenced by GetEntry(), and see_nPixel().

◆ see_nStrip_

std::vector<unsigned int>* Trktree::see_nStrip_

protected

Definition at line 149 of file Trktree.h.

Referenced by Init(), and see_nStrip().

◆ see_nStrip_branch

TBranch* Trktree::see_nStrip_branch

protected

Definition at line 150 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_nStrip().

◆ see_nStrip_isLoaded

bool Trktree::see_nStrip_isLoaded

protected

Definition at line 151 of file Trktree.h.

Referenced by GetEntry(), and see_nStrip().

◆ see_nValid_

std::vector<unsigned int>* Trktree::see_nValid_

protected

Definition at line 920 of file Trktree.h.

Referenced by Init(), and see_nValid().

◆ see_nValid_branch

TBranch* Trktree::see_nValid_branch

protected

Definition at line 921 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_nValid().

◆ see_nValid_isLoaded

bool Trktree::see_nValid_isLoaded

protected

Definition at line 922 of file Trktree.h.

Referenced by GetEntry(), and see_nValid().

◆ see_offset_

std::vector<unsigned int>* Trktree::see_offset_

protected

Definition at line 824 of file Trktree.h.

Referenced by Init(), and see_offset().

◆ see_offset_branch

TBranch* Trktree::see_offset_branch

protected

Definition at line 825 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_offset().

◆ see_offset_isLoaded

bool Trktree::see_offset_isLoaded

protected

Definition at line 826 of file Trktree.h.

Referenced by GetEntry(), and see_offset().

◆ see_phi_

std::vector<float>* Trktree::see_phi_

protected

Definition at line 902 of file Trktree.h.

Referenced by Init(), and see_phi().

◆ see_phi_branch

TBranch* Trktree::see_phi_branch

protected

Definition at line 903 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_phi().

◆ see_phi_isLoaded

bool Trktree::see_phi_isLoaded

protected

Definition at line 904 of file Trktree.h.

Referenced by GetEntry(), and see_phi().

◆ see_phiErr_

std::vector<float>* Trktree::see_phiErr_

protected

Definition at line 725 of file Trktree.h.

Referenced by Init(), and see_phiErr().

◆ see_phiErr_branch

TBranch* Trktree::see_phiErr_branch

protected

Definition at line 726 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_phiErr().

◆ see_phiErr_isLoaded

bool Trktree::see_phiErr_isLoaded

protected

Definition at line 727 of file Trktree.h.

Referenced by GetEntry(), and see_phiErr().

◆ see_pt_

std::vector<float>* Trktree::see_pt_

protected

Definition at line 116 of file Trktree.h.

Referenced by Init(), and see_pt().

◆ see_pt_branch

TBranch* Trktree::see_pt_branch

protected

Definition at line 117 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_pt().

◆ see_pt_isLoaded

bool Trktree::see_pt_isLoaded

protected

Definition at line 118 of file Trktree.h.

Referenced by GetEntry(), and see_pt().

◆ see_ptErr_

std::vector<float>* Trktree::see_ptErr_

protected

Definition at line 545 of file Trktree.h.

Referenced by Init(), and see_ptErr().

◆ see_ptErr_branch

TBranch* Trktree::see_ptErr_branch

protected

Definition at line 546 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_ptErr().

◆ see_ptErr_isLoaded

bool Trktree::see_ptErr_isLoaded

protected

Definition at line 547 of file Trktree.h.

Referenced by GetEntry(), and see_ptErr().

◆ see_px_

std::vector<float>* Trktree::see_px_

protected

Definition at line 605 of file Trktree.h.

Referenced by Init(), and see_px().

◆ see_px_branch

TBranch* Trktree::see_px_branch

protected

Definition at line 606 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_px().

◆ see_px_isLoaded

bool Trktree::see_px_isLoaded

protected

Definition at line 607 of file Trktree.h.

Referenced by GetEntry(), and see_px().

◆ see_py_

std::vector<float>* Trktree::see_py_

protected

Definition at line 92 of file Trktree.h.

Referenced by Init(), and see_py().

◆ see_py_branch

TBranch* Trktree::see_py_branch

protected

Definition at line 93 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_py().

◆ see_py_isLoaded

bool Trktree::see_py_isLoaded

protected

Definition at line 94 of file Trktree.h.

Referenced by GetEntry(), and see_py().

◆ see_pz_

std::vector<float>* Trktree::see_pz_

protected

Definition at line 608 of file Trktree.h.

Referenced by Init(), and see_pz().

◆ see_pz_branch

TBranch* Trktree::see_pz_branch

protected

Definition at line 609 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_pz().

◆ see_pz_isLoaded

bool Trktree::see_pz_isLoaded

protected

Definition at line 610 of file Trktree.h.

Referenced by GetEntry(), and see_pz().

◆ see_q_

std::vector<int>* Trktree::see_q_

protected

Definition at line 161 of file Trktree.h.

Referenced by Init(), and see_q().

◆ see_q_branch

TBranch* Trktree::see_q_branch

protected

Definition at line 162 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_q().

◆ see_q_isLoaded

bool Trktree::see_q_isLoaded

protected

Definition at line 163 of file Trktree.h.

Referenced by GetEntry(), and see_q().

◆ see_simTrkIdx_

std::vector<std::vector<int> >* Trktree::see_simTrkIdx_

protected

Definition at line 326 of file Trktree.h.

Referenced by Init(), and see_simTrkIdx().

◆ see_simTrkIdx_branch

TBranch* Trktree::see_simTrkIdx_branch

protected

Definition at line 327 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_simTrkIdx().

◆ see_simTrkIdx_isLoaded

bool Trktree::see_simTrkIdx_isLoaded

protected

Definition at line 328 of file Trktree.h.

Referenced by GetEntry(), and see_simTrkIdx().

◆ see_simTrkShareFrac_

std::vector<std::vector<float> >* Trktree::see_simTrkShareFrac_

protected

Definition at line 653 of file Trktree.h.

Referenced by Init(), and see_simTrkShareFrac().

◆ see_simTrkShareFrac_branch

TBranch* Trktree::see_simTrkShareFrac_branch

protected

Definition at line 654 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_simTrkShareFrac().

◆ see_simTrkShareFrac_isLoaded

bool Trktree::see_simTrkShareFrac_isLoaded

protected

Definition at line 655 of file Trktree.h.

Referenced by GetEntry(), and see_simTrkShareFrac().

◆ see_stateCcov00_

std::vector<float>* Trktree::see_stateCcov00_

protected

Definition at line 836 of file Trktree.h.

Referenced by Init(), and see_stateCcov00().

◆ see_stateCcov00_branch

TBranch* Trktree::see_stateCcov00_branch

protected

Definition at line 837 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov00().

◆ see_stateCcov00_isLoaded

bool Trktree::see_stateCcov00_isLoaded

protected

Definition at line 838 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov00().

◆ see_stateCcov01_

std::vector<float>* Trktree::see_stateCcov01_

protected

Definition at line 20 of file Trktree.h.

Referenced by Init(), and see_stateCcov01().

◆ see_stateCcov01_branch

TBranch* Trktree::see_stateCcov01_branch

protected

Definition at line 21 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov01().

◆ see_stateCcov01_isLoaded

bool Trktree::see_stateCcov01_isLoaded

protected

Definition at line 22 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov01().

◆ see_stateCcov02_

std::vector<float>* Trktree::see_stateCcov02_

protected

Definition at line 65 of file Trktree.h.

Referenced by Init(), and see_stateCcov02().

◆ see_stateCcov02_branch

TBranch* Trktree::see_stateCcov02_branch

protected

Definition at line 66 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov02().

◆ see_stateCcov02_isLoaded

bool Trktree::see_stateCcov02_isLoaded

protected

Definition at line 67 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov02().

◆ see_stateCcov03_

std::vector<float>* Trktree::see_stateCcov03_

protected

Definition at line 53 of file Trktree.h.

Referenced by Init(), and see_stateCcov03().

◆ see_stateCcov03_branch

TBranch* Trktree::see_stateCcov03_branch

protected

Definition at line 54 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov03().

◆ see_stateCcov03_isLoaded

bool Trktree::see_stateCcov03_isLoaded

protected

Definition at line 55 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov03().

◆ see_stateCcov04_

std::vector<float>* Trktree::see_stateCcov04_

protected

Definition at line 35 of file Trktree.h.

Referenced by Init(), and see_stateCcov04().

◆ see_stateCcov04_branch

TBranch* Trktree::see_stateCcov04_branch

protected

Definition at line 36 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov04().

◆ see_stateCcov04_isLoaded

bool Trktree::see_stateCcov04_isLoaded

protected

Definition at line 37 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov04().

◆ see_stateCcov05_

std::vector<float>* Trktree::see_stateCcov05_

protected

Definition at line 32 of file Trktree.h.

Referenced by Init(), and see_stateCcov05().

◆ see_stateCcov05_branch

TBranch* Trktree::see_stateCcov05_branch

protected

Definition at line 33 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov05().

◆ see_stateCcov05_isLoaded

bool Trktree::see_stateCcov05_isLoaded

protected

Definition at line 34 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov05().

◆ see_stateCcov11_

std::vector<float>* Trktree::see_stateCcov11_

protected

Definition at line 251 of file Trktree.h.

Referenced by Init(), and see_stateCcov11().

◆ see_stateCcov11_branch

TBranch* Trktree::see_stateCcov11_branch

protected

Definition at line 252 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov11().

◆ see_stateCcov11_isLoaded

bool Trktree::see_stateCcov11_isLoaded

protected

Definition at line 253 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov11().

◆ see_stateCcov12_

std::vector<float>* Trktree::see_stateCcov12_

protected

Definition at line 224 of file Trktree.h.

Referenced by Init(), and see_stateCcov12().

◆ see_stateCcov12_branch

TBranch* Trktree::see_stateCcov12_branch

protected

Definition at line 225 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov12().

◆ see_stateCcov12_isLoaded

bool Trktree::see_stateCcov12_isLoaded

protected

Definition at line 226 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov12().

◆ see_stateCcov13_

std::vector<float>* Trktree::see_stateCcov13_

protected

Definition at line 353 of file Trktree.h.

Referenced by Init(), and see_stateCcov13().

◆ see_stateCcov13_branch

TBranch* Trktree::see_stateCcov13_branch

protected

Definition at line 354 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov13().

◆ see_stateCcov13_isLoaded

bool Trktree::see_stateCcov13_isLoaded

protected

Definition at line 355 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov13().

◆ see_stateCcov14_

std::vector<float>* Trktree::see_stateCcov14_

protected

Definition at line 344 of file Trktree.h.

Referenced by Init(), and see_stateCcov14().

◆ see_stateCcov14_branch

TBranch* Trktree::see_stateCcov14_branch

protected

Definition at line 345 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov14().

◆ see_stateCcov14_isLoaded

bool Trktree::see_stateCcov14_isLoaded

protected

Definition at line 346 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov14().

◆ see_stateCcov15_

std::vector<float>* Trktree::see_stateCcov15_

protected

Definition at line 347 of file Trktree.h.

Referenced by Init(), and see_stateCcov15().

◆ see_stateCcov15_branch

TBranch* Trktree::see_stateCcov15_branch

protected

Definition at line 348 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov15().

◆ see_stateCcov15_isLoaded

bool Trktree::see_stateCcov15_isLoaded

protected

Definition at line 349 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov15().

◆ see_stateCcov22_

std::vector<float>* Trktree::see_stateCcov22_

protected

Definition at line 515 of file Trktree.h.

Referenced by Init(), and see_stateCcov22().

◆ see_stateCcov22_branch

TBranch* Trktree::see_stateCcov22_branch

protected

Definition at line 516 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov22().

◆ see_stateCcov22_isLoaded

bool Trktree::see_stateCcov22_isLoaded

protected

Definition at line 517 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov22().

◆ see_stateCcov23_

std::vector<float>* Trktree::see_stateCcov23_

protected

Definition at line 716 of file Trktree.h.

Referenced by Init(), and see_stateCcov23().

◆ see_stateCcov23_branch

TBranch* Trktree::see_stateCcov23_branch

protected

Definition at line 717 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov23().

◆ see_stateCcov23_isLoaded

bool Trktree::see_stateCcov23_isLoaded

protected

Definition at line 718 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov23().

◆ see_stateCcov24_

std::vector<float>* Trktree::see_stateCcov24_

protected

Definition at line 500 of file Trktree.h.

Referenced by Init(), and see_stateCcov24().

◆ see_stateCcov24_branch

TBranch* Trktree::see_stateCcov24_branch

protected

Definition at line 501 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov24().

◆ see_stateCcov24_isLoaded

bool Trktree::see_stateCcov24_isLoaded

protected

Definition at line 502 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov24().

◆ see_stateCcov25_

std::vector<float>* Trktree::see_stateCcov25_

protected

Definition at line 710 of file Trktree.h.

Referenced by Init(), and see_stateCcov25().

◆ see_stateCcov25_branch

TBranch* Trktree::see_stateCcov25_branch

protected

Definition at line 711 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov25().

◆ see_stateCcov25_isLoaded

bool Trktree::see_stateCcov25_isLoaded

protected

Definition at line 712 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov25().

◆ see_stateCcov33_

std::vector<float>* Trktree::see_stateCcov33_

protected

Definition at line 818 of file Trktree.h.

Referenced by Init(), and see_stateCcov33().

◆ see_stateCcov33_branch

TBranch* Trktree::see_stateCcov33_branch

protected

Definition at line 819 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov33().

◆ see_stateCcov33_isLoaded

bool Trktree::see_stateCcov33_isLoaded

protected

Definition at line 820 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov33().

◆ see_stateCcov34_

std::vector<float>* Trktree::see_stateCcov34_

protected

Definition at line 86 of file Trktree.h.

Referenced by Init(), and see_stateCcov34().

◆ see_stateCcov34_branch

TBranch* Trktree::see_stateCcov34_branch

protected

Definition at line 87 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov34().

◆ see_stateCcov34_isLoaded

bool Trktree::see_stateCcov34_isLoaded

protected

Definition at line 88 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov34().

◆ see_stateCcov35_

std::vector<float>* Trktree::see_stateCcov35_

protected

Definition at line 815 of file Trktree.h.

Referenced by Init(), and see_stateCcov35().

◆ see_stateCcov35_branch

TBranch* Trktree::see_stateCcov35_branch

protected

Definition at line 816 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov35().

◆ see_stateCcov35_isLoaded

bool Trktree::see_stateCcov35_isLoaded

protected

Definition at line 817 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov35().

◆ see_stateCcov44_

std::vector<float>* Trktree::see_stateCcov44_

protected

Definition at line 596 of file Trktree.h.

Referenced by Init(), and see_stateCcov44().

◆ see_stateCcov44_branch

TBranch* Trktree::see_stateCcov44_branch

protected

Definition at line 597 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov44().

◆ see_stateCcov44_isLoaded

bool Trktree::see_stateCcov44_isLoaded

protected

Definition at line 598 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov44().

◆ see_stateCcov45_

std::vector<float>* Trktree::see_stateCcov45_

protected

Definition at line 677 of file Trktree.h.

Referenced by Init(), and see_stateCcov45().

◆ see_stateCcov45_branch

TBranch* Trktree::see_stateCcov45_branch

protected

Definition at line 678 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov45().

◆ see_stateCcov45_isLoaded

bool Trktree::see_stateCcov45_isLoaded

protected

Definition at line 679 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov45().

◆ see_stateCcov55_

std::vector<float>* Trktree::see_stateCcov55_

protected

Definition at line 791 of file Trktree.h.

Referenced by Init(), and see_stateCcov55().

◆ see_stateCcov55_branch

TBranch* Trktree::see_stateCcov55_branch

protected

Definition at line 792 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateCcov55().

◆ see_stateCcov55_isLoaded

bool Trktree::see_stateCcov55_isLoaded

protected

Definition at line 793 of file Trktree.h.

Referenced by GetEntry(), and see_stateCcov55().

◆ see_statePt_

std::vector<float>* Trktree::see_statePt_

protected

Definition at line 293 of file Trktree.h.

Referenced by Init(), and see_statePt().

◆ see_statePt_branch

TBranch* Trktree::see_statePt_branch

protected

Definition at line 294 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_statePt().

◆ see_statePt_isLoaded

bool Trktree::see_statePt_isLoaded

protected

Definition at line 295 of file Trktree.h.

Referenced by GetEntry(), and see_statePt().

◆ see_stateTrajGlbPx_

std::vector<float>* Trktree::see_stateTrajGlbPx_

protected

Definition at line 548 of file Trktree.h.

Referenced by Init(), and see_stateTrajGlbPx().

◆ see_stateTrajGlbPx_branch

TBranch* Trktree::see_stateTrajGlbPx_branch

protected

Definition at line 549 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateTrajGlbPx().

◆ see_stateTrajGlbPx_isLoaded

bool Trktree::see_stateTrajGlbPx_isLoaded

protected

Definition at line 550 of file Trktree.h.

Referenced by GetEntry(), and see_stateTrajGlbPx().

◆ see_stateTrajGlbPy_

std::vector<float>* Trktree::see_stateTrajGlbPy_

protected

Definition at line 926 of file Trktree.h.

Referenced by Init(), and see_stateTrajGlbPy().

◆ see_stateTrajGlbPy_branch

TBranch* Trktree::see_stateTrajGlbPy_branch

protected

Definition at line 927 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateTrajGlbPy().

◆ see_stateTrajGlbPy_isLoaded

bool Trktree::see_stateTrajGlbPy_isLoaded

protected

Definition at line 928 of file Trktree.h.

Referenced by GetEntry(), and see_stateTrajGlbPy().

◆ see_stateTrajGlbPz_

std::vector<float>* Trktree::see_stateTrajGlbPz_

protected

Definition at line 74 of file Trktree.h.

Referenced by Init(), and see_stateTrajGlbPz().

◆ see_stateTrajGlbPz_branch

TBranch* Trktree::see_stateTrajGlbPz_branch

protected

Definition at line 75 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateTrajGlbPz().

◆ see_stateTrajGlbPz_isLoaded

bool Trktree::see_stateTrajGlbPz_isLoaded

protected

Definition at line 76 of file Trktree.h.

Referenced by GetEntry(), and see_stateTrajGlbPz().

◆ see_stateTrajGlbX_

std::vector<float>* Trktree::see_stateTrajGlbX_

protected

Definition at line 332 of file Trktree.h.

Referenced by Init(), and see_stateTrajGlbX().

◆ see_stateTrajGlbX_branch

TBranch* Trktree::see_stateTrajGlbX_branch

protected

Definition at line 333 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateTrajGlbX().

◆ see_stateTrajGlbX_isLoaded

bool Trktree::see_stateTrajGlbX_isLoaded

protected

Definition at line 334 of file Trktree.h.

Referenced by GetEntry(), and see_stateTrajGlbX().

◆ see_stateTrajGlbY_

std::vector<float>* Trktree::see_stateTrajGlbY_

protected

Definition at line 335 of file Trktree.h.

Referenced by Init(), and see_stateTrajGlbY().

◆ see_stateTrajGlbY_branch

TBranch* Trktree::see_stateTrajGlbY_branch

protected

Definition at line 336 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateTrajGlbY().

◆ see_stateTrajGlbY_isLoaded

bool Trktree::see_stateTrajGlbY_isLoaded

protected

Definition at line 337 of file Trktree.h.

Referenced by GetEntry(), and see_stateTrajGlbY().

◆ see_stateTrajGlbZ_

std::vector<float>* Trktree::see_stateTrajGlbZ_

protected

Definition at line 329 of file Trktree.h.

Referenced by Init(), and see_stateTrajGlbZ().

◆ see_stateTrajGlbZ_branch

TBranch* Trktree::see_stateTrajGlbZ_branch

protected

Definition at line 330 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateTrajGlbZ().

◆ see_stateTrajGlbZ_isLoaded

bool Trktree::see_stateTrajGlbZ_isLoaded

protected

Definition at line 331 of file Trktree.h.

Referenced by GetEntry(), and see_stateTrajGlbZ().

◆ see_stateTrajPx_

std::vector<float>* Trktree::see_stateTrajPx_

protected

Definition at line 890 of file Trktree.h.

Referenced by Init(), and see_stateTrajPx().

◆ see_stateTrajPx_branch

TBranch* Trktree::see_stateTrajPx_branch

protected

Definition at line 891 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateTrajPx().

◆ see_stateTrajPx_isLoaded

bool Trktree::see_stateTrajPx_isLoaded

protected

Definition at line 892 of file Trktree.h.

Referenced by GetEntry(), and see_stateTrajPx().

◆ see_stateTrajPy_

std::vector<float>* Trktree::see_stateTrajPy_

protected

Definition at line 311 of file Trktree.h.

Referenced by Init(), and see_stateTrajPy().

◆ see_stateTrajPy_branch

TBranch* Trktree::see_stateTrajPy_branch

protected

Definition at line 312 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateTrajPy().

◆ see_stateTrajPy_isLoaded

bool Trktree::see_stateTrajPy_isLoaded

protected

Definition at line 313 of file Trktree.h.

Referenced by GetEntry(), and see_stateTrajPy().

◆ see_stateTrajPz_

std::vector<float>* Trktree::see_stateTrajPz_

protected

Definition at line 644 of file Trktree.h.

Referenced by Init(), and see_stateTrajPz().

◆ see_stateTrajPz_branch

TBranch* Trktree::see_stateTrajPz_branch

protected

Definition at line 645 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateTrajPz().

◆ see_stateTrajPz_isLoaded

bool Trktree::see_stateTrajPz_isLoaded

protected

Definition at line 646 of file Trktree.h.

Referenced by GetEntry(), and see_stateTrajPz().

◆ see_stateTrajX_

std::vector<float>* Trktree::see_stateTrajX_

protected

Definition at line 458 of file Trktree.h.

Referenced by Init(), and see_stateTrajX().

◆ see_stateTrajX_branch

TBranch* Trktree::see_stateTrajX_branch

protected

Definition at line 459 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateTrajX().

◆ see_stateTrajX_isLoaded

bool Trktree::see_stateTrajX_isLoaded

protected

Definition at line 460 of file Trktree.h.

Referenced by GetEntry(), and see_stateTrajX().

◆ see_stateTrajY_

std::vector<float>* Trktree::see_stateTrajY_

protected

Definition at line 461 of file Trktree.h.

Referenced by Init(), and see_stateTrajY().

◆ see_stateTrajY_branch

TBranch* Trktree::see_stateTrajY_branch

protected

Definition at line 462 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stateTrajY().

◆ see_stateTrajY_isLoaded

bool Trktree::see_stateTrajY_isLoaded

protected

Definition at line 463 of file Trktree.h.

Referenced by GetEntry(), and see_stateTrajY().

◆ see_stopReason_

std::vector<unsigned short>* Trktree::see_stopReason_

protected

Definition at line 839 of file Trktree.h.

Referenced by Init(), and see_stopReason().

◆ see_stopReason_branch

TBranch* Trktree::see_stopReason_branch

protected

Definition at line 840 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_stopReason().

◆ see_stopReason_isLoaded

bool Trktree::see_stopReason_isLoaded

protected

Definition at line 841 of file Trktree.h.

Referenced by GetEntry(), and see_stopReason().

◆ see_trkIdx_

std::vector<int>* Trktree::see_trkIdx_

protected

Definition at line 131 of file Trktree.h.

Referenced by Init(), and see_trkIdx().

◆ see_trkIdx_branch

TBranch* Trktree::see_trkIdx_branch

protected

Definition at line 132 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and see_trkIdx().

◆ see_trkIdx_isLoaded

bool Trktree::see_trkIdx_isLoaded

protected

Definition at line 133 of file Trktree.h.

Referenced by GetEntry(), and see_trkIdx().

◆ sim_bunchCrossing_

std::vector<int>* Trktree::sim_bunchCrossing_

protected

Definition at line 674 of file Trktree.h.

Referenced by Init(), and sim_bunchCrossing().

◆ sim_bunchCrossing_branch

TBranch* Trktree::sim_bunchCrossing_branch

protected

Definition at line 675 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_bunchCrossing().

◆ sim_bunchCrossing_isLoaded

bool Trktree::sim_bunchCrossing_isLoaded

protected

Definition at line 676 of file Trktree.h.

Referenced by GetEntry(), and sim_bunchCrossing().

◆ sim_decayVtxIdx_

std::vector<std::vector<int> >* Trktree::sim_decayVtxIdx_

protected

Definition at line 233 of file Trktree.h.

Referenced by Init(), and sim_decayVtxIdx().

◆ sim_decayVtxIdx_branch

TBranch* Trktree::sim_decayVtxIdx_branch

protected

Definition at line 234 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_decayVtxIdx().

◆ sim_decayVtxIdx_isLoaded

bool Trktree::sim_decayVtxIdx_isLoaded

protected

Definition at line 235 of file Trktree.h.

Referenced by GetEntry(), and sim_decayVtxIdx().

◆ sim_eta_

std::vector<float>* Trktree::sim_eta_

protected

Definition at line 56 of file Trktree.h.

Referenced by Init(), and sim_eta().

◆ sim_eta_branch

TBranch* Trktree::sim_eta_branch

protected

Definition at line 57 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_eta().

◆ sim_eta_isLoaded

bool Trktree::sim_eta_isLoaded

protected

Definition at line 58 of file Trktree.h.

Referenced by GetEntry(), and sim_eta().

◆ sim_event_

std::vector<int>* Trktree::sim_event_

protected

Definition at line 44 of file Trktree.h.

Referenced by Init(), and sim_event().

◆ sim_event_branch

TBranch* Trktree::sim_event_branch

protected

Definition at line 45 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_event().

◆ sim_event_isLoaded

bool Trktree::sim_event_isLoaded

protected

Definition at line 46 of file Trktree.h.

Referenced by GetEntry(), and sim_event().

◆ sim_genPdgIds_

std::vector<std::vector<int> >* Trktree::sim_genPdgIds_

protected

Definition at line 494 of file Trktree.h.

Referenced by Init(), and sim_genPdgIds().

◆ sim_genPdgIds_branch

TBranch* Trktree::sim_genPdgIds_branch

protected

Definition at line 495 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_genPdgIds().

◆ sim_genPdgIds_isLoaded

bool Trktree::sim_genPdgIds_isLoaded

protected

Definition at line 496 of file Trktree.h.

Referenced by GetEntry(), and sim_genPdgIds().

◆ sim_hits_

std::vector<float>* Trktree::sim_hits_

protected

Definition at line 557 of file Trktree.h.

Referenced by Init(), and sim_hits().

◆ sim_hits_branch

TBranch* Trktree::sim_hits_branch

protected

Definition at line 558 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_hits().

◆ sim_hits_isLoaded

bool Trktree::sim_hits_isLoaded

protected

Definition at line 559 of file Trktree.h.

Referenced by GetEntry(), and sim_hits().

◆ sim_isFromBHadron_

std::vector<int>* Trktree::sim_isFromBHadron_

protected

Definition at line 245 of file Trktree.h.

Referenced by Init(), and sim_isFromBHadron().

◆ sim_isFromBHadron_branch

TBranch* Trktree::sim_isFromBHadron_branch

protected

Definition at line 246 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_isFromBHadron().

◆ sim_isFromBHadron_isLoaded

bool Trktree::sim_isFromBHadron_isLoaded

protected

Definition at line 247 of file Trktree.h.

Referenced by GetEntry(), and sim_isFromBHadron().

◆ sim_len_

std::vector<float>* Trktree::sim_len_

protected

Definition at line 560 of file Trktree.h.

Referenced by Init(), and sim_len().

◆ sim_len_branch

TBranch* Trktree::sim_len_branch

protected

Definition at line 561 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_len().

◆ sim_len_isLoaded

bool Trktree::sim_len_isLoaded

protected

Definition at line 562 of file Trktree.h.

Referenced by GetEntry(), and sim_len().

◆ sim_lengap_

std::vector<float>* Trktree::sim_lengap_

protected

Definition at line 563 of file Trktree.h.

Referenced by Init(), and sim_lengap().

◆ sim_lengap_branch

TBranch* Trktree::sim_lengap_branch

protected

Definition at line 564 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_lengap().

◆ sim_lengap_isLoaded

bool Trktree::sim_lengap_isLoaded

protected

Definition at line 565 of file Trktree.h.

Referenced by GetEntry(), and sim_lengap().

◆ sim_n3DLay_

std::vector<unsigned int>* Trktree::sim_n3DLay_

protected

Definition at line 857 of file Trktree.h.

Referenced by Init(), and sim_n3DLay().

◆ sim_n3DLay_branch

TBranch* Trktree::sim_n3DLay_branch

protected

Definition at line 858 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_n3DLay().

◆ sim_n3DLay_isLoaded

bool Trktree::sim_n3DLay_isLoaded

protected

Definition at line 859 of file Trktree.h.

Referenced by GetEntry(), and sim_n3DLay().

◆ sim_nLay_

std::vector<unsigned int>* Trktree::sim_nLay_

protected

Definition at line 827 of file Trktree.h.

Referenced by Init(), and sim_nLay().

◆ sim_nLay_branch

TBranch* Trktree::sim_nLay_branch

protected

Definition at line 828 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_nLay().

◆ sim_nLay_isLoaded

bool Trktree::sim_nLay_isLoaded

protected

Definition at line 829 of file Trktree.h.

Referenced by GetEntry(), and sim_nLay().

◆ sim_nPixel_

std::vector<unsigned int>* Trktree::sim_nPixel_

protected

Definition at line 584 of file Trktree.h.

Referenced by Init(), and sim_nPixel().

◆ sim_nPixel_branch

TBranch* Trktree::sim_nPixel_branch

protected

Definition at line 585 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_nPixel().

◆ sim_nPixel_isLoaded

bool Trktree::sim_nPixel_isLoaded

protected

Definition at line 586 of file Trktree.h.

Referenced by GetEntry(), and sim_nPixel().

◆ sim_nPixelLay_

std::vector<unsigned int>* Trktree::sim_nPixelLay_

protected

Definition at line 917 of file Trktree.h.

Referenced by Init(), and sim_nPixelLay().

◆ sim_nPixelLay_branch

TBranch* Trktree::sim_nPixelLay_branch

protected

Definition at line 918 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_nPixelLay().

◆ sim_nPixelLay_isLoaded

bool Trktree::sim_nPixelLay_isLoaded

protected

Definition at line 919 of file Trktree.h.

Referenced by GetEntry(), and sim_nPixelLay().

◆ sim_nRecoClusters_

std::vector<unsigned int>* Trktree::sim_nRecoClusters_

protected

Definition at line 368 of file Trktree.h.

Referenced by Init(), and sim_nRecoClusters().

◆ sim_nRecoClusters_branch

TBranch* Trktree::sim_nRecoClusters_branch

protected

Definition at line 369 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_nRecoClusters().

◆ sim_nRecoClusters_isLoaded

bool Trktree::sim_nRecoClusters_isLoaded

protected

Definition at line 370 of file Trktree.h.

Referenced by GetEntry(), and sim_nRecoClusters().

◆ sim_nStrip_

std::vector<unsigned int>* Trktree::sim_nStrip_

protected

Definition at line 671 of file Trktree.h.

Referenced by Init(), and sim_nStrip().

◆ sim_nStrip_branch

TBranch* Trktree::sim_nStrip_branch

protected

Definition at line 672 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_nStrip().

◆ sim_nStrip_isLoaded

bool Trktree::sim_nStrip_isLoaded

protected

Definition at line 673 of file Trktree.h.

Referenced by GetEntry(), and sim_nStrip().

◆ sim_nTrackerHits_

std::vector<unsigned int>* Trktree::sim_nTrackerHits_

protected

Definition at line 884 of file Trktree.h.

Referenced by Init(), and sim_nTrackerHits().

◆ sim_nTrackerHits_branch

TBranch* Trktree::sim_nTrackerHits_branch

protected

Definition at line 885 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_nTrackerHits().

◆ sim_nTrackerHits_isLoaded

bool Trktree::sim_nTrackerHits_isLoaded

protected

Definition at line 886 of file Trktree.h.

Referenced by GetEntry(), and sim_nTrackerHits().

◆ sim_nValid_

std::vector<unsigned int>* Trktree::sim_nValid_

protected

Definition at line 767 of file Trktree.h.

Referenced by Init(), and sim_nValid().

◆ sim_nValid_branch

TBranch* Trktree::sim_nValid_branch

protected

Definition at line 768 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_nValid().

◆ sim_nValid_isLoaded

bool Trktree::sim_nValid_isLoaded

protected

Definition at line 769 of file Trktree.h.

Referenced by GetEntry(), and sim_nValid().

◆ sim_parentVtxIdx_

std::vector<int>* Trktree::sim_parentVtxIdx_

protected

Definition at line 713 of file Trktree.h.

Referenced by Init(), and sim_parentVtxIdx().

◆ sim_parentVtxIdx_branch

TBranch* Trktree::sim_parentVtxIdx_branch

protected

Definition at line 714 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_parentVtxIdx().

◆ sim_parentVtxIdx_isLoaded

bool Trktree::sim_parentVtxIdx_isLoaded

protected

Definition at line 715 of file Trktree.h.

Referenced by GetEntry(), and sim_parentVtxIdx().

◆ sim_pca_cotTheta_

std::vector<float>* Trktree::sim_pca_cotTheta_

protected

Definition at line 803 of file Trktree.h.

Referenced by Init(), and sim_pca_cotTheta().

◆ sim_pca_cotTheta_branch

TBranch* Trktree::sim_pca_cotTheta_branch

protected

Definition at line 804 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_pca_cotTheta().

◆ sim_pca_cotTheta_isLoaded

bool Trktree::sim_pca_cotTheta_isLoaded

protected

Definition at line 805 of file Trktree.h.

Referenced by GetEntry(), and sim_pca_cotTheta().

◆ sim_pca_dxy_

std::vector<float>* Trktree::sim_pca_dxy_

protected

Definition at line 467 of file Trktree.h.

Referenced by Init(), and sim_pca_dxy().

◆ sim_pca_dxy_branch

TBranch* Trktree::sim_pca_dxy_branch

protected

Definition at line 468 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_pca_dxy().

◆ sim_pca_dxy_isLoaded

bool Trktree::sim_pca_dxy_isLoaded

protected

Definition at line 469 of file Trktree.h.

Referenced by GetEntry(), and sim_pca_dxy().

◆ sim_pca_dz_

std::vector<float>* Trktree::sim_pca_dz_

protected

Definition at line 617 of file Trktree.h.

Referenced by Init(), and sim_pca_dz().

◆ sim_pca_dz_branch

TBranch* Trktree::sim_pca_dz_branch

protected

Definition at line 618 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_pca_dz().

◆ sim_pca_dz_isLoaded

bool Trktree::sim_pca_dz_isLoaded

protected

Definition at line 619 of file Trktree.h.

Referenced by GetEntry(), and sim_pca_dz().

◆ sim_pca_eta_

std::vector<float>* Trktree::sim_pca_eta_

protected

Definition at line 386 of file Trktree.h.

Referenced by Init(), and sim_pca_eta().

◆ sim_pca_eta_branch

TBranch* Trktree::sim_pca_eta_branch

protected

Definition at line 387 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_pca_eta().

◆ sim_pca_eta_isLoaded

bool Trktree::sim_pca_eta_isLoaded

protected

Definition at line 388 of file Trktree.h.

Referenced by GetEntry(), and sim_pca_eta().

◆ sim_pca_lambda_

std::vector<float>* Trktree::sim_pca_lambda_

protected

Definition at line 167 of file Trktree.h.

Referenced by Init(), and sim_pca_lambda().

◆ sim_pca_lambda_branch

TBranch* Trktree::sim_pca_lambda_branch

protected

Definition at line 168 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_pca_lambda().

◆ sim_pca_lambda_isLoaded

bool Trktree::sim_pca_lambda_isLoaded

protected

Definition at line 169 of file Trktree.h.

Referenced by GetEntry(), and sim_pca_lambda().

◆ sim_pca_phi_

std::vector<float>* Trktree::sim_pca_phi_

protected

Definition at line 263 of file Trktree.h.

Referenced by Init(), and sim_pca_phi().

◆ sim_pca_phi_branch

TBranch* Trktree::sim_pca_phi_branch

protected

Definition at line 264 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_pca_phi().

◆ sim_pca_phi_isLoaded

bool Trktree::sim_pca_phi_isLoaded

protected

Definition at line 265 of file Trktree.h.

Referenced by GetEntry(), and sim_pca_phi().

◆ sim_pca_pt_

std::vector<float>* Trktree::sim_pca_pt_

protected

Definition at line 128 of file Trktree.h.

Referenced by Init(), and sim_pca_pt().

◆ sim_pca_pt_branch

TBranch* Trktree::sim_pca_pt_branch

protected

Definition at line 129 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_pca_pt().

◆ sim_pca_pt_isLoaded

bool Trktree::sim_pca_pt_isLoaded

protected

Definition at line 130 of file Trktree.h.

Referenced by GetEntry(), and sim_pca_pt().

◆ sim_pdgId_

std::vector<int>* Trktree::sim_pdgId_

protected

Definition at line 257 of file Trktree.h.

Referenced by Init(), and sim_pdgId().

◆ sim_pdgId_branch

TBranch* Trktree::sim_pdgId_branch

protected

Definition at line 258 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_pdgId().

◆ sim_pdgId_isLoaded

bool Trktree::sim_pdgId_isLoaded

protected

Definition at line 259 of file Trktree.h.

Referenced by GetEntry(), and sim_pdgId().

◆ sim_phi_

std::vector<float>* Trktree::sim_phi_

protected

Definition at line 689 of file Trktree.h.

Referenced by Init(), and sim_phi().

◆ sim_phi_branch

TBranch* Trktree::sim_phi_branch

protected

Definition at line 690 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_phi().

◆ sim_phi_isLoaded

bool Trktree::sim_phi_isLoaded

protected

Definition at line 691 of file Trktree.h.

Referenced by GetEntry(), and sim_phi().

◆ sim_pt_

std::vector<float>* Trktree::sim_pt_

protected

Definition at line 227 of file Trktree.h.

Referenced by Init(), and sim_pt().

◆ sim_pt_branch

TBranch* Trktree::sim_pt_branch

protected

Definition at line 228 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_pt().

◆ sim_pt_isLoaded

bool Trktree::sim_pt_isLoaded

protected

Definition at line 229 of file Trktree.h.

Referenced by GetEntry(), and sim_pt().

◆ sim_px_

std::vector<float>* Trktree::sim_px_

protected

Definition at line 218 of file Trktree.h.

Referenced by Init(), and sim_px().

◆ sim_px_branch

TBranch* Trktree::sim_px_branch

protected

Definition at line 219 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_px().

◆ sim_px_isLoaded

bool Trktree::sim_px_isLoaded

protected

Definition at line 220 of file Trktree.h.

Referenced by GetEntry(), and sim_px().

◆ sim_py_

std::vector<float>* Trktree::sim_py_

protected

Definition at line 230 of file Trktree.h.

Referenced by Init(), and sim_py().

◆ sim_py_branch

TBranch* Trktree::sim_py_branch

protected

Definition at line 231 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_py().

◆ sim_py_isLoaded

bool Trktree::sim_py_isLoaded

protected

Definition at line 232 of file Trktree.h.

Referenced by GetEntry(), and sim_py().

◆ sim_pz_

std::vector<float>* Trktree::sim_pz_

protected

Definition at line 212 of file Trktree.h.

Referenced by Init(), and sim_pz().

◆ sim_pz_branch

TBranch* Trktree::sim_pz_branch

protected

Definition at line 213 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_pz().

◆ sim_pz_isLoaded

bool Trktree::sim_pz_isLoaded

protected

Definition at line 214 of file Trktree.h.

Referenced by GetEntry(), and sim_pz().

◆ sim_q_

std::vector<int>* Trktree::sim_q_

protected

Definition at line 170 of file Trktree.h.

Referenced by Init(), and sim_q().

◆ sim_q_branch

TBranch* Trktree::sim_q_branch

protected

Definition at line 171 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_q().

◆ sim_q_isLoaded

bool Trktree::sim_q_isLoaded

protected

Definition at line 172 of file Trktree.h.

Referenced by GetEntry(), and sim_q().

◆ sim_seedIdx_

std::vector<std::vector<int> >* Trktree::sim_seedIdx_

protected

Definition at line 362 of file Trktree.h.

Referenced by Init(), and sim_seedIdx().

◆ sim_seedIdx_branch

TBranch* Trktree::sim_seedIdx_branch

protected

Definition at line 363 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_seedIdx().

◆ sim_seedIdx_isLoaded

bool Trktree::sim_seedIdx_isLoaded

protected

Definition at line 364 of file Trktree.h.

Referenced by GetEntry(), and sim_seedIdx().

◆ sim_simHitIdx_

std::vector<std::vector<int> >* Trktree::sim_simHitIdx_

protected

Definition at line 830 of file Trktree.h.

Referenced by Init(), and sim_simHitIdx().

◆ sim_simHitIdx_branch

TBranch* Trktree::sim_simHitIdx_branch

protected

Definition at line 831 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_simHitIdx().

◆ sim_simHitIdx_isLoaded

bool Trktree::sim_simHitIdx_isLoaded

protected

Definition at line 832 of file Trktree.h.

Referenced by GetEntry(), and sim_simHitIdx().

◆ sim_trkIdx_

std::vector<std::vector<int> >* Trktree::sim_trkIdx_

protected

Definition at line 95 of file Trktree.h.

Referenced by Init(), and sim_trkIdx().

◆ sim_trkIdx_branch

TBranch* Trktree::sim_trkIdx_branch

protected

Definition at line 96 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_trkIdx().

◆ sim_trkIdx_isLoaded

bool Trktree::sim_trkIdx_isLoaded

protected

Definition at line 97 of file Trktree.h.

Referenced by GetEntry(), and sim_trkIdx().

◆ sim_trkShareFrac_

std::vector<std::vector<float> >* Trktree::sim_trkShareFrac_

protected

Definition at line 683 of file Trktree.h.

Referenced by Init(), and sim_trkShareFrac().

◆ sim_trkShareFrac_branch

TBranch* Trktree::sim_trkShareFrac_branch

protected

Definition at line 684 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and sim_trkShareFrac().

◆ sim_trkShareFrac_isLoaded

bool Trktree::sim_trkShareFrac_isLoaded

protected

Definition at line 685 of file Trktree.h.

Referenced by GetEntry(), and sim_trkShareFrac().

◆ simhit_blade_

std::vector<unsigned short>* Trktree::simhit_blade_

protected

Definition at line 194 of file Trktree.h.

Referenced by Init(), and simhit_blade().

◆ simhit_blade_branch

TBranch* Trktree::simhit_blade_branch

protected

Definition at line 195 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_blade().

◆ simhit_blade_isLoaded

bool Trktree::simhit_blade_isLoaded

protected

Definition at line 196 of file Trktree.h.

Referenced by GetEntry(), and simhit_blade().

◆ simhit_detId_

std::vector<unsigned int>* Trktree::simhit_detId_

protected

Definition at line 107 of file Trktree.h.

Referenced by Init(), and simhit_detId().

◆ simhit_detId_branch

TBranch* Trktree::simhit_detId_branch

protected

Definition at line 108 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_detId().

◆ simhit_detId_isLoaded

bool Trktree::simhit_detId_isLoaded

protected

Definition at line 109 of file Trktree.h.

Referenced by GetEntry(), and simhit_detId().

◆ simhit_eloss_

std::vector<float>* Trktree::simhit_eloss_

protected

Definition at line 248 of file Trktree.h.

Referenced by Init(), and simhit_eloss().

◆ simhit_eloss_branch

TBranch* Trktree::simhit_eloss_branch

protected

Definition at line 249 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_eloss().

◆ simhit_eloss_isLoaded

bool Trktree::simhit_eloss_isLoaded

protected

Definition at line 250 of file Trktree.h.

Referenced by GetEntry(), and simhit_eloss().

◆ simhit_hitIdx_

std::vector<std::vector<int> >* Trktree::simhit_hitIdx_

protected

Definition at line 893 of file Trktree.h.

Referenced by Init(), and simhit_hitIdx().

◆ simhit_hitIdx_branch

TBranch* Trktree::simhit_hitIdx_branch

protected

Definition at line 894 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_hitIdx().

◆ simhit_hitIdx_isLoaded

bool Trktree::simhit_hitIdx_isLoaded

protected

Definition at line 895 of file Trktree.h.

Referenced by GetEntry(), and simhit_hitIdx().

◆ simhit_hitType_

std::vector<std::vector<int> >* Trktree::simhit_hitType_

protected

Definition at line 143 of file Trktree.h.

Referenced by Init(), and simhit_hitType().

◆ simhit_hitType_branch

TBranch* Trktree::simhit_hitType_branch

protected

Definition at line 144 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_hitType().

◆ simhit_hitType_isLoaded

bool Trktree::simhit_hitType_isLoaded

protected

Definition at line 145 of file Trktree.h.

Referenced by GetEntry(), and simhit_hitType().

◆ simhit_isLower_

std::vector<unsigned short>* Trktree::simhit_isLower_

protected

Definition at line 266 of file Trktree.h.

Referenced by Init(), and simhit_isLower().

◆ simhit_isLower_branch

TBranch* Trktree::simhit_isLower_branch

protected

Definition at line 267 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_isLower().

◆ simhit_isLower_isLoaded

bool Trktree::simhit_isLower_isLoaded

protected

Definition at line 268 of file Trktree.h.

Referenced by GetEntry(), and simhit_isLower().

◆ simhit_isStack_

std::vector<unsigned short>* Trktree::simhit_isStack_

protected

Definition at line 47 of file Trktree.h.

Referenced by Init(), and simhit_isStack().

◆ simhit_isStack_branch

TBranch* Trktree::simhit_isStack_branch

protected

Definition at line 48 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_isStack().

◆ simhit_isStack_isLoaded

bool Trktree::simhit_isStack_isLoaded

protected

Definition at line 49 of file Trktree.h.

Referenced by GetEntry(), and simhit_isStack().

◆ simhit_isUpper_

std::vector<unsigned short>* Trktree::simhit_isUpper_

protected

Definition at line 833 of file Trktree.h.

Referenced by Init(), and simhit_isUpper().

◆ simhit_isUpper_branch

TBranch* Trktree::simhit_isUpper_branch

protected

Definition at line 834 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_isUpper().

◆ simhit_isUpper_isLoaded

bool Trktree::simhit_isUpper_isLoaded

protected

Definition at line 835 of file Trktree.h.

Referenced by GetEntry(), and simhit_isUpper().

◆ simhit_ladder_

std::vector<unsigned short>* Trktree::simhit_ladder_

protected

Definition at line 896 of file Trktree.h.

Referenced by Init(), and simhit_ladder().

◆ simhit_ladder_branch

TBranch* Trktree::simhit_ladder_branch

protected

Definition at line 897 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_ladder().

◆ simhit_ladder_isLoaded

bool Trktree::simhit_ladder_isLoaded

protected

Definition at line 898 of file Trktree.h.

Referenced by GetEntry(), and simhit_ladder().

◆ simhit_layer_

std::vector<unsigned short>* Trktree::simhit_layer_

protected

Definition at line 440 of file Trktree.h.

Referenced by Init(), and simhit_layer().

◆ simhit_layer_branch

TBranch* Trktree::simhit_layer_branch

protected

Definition at line 441 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_layer().

◆ simhit_layer_isLoaded

bool Trktree::simhit_layer_isLoaded

protected

Definition at line 442 of file Trktree.h.

Referenced by GetEntry(), and simhit_layer().

◆ simhit_module_

std::vector<unsigned short>* Trktree::simhit_module_

protected

Definition at line 734 of file Trktree.h.

Referenced by Init(), and simhit_module().

◆ simhit_module_branch

TBranch* Trktree::simhit_module_branch

protected

Definition at line 735 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_module().

◆ simhit_module_isLoaded

bool Trktree::simhit_module_isLoaded

protected

Definition at line 736 of file Trktree.h.

Referenced by GetEntry(), and simhit_module().

◆ simhit_order_

std::vector<unsigned short>* Trktree::simhit_order_

protected

Definition at line 275 of file Trktree.h.

Referenced by Init(), and simhit_order().

◆ simhit_order_branch

TBranch* Trktree::simhit_order_branch

protected

Definition at line 276 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_order().

◆ simhit_order_isLoaded

bool Trktree::simhit_order_isLoaded

protected

Definition at line 277 of file Trktree.h.

Referenced by GetEntry(), and simhit_order().

◆ simhit_panel_

std::vector<unsigned short>* Trktree::simhit_panel_

protected

Definition at line 209 of file Trktree.h.

Referenced by Init(), and simhit_panel().

◆ simhit_panel_branch

TBranch* Trktree::simhit_panel_branch

protected

Definition at line 210 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_panel().

◆ simhit_panel_isLoaded

bool Trktree::simhit_panel_isLoaded

protected

Definition at line 211 of file Trktree.h.

Referenced by GetEntry(), and simhit_panel().

◆ simhit_particle_

std::vector<int>* Trktree::simhit_particle_

protected

Definition at line 638 of file Trktree.h.

Referenced by Init(), and simhit_particle().

◆ simhit_particle_branch

TBranch* Trktree::simhit_particle_branch

protected

Definition at line 639 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_particle().

◆ simhit_particle_isLoaded

bool Trktree::simhit_particle_isLoaded

protected

Definition at line 640 of file Trktree.h.

Referenced by GetEntry(), and simhit_particle().

◆ simhit_process_

std::vector<short>* Trktree::simhit_process_

protected

Definition at line 83 of file Trktree.h.

Referenced by Init(), and simhit_process().

◆ simhit_process_branch

TBranch* Trktree::simhit_process_branch

protected

Definition at line 84 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_process().

◆ simhit_process_isLoaded

bool Trktree::simhit_process_isLoaded

protected

Definition at line 85 of file Trktree.h.

Referenced by GetEntry(), and simhit_process().

◆ simhit_px_

std::vector<float>* Trktree::simhit_px_

protected

Definition at line 455 of file Trktree.h.

Referenced by Init(), and simhit_px().

◆ simhit_px_branch

TBranch* Trktree::simhit_px_branch

protected

Definition at line 456 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_px().

◆ simhit_px_isLoaded

bool Trktree::simhit_px_isLoaded

protected

Definition at line 457 of file Trktree.h.

Referenced by GetEntry(), and simhit_px().

◆ simhit_py_

std::vector<float>* Trktree::simhit_py_

protected

Definition at line 323 of file Trktree.h.

Referenced by Init(), and simhit_py().

◆ simhit_py_branch

TBranch* Trktree::simhit_py_branch

protected

Definition at line 324 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_py().

◆ simhit_py_isLoaded

bool Trktree::simhit_py_isLoaded

protected

Definition at line 325 of file Trktree.h.

Referenced by GetEntry(), and simhit_py().

◆ simhit_pz_

std::vector<float>* Trktree::simhit_pz_

protected

Definition at line 254 of file Trktree.h.

Referenced by Init(), and simhit_pz().

◆ simhit_pz_branch

TBranch* Trktree::simhit_pz_branch

protected

Definition at line 255 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_pz().

◆ simhit_pz_isLoaded

bool Trktree::simhit_pz_isLoaded

protected

Definition at line 256 of file Trktree.h.

Referenced by GetEntry(), and simhit_pz().

◆ simhit_ring_

std::vector<unsigned short>* Trktree::simhit_ring_

protected

Definition at line 521 of file Trktree.h.

Referenced by Init(), and simhit_ring().

◆ simhit_ring_branch

TBranch* Trktree::simhit_ring_branch

protected

Definition at line 522 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_ring().

◆ simhit_ring_isLoaded

bool Trktree::simhit_ring_isLoaded

protected

Definition at line 523 of file Trktree.h.

Referenced by GetEntry(), and simhit_ring().

◆ simhit_rod_

std::vector<unsigned short>* Trktree::simhit_rod_

protected

Definition at line 23 of file Trktree.h.

Referenced by Init(), and simhit_rod().

◆ simhit_rod_branch

TBranch* Trktree::simhit_rod_branch

protected

Definition at line 24 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_rod().

◆ simhit_rod_isLoaded

bool Trktree::simhit_rod_isLoaded

protected

Definition at line 25 of file Trktree.h.

Referenced by GetEntry(), and simhit_rod().

◆ simhit_side_

std::vector<unsigned short>* Trktree::simhit_side_

protected

Definition at line 155 of file Trktree.h.

Referenced by Init(), and simhit_side().

◆ simhit_side_branch

TBranch* Trktree::simhit_side_branch

protected

Definition at line 156 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_side().

◆ simhit_side_isLoaded

bool Trktree::simhit_side_isLoaded

protected

Definition at line 157 of file Trktree.h.

Referenced by GetEntry(), and simhit_side().

◆ simhit_simTrkIdx_

std::vector<int>* Trktree::simhit_simTrkIdx_

protected

Definition at line 770 of file Trktree.h.

Referenced by Init(), and simhit_simTrkIdx().

◆ simhit_simTrkIdx_branch

TBranch* Trktree::simhit_simTrkIdx_branch

protected

Definition at line 771 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_simTrkIdx().

◆ simhit_simTrkIdx_isLoaded

bool Trktree::simhit_simTrkIdx_isLoaded

protected

Definition at line 772 of file Trktree.h.

Referenced by GetEntry(), and simhit_simTrkIdx().

◆ simhit_subdet_

std::vector<unsigned short>* Trktree::simhit_subdet_

protected

Definition at line 110 of file Trktree.h.

Referenced by Init(), and simhit_subdet().

◆ simhit_subdet_branch

TBranch* Trktree::simhit_subdet_branch

protected

Definition at line 111 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_subdet().

◆ simhit_subdet_isLoaded

bool Trktree::simhit_subdet_isLoaded

protected

Definition at line 112 of file Trktree.h.

Referenced by GetEntry(), and simhit_subdet().

◆ simhit_tof_

std::vector<float>* Trktree::simhit_tof_

protected

Definition at line 41 of file Trktree.h.

Referenced by Init(), and simhit_tof().

◆ simhit_tof_branch

TBranch* Trktree::simhit_tof_branch

protected

Definition at line 42 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_tof().

◆ simhit_tof_isLoaded

bool Trktree::simhit_tof_isLoaded

protected

Definition at line 43 of file Trktree.h.

Referenced by GetEntry(), and simhit_tof().

◆ simhit_x_

std::vector<float>* Trktree::simhit_x_

protected

Definition at line 158 of file Trktree.h.

Referenced by Init(), and simhit_x().

◆ simhit_x_branch

TBranch* Trktree::simhit_x_branch

protected

Definition at line 159 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_x().

◆ simhit_x_isLoaded

bool Trktree::simhit_x_isLoaded

protected

Definition at line 160 of file Trktree.h.

Referenced by GetEntry(), and simhit_x().

◆ simhit_y_

std::vector<float>* Trktree::simhit_y_

protected

Definition at line 746 of file Trktree.h.

Referenced by Init(), and simhit_y().

◆ simhit_y_branch

TBranch* Trktree::simhit_y_branch

protected

Definition at line 747 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_y().

◆ simhit_y_isLoaded

bool Trktree::simhit_y_isLoaded

protected

Definition at line 748 of file Trktree.h.

Referenced by GetEntry(), and simhit_y().

◆ simhit_z_

std::vector<float>* Trktree::simhit_z_

protected

Definition at line 164 of file Trktree.h.

Referenced by Init(), and simhit_z().

◆ simhit_z_branch

TBranch* Trktree::simhit_z_branch

protected

Definition at line 165 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simhit_z().

◆ simhit_z_isLoaded

bool Trktree::simhit_z_isLoaded

protected

Definition at line 166 of file Trktree.h.

Referenced by GetEntry(), and simhit_z().

◆ simpv_idx_

std::vector<int>* Trktree::simpv_idx_

protected

Definition at line 806 of file Trktree.h.

Referenced by Init(), and simpv_idx().

◆ simpv_idx_branch

TBranch* Trktree::simpv_idx_branch

protected

Definition at line 807 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simpv_idx().

◆ simpv_idx_isLoaded

bool Trktree::simpv_idx_isLoaded

protected

Definition at line 808 of file Trktree.h.

Referenced by GetEntry(), and simpv_idx().

◆ simvtx_bunchCrossing_

std::vector<int>* Trktree::simvtx_bunchCrossing_

protected

Definition at line 614 of file Trktree.h.

Referenced by Init(), and simvtx_bunchCrossing().

◆ simvtx_bunchCrossing_branch

TBranch* Trktree::simvtx_bunchCrossing_branch

protected

Definition at line 615 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simvtx_bunchCrossing().

◆ simvtx_bunchCrossing_isLoaded

bool Trktree::simvtx_bunchCrossing_isLoaded

protected

Definition at line 616 of file Trktree.h.

Referenced by GetEntry(), and simvtx_bunchCrossing().

◆ simvtx_daughterSimIdx_

std::vector<std::vector<int> >* Trktree::simvtx_daughterSimIdx_

protected

Definition at line 737 of file Trktree.h.

Referenced by Init(), and simvtx_daughterSimIdx().

◆ simvtx_daughterSimIdx_branch

TBranch* Trktree::simvtx_daughterSimIdx_branch

protected

Definition at line 738 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simvtx_daughterSimIdx().

◆ simvtx_daughterSimIdx_isLoaded

bool Trktree::simvtx_daughterSimIdx_isLoaded

protected

Definition at line 739 of file Trktree.h.

Referenced by GetEntry(), and simvtx_daughterSimIdx().

◆ simvtx_event_

std::vector<int>* Trktree::simvtx_event_

protected

Definition at line 482 of file Trktree.h.

Referenced by Init(), and simvtx_event().

◆ simvtx_event_branch

TBranch* Trktree::simvtx_event_branch

protected

Definition at line 483 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simvtx_event().

◆ simvtx_event_isLoaded

bool Trktree::simvtx_event_isLoaded

protected

Definition at line 484 of file Trktree.h.

Referenced by GetEntry(), and simvtx_event().

◆ simvtx_processType_

std::vector<unsigned int>* Trktree::simvtx_processType_

protected

Definition at line 59 of file Trktree.h.

Referenced by Init(), and simvtx_processType().

◆ simvtx_processType_branch

TBranch* Trktree::simvtx_processType_branch

protected

Definition at line 60 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simvtx_processType().

◆ simvtx_processType_isLoaded

bool Trktree::simvtx_processType_isLoaded

protected

Definition at line 61 of file Trktree.h.

Referenced by GetEntry(), and simvtx_processType().

◆ simvtx_sourceSimIdx_

std::vector<std::vector<int> >* Trktree::simvtx_sourceSimIdx_

protected

Definition at line 296 of file Trktree.h.

Referenced by Init(), and simvtx_sourceSimIdx().

◆ simvtx_sourceSimIdx_branch

TBranch* Trktree::simvtx_sourceSimIdx_branch

protected

Definition at line 297 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simvtx_sourceSimIdx().

◆ simvtx_sourceSimIdx_isLoaded

bool Trktree::simvtx_sourceSimIdx_isLoaded

protected

Definition at line 298 of file Trktree.h.

Referenced by GetEntry(), and simvtx_sourceSimIdx().

◆ simvtx_x_

std::vector<float>* Trktree::simvtx_x_

protected

Definition at line 566 of file Trktree.h.

Referenced by Init(), and simvtx_x().

◆ simvtx_x_branch

TBranch* Trktree::simvtx_x_branch

protected

Definition at line 567 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simvtx_x().

◆ simvtx_x_isLoaded

bool Trktree::simvtx_x_isLoaded

protected

Definition at line 568 of file Trktree.h.

Referenced by GetEntry(), and simvtx_x().

◆ simvtx_y_

std::vector<float>* Trktree::simvtx_y_

protected

Definition at line 620 of file Trktree.h.

Referenced by Init(), and simvtx_y().

◆ simvtx_y_branch

TBranch* Trktree::simvtx_y_branch

protected

Definition at line 621 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simvtx_y().

◆ simvtx_y_isLoaded

bool Trktree::simvtx_y_isLoaded

protected

Definition at line 622 of file Trktree.h.

Referenced by GetEntry(), and simvtx_y().

◆ simvtx_z_

std::vector<float>* Trktree::simvtx_z_

protected

Definition at line 881 of file Trktree.h.

Referenced by Init(), and simvtx_z().

◆ simvtx_z_branch

TBranch* Trktree::simvtx_z_branch

protected

Definition at line 882 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and simvtx_z().

◆ simvtx_z_isLoaded

bool Trktree::simvtx_z_isLoaded

protected

Definition at line 883 of file Trktree.h.

Referenced by GetEntry(), and simvtx_z().

◆ trk_algo_

std::vector<unsigned int>* Trktree::trk_algo_

protected

Definition at line 470 of file Trktree.h.

Referenced by Init(), and trk_algo().

◆ trk_algo_branch

TBranch* Trktree::trk_algo_branch

protected

Definition at line 471 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_algo().

◆ trk_algo_isLoaded

bool Trktree::trk_algo_isLoaded

protected

Definition at line 472 of file Trktree.h.

Referenced by GetEntry(), and trk_algo().

◆ trk_algoMask_

std::vector<ULong64_t>* Trktree::trk_algoMask_

protected

Definition at line 719 of file Trktree.h.

Referenced by Init(), and trk_algoMask().

◆ trk_algoMask_branch

TBranch* Trktree::trk_algoMask_branch

protected

Definition at line 720 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_algoMask().

◆ trk_algoMask_isLoaded

bool Trktree::trk_algoMask_isLoaded

protected

Definition at line 721 of file Trktree.h.

Referenced by GetEntry(), and trk_algoMask().

◆ trk_bestFromFirstHitSimTrkIdx_

std::vector<int>* Trktree::trk_bestFromFirstHitSimTrkIdx_

protected

Definition at line 452 of file Trktree.h.

Referenced by Init(), and trk_bestFromFirstHitSimTrkIdx().

◆ trk_bestFromFirstHitSimTrkIdx_branch

TBranch* Trktree::trk_bestFromFirstHitSimTrkIdx_branch

protected

Definition at line 453 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_bestFromFirstHitSimTrkIdx().

◆ trk_bestFromFirstHitSimTrkIdx_isLoaded

bool Trktree::trk_bestFromFirstHitSimTrkIdx_isLoaded

protected

Definition at line 454 of file Trktree.h.

Referenced by GetEntry(), and trk_bestFromFirstHitSimTrkIdx().

◆ trk_bestFromFirstHitSimTrkNChi2_

std::vector<float>* Trktree::trk_bestFromFirstHitSimTrkNChi2_

protected

Definition at line 137 of file Trktree.h.

Referenced by Init(), and trk_bestFromFirstHitSimTrkNChi2().

◆ trk_bestFromFirstHitSimTrkNChi2_branch

TBranch* Trktree::trk_bestFromFirstHitSimTrkNChi2_branch

protected

Definition at line 138 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_bestFromFirstHitSimTrkNChi2().

◆ trk_bestFromFirstHitSimTrkNChi2_isLoaded

bool Trktree::trk_bestFromFirstHitSimTrkNChi2_isLoaded

protected

Definition at line 139 of file Trktree.h.

Referenced by GetEntry(), and trk_bestFromFirstHitSimTrkNChi2().

◆ trk_bestFromFirstHitSimTrkShareFrac_

std::vector<float>* Trktree::trk_bestFromFirstHitSimTrkShareFrac_

protected

Definition at line 476 of file Trktree.h.

Referenced by Init(), and trk_bestFromFirstHitSimTrkShareFrac().

◆ trk_bestFromFirstHitSimTrkShareFrac_branch

TBranch* Trktree::trk_bestFromFirstHitSimTrkShareFrac_branch

protected

Definition at line 477 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_bestFromFirstHitSimTrkShareFrac().

◆ trk_bestFromFirstHitSimTrkShareFrac_isLoaded

bool Trktree::trk_bestFromFirstHitSimTrkShareFrac_isLoaded

protected

Definition at line 478 of file Trktree.h.

Referenced by GetEntry(), and trk_bestFromFirstHitSimTrkShareFrac().

◆ trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_

std::vector<float>* Trktree::trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_

protected

Definition at line 554 of file Trktree.h.

Referenced by Init(), and trk_bestFromFirstHitSimTrkShareFracSimClusterDenom().

◆ trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch

TBranch* Trktree::trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch

protected

Definition at line 555 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_bestFromFirstHitSimTrkShareFracSimClusterDenom().

◆ trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_isLoaded

bool Trktree::trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_isLoaded

protected

Definition at line 556 of file Trktree.h.

Referenced by GetEntry(), and trk_bestFromFirstHitSimTrkShareFracSimClusterDenom().

◆ trk_bestFromFirstHitSimTrkShareFracSimDenom_

std::vector<float>* Trktree::trk_bestFromFirstHitSimTrkShareFracSimDenom_

protected

Definition at line 863 of file Trktree.h.

Referenced by Init(), and trk_bestFromFirstHitSimTrkShareFracSimDenom().

◆ trk_bestFromFirstHitSimTrkShareFracSimDenom_branch

TBranch* Trktree::trk_bestFromFirstHitSimTrkShareFracSimDenom_branch

protected

Definition at line 864 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_bestFromFirstHitSimTrkShareFracSimDenom().

◆ trk_bestFromFirstHitSimTrkShareFracSimDenom_isLoaded

bool Trktree::trk_bestFromFirstHitSimTrkShareFracSimDenom_isLoaded

protected

Definition at line 865 of file Trktree.h.

Referenced by GetEntry(), and trk_bestFromFirstHitSimTrkShareFracSimDenom().

◆ trk_bestSimTrkIdx_

std::vector<int>* Trktree::trk_bestSimTrkIdx_

protected

Definition at line 71 of file Trktree.h.

Referenced by Init(), and trk_bestSimTrkIdx().

◆ trk_bestSimTrkIdx_branch

TBranch* Trktree::trk_bestSimTrkIdx_branch

protected

Definition at line 72 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_bestSimTrkIdx().

◆ trk_bestSimTrkIdx_isLoaded

bool Trktree::trk_bestSimTrkIdx_isLoaded

protected

Definition at line 73 of file Trktree.h.

Referenced by GetEntry(), and trk_bestSimTrkIdx().

◆ trk_bestSimTrkNChi2_

std::vector<float>* Trktree::trk_bestSimTrkNChi2_

protected

Definition at line 308 of file Trktree.h.

Referenced by Init(), and trk_bestSimTrkNChi2().

◆ trk_bestSimTrkNChi2_branch

TBranch* Trktree::trk_bestSimTrkNChi2_branch

protected

Definition at line 309 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_bestSimTrkNChi2().

◆ trk_bestSimTrkNChi2_isLoaded

bool Trktree::trk_bestSimTrkNChi2_isLoaded

protected

Definition at line 310 of file Trktree.h.

Referenced by GetEntry(), and trk_bestSimTrkNChi2().

◆ trk_bestSimTrkShareFrac_

std::vector<float>* Trktree::trk_bestSimTrkShareFrac_

protected

Definition at line 647 of file Trktree.h.

Referenced by Init(), and trk_bestSimTrkShareFrac().

◆ trk_bestSimTrkShareFrac_branch

TBranch* Trktree::trk_bestSimTrkShareFrac_branch

protected

Definition at line 648 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_bestSimTrkShareFrac().

◆ trk_bestSimTrkShareFrac_isLoaded

bool Trktree::trk_bestSimTrkShareFrac_isLoaded

protected

Definition at line 649 of file Trktree.h.

Referenced by GetEntry(), and trk_bestSimTrkShareFrac().

◆ trk_bestSimTrkShareFracSimClusterDenom_

std::vector<float>* Trktree::trk_bestSimTrkShareFracSimClusterDenom_

protected

Definition at line 152 of file Trktree.h.

Referenced by Init(), and trk_bestSimTrkShareFracSimClusterDenom().

◆ trk_bestSimTrkShareFracSimClusterDenom_branch

TBranch* Trktree::trk_bestSimTrkShareFracSimClusterDenom_branch

protected

Definition at line 153 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_bestSimTrkShareFracSimClusterDenom().

◆ trk_bestSimTrkShareFracSimClusterDenom_isLoaded

bool Trktree::trk_bestSimTrkShareFracSimClusterDenom_isLoaded

protected

Definition at line 154 of file Trktree.h.

Referenced by GetEntry(), and trk_bestSimTrkShareFracSimClusterDenom().

◆ trk_bestSimTrkShareFracSimDenom_

std::vector<float>* Trktree::trk_bestSimTrkShareFracSimDenom_

protected

Definition at line 395 of file Trktree.h.

Referenced by Init(), and trk_bestSimTrkShareFracSimDenom().

◆ trk_bestSimTrkShareFracSimDenom_branch

TBranch* Trktree::trk_bestSimTrkShareFracSimDenom_branch

protected

Definition at line 396 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_bestSimTrkShareFracSimDenom().

◆ trk_bestSimTrkShareFracSimDenom_isLoaded

bool Trktree::trk_bestSimTrkShareFracSimDenom_isLoaded

protected

Definition at line 397 of file Trktree.h.

Referenced by GetEntry(), and trk_bestSimTrkShareFracSimDenom().

◆ trk_cotTheta_

std::vector<float>* Trktree::trk_cotTheta_

protected

Definition at line 728 of file Trktree.h.

Referenced by Init(), and trk_cotTheta().

◆ trk_cotTheta_branch

TBranch* Trktree::trk_cotTheta_branch

protected

Definition at line 729 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_cotTheta().

◆ trk_cotTheta_isLoaded

bool Trktree::trk_cotTheta_isLoaded

protected

Definition at line 730 of file Trktree.h.

Referenced by GetEntry(), and trk_cotTheta().

◆ trk_dxy_

std::vector<float>* Trktree::trk_dxy_

protected

Definition at line 215 of file Trktree.h.

Referenced by Init(), and trk_dxy().

◆ trk_dxy_branch

TBranch* Trktree::trk_dxy_branch

protected

Definition at line 216 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_dxy().

◆ trk_dxy_isLoaded

bool Trktree::trk_dxy_isLoaded

protected

Definition at line 217 of file Trktree.h.

Referenced by GetEntry(), and trk_dxy().

◆ trk_dxyClosestPV_

std::vector<float>* Trktree::trk_dxyClosestPV_

protected

Definition at line 278 of file Trktree.h.

Referenced by Init(), and trk_dxyClosestPV().

◆ trk_dxyClosestPV_branch

TBranch* Trktree::trk_dxyClosestPV_branch

protected

Definition at line 279 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_dxyClosestPV().

◆ trk_dxyClosestPV_isLoaded

bool Trktree::trk_dxyClosestPV_isLoaded

protected

Definition at line 280 of file Trktree.h.

Referenced by GetEntry(), and trk_dxyClosestPV().

◆ trk_dxyErr_

std::vector<float>* Trktree::trk_dxyErr_

protected

Definition at line 914 of file Trktree.h.

Referenced by Init(), and trk_dxyErr().

◆ trk_dxyErr_branch

TBranch* Trktree::trk_dxyErr_branch

protected

Definition at line 915 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_dxyErr().

◆ trk_dxyErr_isLoaded

bool Trktree::trk_dxyErr_isLoaded

protected

Definition at line 916 of file Trktree.h.

Referenced by GetEntry(), and trk_dxyErr().

◆ trk_dxyPV_

std::vector<float>* Trktree::trk_dxyPV_

protected

Definition at line 38 of file Trktree.h.

Referenced by Init(), and trk_dxyPV().

◆ trk_dxyPV_branch

TBranch* Trktree::trk_dxyPV_branch

protected

Definition at line 39 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_dxyPV().

◆ trk_dxyPV_isLoaded

bool Trktree::trk_dxyPV_isLoaded

protected

Definition at line 40 of file Trktree.h.

Referenced by GetEntry(), and trk_dxyPV().

◆ trk_dz_

std::vector<float>* Trktree::trk_dz_

protected

Definition at line 50 of file Trktree.h.

Referenced by Init(), and trk_dz().

◆ trk_dz_branch

TBranch* Trktree::trk_dz_branch

protected

Definition at line 51 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_dz().

◆ trk_dz_isLoaded

bool Trktree::trk_dz_isLoaded

protected

Definition at line 52 of file Trktree.h.

Referenced by GetEntry(), and trk_dz().

◆ trk_dzClosestPV_

std::vector<float>* Trktree::trk_dzClosestPV_

protected

Definition at line 503 of file Trktree.h.

Referenced by Init(), and trk_dzClosestPV().

◆ trk_dzClosestPV_branch

TBranch* Trktree::trk_dzClosestPV_branch

protected

Definition at line 504 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_dzClosestPV().

◆ trk_dzClosestPV_isLoaded

bool Trktree::trk_dzClosestPV_isLoaded

protected

Definition at line 505 of file Trktree.h.

Referenced by GetEntry(), and trk_dzClosestPV().

◆ trk_dzErr_

std::vector<float>* Trktree::trk_dzErr_

protected

Definition at line 185 of file Trktree.h.

Referenced by Init(), and trk_dzErr().

◆ trk_dzErr_branch

TBranch* Trktree::trk_dzErr_branch

protected

Definition at line 186 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_dzErr().

◆ trk_dzErr_isLoaded

bool Trktree::trk_dzErr_isLoaded

protected

Definition at line 187 of file Trktree.h.

Referenced by GetEntry(), and trk_dzErr().

◆ trk_dzPV_

std::vector<float>* Trktree::trk_dzPV_

protected

Definition at line 782 of file Trktree.h.

Referenced by Init(), and trk_dzPV().

◆ trk_dzPV_branch

TBranch* Trktree::trk_dzPV_branch

protected

Definition at line 783 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_dzPV().

◆ trk_dzPV_isLoaded

bool Trktree::trk_dzPV_isLoaded

protected

Definition at line 784 of file Trktree.h.

Referenced by GetEntry(), and trk_dzPV().

◆ trk_eta_

std::vector<float>* Trktree::trk_eta_

protected

Definition at line 239 of file Trktree.h.

Referenced by Init(), and trk_eta().

◆ trk_eta_branch

TBranch* Trktree::trk_eta_branch

protected

Definition at line 240 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_eta().

◆ trk_eta_isLoaded

bool Trktree::trk_eta_isLoaded

protected

Definition at line 241 of file Trktree.h.

Referenced by GetEntry(), and trk_eta().

◆ trk_etaErr_

std::vector<float>* Trktree::trk_etaErr_

protected

Definition at line 629 of file Trktree.h.

Referenced by Init(), and trk_etaErr().

◆ trk_etaErr_branch

TBranch* Trktree::trk_etaErr_branch

protected

Definition at line 630 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_etaErr().

◆ trk_etaErr_isLoaded

bool Trktree::trk_etaErr_isLoaded

protected

Definition at line 631 of file Trktree.h.

Referenced by GetEntry(), and trk_etaErr().

◆ trk_hitIdx_

std::vector<std::vector<int> >* Trktree::trk_hitIdx_

protected

Definition at line 512 of file Trktree.h.

Referenced by Init(), and trk_hitIdx().

◆ trk_hitIdx_branch

TBranch* Trktree::trk_hitIdx_branch

protected

Definition at line 513 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_hitIdx().

◆ trk_hitIdx_isLoaded

bool Trktree::trk_hitIdx_isLoaded

protected

Definition at line 514 of file Trktree.h.

Referenced by GetEntry(), and trk_hitIdx().

◆ trk_hitType_

std::vector<std::vector<int> >* Trktree::trk_hitType_

protected

Definition at line 473 of file Trktree.h.

Referenced by Init(), and trk_hitType().

◆ trk_hitType_branch

TBranch* Trktree::trk_hitType_branch

protected

Definition at line 474 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_hitType().

◆ trk_hitType_isLoaded

bool Trktree::trk_hitType_isLoaded

protected

Definition at line 475 of file Trktree.h.

Referenced by GetEntry(), and trk_hitType().

◆ trk_inner_pt_

std::vector<float>* Trktree::trk_inner_pt_

protected

Definition at line 923 of file Trktree.h.

Referenced by Init(), and trk_inner_pt().

◆ trk_inner_pt_branch

TBranch* Trktree::trk_inner_pt_branch

protected

Definition at line 924 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_inner_pt().

◆ trk_inner_pt_isLoaded

bool Trktree::trk_inner_pt_isLoaded

protected

Definition at line 925 of file Trktree.h.

Referenced by GetEntry(), and trk_inner_pt().

◆ trk_inner_px_

std::vector<float>* Trktree::trk_inner_px_

protected

Definition at line 911 of file Trktree.h.

Referenced by Init(), and trk_inner_px().

◆ trk_inner_px_branch

TBranch* Trktree::trk_inner_px_branch

protected

Definition at line 912 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_inner_px().

◆ trk_inner_px_isLoaded

bool Trktree::trk_inner_px_isLoaded

protected

Definition at line 913 of file Trktree.h.

Referenced by GetEntry(), and trk_inner_px().

◆ trk_inner_py_

std::vector<float>* Trktree::trk_inner_py_

protected

Definition at line 908 of file Trktree.h.

Referenced by Init(), and trk_inner_py().

◆ trk_inner_py_branch

TBranch* Trktree::trk_inner_py_branch

protected

Definition at line 909 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_inner_py().

◆ trk_inner_py_isLoaded

bool Trktree::trk_inner_py_isLoaded

protected

Definition at line 910 of file Trktree.h.

Referenced by GetEntry(), and trk_inner_py().

◆ trk_inner_pz_

std::vector<float>* Trktree::trk_inner_pz_

protected

Definition at line 809 of file Trktree.h.

Referenced by Init(), and trk_inner_pz().

◆ trk_inner_pz_branch

TBranch* Trktree::trk_inner_pz_branch

protected

Definition at line 810 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_inner_pz().

◆ trk_inner_pz_isLoaded

bool Trktree::trk_inner_pz_isLoaded

protected

Definition at line 811 of file Trktree.h.

Referenced by GetEntry(), and trk_inner_pz().

◆ trk_isHP_

std::vector<short>* Trktree::trk_isHP_

protected

Definition at line 140 of file Trktree.h.

Referenced by Init(), and trk_isHP().

◆ trk_isHP_branch

TBranch* Trktree::trk_isHP_branch

protected

Definition at line 141 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_isHP().

◆ trk_isHP_isLoaded

bool Trktree::trk_isHP_isLoaded

protected

Definition at line 142 of file Trktree.h.

Referenced by GetEntry(), and trk_isHP().

◆ trk_lambda_

std::vector<float>* Trktree::trk_lambda_

protected

Definition at line 221 of file Trktree.h.

Referenced by Init(), and trk_lambda().

◆ trk_lambda_branch

TBranch* Trktree::trk_lambda_branch

protected

Definition at line 222 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_lambda().

◆ trk_lambda_isLoaded

bool Trktree::trk_lambda_isLoaded

protected

Definition at line 223 of file Trktree.h.

Referenced by GetEntry(), and trk_lambda().

◆ trk_lambdaErr_

std::vector<float>* Trktree::trk_lambdaErr_

protected

Definition at line 650 of file Trktree.h.

Referenced by Init(), and trk_lambdaErr().

◆ trk_lambdaErr_branch

TBranch* Trktree::trk_lambdaErr_branch

protected

Definition at line 651 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_lambdaErr().

◆ trk_lambdaErr_isLoaded

bool Trktree::trk_lambdaErr_isLoaded

protected

Definition at line 652 of file Trktree.h.

Referenced by GetEntry(), and trk_lambdaErr().

◆ trk_mva_

std::vector<float>* Trktree::trk_mva_

protected

Definition at line 497 of file Trktree.h.

Referenced by Init(), and trk_mva().

◆ trk_mva_branch

TBranch* Trktree::trk_mva_branch

protected

Definition at line 498 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_mva().

◆ trk_mva_isLoaded

bool Trktree::trk_mva_isLoaded

protected

Definition at line 499 of file Trktree.h.

Referenced by GetEntry(), and trk_mva().

◆ trk_n3DLay_

std::vector<unsigned int>* Trktree::trk_n3DLay_

protected

Definition at line 539 of file Trktree.h.

Referenced by Init(), and trk_n3DLay().

◆ trk_n3DLay_branch

TBranch* Trktree::trk_n3DLay_branch

protected

Definition at line 540 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_n3DLay().

◆ trk_n3DLay_isLoaded

bool Trktree::trk_n3DLay_isLoaded

protected

Definition at line 541 of file Trktree.h.

Referenced by GetEntry(), and trk_n3DLay().

◆ trk_nChi2_

std::vector<float>* Trktree::trk_nChi2_

protected

Definition at line 377 of file Trktree.h.

Referenced by Init(), and trk_nChi2().

◆ trk_nChi2_1Dmod_

std::vector<float>* Trktree::trk_nChi2_1Dmod_

protected

Definition at line 905 of file Trktree.h.

Referenced by Init(), and trk_nChi2_1Dmod().

◆ trk_nChi2_1Dmod_branch

TBranch* Trktree::trk_nChi2_1Dmod_branch

protected

Definition at line 906 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_nChi2_1Dmod().

◆ trk_nChi2_1Dmod_isLoaded

bool Trktree::trk_nChi2_1Dmod_isLoaded

protected

Definition at line 907 of file Trktree.h.

Referenced by GetEntry(), and trk_nChi2_1Dmod().

◆ trk_nChi2_branch

TBranch* Trktree::trk_nChi2_branch

protected

Definition at line 378 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_nChi2().

◆ trk_nChi2_isLoaded

bool Trktree::trk_nChi2_isLoaded

protected

Definition at line 379 of file Trktree.h.

Referenced by GetEntry(), and trk_nChi2().

◆ trk_nCluster_

std::vector<unsigned int>* Trktree::trk_nCluster_

protected

Definition at line 134 of file Trktree.h.

Referenced by Init(), and trk_nCluster().

◆ trk_nCluster_branch

TBranch* Trktree::trk_nCluster_branch

protected

Definition at line 135 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_nCluster().

◆ trk_nCluster_isLoaded

bool Trktree::trk_nCluster_isLoaded

protected

Definition at line 136 of file Trktree.h.

Referenced by GetEntry(), and trk_nCluster().

◆ trk_ndof_

std::vector<float>* Trktree::trk_ndof_

protected

Definition at line 413 of file Trktree.h.

Referenced by Init(), and trk_ndof().

◆ trk_ndof_branch

TBranch* Trktree::trk_ndof_branch

protected

Definition at line 414 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_ndof().

◆ trk_ndof_isLoaded

bool Trktree::trk_ndof_isLoaded

protected

Definition at line 415 of file Trktree.h.

Referenced by GetEntry(), and trk_ndof().

◆ trk_nInactive_

std::vector<unsigned int>* Trktree::trk_nInactive_

protected

Definition at line 698 of file Trktree.h.

Referenced by Init(), and trk_nInactive().

◆ trk_nInactive_branch

TBranch* Trktree::trk_nInactive_branch

protected

Definition at line 699 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_nInactive().

◆ trk_nInactive_isLoaded

bool Trktree::trk_nInactive_isLoaded

protected

Definition at line 700 of file Trktree.h.

Referenced by GetEntry(), and trk_nInactive().

◆ trk_nInnerInactive_

std::vector<unsigned int>* Trktree::trk_nInnerInactive_

protected

Definition at line 188 of file Trktree.h.

Referenced by Init(), and trk_nInnerInactive().

◆ trk_nInnerInactive_branch

TBranch* Trktree::trk_nInnerInactive_branch

protected

Definition at line 189 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_nInnerInactive().

◆ trk_nInnerInactive_isLoaded

bool Trktree::trk_nInnerInactive_isLoaded

protected

Definition at line 190 of file Trktree.h.

Referenced by GetEntry(), and trk_nInnerInactive().

◆ trk_nInnerLost_

std::vector<unsigned int>* Trktree::trk_nInnerLost_

protected

Definition at line 89 of file Trktree.h.

Referenced by Init(), and trk_nInnerLost().

◆ trk_nInnerLost_branch

TBranch* Trktree::trk_nInnerLost_branch

protected

Definition at line 90 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_nInnerLost().

◆ trk_nInnerLost_isLoaded

bool Trktree::trk_nInnerLost_isLoaded

protected

Definition at line 91 of file Trktree.h.

Referenced by GetEntry(), and trk_nInnerLost().

◆ trk_nLost_

std::vector<unsigned int>* Trktree::trk_nLost_

protected

Definition at line 98 of file Trktree.h.

Referenced by Init(), and trk_nLost().

◆ trk_nLost_branch

TBranch* Trktree::trk_nLost_branch

protected

Definition at line 99 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_nLost().

◆ trk_nLost_isLoaded

bool Trktree::trk_nLost_isLoaded

protected

Definition at line 100 of file Trktree.h.

Referenced by GetEntry(), and trk_nLost().

◆ trk_nLostLay_

std::vector<unsigned int>* Trktree::trk_nLostLay_

protected

Definition at line 752 of file Trktree.h.

Referenced by Init(), and trk_nLostLay().

◆ trk_nLostLay_branch

TBranch* Trktree::trk_nLostLay_branch

protected

Definition at line 753 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_nLostLay().

◆ trk_nLostLay_isLoaded

bool Trktree::trk_nLostLay_isLoaded

protected

Definition at line 754 of file Trktree.h.

Referenced by GetEntry(), and trk_nLostLay().

◆ trk_nOuterInactive_

std::vector<unsigned int>* Trktree::trk_nOuterInactive_

protected

Definition at line 464 of file Trktree.h.

Referenced by Init(), and trk_nOuterInactive().

◆ trk_nOuterInactive_branch

TBranch* Trktree::trk_nOuterInactive_branch

protected

Definition at line 465 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_nOuterInactive().

◆ trk_nOuterInactive_isLoaded

bool Trktree::trk_nOuterInactive_isLoaded

protected

Definition at line 466 of file Trktree.h.

Referenced by GetEntry(), and trk_nOuterInactive().

◆ trk_nOuterLost_

std::vector<unsigned int>* Trktree::trk_nOuterLost_

protected

Definition at line 431 of file Trktree.h.

Referenced by Init(), and trk_nOuterLost().

◆ trk_nOuterLost_branch

TBranch* Trktree::trk_nOuterLost_branch

protected

Definition at line 432 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_nOuterLost().

◆ trk_nOuterLost_isLoaded

bool Trktree::trk_nOuterLost_isLoaded

protected

Definition at line 433 of file Trktree.h.

Referenced by GetEntry(), and trk_nOuterLost().

◆ trk_nPixel_

std::vector<unsigned int>* Trktree::trk_nPixel_

protected

Definition at line 341 of file Trktree.h.

Referenced by Init(), and trk_nPixel().

◆ trk_nPixel_branch

TBranch* Trktree::trk_nPixel_branch

protected

Definition at line 342 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_nPixel().

◆ trk_nPixel_isLoaded

bool Trktree::trk_nPixel_isLoaded

protected

Definition at line 343 of file Trktree.h.

Referenced by GetEntry(), and trk_nPixel().

◆ trk_nPixelLay_

std::vector<unsigned int>* Trktree::trk_nPixelLay_

protected

Definition at line 701 of file Trktree.h.

Referenced by Init(), and trk_nPixelLay().

◆ trk_nPixelLay_branch

TBranch* Trktree::trk_nPixelLay_branch

protected

Definition at line 702 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_nPixelLay().

◆ trk_nPixelLay_isLoaded

bool Trktree::trk_nPixelLay_isLoaded

protected

Definition at line 703 of file Trktree.h.

Referenced by GetEntry(), and trk_nPixelLay().

◆ trk_nStrip_

std::vector<unsigned int>* Trktree::trk_nStrip_

protected

Definition at line 626 of file Trktree.h.

Referenced by Init(), and trk_nStrip().

◆ trk_nStrip_branch

TBranch* Trktree::trk_nStrip_branch

protected

Definition at line 627 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_nStrip().

◆ trk_nStrip_isLoaded

bool Trktree::trk_nStrip_isLoaded

protected

Definition at line 628 of file Trktree.h.

Referenced by GetEntry(), and trk_nStrip().

◆ trk_nStripLay_

std::vector<unsigned int>* Trktree::trk_nStripLay_

protected

Definition at line 122 of file Trktree.h.

Referenced by Init(), and trk_nStripLay().

◆ trk_nStripLay_branch

TBranch* Trktree::trk_nStripLay_branch

protected

Definition at line 123 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_nStripLay().

◆ trk_nStripLay_isLoaded

bool Trktree::trk_nStripLay_isLoaded

protected

Definition at line 124 of file Trktree.h.

Referenced by GetEntry(), and trk_nStripLay().

◆ trk_nValid_

std::vector<unsigned int>* Trktree::trk_nValid_

protected

Definition at line 542 of file Trktree.h.

Referenced by Init(), and trk_nValid().

◆ trk_nValid_branch

TBranch* Trktree::trk_nValid_branch

protected

Definition at line 543 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_nValid().

◆ trk_nValid_isLoaded

bool Trktree::trk_nValid_isLoaded

protected

Definition at line 544 of file Trktree.h.

Referenced by GetEntry(), and trk_nValid().

◆ trk_originalAlgo_

std::vector<unsigned int>* Trktree::trk_originalAlgo_

protected

Definition at line 338 of file Trktree.h.

Referenced by Init(), and trk_originalAlgo().

◆ trk_originalAlgo_branch

TBranch* Trktree::trk_originalAlgo_branch

protected

Definition at line 339 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_originalAlgo().

◆ trk_originalAlgo_isLoaded

bool Trktree::trk_originalAlgo_isLoaded

protected

Definition at line 340 of file Trktree.h.

Referenced by GetEntry(), and trk_originalAlgo().

◆ trk_outer_pt_

std::vector<float>* Trktree::trk_outer_pt_

protected

Definition at line 536 of file Trktree.h.

Referenced by Init(), and trk_outer_pt().

◆ trk_outer_pt_branch

TBranch* Trktree::trk_outer_pt_branch

protected

Definition at line 537 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_outer_pt().

◆ trk_outer_pt_isLoaded

bool Trktree::trk_outer_pt_isLoaded

protected

Definition at line 538 of file Trktree.h.

Referenced by GetEntry(), and trk_outer_pt().

◆ trk_outer_px_

std::vector<float>* Trktree::trk_outer_px_

protected

Definition at line 524 of file Trktree.h.

Referenced by Init(), and trk_outer_px().

◆ trk_outer_px_branch

TBranch* Trktree::trk_outer_px_branch

protected

Definition at line 525 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_outer_px().

◆ trk_outer_px_isLoaded

bool Trktree::trk_outer_px_isLoaded

protected

Definition at line 526 of file Trktree.h.

Referenced by GetEntry(), and trk_outer_px().

◆ trk_outer_py_

std::vector<float>* Trktree::trk_outer_py_

protected

Definition at line 527 of file Trktree.h.

Referenced by Init(), and trk_outer_py().

◆ trk_outer_py_branch

TBranch* Trktree::trk_outer_py_branch

protected

Definition at line 528 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_outer_py().

◆ trk_outer_py_isLoaded

bool Trktree::trk_outer_py_isLoaded

protected

Definition at line 529 of file Trktree.h.

Referenced by GetEntry(), and trk_outer_py().

◆ trk_outer_pz_

std::vector<float>* Trktree::trk_outer_pz_

protected

Definition at line 530 of file Trktree.h.

Referenced by Init(), and trk_outer_pz().

◆ trk_outer_pz_branch

TBranch* Trktree::trk_outer_pz_branch

protected

Definition at line 531 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_outer_pz().

◆ trk_outer_pz_isLoaded

bool Trktree::trk_outer_pz_isLoaded

protected

Definition at line 532 of file Trktree.h.

Referenced by GetEntry(), and trk_outer_pz().

◆ trk_phi_

std::vector<float>* Trktree::trk_phi_

protected

Definition at line 26 of file Trktree.h.

Referenced by Init(), and trk_phi().

◆ trk_phi_branch

TBranch* Trktree::trk_phi_branch

protected

Definition at line 27 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_phi().

◆ trk_phi_isLoaded

bool Trktree::trk_phi_isLoaded

protected

Definition at line 28 of file Trktree.h.

Referenced by GetEntry(), and trk_phi().

◆ trk_phiErr_

std::vector<float>* Trktree::trk_phiErr_

protected

Definition at line 350 of file Trktree.h.

Referenced by Init(), and trk_phiErr().

◆ trk_phiErr_branch

TBranch* Trktree::trk_phiErr_branch

protected

Definition at line 351 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_phiErr().

◆ trk_phiErr_isLoaded

bool Trktree::trk_phiErr_isLoaded

protected

Definition at line 352 of file Trktree.h.

Referenced by GetEntry(), and trk_phiErr().

◆ trk_pt_

std::vector<float>* Trktree::trk_pt_

protected

Definition at line 593 of file Trktree.h.

Referenced by Init(), and trk_pt().

◆ trk_pt_branch

TBranch* Trktree::trk_pt_branch

protected

Definition at line 594 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_pt().

◆ trk_pt_isLoaded

bool Trktree::trk_pt_isLoaded

protected

Definition at line 595 of file Trktree.h.

Referenced by GetEntry(), and trk_pt().

◆ trk_ptErr_

std::vector<float>* Trktree::trk_ptErr_

protected

Definition at line 875 of file Trktree.h.

Referenced by Init(), and trk_ptErr().

◆ trk_ptErr_branch

TBranch* Trktree::trk_ptErr_branch

protected

Definition at line 876 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_ptErr().

◆ trk_ptErr_isLoaded

bool Trktree::trk_ptErr_isLoaded

protected

Definition at line 877 of file Trktree.h.

Referenced by GetEntry(), and trk_ptErr().

◆ trk_px_

std::vector<float>* Trktree::trk_px_

protected

Definition at line 575 of file Trktree.h.

Referenced by Init(), and trk_px().

◆ trk_px_branch

TBranch* Trktree::trk_px_branch

protected

Definition at line 576 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_px().

◆ trk_px_isLoaded

bool Trktree::trk_px_isLoaded

protected

Definition at line 577 of file Trktree.h.

Referenced by GetEntry(), and trk_px().

◆ trk_py_

std::vector<float>* Trktree::trk_py_

protected

Definition at line 578 of file Trktree.h.

Referenced by Init(), and trk_py().

◆ trk_py_branch

TBranch* Trktree::trk_py_branch

protected

Definition at line 579 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_py().

◆ trk_py_isLoaded

bool Trktree::trk_py_isLoaded

protected

Definition at line 580 of file Trktree.h.

Referenced by GetEntry(), and trk_py().

◆ trk_pz_

std::vector<float>* Trktree::trk_pz_

protected

Definition at line 569 of file Trktree.h.

Referenced by Init(), and trk_pz().

◆ trk_pz_branch

TBranch* Trktree::trk_pz_branch

protected

Definition at line 570 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_pz().

◆ trk_pz_isLoaded

bool Trktree::trk_pz_isLoaded

protected

Definition at line 571 of file Trktree.h.

Referenced by GetEntry(), and trk_pz().

◆ trk_q_

std::vector<int>* Trktree::trk_q_

protected

Definition at line 359 of file Trktree.h.

Referenced by Init(), and trk_q().

◆ trk_q_branch

TBranch* Trktree::trk_q_branch

protected

Definition at line 360 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_q().

◆ trk_q_isLoaded

bool Trktree::trk_q_isLoaded

protected

Definition at line 361 of file Trktree.h.

Referenced by GetEntry(), and trk_q().

◆ trk_qualityMask_

std::vector<unsigned short>* Trktree::trk_qualityMask_

protected

Definition at line 410 of file Trktree.h.

Referenced by Init(), and trk_qualityMask().

◆ trk_qualityMask_branch

TBranch* Trktree::trk_qualityMask_branch

protected

Definition at line 411 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_qualityMask().

◆ trk_qualityMask_isLoaded

bool Trktree::trk_qualityMask_isLoaded

protected

Definition at line 412 of file Trktree.h.

Referenced by GetEntry(), and trk_qualityMask().

◆ trk_refpoint_x_

std::vector<float>* Trktree::trk_refpoint_x_

protected

Definition at line 848 of file Trktree.h.

Referenced by Init(), and trk_refpoint_x().

◆ trk_refpoint_x_branch

TBranch* Trktree::trk_refpoint_x_branch

protected

Definition at line 849 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_refpoint_x().

◆ trk_refpoint_x_isLoaded

bool Trktree::trk_refpoint_x_isLoaded

protected

Definition at line 850 of file Trktree.h.

Referenced by GetEntry(), and trk_refpoint_x().

◆ trk_refpoint_y_

std::vector<float>* Trktree::trk_refpoint_y_

protected

Definition at line 851 of file Trktree.h.

Referenced by Init(), and trk_refpoint_y().

◆ trk_refpoint_y_branch

TBranch* Trktree::trk_refpoint_y_branch

protected

Definition at line 852 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_refpoint_y().

◆ trk_refpoint_y_isLoaded

bool Trktree::trk_refpoint_y_isLoaded

protected

Definition at line 853 of file Trktree.h.

Referenced by GetEntry(), and trk_refpoint_y().

◆ trk_refpoint_z_

std::vector<float>* Trktree::trk_refpoint_z_

protected

Definition at line 854 of file Trktree.h.

Referenced by Init(), and trk_refpoint_z().

◆ trk_refpoint_z_branch

TBranch* Trktree::trk_refpoint_z_branch

protected

Definition at line 855 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_refpoint_z().

◆ trk_refpoint_z_isLoaded

bool Trktree::trk_refpoint_z_isLoaded

protected

Definition at line 856 of file Trktree.h.

Referenced by GetEntry(), and trk_refpoint_z().

◆ trk_seedIdx_

std::vector<int>* Trktree::trk_seedIdx_

protected

Definition at line 743 of file Trktree.h.

Referenced by Init(), and trk_seedIdx().

◆ trk_seedIdx_branch

TBranch* Trktree::trk_seedIdx_branch

protected

Definition at line 744 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_seedIdx().

◆ trk_seedIdx_isLoaded

bool Trktree::trk_seedIdx_isLoaded

protected

Definition at line 745 of file Trktree.h.

Referenced by GetEntry(), and trk_seedIdx().

◆ trk_simTrkIdx_

std::vector<std::vector<int> >* Trktree::trk_simTrkIdx_

protected

Definition at line 722 of file Trktree.h.

Referenced by Init(), and trk_simTrkIdx().

◆ trk_simTrkIdx_branch

TBranch* Trktree::trk_simTrkIdx_branch

protected

Definition at line 723 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_simTrkIdx().

◆ trk_simTrkIdx_isLoaded

bool Trktree::trk_simTrkIdx_isLoaded

protected

Definition at line 724 of file Trktree.h.

Referenced by GetEntry(), and trk_simTrkIdx().

◆ trk_simTrkNChi2_

std::vector<std::vector<float> >* Trktree::trk_simTrkNChi2_

protected

Definition at line 632 of file Trktree.h.

Referenced by Init(), and trk_simTrkNChi2().

◆ trk_simTrkNChi2_branch

TBranch* Trktree::trk_simTrkNChi2_branch

protected

Definition at line 633 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_simTrkNChi2().

◆ trk_simTrkNChi2_isLoaded

bool Trktree::trk_simTrkNChi2_isLoaded

protected

Definition at line 634 of file Trktree.h.

Referenced by GetEntry(), and trk_simTrkNChi2().

◆ trk_simTrkShareFrac_

std::vector<std::vector<float> >* Trktree::trk_simTrkShareFrac_

protected

Definition at line 686 of file Trktree.h.

Referenced by Init(), and trk_simTrkShareFrac().

◆ trk_simTrkShareFrac_branch

TBranch* Trktree::trk_simTrkShareFrac_branch

protected

Definition at line 687 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_simTrkShareFrac().

◆ trk_simTrkShareFrac_isLoaded

bool Trktree::trk_simTrkShareFrac_isLoaded

protected

Definition at line 688 of file Trktree.h.

Referenced by GetEntry(), and trk_simTrkShareFrac().

◆ trk_stopReason_

std::vector<unsigned short>* Trktree::trk_stopReason_

protected

Definition at line 260 of file Trktree.h.

Referenced by Init(), and trk_stopReason().

◆ trk_stopReason_branch

TBranch* Trktree::trk_stopReason_branch

protected

Definition at line 261 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_stopReason().

◆ trk_stopReason_isLoaded

bool Trktree::trk_stopReason_isLoaded

protected

Definition at line 262 of file Trktree.h.

Referenced by GetEntry(), and trk_stopReason().

◆ trk_vtxIdx_

std::vector<int>* Trktree::trk_vtxIdx_

protected

Definition at line 581 of file Trktree.h.

Referenced by Init(), and trk_vtxIdx().

◆ trk_vtxIdx_branch

TBranch* Trktree::trk_vtxIdx_branch

protected

Definition at line 582 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and trk_vtxIdx().

◆ trk_vtxIdx_isLoaded

bool Trktree::trk_vtxIdx_isLoaded

protected

Definition at line 583 of file Trktree.h.

Referenced by GetEntry(), and trk_vtxIdx().

◆ vtx_chi2_

std::vector<float>* Trktree::vtx_chi2_

protected

Definition at line 587 of file Trktree.h.

Referenced by Init(), and vtx_chi2().

◆ vtx_chi2_branch

TBranch* Trktree::vtx_chi2_branch

protected

Definition at line 588 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and vtx_chi2().

◆ vtx_chi2_isLoaded

bool Trktree::vtx_chi2_isLoaded

protected

Definition at line 589 of file Trktree.h.

Referenced by GetEntry(), and vtx_chi2().

◆ vtx_fake_

std::vector<short>* Trktree::vtx_fake_

protected

Definition at line 695 of file Trktree.h.

Referenced by Init(), and vtx_fake().

◆ vtx_fake_branch

TBranch* Trktree::vtx_fake_branch

protected

Definition at line 696 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and vtx_fake().

◆ vtx_fake_isLoaded

bool Trktree::vtx_fake_isLoaded

protected

Definition at line 697 of file Trktree.h.

Referenced by GetEntry(), and vtx_fake().

◆ vtx_ndof_

std::vector<float>* Trktree::vtx_ndof_

protected

Definition at line 665 of file Trktree.h.

Referenced by Init(), and vtx_ndof().

◆ vtx_ndof_branch

TBranch* Trktree::vtx_ndof_branch

protected

Definition at line 666 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and vtx_ndof().

◆ vtx_ndof_isLoaded

bool Trktree::vtx_ndof_isLoaded

protected

Definition at line 667 of file Trktree.h.

Referenced by GetEntry(), and vtx_ndof().

◆ vtx_trkIdx_

std::vector<std::vector<int> >* Trktree::vtx_trkIdx_

protected

Definition at line 659 of file Trktree.h.

Referenced by Init(), and vtx_trkIdx().

◆ vtx_trkIdx_branch

TBranch* Trktree::vtx_trkIdx_branch

protected

Definition at line 660 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and vtx_trkIdx().

◆ vtx_trkIdx_isLoaded

bool Trktree::vtx_trkIdx_isLoaded

protected

Definition at line 661 of file Trktree.h.

Referenced by GetEntry(), and vtx_trkIdx().

◆ vtx_valid_

std::vector<short>* Trktree::vtx_valid_

protected

Definition at line 842 of file Trktree.h.

Referenced by Init(), and vtx_valid().

◆ vtx_valid_branch

TBranch* Trktree::vtx_valid_branch

protected

Definition at line 843 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and vtx_valid().

◆ vtx_valid_isLoaded

bool Trktree::vtx_valid_isLoaded

protected

Definition at line 844 of file Trktree.h.

Referenced by GetEntry(), and vtx_valid().

◆ vtx_x_

std::vector<float>* Trktree::vtx_x_

protected

Definition at line 740 of file Trktree.h.

Referenced by Init(), and vtx_x().

◆ vtx_x_branch

TBranch* Trktree::vtx_x_branch

protected

Definition at line 741 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and vtx_x().

◆ vtx_x_isLoaded

bool Trktree::vtx_x_isLoaded

protected

Definition at line 742 of file Trktree.h.

Referenced by GetEntry(), and vtx_x().

◆ vtx_xErr_

std::vector<float>* Trktree::vtx_xErr_

protected

Definition at line 707 of file Trktree.h.

Referenced by Init(), and vtx_xErr().

◆ vtx_xErr_branch

TBranch* Trktree::vtx_xErr_branch

protected

Definition at line 708 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and vtx_xErr().

◆ vtx_xErr_isLoaded

bool Trktree::vtx_xErr_isLoaded

protected

Definition at line 709 of file Trktree.h.

Referenced by GetEntry(), and vtx_xErr().

◆ vtx_y_

std::vector<float>* Trktree::vtx_y_

protected

Definition at line 443 of file Trktree.h.

Referenced by Init(), and vtx_y().

◆ vtx_y_branch

TBranch* Trktree::vtx_y_branch

protected

Definition at line 444 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and vtx_y().

◆ vtx_y_isLoaded

bool Trktree::vtx_y_isLoaded

protected

Definition at line 445 of file Trktree.h.

Referenced by GetEntry(), and vtx_y().

◆ vtx_yErr_

std::vector<float>* Trktree::vtx_yErr_

protected

Definition at line 779 of file Trktree.h.

Referenced by Init(), and vtx_yErr().

◆ vtx_yErr_branch

TBranch* Trktree::vtx_yErr_branch

protected

Definition at line 780 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and vtx_yErr().

◆ vtx_yErr_isLoaded

bool Trktree::vtx_yErr_isLoaded

protected

Definition at line 781 of file Trktree.h.

Referenced by GetEntry(), and vtx_yErr().

◆ vtx_z_

std::vector<float>* Trktree::vtx_z_

protected

Definition at line 437 of file Trktree.h.

Referenced by Init(), and vtx_z().

◆ vtx_z_branch

TBranch* Trktree::vtx_z_branch

protected

Definition at line 438 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and vtx_z().

◆ vtx_z_isLoaded

bool Trktree::vtx_z_isLoaded

protected

Definition at line 439 of file Trktree.h.

Referenced by GetEntry(), and vtx_z().

◆ vtx_zErr_

std::vector<float>* Trktree::vtx_zErr_

protected

Definition at line 602 of file Trktree.h.

Referenced by Init(), and vtx_zErr().

◆ vtx_zErr_branch

TBranch* Trktree::vtx_zErr_branch

protected

Definition at line 603 of file Trktree.h.

Referenced by Init(), LoadAllBranches(), and vtx_zErr().

◆ vtx_zErr_isLoaded

bool Trktree::vtx_zErr_isLoaded

protected

Definition at line 604 of file Trktree.h.

Referenced by GetEntry(), and vtx_zErr().

Public Member Functions

Static Public Member Functions

Protected Attributes

Detailed Description

Member Function Documentation

◆ bsp_sigmax()

◆ bsp_sigmay()

◆ bsp_sigmaz()

◆ bsp_x()

◆ bsp_y()

◆ bsp_z()

◆ event()

◆ GetEntry()

◆ Init()

◆ inv_blade()

◆ inv_detId()

◆ inv_isBarrel()

◆ inv_isLower()

◆ inv_isStack()

◆ inv_isUpper()

◆ inv_ladder()

◆ inv_layer()

◆ inv_module()

◆ inv_order()

◆ inv_panel()

◆ inv_ring()

◆ inv_rod()

◆ inv_side()

◆ inv_subdet()

◆ inv_type()

◆ LoadAllBranches()

◆ lumi()

◆ ph2_bbxi()

◆ ph2_detId()

◆ ph2_isBarrel()

◆ ph2_isLower()

◆ ph2_isStack()

◆ ph2_isUpper()

◆ ph2_layer()

◆ ph2_module()

◆ ph2_order()

◆ ph2_radL()

◆ ph2_ring()

◆ ph2_rod()

◆ ph2_seeIdx()

◆ ph2_side()

◆ ph2_simHitIdx()

◆ ph2_simType()

◆ ph2_subdet()

◆ ph2_trkIdx()

◆ ph2_x()

◆ ph2_xx()

◆ ph2_xy()

◆ ph2_xySignificance()

◆ ph2_y()

◆ ph2_yy()

◆ ph2_yz()

◆ ph2_z()

◆ ph2_zx()

◆ ph2_zz()

◆ pix_bbxi()

◆ pix_blade()

◆ pix_chargeFraction()

◆ pix_detId()

◆ pix_isBarrel()

◆ pix_ladder()

◆ pix_layer()

◆ pix_module()

◆ pix_panel()

◆ pix_radL()

◆ pix_seeIdx()

◆ pix_side()

◆ pix_simHitIdx()

◆ pix_simType()

◆ pix_subdet()

◆ pix_trkIdx()

◆ pix_x()

◆ pix_xx()

◆ pix_xy()

◆ pix_xySignificance()