#include <LSTEff.h>

Public Member Functions
void	GetEntry (unsigned int idx)

void	Init (TTree *tree)

void	LoadAllBranches ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const int &	pT3_occupancies ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const int &	pT5_occupancies ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const std::vector< bool > &	sim_isGood ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const int &	tc_occupancies ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Protected Attributes
unsigned int	index

std::vector< int > *	md_occupancies_

TBranch *	md_occupancies_branch

bool	md_occupancies_isLoaded

std::vector< int > *	module_layers_

TBranch *	module_layers_branch

bool	module_layers_isLoaded

std::vector< int > *	module_rings_

TBranch *	module_rings_branch

bool	module_rings_isLoaded

std::vector< int > *	module_subdets_

TBranch *	module_subdets_branch

bool	module_subdets_isLoaded

std::vector< float > *	pLS_eta_

TBranch *	pLS_eta_branch

bool	pLS_eta_isLoaded

std::vector< int > *	pLS_isDuplicate_

TBranch *	pLS_isDuplicate_branch

bool	pLS_isDuplicate_isLoaded

std::vector< int > *	pLS_isFake_

TBranch *	pLS_isFake_branch

bool	pLS_isFake_isLoaded

std::vector< float > *	pLS_phi_

TBranch *	pLS_phi_branch

bool	pLS_phi_isLoaded

std::vector< float > *	pLS_pt_

TBranch *	pLS_pt_branch

bool	pLS_pt_isLoaded

std::vector< float > *	pLS_score_

TBranch *	pLS_score_branch

bool	pLS_score_isLoaded

std::vector< float > *	pT3_eta_

std::vector< float > *	pT3_eta_2_

TBranch *	pT3_eta_2_branch

bool	pT3_eta_2_isLoaded

TBranch *	pT3_eta_branch

bool	pT3_eta_isLoaded

std::vector< int > *	pT3_foundDuplicate_

TBranch *	pT3_foundDuplicate_branch

bool	pT3_foundDuplicate_isLoaded

std::vector< std::vector< int > > *	pT3_hitIdxs_

TBranch *	pT3_hitIdxs_branch

bool	pT3_hitIdxs_isLoaded

std::vector< int > *	pT3_isDuplicate_

TBranch *	pT3_isDuplicate_branch

bool	pT3_isDuplicate_isLoaded

std::vector< int > *	pT3_isFake_

TBranch *	pT3_isFake_branch

bool	pT3_isFake_isLoaded

std::vector< std::vector< int > > *	pT3_matched_simIdx_

TBranch *	pT3_matched_simIdx_branch

bool	pT3_matched_simIdx_isLoaded

int	pT3_occupancies_

TBranch *	pT3_occupancies_branch

bool	pT3_occupancies_isLoaded

std::vector< float > *	pT3_phi_

std::vector< float > *	pT3_phi_2_

TBranch *	pT3_phi_2_branch

bool	pT3_phi_2_isLoaded

TBranch *	pT3_phi_branch

bool	pT3_phi_isLoaded

std::vector< float > *	pT3_pt_

TBranch *	pT3_pt_branch

bool	pT3_pt_isLoaded

std::vector< float > *	pT3_score_

TBranch *	pT3_score_branch

bool	pT3_score_isLoaded

std::vector< float > *	pT4_eta_

TBranch *	pT4_eta_branch

bool	pT4_eta_isLoaded

std::vector< int > *	pT4_isDuplicate_

TBranch *	pT4_isDuplicate_branch

bool	pT4_isDuplicate_isLoaded

std::vector< int > *	pT4_isFake_

TBranch *	pT4_isFake_branch

bool	pT4_isFake_isLoaded

std::vector< float > *	pT4_phi_

TBranch *	pT4_phi_branch

bool	pT4_phi_isLoaded

std::vector< float > *	pT4_pt_

TBranch *	pT4_pt_branch

bool	pT4_pt_isLoaded

std::vector< float > *	pT5_eta_

TBranch *	pT5_eta_branch

bool	pT5_eta_isLoaded

std::vector< std::vector< int > > *	pT5_hitIdxs_

TBranch *	pT5_hitIdxs_branch

bool	pT5_hitIdxs_isLoaded

std::vector< int > *	pT5_isDuplicate_

TBranch *	pT5_isDuplicate_branch

bool	pT5_isDuplicate_isLoaded

std::vector< int > *	pT5_isFake_

TBranch *	pT5_isFake_branch

bool	pT5_isFake_isLoaded

std::vector< std::vector< int > > *	pT5_matched_simIdx_

TBranch *	pT5_matched_simIdx_branch

bool	pT5_matched_simIdx_isLoaded

int	pT5_occupancies_

TBranch *	pT5_occupancies_branch

bool	pT5_occupancies_isLoaded

std::vector< float > *	pT5_phi_

TBranch *	pT5_phi_branch

bool	pT5_phi_isLoaded

std::vector< float > *	pT5_pt_

TBranch *	pT5_pt_branch

bool	pT5_pt_isLoaded

std::vector< int > *	pT5_score_

TBranch *	pT5_score_branch

bool	pT5_score_isLoaded

std::vector< int > *	pureTCE_anchorIndex_

TBranch *	pureTCE_anchorIndex_branch

bool	pureTCE_anchorIndex_isLoaded

std::vector< int > *	pureTCE_anchorType_

TBranch *	pureTCE_anchorType_branch

bool	pureTCE_anchorType_isLoaded

std::vector< float > *	pureTCE_eta_

TBranch *	pureTCE_eta_branch

bool	pureTCE_eta_isLoaded

std::vector< std::vector< int > > *	pureTCE_hitIdxs_

TBranch *	pureTCE_hitIdxs_branch

bool	pureTCE_hitIdxs_isLoaded

std::vector< int > *	pureTCE_isDuplicate_

TBranch *	pureTCE_isDuplicate_branch

bool	pureTCE_isDuplicate_isLoaded

std::vector< int > *	pureTCE_isFake_

TBranch *	pureTCE_isFake_branch

bool	pureTCE_isFake_isLoaded

std::vector< int > *	pureTCE_layer_binary_

TBranch *	pureTCE_layer_binary_branch

bool	pureTCE_layer_binary_isLoaded

std::vector< std::vector< int > > *	pureTCE_matched_simIdx_

TBranch *	pureTCE_matched_simIdx_branch

bool	pureTCE_matched_simIdx_isLoaded

std::vector< int > *	pureTCE_maxHitMatchedCounts_

TBranch *	pureTCE_maxHitMatchedCounts_branch

bool	pureTCE_maxHitMatchedCounts_isLoaded

std::vector< std::vector< int > > *	pureTCE_nHitOverlaps_

TBranch *	pureTCE_nHitOverlaps_branch

bool	pureTCE_nHitOverlaps_isLoaded

std::vector< std::vector< int > > *	pureTCE_nLayerOverlaps_

TBranch *	pureTCE_nLayerOverlaps_branch

bool	pureTCE_nLayerOverlaps_isLoaded

std::vector< float > *	pureTCE_phi_

TBranch *	pureTCE_phi_branch

bool	pureTCE_phi_isLoaded

std::vector< float > *	pureTCE_pt_

TBranch *	pureTCE_pt_branch

bool	pureTCE_pt_isLoaded

std::vector< float > *	pureTCE_rPhiChiSquared_

TBranch *	pureTCE_rPhiChiSquared_branch

bool	pureTCE_rPhiChiSquared_isLoaded

std::vector< float > *	pureTCE_rzChiSquared_

TBranch *	pureTCE_rzChiSquared_branch

bool	pureTCE_rzChiSquared_isLoaded

std::vector< int > *	sg_occupancies_

TBranch *	sg_occupancies_branch

bool	sg_occupancies_isLoaded

std::vector< int > *	sim_bunchCrossing_

TBranch *	sim_bunchCrossing_branch

bool	sim_bunchCrossing_isLoaded

std::vector< int > *	sim_denom_

TBranch *	sim_denom_branch

bool	sim_denom_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< float > *	sim_hits_

TBranch *	sim_hits_branch

bool	sim_hits_isLoaded

std::vector< bool > *	sim_isGood_

TBranch *	sim_isGood_branch

bool	sim_isGood_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< int > *	sim_parentVtxIdx_

TBranch *	sim_parentVtxIdx_branch

bool	sim_parentVtxIdx_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< 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< int > *	sim_pLS_matched_

TBranch *	sim_pLS_matched_branch

bool	sim_pLS_matched_isLoaded

std::vector< std::vector< int > > *	sim_pLS_types_

TBranch *	sim_pLS_types_branch

bool	sim_pLS_types_isLoaded

std::vector< int > *	sim_pT3_matched_

TBranch *	sim_pT3_matched_branch

bool	sim_pT3_matched_isLoaded

std::vector< std::vector< int > > *	sim_pT3_types_

TBranch *	sim_pT3_types_branch

bool	sim_pT3_types_isLoaded

std::vector< int > *	sim_pT4_matched_

TBranch *	sim_pT4_matched_branch

bool	sim_pT4_matched_isLoaded

std::vector< std::vector< int > > *	sim_pT4_types_

TBranch *	sim_pT4_types_branch

bool	sim_pT4_types_isLoaded

std::vector< int > *	sim_pT5_matched_

TBranch *	sim_pT5_matched_branch

bool	sim_pT5_matched_isLoaded

std::vector< std::vector< int > > *	sim_pT5_types_

TBranch *	sim_pT5_types_branch

bool	sim_pT5_types_isLoaded

std::vector< float > *	sim_pt_

TBranch *	sim_pt_branch

bool	sim_pt_isLoaded

std::vector< int > *	sim_pureTCE_matched_

TBranch *	sim_pureTCE_matched_branch

bool	sim_pureTCE_matched_isLoaded

std::vector< std::vector< int > > *	sim_pureTCE_types_

TBranch *	sim_pureTCE_types_branch

bool	sim_pureTCE_types_isLoaded

std::vector< int > *	sim_q_

TBranch *	sim_q_branch

bool	sim_q_isLoaded

std::vector< int > *	sim_T3_matched_

TBranch *	sim_T3_matched_branch

bool	sim_T3_matched_isLoaded

std::vector< std::vector< int > > *	sim_T3_types_

TBranch *	sim_T3_types_branch

bool	sim_T3_types_isLoaded

std::vector< int > *	sim_T4_matched_

TBranch *	sim_T4_matched_branch

bool	sim_T4_matched_isLoaded

std::vector< std::vector< int > > *	sim_T4_types_

TBranch *	sim_T4_types_branch

bool	sim_T4_types_isLoaded

std::vector< int > *	sim_T5_matched_

TBranch *	sim_T5_matched_branch

bool	sim_T5_matched_isLoaded

std::vector< std::vector< int > > *	sim_T5_types_

TBranch *	sim_T5_types_branch

bool	sim_T5_types_isLoaded

std::vector< int > *	sim_TC_matched_

TBranch *	sim_TC_matched_branch

bool	sim_TC_matched_isLoaded

std::vector< int > *	sim_TC_matched_mask_

TBranch *	sim_TC_matched_mask_branch

bool	sim_TC_matched_mask_isLoaded

std::vector< int > *	sim_TC_matched_nonextended_

TBranch *	sim_TC_matched_nonextended_branch

bool	sim_TC_matched_nonextended_isLoaded

std::vector< std::vector< int > > *	sim_TC_types_

TBranch *	sim_TC_types_branch

bool	sim_TC_types_isLoaded

std::vector< int > *	sim_tce_matched_

TBranch *	sim_tce_matched_branch

bool	sim_tce_matched_isLoaded

std::vector< std::vector< int > > *	sim_tce_types_

TBranch *	sim_tce_types_branch

bool	sim_tce_types_isLoaded

std::vector< std::vector< int > > *	sim_tcIdx_

TBranch *	sim_tcIdx_branch

bool	sim_tcIdx_isLoaded

std::vector< float > *	sim_vx_

TBranch *	sim_vx_branch

bool	sim_vx_isLoaded

std::vector< float > *	sim_vy_

TBranch *	sim_vy_branch

bool	sim_vy_isLoaded

std::vector< float > *	sim_vz_

TBranch *	sim_vz_branch

bool	sim_vz_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< float > *	t3_eta_

TBranch *	t3_eta_branch

bool	t3_eta_isLoaded

std::vector< int > *	t3_isDuplicate_

TBranch *	t3_isDuplicate_branch

bool	t3_isDuplicate_isLoaded

std::vector< int > *	t3_isFake_

TBranch *	t3_isFake_branch

bool	t3_isFake_isLoaded

std::vector< int > *	t3_occupancies_

TBranch *	t3_occupancies_branch

bool	t3_occupancies_isLoaded

std::vector< float > *	t3_phi_

TBranch *	t3_phi_branch

bool	t3_phi_isLoaded

std::vector< float > *	t3_pt_

TBranch *	t3_pt_branch

bool	t3_pt_isLoaded

std::vector< float > *	t4_eta_

TBranch *	t4_eta_branch

bool	t4_eta_isLoaded

std::vector< int > *	t4_isDuplicate_

TBranch *	t4_isDuplicate_branch

bool	t4_isDuplicate_isLoaded

std::vector< int > *	t4_isFake_

TBranch *	t4_isFake_branch

bool	t4_isFake_isLoaded

std::vector< int > *	t4_occupancies_

TBranch *	t4_occupancies_branch

bool	t4_occupancies_isLoaded

std::vector< float > *	t4_phi_

TBranch *	t4_phi_branch

bool	t4_phi_isLoaded

std::vector< float > *	t4_pt_

TBranch *	t4_pt_branch

bool	t4_pt_isLoaded

std::vector< float > *	t5_eta_

std::vector< float > *	t5_eta_2_

TBranch *	t5_eta_2_branch

bool	t5_eta_2_isLoaded

TBranch *	t5_eta_branch

bool	t5_eta_isLoaded

std::vector< int > *	t5_foundDuplicate_

TBranch *	t5_foundDuplicate_branch

bool	t5_foundDuplicate_isLoaded

std::vector< std::vector< int > > *	t5_hitIdxs_

TBranch *	t5_hitIdxs_branch

bool	t5_hitIdxs_isLoaded

std::vector< int > *	t5_isDuplicate_

TBranch *	t5_isDuplicate_branch

bool	t5_isDuplicate_isLoaded

std::vector< int > *	t5_isFake_

TBranch *	t5_isFake_branch

bool	t5_isFake_isLoaded

std::vector< std::vector< int > > *	t5_matched_simIdx_

TBranch *	t5_matched_simIdx_branch

bool	t5_matched_simIdx_isLoaded

std::vector< int > *	t5_occupancies_

TBranch *	t5_occupancies_branch

bool	t5_occupancies_isLoaded

std::vector< float > *	t5_phi_

std::vector< float > *	t5_phi_2_

TBranch *	t5_phi_2_branch

bool	t5_phi_2_isLoaded

TBranch *	t5_phi_branch

bool	t5_phi_isLoaded

std::vector< float > *	t5_pt_

TBranch *	t5_pt_branch

bool	t5_pt_isLoaded

std::vector< float > *	t5_score_rphisum_

TBranch *	t5_score_rphisum_branch

bool	t5_score_rphisum_isLoaded

std::vector< float > *	tc_eta_

TBranch *	tc_eta_branch

bool	tc_eta_isLoaded

std::vector< std::vector< int > > *	tc_hitIdxs_

TBranch *	tc_hitIdxs_branch

bool	tc_hitIdxs_isLoaded

std::vector< int > *	tc_isDuplicate_

TBranch *	tc_isDuplicate_branch

bool	tc_isDuplicate_isLoaded

std::vector< int > *	tc_isFake_

TBranch *	tc_isFake_branch

bool	tc_isFake_isLoaded

std::vector< std::vector< int > > *	tc_matched_simIdx_

TBranch *	tc_matched_simIdx_branch

bool	tc_matched_simIdx_isLoaded

std::vector< int > *	tc_maxHitMatchedCounts_

TBranch *	tc_maxHitMatchedCounts_branch

bool	tc_maxHitMatchedCounts_isLoaded

int	tc_occupancies_

TBranch *	tc_occupancies_branch

bool	tc_occupancies_isLoaded

std::vector< int > *	tc_partOfExtension_

TBranch *	tc_partOfExtension_branch

bool	tc_partOfExtension_isLoaded

std::vector< float > *	tc_phi_

TBranch *	tc_phi_branch

bool	tc_phi_isLoaded

std::vector< float > *	tc_pt_

TBranch *	tc_pt_branch

bool	tc_pt_isLoaded

std::vector< int > *	tc_sim_

TBranch *	tc_sim_branch

bool	tc_sim_isLoaded

std::vector< int > *	tc_type_

TBranch *	tc_type_branch

bool	tc_type_isLoaded

std::vector< int > *	tce_anchorIndex_

TBranch *	tce_anchorIndex_branch

bool	tce_anchorIndex_isLoaded

std::vector< int > *	tce_anchorType_

TBranch *	tce_anchorType_branch

bool	tce_anchorType_isLoaded

std::vector< float > *	tce_eta_

TBranch *	tce_eta_branch

bool	tce_eta_isLoaded

std::vector< int > *	tce_isDuplicate_

TBranch *	tce_isDuplicate_branch

bool	tce_isDuplicate_isLoaded

std::vector< int > *	tce_isFake_

TBranch *	tce_isFake_branch

bool	tce_isFake_isLoaded

std::vector< int > *	tce_layer_binary_

TBranch *	tce_layer_binary_branch

bool	tce_layer_binary_isLoaded

std::vector< std::vector< int > > *	tce_matched_simIdx_

TBranch *	tce_matched_simIdx_branch

bool	tce_matched_simIdx_isLoaded

std::vector< int > *	tce_maxHitMatchedCounts_

TBranch *	tce_maxHitMatchedCounts_branch

bool	tce_maxHitMatchedCounts_isLoaded

std::vector< std::vector< int > > *	tce_nHitOverlaps_

TBranch *	tce_nHitOverlaps_branch

bool	tce_nHitOverlaps_isLoaded

std::vector< std::vector< int > > *	tce_nLayerOverlaps_

TBranch *	tce_nLayerOverlaps_branch

bool	tce_nLayerOverlaps_isLoaded

std::vector< float > *	tce_phi_

TBranch *	tce_phi_branch

bool	tce_phi_isLoaded

std::vector< float > *	tce_pt_

TBranch *	tce_pt_branch

bool	tce_pt_isLoaded

std::vector< float > *	tce_rPhiChiSquared_

TBranch *	tce_rPhiChiSquared_branch

bool	tce_rPhiChiSquared_isLoaded

std::vector< float > *	tce_rzChiSquared_

TBranch *	tce_rzChiSquared_branch

bool	tce_rzChiSquared_isLoaded

Detailed Description

Definition at line 16 of file LSTEff.h.

Member Function Documentation

◆ GetEntry()

void LSTEff::GetEntry ( unsigned int idx )

Definition at line 1030 of file LSTEff.cc.

                                       {
   index = idx;
   pT5_occupancies_isLoaded = false;
   t3_phi_isLoaded = false;
   t5_score_rphisum_isLoaded = false;
   pT4_isFake_isLoaded = false;
   t3_isDuplicate_isLoaded = false;
   sim_event_isLoaded = false;
   sim_q_isLoaded = false;
   sim_eta_isLoaded = false;
   pT3_foundDuplicate_isLoaded = false;
   sim_len_isLoaded = false;
   pureTCE_isDuplicate_isLoaded = false;
   pT3_score_isLoaded = false;
   t5_eta_isLoaded = false;
   sim_denom_isLoaded = false;
   pT5_isDuplicate_isLoaded = false;
   sim_tce_matched_isLoaded = false;
   pT3_isDuplicate_isLoaded = false;
   tc_isDuplicate_isLoaded = false;
   pT3_eta_2_isLoaded = false;
   sim_pT3_matched_isLoaded = false;
   pureTCE_rzChiSquared_isLoaded = false;
   t4_isDuplicate_isLoaded = false;
   pureTCE_eta_isLoaded = false;
   tce_rPhiChiSquared_isLoaded = false;
   pureTCE_anchorType_isLoaded = false;
   pureTCE_pt_isLoaded = false;
   sim_pt_isLoaded = false;
   t5_eta_2_isLoaded = false;
   pLS_eta_isLoaded = false;
   sim_pdgId_isLoaded = false;
   t3_eta_isLoaded = false;
   tce_layer_binary_isLoaded = false;
   sim_TC_matched_nonextended_isLoaded = false;
   t4_occupancies_isLoaded = false;
   tce_eta_isLoaded = false;
   tce_isDuplicate_isLoaded = false;
   pT5_matched_simIdx_isLoaded = false;
   sim_tcIdx_isLoaded = false;
   t5_phi_2_isLoaded = false;
   pureTCE_maxHitMatchedCounts_isLoaded = false;
   t5_matched_simIdx_isLoaded = false;
   module_subdets_isLoaded = false;
   tce_anchorType_isLoaded = false;
   tce_nHitOverlaps_isLoaded = false;
   t3_isFake_isLoaded = false;
   tce_phi_isLoaded = false;
   t5_isFake_isLoaded = false;
   md_occupancies_isLoaded = false;
   t5_hitIdxs_isLoaded = false;
   sim_pT3_types_isLoaded = false;
   sim_pureTCE_types_isLoaded = false;
   t4_phi_isLoaded = false;
   t5_phi_isLoaded = false;
   pT5_hitIdxs_isLoaded = false;
   t5_pt_isLoaded = false;
   pT5_phi_isLoaded = false;
   pureTCE_isFake_isLoaded = false;
   tce_pt_isLoaded = false;
   tc_isFake_isLoaded = false;
   pT3_isFake_isLoaded = false;
   tce_nLayerOverlaps_isLoaded = false;
   tc_sim_isLoaded = false;
   sim_pLS_types_isLoaded = false;
   sim_pca_dxy_isLoaded = false;
   pT4_phi_isLoaded = false;
   sim_hits_isLoaded = false;
   pLS_phi_isLoaded = false;
   sim_pureTCE_matched_isLoaded = false;
   t3_occupancies_isLoaded = false;
   t5_foundDuplicate_isLoaded = false;
   sim_pT4_types_isLoaded = false;
   t4_isFake_isLoaded = false;
   simvtx_x_isLoaded = false;
   simvtx_y_isLoaded = false;
   simvtx_z_isLoaded = false;
   sim_T4_matched_isLoaded = false;
   sim_isGood_isLoaded = false;
   pT3_pt_isLoaded = false;
   tc_pt_isLoaded = false;
   pT3_phi_2_isLoaded = false;
   pT5_pt_isLoaded = false;
   pureTCE_rPhiChiSquared_isLoaded = false;
   pT5_score_isLoaded = false;
   sim_phi_isLoaded = false;
   pT5_isFake_isLoaded = false;
   tc_maxHitMatchedCounts_isLoaded = false;
   pureTCE_nLayerOverlaps_isLoaded = false;
   sim_pca_dz_isLoaded = false;
   pureTCE_hitIdxs_isLoaded = false;
   pureTCE_nHitOverlaps_isLoaded = false;
   sim_pLS_matched_isLoaded = false;
   tc_matched_simIdx_isLoaded = false;
   sim_T3_matched_isLoaded = false;
   pLS_score_isLoaded = false;
   pT3_phi_isLoaded = false;
   pT5_eta_isLoaded = false;
   tc_phi_isLoaded = false;
   t4_eta_isLoaded = false;
   pLS_isFake_isLoaded = false;
   pureTCE_matched_simIdx_isLoaded = false;
   sim_bunchCrossing_isLoaded = false;
   tc_partOfExtension_isLoaded = false;
   pT3_eta_isLoaded = false;
   sim_parentVtxIdx_isLoaded = false;
   pureTCE_layer_binary_isLoaded = false;
   sim_pT4_matched_isLoaded = false;
   tc_eta_isLoaded = false;
   sim_lengap_isLoaded = false;
   sim_T5_matched_isLoaded = false;
   sim_T5_types_isLoaded = false;
   tce_matched_simIdx_isLoaded = false;
   t5_isDuplicate_isLoaded = false;
   pT3_hitIdxs_isLoaded = false;
   tc_hitIdxs_isLoaded = false;
   pT3_occupancies_isLoaded = false;
   tc_occupancies_isLoaded = false;
   sim_TC_matched_isLoaded = false;
   sim_TC_matched_mask_isLoaded = false;
   pLS_isDuplicate_isLoaded = false;
   tce_anchorIndex_isLoaded = false;
   t5_occupancies_isLoaded = false;
   tc_type_isLoaded = false;
   tce_isFake_isLoaded = false;
   pLS_pt_isLoaded = false;
   pureTCE_anchorIndex_isLoaded = false;
   sim_T4_types_isLoaded = false;
   pT4_isDuplicate_isLoaded = false;
   t4_pt_isLoaded = false;
   sim_TC_types_isLoaded = false;
   sg_occupancies_isLoaded = false;
   pT4_pt_isLoaded = false;
   pureTCE_phi_isLoaded = false;
   sim_vx_isLoaded = false;
   sim_vy_isLoaded = false;
   sim_vz_isLoaded = false;
   tce_maxHitMatchedCounts_isLoaded = false;
   t3_pt_isLoaded = false;
   module_rings_isLoaded = false;
   sim_T3_types_isLoaded = false;
   sim_pT5_types_isLoaded = false;
   sim_pT5_matched_isLoaded = false;
   module_layers_isLoaded = false;
   pT4_eta_isLoaded = false;
   sim_tce_types_isLoaded = false;
   tce_rzChiSquared_isLoaded = false;
   pT3_matched_simIdx_isLoaded = false;
 }

◆ Init()

void LSTEff::Init ( TTree * tree )

Definition at line 4 of file LSTEff.cc.

References md_occupancies_, md_occupancies_branch, module_layers_, module_layers_branch, module_rings_, module_rings_branch, module_subdets_, module_subdets_branch, pLS_eta_, pLS_eta_branch, pLS_isDuplicate_, pLS_isDuplicate_branch, pLS_isFake_, pLS_isFake_branch, pLS_phi_, pLS_phi_branch, pLS_pt_, pLS_pt_branch, pLS_score_, pLS_score_branch, pT3_eta_, pT3_eta_2_, pT3_eta_2_branch, pT3_eta_branch, pT3_foundDuplicate_, pT3_foundDuplicate_branch, pT3_hitIdxs_, pT3_hitIdxs_branch, pT3_isDuplicate_, pT3_isDuplicate_branch, pT3_isFake_, pT3_isFake_branch, pT3_matched_simIdx_, pT3_matched_simIdx_branch, pT3_occupancies_, pT3_occupancies_branch, pT3_phi_, pT3_phi_2_, pT3_phi_2_branch, pT3_phi_branch, pT3_pt_, pT3_pt_branch, pT3_score_, pT3_score_branch, pT4_eta_, pT4_eta_branch, pT4_isDuplicate_, pT4_isDuplicate_branch, pT4_isFake_, pT4_isFake_branch, pT4_phi_, pT4_phi_branch, pT4_pt_, pT4_pt_branch, pT5_eta_, pT5_eta_branch, pT5_hitIdxs_, pT5_hitIdxs_branch, pT5_isDuplicate_, pT5_isDuplicate_branch, pT5_isFake_, pT5_isFake_branch, pT5_matched_simIdx_, pT5_matched_simIdx_branch, pT5_occupancies_, pT5_occupancies_branch, pT5_phi_, pT5_phi_branch, pT5_pt_, pT5_pt_branch, pT5_score_, pT5_score_branch, pureTCE_anchorIndex_, pureTCE_anchorIndex_branch, pureTCE_anchorType_, pureTCE_anchorType_branch, pureTCE_eta_, pureTCE_eta_branch, pureTCE_hitIdxs_, pureTCE_hitIdxs_branch, pureTCE_isDuplicate_, pureTCE_isDuplicate_branch, pureTCE_isFake_, pureTCE_isFake_branch, pureTCE_layer_binary_, pureTCE_layer_binary_branch, pureTCE_matched_simIdx_, pureTCE_matched_simIdx_branch, pureTCE_maxHitMatchedCounts_, pureTCE_maxHitMatchedCounts_branch, pureTCE_nHitOverlaps_, pureTCE_nHitOverlaps_branch, pureTCE_nLayerOverlaps_, pureTCE_nLayerOverlaps_branch, pureTCE_phi_, pureTCE_phi_branch, pureTCE_pt_, pureTCE_pt_branch, pureTCE_rPhiChiSquared_, pureTCE_rPhiChiSquared_branch, pureTCE_rzChiSquared_, pureTCE_rzChiSquared_branch, sg_occupancies_, sg_occupancies_branch, sim_bunchCrossing_, sim_bunchCrossing_branch, sim_denom_, sim_denom_branch, sim_eta_, sim_eta_branch, sim_event_, sim_event_branch, sim_hits_, sim_hits_branch, sim_isGood_, sim_isGood_branch, sim_len_, sim_len_branch, sim_lengap_, sim_lengap_branch, sim_parentVtxIdx_, sim_parentVtxIdx_branch, sim_pca_dxy_, sim_pca_dxy_branch, sim_pca_dz_, sim_pca_dz_branch, sim_pdgId_, sim_pdgId_branch, sim_phi_, sim_phi_branch, sim_pLS_matched_, sim_pLS_matched_branch, sim_pLS_types_, sim_pLS_types_branch, sim_pT3_matched_, sim_pT3_matched_branch, sim_pT3_types_, sim_pT3_types_branch, sim_pT4_matched_, sim_pT4_matched_branch, sim_pT4_types_, sim_pT4_types_branch, sim_pT5_matched_, sim_pT5_matched_branch, sim_pT5_types_, sim_pT5_types_branch, sim_pt_, sim_pt_branch, sim_pureTCE_matched_, sim_pureTCE_matched_branch, sim_pureTCE_types_, sim_pureTCE_types_branch, sim_q_, sim_q_branch, sim_T3_matched_, sim_T3_matched_branch, sim_T3_types_, sim_T3_types_branch, sim_T4_matched_, sim_T4_matched_branch, sim_T4_types_, sim_T4_types_branch, sim_T5_matched_, sim_T5_matched_branch, sim_T5_types_, sim_T5_types_branch, sim_TC_matched_, sim_TC_matched_branch, sim_TC_matched_mask_, sim_TC_matched_mask_branch, sim_TC_matched_nonextended_, sim_TC_matched_nonextended_branch, sim_TC_types_, sim_TC_types_branch, sim_tce_matched_, sim_tce_matched_branch, sim_tce_types_, sim_tce_types_branch, sim_tcIdx_, sim_tcIdx_branch, sim_vx_, sim_vx_branch, sim_vy_, sim_vy_branch, sim_vz_, sim_vz_branch, simvtx_x_, simvtx_x_branch, simvtx_y_, simvtx_y_branch, simvtx_z_, simvtx_z_branch, t3_eta_, t3_eta_branch, t3_isDuplicate_, t3_isDuplicate_branch, t3_isFake_, t3_isFake_branch, t3_occupancies_, t3_occupancies_branch, t3_phi_, t3_phi_branch, t3_pt_, t3_pt_branch, t4_eta_, t4_eta_branch, t4_isDuplicate_, t4_isDuplicate_branch, t4_isFake_, t4_isFake_branch, t4_occupancies_, t4_occupancies_branch, t4_phi_, t4_phi_branch, t4_pt_, t4_pt_branch, t5_eta_, t5_eta_2_, t5_eta_2_branch, t5_eta_branch, t5_foundDuplicate_, t5_foundDuplicate_branch, t5_hitIdxs_, t5_hitIdxs_branch, t5_isDuplicate_, t5_isDuplicate_branch, t5_isFake_, t5_isFake_branch, t5_matched_simIdx_, t5_matched_simIdx_branch, t5_occupancies_, t5_occupancies_branch, t5_phi_, t5_phi_2_, t5_phi_2_branch, t5_phi_branch, t5_pt_, t5_pt_branch, t5_score_rphisum_, t5_score_rphisum_branch, tc_eta_, tc_eta_branch, tc_hitIdxs_, tc_hitIdxs_branch, tc_isDuplicate_, tc_isDuplicate_branch, tc_isFake_, tc_isFake_branch, tc_matched_simIdx_, tc_matched_simIdx_branch, tc_maxHitMatchedCounts_, tc_maxHitMatchedCounts_branch, tc_occupancies_, tc_occupancies_branch, tc_partOfExtension_, tc_partOfExtension_branch, tc_phi_, tc_phi_branch, tc_pt_, tc_pt_branch, tc_sim_, tc_sim_branch, tc_type_, tc_type_branch, tce_anchorIndex_, tce_anchorIndex_branch, tce_anchorType_, tce_anchorType_branch, tce_eta_, tce_eta_branch, tce_isDuplicate_, tce_isDuplicate_branch, tce_isFake_, tce_isFake_branch, tce_layer_binary_, tce_layer_binary_branch, tce_matched_simIdx_, tce_matched_simIdx_branch, tce_maxHitMatchedCounts_, tce_maxHitMatchedCounts_branch, tce_nHitOverlaps_, tce_nHitOverlaps_branch, tce_nLayerOverlaps_, tce_nLayerOverlaps_branch, tce_phi_, tce_phi_branch, tce_pt_, tce_pt_branch, tce_rPhiChiSquared_, tce_rPhiChiSquared_branch, tce_rzChiSquared_, and tce_rzChiSquared_branch.

                              {
   tree->SetMakeClass(1);
   pT5_occupancies_branch = 0;
   if (tree->GetBranch("pT5_occupancies") != 0) {
     pT5_occupancies_branch = tree->GetBranch("pT5_occupancies");
     if (pT5_occupancies_branch) {
       pT5_occupancies_branch->SetAddress(&pT5_occupancies_);
     }
   }
   t3_phi_branch = 0;
   if (tree->GetBranch("t3_phi") != 0) {
     t3_phi_branch = tree->GetBranch("t3_phi");
     if (t3_phi_branch) {
       t3_phi_branch->SetAddress(&t3_phi_);
     }
   }
   t5_score_rphisum_branch = 0;
   if (tree->GetBranch("t5_score_rphisum") != 0) {
     t5_score_rphisum_branch = tree->GetBranch("t5_score_rphisum");
     if (t5_score_rphisum_branch) {
       t5_score_rphisum_branch->SetAddress(&t5_score_rphisum_);
     }
   }
   pT4_isFake_branch = 0;
   if (tree->GetBranch("pT4_isFake") != 0) {
     pT4_isFake_branch = tree->GetBranch("pT4_isFake");
     if (pT4_isFake_branch) {
       pT4_isFake_branch->SetAddress(&pT4_isFake_);
     }
   }
   t3_isDuplicate_branch = 0;
   if (tree->GetBranch("t3_isDuplicate") != 0) {
     t3_isDuplicate_branch = tree->GetBranch("t3_isDuplicate");
     if (t3_isDuplicate_branch) {
       t3_isDuplicate_branch->SetAddress(&t3_isDuplicate_);
     }
   }
   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_);
     }
   }
   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_);
     }
   }
   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_);
     }
   }
   pT3_foundDuplicate_branch = 0;
   if (tree->GetBranch("pT3_foundDuplicate") != 0) {
     pT3_foundDuplicate_branch = tree->GetBranch("pT3_foundDuplicate");
     if (pT3_foundDuplicate_branch) {
       pT3_foundDuplicate_branch->SetAddress(&pT3_foundDuplicate_);
     }
   }
   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_);
     }
   }
   pureTCE_isDuplicate_branch = 0;
   if (tree->GetBranch("pureTCE_isDuplicate") != 0) {
     pureTCE_isDuplicate_branch = tree->GetBranch("pureTCE_isDuplicate");
     if (pureTCE_isDuplicate_branch) {
       pureTCE_isDuplicate_branch->SetAddress(&pureTCE_isDuplicate_);
     }
   }
   pT3_score_branch = 0;
   if (tree->GetBranch("pT3_score") != 0) {
     pT3_score_branch = tree->GetBranch("pT3_score");
     if (pT3_score_branch) {
       pT3_score_branch->SetAddress(&pT3_score_);
     }
   }
   t5_eta_branch = 0;
   if (tree->GetBranch("t5_eta") != 0) {
     t5_eta_branch = tree->GetBranch("t5_eta");
     if (t5_eta_branch) {
       t5_eta_branch->SetAddress(&t5_eta_);
     }
   }
   sim_denom_branch = 0;
   if (tree->GetBranch("sim_denom") != 0) {
     sim_denom_branch = tree->GetBranch("sim_denom");
     if (sim_denom_branch) {
       sim_denom_branch->SetAddress(&sim_denom_);
     }
   }
   pT5_isDuplicate_branch = 0;
   if (tree->GetBranch("pT5_isDuplicate") != 0) {
     pT5_isDuplicate_branch = tree->GetBranch("pT5_isDuplicate");
     if (pT5_isDuplicate_branch) {
       pT5_isDuplicate_branch->SetAddress(&pT5_isDuplicate_);
     }
   }
   sim_tce_matched_branch = 0;
   if (tree->GetBranch("sim_tce_matched") != 0) {
     sim_tce_matched_branch = tree->GetBranch("sim_tce_matched");
     if (sim_tce_matched_branch) {
       sim_tce_matched_branch->SetAddress(&sim_tce_matched_);
     }
   }
   pT3_isDuplicate_branch = 0;
   if (tree->GetBranch("pT3_isDuplicate") != 0) {
     pT3_isDuplicate_branch = tree->GetBranch("pT3_isDuplicate");
     if (pT3_isDuplicate_branch) {
       pT3_isDuplicate_branch->SetAddress(&pT3_isDuplicate_);
     }
   }
   tc_isDuplicate_branch = 0;
   if (tree->GetBranch("tc_isDuplicate") != 0) {
     tc_isDuplicate_branch = tree->GetBranch("tc_isDuplicate");
     if (tc_isDuplicate_branch) {
       tc_isDuplicate_branch->SetAddress(&tc_isDuplicate_);
     }
   }
   pT3_eta_2_branch = 0;
   if (tree->GetBranch("pT3_eta_2") != 0) {
     pT3_eta_2_branch = tree->GetBranch("pT3_eta_2");
     if (pT3_eta_2_branch) {
       pT3_eta_2_branch->SetAddress(&pT3_eta_2_);
     }
   }
   sim_pT3_matched_branch = 0;
   if (tree->GetBranch("sim_pT3_matched") != 0) {
     sim_pT3_matched_branch = tree->GetBranch("sim_pT3_matched");
     if (sim_pT3_matched_branch) {
       sim_pT3_matched_branch->SetAddress(&sim_pT3_matched_);
     }
   }
   pureTCE_rzChiSquared_branch = 0;
   if (tree->GetBranch("pureTCE_rzChiSquared") != 0) {
     pureTCE_rzChiSquared_branch = tree->GetBranch("pureTCE_rzChiSquared");
     if (pureTCE_rzChiSquared_branch) {
       pureTCE_rzChiSquared_branch->SetAddress(&pureTCE_rzChiSquared_);
     }
   }
   t4_isDuplicate_branch = 0;
   if (tree->GetBranch("t4_isDuplicate") != 0) {
     t4_isDuplicate_branch = tree->GetBranch("t4_isDuplicate");
     if (t4_isDuplicate_branch) {
       t4_isDuplicate_branch->SetAddress(&t4_isDuplicate_);
     }
   }
   pureTCE_eta_branch = 0;
   if (tree->GetBranch("pureTCE_eta") != 0) {
     pureTCE_eta_branch = tree->GetBranch("pureTCE_eta");
     if (pureTCE_eta_branch) {
       pureTCE_eta_branch->SetAddress(&pureTCE_eta_);
     }
   }
   tce_rPhiChiSquared_branch = 0;
   if (tree->GetBranch("tce_rPhiChiSquared") != 0) {
     tce_rPhiChiSquared_branch = tree->GetBranch("tce_rPhiChiSquared");
     if (tce_rPhiChiSquared_branch) {
       tce_rPhiChiSquared_branch->SetAddress(&tce_rPhiChiSquared_);
     }
   }
   pureTCE_anchorType_branch = 0;
   if (tree->GetBranch("pureTCE_anchorType") != 0) {
     pureTCE_anchorType_branch = tree->GetBranch("pureTCE_anchorType");
     if (pureTCE_anchorType_branch) {
       pureTCE_anchorType_branch->SetAddress(&pureTCE_anchorType_);
     }
   }
   pureTCE_pt_branch = 0;
   if (tree->GetBranch("pureTCE_pt") != 0) {
     pureTCE_pt_branch = tree->GetBranch("pureTCE_pt");
     if (pureTCE_pt_branch) {
       pureTCE_pt_branch->SetAddress(&pureTCE_pt_);
     }
   }
   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_);
     }
   }
   t5_eta_2_branch = 0;
   if (tree->GetBranch("t5_eta_2") != 0) {
     t5_eta_2_branch = tree->GetBranch("t5_eta_2");
     if (t5_eta_2_branch) {
       t5_eta_2_branch->SetAddress(&t5_eta_2_);
     }
   }
   pLS_eta_branch = 0;
   if (tree->GetBranch("pLS_eta") != 0) {
     pLS_eta_branch = tree->GetBranch("pLS_eta");
     if (pLS_eta_branch) {
       pLS_eta_branch->SetAddress(&pLS_eta_);
     }
   }
   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_);
     }
   }
   t3_eta_branch = 0;
   if (tree->GetBranch("t3_eta") != 0) {
     t3_eta_branch = tree->GetBranch("t3_eta");
     if (t3_eta_branch) {
       t3_eta_branch->SetAddress(&t3_eta_);
     }
   }
   tce_layer_binary_branch = 0;
   if (tree->GetBranch("tce_layer_binary") != 0) {
     tce_layer_binary_branch = tree->GetBranch("tce_layer_binary");
     if (tce_layer_binary_branch) {
       tce_layer_binary_branch->SetAddress(&tce_layer_binary_);
     }
   }
   sim_TC_matched_nonextended_branch = 0;
   if (tree->GetBranch("sim_TC_matched_nonextended") != 0) {
     sim_TC_matched_nonextended_branch = tree->GetBranch("sim_TC_matched_nonextended");
     if (sim_TC_matched_nonextended_branch) {
       sim_TC_matched_nonextended_branch->SetAddress(&sim_TC_matched_nonextended_);
     }
   }
   t4_occupancies_branch = 0;
   if (tree->GetBranch("t4_occupancies") != 0) {
     t4_occupancies_branch = tree->GetBranch("t4_occupancies");
     if (t4_occupancies_branch) {
       t4_occupancies_branch->SetAddress(&t4_occupancies_);
     }
   }
   tce_eta_branch = 0;
   if (tree->GetBranch("tce_eta") != 0) {
     tce_eta_branch = tree->GetBranch("tce_eta");
     if (tce_eta_branch) {
       tce_eta_branch->SetAddress(&tce_eta_);
     }
   }
   tce_isDuplicate_branch = 0;
   if (tree->GetBranch("tce_isDuplicate") != 0) {
     tce_isDuplicate_branch = tree->GetBranch("tce_isDuplicate");
     if (tce_isDuplicate_branch) {
       tce_isDuplicate_branch->SetAddress(&tce_isDuplicate_);
     }
   }
   pT5_matched_simIdx_branch = 0;
   if (tree->GetBranch("pT5_matched_simIdx") != 0) {
     pT5_matched_simIdx_branch = tree->GetBranch("pT5_matched_simIdx");
     if (pT5_matched_simIdx_branch) {
       pT5_matched_simIdx_branch->SetAddress(&pT5_matched_simIdx_);
     }
   }
   sim_tcIdx_branch = 0;
   if (tree->GetBranch("sim_tcIdx") != 0) {
     sim_tcIdx_branch = tree->GetBranch("sim_tcIdx");
     if (sim_tcIdx_branch) {
       sim_tcIdx_branch->SetAddress(&sim_tcIdx_);
     }
   }
   t5_phi_2_branch = 0;
   if (tree->GetBranch("t5_phi_2") != 0) {
     t5_phi_2_branch = tree->GetBranch("t5_phi_2");
     if (t5_phi_2_branch) {
       t5_phi_2_branch->SetAddress(&t5_phi_2_);
     }
   }
   pureTCE_maxHitMatchedCounts_branch = 0;
   if (tree->GetBranch("pureTCE_maxHitMatchedCounts") != 0) {
     pureTCE_maxHitMatchedCounts_branch = tree->GetBranch("pureTCE_maxHitMatchedCounts");
     if (pureTCE_maxHitMatchedCounts_branch) {
       pureTCE_maxHitMatchedCounts_branch->SetAddress(&pureTCE_maxHitMatchedCounts_);
     }
   }
   t5_matched_simIdx_branch = 0;
   if (tree->GetBranch("t5_matched_simIdx") != 0) {
     t5_matched_simIdx_branch = tree->GetBranch("t5_matched_simIdx");
     if (t5_matched_simIdx_branch) {
       t5_matched_simIdx_branch->SetAddress(&t5_matched_simIdx_);
     }
   }
   module_subdets_branch = 0;
   if (tree->GetBranch("module_subdets") != 0) {
     module_subdets_branch = tree->GetBranch("module_subdets");
     if (module_subdets_branch) {
       module_subdets_branch->SetAddress(&module_subdets_);
     }
   }
   tce_anchorType_branch = 0;
   if (tree->GetBranch("tce_anchorType") != 0) {
     tce_anchorType_branch = tree->GetBranch("tce_anchorType");
     if (tce_anchorType_branch) {
       tce_anchorType_branch->SetAddress(&tce_anchorType_);
     }
   }
   tce_nHitOverlaps_branch = 0;
   if (tree->GetBranch("tce_nHitOverlaps") != 0) {
     tce_nHitOverlaps_branch = tree->GetBranch("tce_nHitOverlaps");
     if (tce_nHitOverlaps_branch) {
       tce_nHitOverlaps_branch->SetAddress(&tce_nHitOverlaps_);
     }
   }
   t3_isFake_branch = 0;
   if (tree->GetBranch("t3_isFake") != 0) {
     t3_isFake_branch = tree->GetBranch("t3_isFake");
     if (t3_isFake_branch) {
       t3_isFake_branch->SetAddress(&t3_isFake_);
     }
   }
   tce_phi_branch = 0;
   if (tree->GetBranch("tce_phi") != 0) {
     tce_phi_branch = tree->GetBranch("tce_phi");
     if (tce_phi_branch) {
       tce_phi_branch->SetAddress(&tce_phi_);
     }
   }
   t5_isFake_branch = 0;
   if (tree->GetBranch("t5_isFake") != 0) {
     t5_isFake_branch = tree->GetBranch("t5_isFake");
     if (t5_isFake_branch) {
       t5_isFake_branch->SetAddress(&t5_isFake_);
     }
   }
   md_occupancies_branch = 0;
   if (tree->GetBranch("md_occupancies") != 0) {
     md_occupancies_branch = tree->GetBranch("md_occupancies");
     if (md_occupancies_branch) {
       md_occupancies_branch->SetAddress(&md_occupancies_);
     }
   }
   t5_hitIdxs_branch = 0;
   if (tree->GetBranch("t5_hitIdxs") != 0) {
     t5_hitIdxs_branch = tree->GetBranch("t5_hitIdxs");
     if (t5_hitIdxs_branch) {
       t5_hitIdxs_branch->SetAddress(&t5_hitIdxs_);
     }
   }
   sim_pT3_types_branch = 0;
   if (tree->GetBranch("sim_pT3_types") != 0) {
     sim_pT3_types_branch = tree->GetBranch("sim_pT3_types");
     if (sim_pT3_types_branch) {
       sim_pT3_types_branch->SetAddress(&sim_pT3_types_);
     }
   }
   sim_pureTCE_types_branch = 0;
   if (tree->GetBranch("sim_pureTCE_types") != 0) {
     sim_pureTCE_types_branch = tree->GetBranch("sim_pureTCE_types");
     if (sim_pureTCE_types_branch) {
       sim_pureTCE_types_branch->SetAddress(&sim_pureTCE_types_);
     }
   }
   t4_phi_branch = 0;
   if (tree->GetBranch("t4_phi") != 0) {
     t4_phi_branch = tree->GetBranch("t4_phi");
     if (t4_phi_branch) {
       t4_phi_branch->SetAddress(&t4_phi_);
     }
   }
   t5_phi_branch = 0;
   if (tree->GetBranch("t5_phi") != 0) {
     t5_phi_branch = tree->GetBranch("t5_phi");
     if (t5_phi_branch) {
       t5_phi_branch->SetAddress(&t5_phi_);
     }
   }
   pT5_hitIdxs_branch = 0;
   if (tree->GetBranch("pT5_hitIdxs") != 0) {
     pT5_hitIdxs_branch = tree->GetBranch("pT5_hitIdxs");
     if (pT5_hitIdxs_branch) {
       pT5_hitIdxs_branch->SetAddress(&pT5_hitIdxs_);
     }
   }
   t5_pt_branch = 0;
   if (tree->GetBranch("t5_pt") != 0) {
     t5_pt_branch = tree->GetBranch("t5_pt");
     if (t5_pt_branch) {
       t5_pt_branch->SetAddress(&t5_pt_);
     }
   }
   pT5_phi_branch = 0;
   if (tree->GetBranch("pT5_phi") != 0) {
     pT5_phi_branch = tree->GetBranch("pT5_phi");
     if (pT5_phi_branch) {
       pT5_phi_branch->SetAddress(&pT5_phi_);
     }
   }
   pureTCE_isFake_branch = 0;
   if (tree->GetBranch("pureTCE_isFake") != 0) {
     pureTCE_isFake_branch = tree->GetBranch("pureTCE_isFake");
     if (pureTCE_isFake_branch) {
       pureTCE_isFake_branch->SetAddress(&pureTCE_isFake_);
     }
   }
   tce_pt_branch = 0;
   if (tree->GetBranch("tce_pt") != 0) {
     tce_pt_branch = tree->GetBranch("tce_pt");
     if (tce_pt_branch) {
       tce_pt_branch->SetAddress(&tce_pt_);
     }
   }
   tc_isFake_branch = 0;
   if (tree->GetBranch("tc_isFake") != 0) {
     tc_isFake_branch = tree->GetBranch("tc_isFake");
     if (tc_isFake_branch) {
       tc_isFake_branch->SetAddress(&tc_isFake_);
     }
   }
   pT3_isFake_branch = 0;
   if (tree->GetBranch("pT3_isFake") != 0) {
     pT3_isFake_branch = tree->GetBranch("pT3_isFake");
     if (pT3_isFake_branch) {
       pT3_isFake_branch->SetAddress(&pT3_isFake_);
     }
   }
   tce_nLayerOverlaps_branch = 0;
   if (tree->GetBranch("tce_nLayerOverlaps") != 0) {
     tce_nLayerOverlaps_branch = tree->GetBranch("tce_nLayerOverlaps");
     if (tce_nLayerOverlaps_branch) {
       tce_nLayerOverlaps_branch->SetAddress(&tce_nLayerOverlaps_);
     }
   }
   tc_sim_branch = 0;
   if (tree->GetBranch("tc_sim") != 0) {
     tc_sim_branch = tree->GetBranch("tc_sim");
     if (tc_sim_branch) {
       tc_sim_branch->SetAddress(&tc_sim_);
     }
   }
   sim_pLS_types_branch = 0;
   if (tree->GetBranch("sim_pLS_types") != 0) {
     sim_pLS_types_branch = tree->GetBranch("sim_pLS_types");
     if (sim_pLS_types_branch) {
       sim_pLS_types_branch->SetAddress(&sim_pLS_types_);
     }
   }
   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_);
     }
   }
   pT4_phi_branch = 0;
   if (tree->GetBranch("pT4_phi") != 0) {
     pT4_phi_branch = tree->GetBranch("pT4_phi");
     if (pT4_phi_branch) {
       pT4_phi_branch->SetAddress(&pT4_phi_);
     }
   }
   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_);
     }
   }
   pLS_phi_branch = 0;
   if (tree->GetBranch("pLS_phi") != 0) {
     pLS_phi_branch = tree->GetBranch("pLS_phi");
     if (pLS_phi_branch) {
       pLS_phi_branch->SetAddress(&pLS_phi_);
     }
   }
   sim_pureTCE_matched_branch = 0;
   if (tree->GetBranch("sim_pureTCE_matched") != 0) {
     sim_pureTCE_matched_branch = tree->GetBranch("sim_pureTCE_matched");
     if (sim_pureTCE_matched_branch) {
       sim_pureTCE_matched_branch->SetAddress(&sim_pureTCE_matched_);
     }
   }
   t3_occupancies_branch = 0;
   if (tree->GetBranch("t3_occupancies") != 0) {
     t3_occupancies_branch = tree->GetBranch("t3_occupancies");
     if (t3_occupancies_branch) {
       t3_occupancies_branch->SetAddress(&t3_occupancies_);
     }
   }
   t5_foundDuplicate_branch = 0;
   if (tree->GetBranch("t5_foundDuplicate") != 0) {
     t5_foundDuplicate_branch = tree->GetBranch("t5_foundDuplicate");
     if (t5_foundDuplicate_branch) {
       t5_foundDuplicate_branch->SetAddress(&t5_foundDuplicate_);
     }
   }
   sim_pT4_types_branch = 0;
   if (tree->GetBranch("sim_pT4_types") != 0) {
     sim_pT4_types_branch = tree->GetBranch("sim_pT4_types");
     if (sim_pT4_types_branch) {
       sim_pT4_types_branch->SetAddress(&sim_pT4_types_);
     }
   }
   t4_isFake_branch = 0;
   if (tree->GetBranch("t4_isFake") != 0) {
     t4_isFake_branch = tree->GetBranch("t4_isFake");
     if (t4_isFake_branch) {
       t4_isFake_branch->SetAddress(&t4_isFake_);
     }
   }
   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_);
     }
   }
   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_);
     }
   }
   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_T4_matched_branch = 0;
   if (tree->GetBranch("sim_T4_matched") != 0) {
     sim_T4_matched_branch = tree->GetBranch("sim_T4_matched");
     if (sim_T4_matched_branch) {
       sim_T4_matched_branch->SetAddress(&sim_T4_matched_);
     }
   }
   sim_isGood_branch = 0;
   if (tree->GetBranch("sim_isGood") != 0) {
     sim_isGood_branch = tree->GetBranch("sim_isGood");
     if (sim_isGood_branch) {
       sim_isGood_branch->SetAddress(&sim_isGood_);
     }
   }
   pT3_pt_branch = 0;
   if (tree->GetBranch("pT3_pt") != 0) {
     pT3_pt_branch = tree->GetBranch("pT3_pt");
     if (pT3_pt_branch) {
       pT3_pt_branch->SetAddress(&pT3_pt_);
     }
   }
   tc_pt_branch = 0;
   if (tree->GetBranch("tc_pt") != 0) {
     tc_pt_branch = tree->GetBranch("tc_pt");
     if (tc_pt_branch) {
       tc_pt_branch->SetAddress(&tc_pt_);
     }
   }
   pT3_phi_2_branch = 0;
   if (tree->GetBranch("pT3_phi_2") != 0) {
     pT3_phi_2_branch = tree->GetBranch("pT3_phi_2");
     if (pT3_phi_2_branch) {
       pT3_phi_2_branch->SetAddress(&pT3_phi_2_);
     }
   }
   pT5_pt_branch = 0;
   if (tree->GetBranch("pT5_pt") != 0) {
     pT5_pt_branch = tree->GetBranch("pT5_pt");
     if (pT5_pt_branch) {
       pT5_pt_branch->SetAddress(&pT5_pt_);
     }
   }
   pureTCE_rPhiChiSquared_branch = 0;
   if (tree->GetBranch("pureTCE_rPhiChiSquared") != 0) {
     pureTCE_rPhiChiSquared_branch = tree->GetBranch("pureTCE_rPhiChiSquared");
     if (pureTCE_rPhiChiSquared_branch) {
       pureTCE_rPhiChiSquared_branch->SetAddress(&pureTCE_rPhiChiSquared_);
     }
   }
   pT5_score_branch = 0;
   if (tree->GetBranch("pT5_score") != 0) {
     pT5_score_branch = tree->GetBranch("pT5_score");
     if (pT5_score_branch) {
       pT5_score_branch->SetAddress(&pT5_score_);
     }
   }
   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_);
     }
   }
   pT5_isFake_branch = 0;
   if (tree->GetBranch("pT5_isFake") != 0) {
     pT5_isFake_branch = tree->GetBranch("pT5_isFake");
     if (pT5_isFake_branch) {
       pT5_isFake_branch->SetAddress(&pT5_isFake_);
     }
   }
   tc_maxHitMatchedCounts_branch = 0;
   if (tree->GetBranch("tc_maxHitMatchedCounts") != 0) {
     tc_maxHitMatchedCounts_branch = tree->GetBranch("tc_maxHitMatchedCounts");
     if (tc_maxHitMatchedCounts_branch) {
       tc_maxHitMatchedCounts_branch->SetAddress(&tc_maxHitMatchedCounts_);
     }
   }
   pureTCE_nLayerOverlaps_branch = 0;
   if (tree->GetBranch("pureTCE_nLayerOverlaps") != 0) {
     pureTCE_nLayerOverlaps_branch = tree->GetBranch("pureTCE_nLayerOverlaps");
     if (pureTCE_nLayerOverlaps_branch) {
       pureTCE_nLayerOverlaps_branch->SetAddress(&pureTCE_nLayerOverlaps_);
     }
   }
   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_);
     }
   }
   pureTCE_hitIdxs_branch = 0;
   if (tree->GetBranch("pureTCE_hitIdxs") != 0) {
     pureTCE_hitIdxs_branch = tree->GetBranch("pureTCE_hitIdxs");
     if (pureTCE_hitIdxs_branch) {
       pureTCE_hitIdxs_branch->SetAddress(&pureTCE_hitIdxs_);
     }
   }
   pureTCE_nHitOverlaps_branch = 0;
   if (tree->GetBranch("pureTCE_nHitOverlaps") != 0) {
     pureTCE_nHitOverlaps_branch = tree->GetBranch("pureTCE_nHitOverlaps");
     if (pureTCE_nHitOverlaps_branch) {
       pureTCE_nHitOverlaps_branch->SetAddress(&pureTCE_nHitOverlaps_);
     }
   }
   sim_pLS_matched_branch = 0;
   if (tree->GetBranch("sim_pLS_matched") != 0) {
     sim_pLS_matched_branch = tree->GetBranch("sim_pLS_matched");
     if (sim_pLS_matched_branch) {
       sim_pLS_matched_branch->SetAddress(&sim_pLS_matched_);
     }
   }
   tc_matched_simIdx_branch = 0;
   if (tree->GetBranch("tc_matched_simIdx") != 0) {
     tc_matched_simIdx_branch = tree->GetBranch("tc_matched_simIdx");
     if (tc_matched_simIdx_branch) {
       tc_matched_simIdx_branch->SetAddress(&tc_matched_simIdx_);
     }
   }
   sim_T3_matched_branch = 0;
   if (tree->GetBranch("sim_T3_matched") != 0) {
     sim_T3_matched_branch = tree->GetBranch("sim_T3_matched");
     if (sim_T3_matched_branch) {
       sim_T3_matched_branch->SetAddress(&sim_T3_matched_);
     }
   }
   pLS_score_branch = 0;
   if (tree->GetBranch("pLS_score") != 0) {
     pLS_score_branch = tree->GetBranch("pLS_score");
     if (pLS_score_branch) {
       pLS_score_branch->SetAddress(&pLS_score_);
     }
   }
   pT3_phi_branch = 0;
   if (tree->GetBranch("pT3_phi") != 0) {
     pT3_phi_branch = tree->GetBranch("pT3_phi");
     if (pT3_phi_branch) {
       pT3_phi_branch->SetAddress(&pT3_phi_);
     }
   }
   pT5_eta_branch = 0;
   if (tree->GetBranch("pT5_eta") != 0) {
     pT5_eta_branch = tree->GetBranch("pT5_eta");
     if (pT5_eta_branch) {
       pT5_eta_branch->SetAddress(&pT5_eta_);
     }
   }
   tc_phi_branch = 0;
   if (tree->GetBranch("tc_phi") != 0) {
     tc_phi_branch = tree->GetBranch("tc_phi");
     if (tc_phi_branch) {
       tc_phi_branch->SetAddress(&tc_phi_);
     }
   }
   t4_eta_branch = 0;
   if (tree->GetBranch("t4_eta") != 0) {
     t4_eta_branch = tree->GetBranch("t4_eta");
     if (t4_eta_branch) {
       t4_eta_branch->SetAddress(&t4_eta_);
     }
   }
   pLS_isFake_branch = 0;
   if (tree->GetBranch("pLS_isFake") != 0) {
     pLS_isFake_branch = tree->GetBranch("pLS_isFake");
     if (pLS_isFake_branch) {
       pLS_isFake_branch->SetAddress(&pLS_isFake_);
     }
   }
   pureTCE_matched_simIdx_branch = 0;
   if (tree->GetBranch("pureTCE_matched_simIdx") != 0) {
     pureTCE_matched_simIdx_branch = tree->GetBranch("pureTCE_matched_simIdx");
     if (pureTCE_matched_simIdx_branch) {
       pureTCE_matched_simIdx_branch->SetAddress(&pureTCE_matched_simIdx_);
     }
   }
   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_);
     }
   }
   tc_partOfExtension_branch = 0;
   if (tree->GetBranch("tc_partOfExtension") != 0) {
     tc_partOfExtension_branch = tree->GetBranch("tc_partOfExtension");
     if (tc_partOfExtension_branch) {
       tc_partOfExtension_branch->SetAddress(&tc_partOfExtension_);
     }
   }
   pT3_eta_branch = 0;
   if (tree->GetBranch("pT3_eta") != 0) {
     pT3_eta_branch = tree->GetBranch("pT3_eta");
     if (pT3_eta_branch) {
       pT3_eta_branch->SetAddress(&pT3_eta_);
     }
   }
   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_);
     }
   }
   pureTCE_layer_binary_branch = 0;
   if (tree->GetBranch("pureTCE_layer_binary") != 0) {
     pureTCE_layer_binary_branch = tree->GetBranch("pureTCE_layer_binary");
     if (pureTCE_layer_binary_branch) {
       pureTCE_layer_binary_branch->SetAddress(&pureTCE_layer_binary_);
     }
   }
   sim_pT4_matched_branch = 0;
   if (tree->GetBranch("sim_pT4_matched") != 0) {
     sim_pT4_matched_branch = tree->GetBranch("sim_pT4_matched");
     if (sim_pT4_matched_branch) {
       sim_pT4_matched_branch->SetAddress(&sim_pT4_matched_);
     }
   }
   tc_eta_branch = 0;
   if (tree->GetBranch("tc_eta") != 0) {
     tc_eta_branch = tree->GetBranch("tc_eta");
     if (tc_eta_branch) {
       tc_eta_branch->SetAddress(&tc_eta_);
     }
   }
   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_);
     }
   }
   sim_T5_matched_branch = 0;
   if (tree->GetBranch("sim_T5_matched") != 0) {
     sim_T5_matched_branch = tree->GetBranch("sim_T5_matched");
     if (sim_T5_matched_branch) {
       sim_T5_matched_branch->SetAddress(&sim_T5_matched_);
     }
   }
   sim_T5_types_branch = 0;
   if (tree->GetBranch("sim_T5_types") != 0) {
     sim_T5_types_branch = tree->GetBranch("sim_T5_types");
     if (sim_T5_types_branch) {
       sim_T5_types_branch->SetAddress(&sim_T5_types_);
     }
   }
   tce_matched_simIdx_branch = 0;
   if (tree->GetBranch("tce_matched_simIdx") != 0) {
     tce_matched_simIdx_branch = tree->GetBranch("tce_matched_simIdx");
     if (tce_matched_simIdx_branch) {
       tce_matched_simIdx_branch->SetAddress(&tce_matched_simIdx_);
     }
   }
   t5_isDuplicate_branch = 0;
   if (tree->GetBranch("t5_isDuplicate") != 0) {
     t5_isDuplicate_branch = tree->GetBranch("t5_isDuplicate");
     if (t5_isDuplicate_branch) {
       t5_isDuplicate_branch->SetAddress(&t5_isDuplicate_);
     }
   }
   pT3_hitIdxs_branch = 0;
   if (tree->GetBranch("pT3_hitIdxs") != 0) {
     pT3_hitIdxs_branch = tree->GetBranch("pT3_hitIdxs");
     if (pT3_hitIdxs_branch) {
       pT3_hitIdxs_branch->SetAddress(&pT3_hitIdxs_);
     }
   }
   tc_hitIdxs_branch = 0;
   if (tree->GetBranch("tc_hitIdxs") != 0) {
     tc_hitIdxs_branch = tree->GetBranch("tc_hitIdxs");
     if (tc_hitIdxs_branch) {
       tc_hitIdxs_branch->SetAddress(&tc_hitIdxs_);
     }
   }
   pT3_occupancies_branch = 0;
   if (tree->GetBranch("pT3_occupancies") != 0) {
     pT3_occupancies_branch = tree->GetBranch("pT3_occupancies");
     if (pT3_occupancies_branch) {
       pT3_occupancies_branch->SetAddress(&pT3_occupancies_);
     }
   }
   tc_occupancies_branch = 0;
   if (tree->GetBranch("tc_occupancies") != 0) {
     tc_occupancies_branch = tree->GetBranch("tc_occupancies");
     if (tc_occupancies_branch) {
       tc_occupancies_branch->SetAddress(&tc_occupancies_);
     }
   }
   sim_TC_matched_branch = 0;
   if (tree->GetBranch("sim_TC_matched") != 0) {
     sim_TC_matched_branch = tree->GetBranch("sim_TC_matched");
     if (sim_TC_matched_branch) {
       sim_TC_matched_branch->SetAddress(&sim_TC_matched_);
     }
   }
   sim_TC_matched_mask_branch = 0;
   if (tree->GetBranch("sim_TC_matched_mask") != 0) {
     sim_TC_matched_mask_branch = tree->GetBranch("sim_TC_matched_mask");
     if (sim_TC_matched_mask_branch) {
       sim_TC_matched_mask_branch->SetAddress(&sim_TC_matched_mask_);
     }
   }
   pLS_isDuplicate_branch = 0;
   if (tree->GetBranch("pLS_isDuplicate") != 0) {
     pLS_isDuplicate_branch = tree->GetBranch("pLS_isDuplicate");
     if (pLS_isDuplicate_branch) {
       pLS_isDuplicate_branch->SetAddress(&pLS_isDuplicate_);
     }
   }
   tce_anchorIndex_branch = 0;
   if (tree->GetBranch("tce_anchorIndex") != 0) {
     tce_anchorIndex_branch = tree->GetBranch("tce_anchorIndex");
     if (tce_anchorIndex_branch) {
       tce_anchorIndex_branch->SetAddress(&tce_anchorIndex_);
     }
   }
   t5_occupancies_branch = 0;
   if (tree->GetBranch("t5_occupancies") != 0) {
     t5_occupancies_branch = tree->GetBranch("t5_occupancies");
     if (t5_occupancies_branch) {
       t5_occupancies_branch->SetAddress(&t5_occupancies_);
     }
   }
   tc_type_branch = 0;
   if (tree->GetBranch("tc_type") != 0) {
     tc_type_branch = tree->GetBranch("tc_type");
     if (tc_type_branch) {
       tc_type_branch->SetAddress(&tc_type_);
     }
   }
   tce_isFake_branch = 0;
   if (tree->GetBranch("tce_isFake") != 0) {
     tce_isFake_branch = tree->GetBranch("tce_isFake");
     if (tce_isFake_branch) {
       tce_isFake_branch->SetAddress(&tce_isFake_);
     }
   }
   pLS_pt_branch = 0;
   if (tree->GetBranch("pLS_pt") != 0) {
     pLS_pt_branch = tree->GetBranch("pLS_pt");
     if (pLS_pt_branch) {
       pLS_pt_branch->SetAddress(&pLS_pt_);
     }
   }
   pureTCE_anchorIndex_branch = 0;
   if (tree->GetBranch("pureTCE_anchorIndex") != 0) {
     pureTCE_anchorIndex_branch = tree->GetBranch("pureTCE_anchorIndex");
     if (pureTCE_anchorIndex_branch) {
       pureTCE_anchorIndex_branch->SetAddress(&pureTCE_anchorIndex_);
     }
   }
   sim_T4_types_branch = 0;
   if (tree->GetBranch("sim_T4_types") != 0) {
     sim_T4_types_branch = tree->GetBranch("sim_T4_types");
     if (sim_T4_types_branch) {
       sim_T4_types_branch->SetAddress(&sim_T4_types_);
     }
   }
   pT4_isDuplicate_branch = 0;
   if (tree->GetBranch("pT4_isDuplicate") != 0) {
     pT4_isDuplicate_branch = tree->GetBranch("pT4_isDuplicate");
     if (pT4_isDuplicate_branch) {
       pT4_isDuplicate_branch->SetAddress(&pT4_isDuplicate_);
     }
   }
   t4_pt_branch = 0;
   if (tree->GetBranch("t4_pt") != 0) {
     t4_pt_branch = tree->GetBranch("t4_pt");
     if (t4_pt_branch) {
       t4_pt_branch->SetAddress(&t4_pt_);
     }
   }
   sim_TC_types_branch = 0;
   if (tree->GetBranch("sim_TC_types") != 0) {
     sim_TC_types_branch = tree->GetBranch("sim_TC_types");
     if (sim_TC_types_branch) {
       sim_TC_types_branch->SetAddress(&sim_TC_types_);
     }
   }
   sg_occupancies_branch = 0;
   if (tree->GetBranch("sg_occupancies") != 0) {
     sg_occupancies_branch = tree->GetBranch("sg_occupancies");
     if (sg_occupancies_branch) {
       sg_occupancies_branch->SetAddress(&sg_occupancies_);
     }
   }
   pT4_pt_branch = 0;
   if (tree->GetBranch("pT4_pt") != 0) {
     pT4_pt_branch = tree->GetBranch("pT4_pt");
     if (pT4_pt_branch) {
       pT4_pt_branch->SetAddress(&pT4_pt_);
     }
   }
   pureTCE_phi_branch = 0;
   if (tree->GetBranch("pureTCE_phi") != 0) {
     pureTCE_phi_branch = tree->GetBranch("pureTCE_phi");
     if (pureTCE_phi_branch) {
       pureTCE_phi_branch->SetAddress(&pureTCE_phi_);
     }
   }
   sim_vx_branch = 0;
   if (tree->GetBranch("sim_vx") != 0) {
     sim_vx_branch = tree->GetBranch("sim_vx");
     if (sim_vx_branch) {
       sim_vx_branch->SetAddress(&sim_vx_);
     }
   }
   sim_vy_branch = 0;
   if (tree->GetBranch("sim_vy") != 0) {
     sim_vy_branch = tree->GetBranch("sim_vy");
     if (sim_vy_branch) {
       sim_vy_branch->SetAddress(&sim_vy_);
     }
   }
   sim_vz_branch = 0;
   if (tree->GetBranch("sim_vz") != 0) {
     sim_vz_branch = tree->GetBranch("sim_vz");
     if (sim_vz_branch) {
       sim_vz_branch->SetAddress(&sim_vz_);
     }
   }
   tce_maxHitMatchedCounts_branch = 0;
   if (tree->GetBranch("tce_maxHitMatchedCounts") != 0) {
     tce_maxHitMatchedCounts_branch = tree->GetBranch("tce_maxHitMatchedCounts");
     if (tce_maxHitMatchedCounts_branch) {
       tce_maxHitMatchedCounts_branch->SetAddress(&tce_maxHitMatchedCounts_);
     }
   }
   t3_pt_branch = 0;
   if (tree->GetBranch("t3_pt") != 0) {
     t3_pt_branch = tree->GetBranch("t3_pt");
     if (t3_pt_branch) {
       t3_pt_branch->SetAddress(&t3_pt_);
     }
   }
   module_rings_branch = 0;
   if (tree->GetBranch("module_rings") != 0) {
     module_rings_branch = tree->GetBranch("module_rings");
     if (module_rings_branch) {
       module_rings_branch->SetAddress(&module_rings_);
     }
   }
   sim_T3_types_branch = 0;
   if (tree->GetBranch("sim_T3_types") != 0) {
     sim_T3_types_branch = tree->GetBranch("sim_T3_types");
     if (sim_T3_types_branch) {
       sim_T3_types_branch->SetAddress(&sim_T3_types_);
     }
   }
   sim_pT5_types_branch = 0;
   if (tree->GetBranch("sim_pT5_types") != 0) {
     sim_pT5_types_branch = tree->GetBranch("sim_pT5_types");
     if (sim_pT5_types_branch) {
       sim_pT5_types_branch->SetAddress(&sim_pT5_types_);
     }
   }
   sim_pT5_matched_branch = 0;
   if (tree->GetBranch("sim_pT5_matched") != 0) {
     sim_pT5_matched_branch = tree->GetBranch("sim_pT5_matched");
     if (sim_pT5_matched_branch) {
       sim_pT5_matched_branch->SetAddress(&sim_pT5_matched_);
     }
   }
   module_layers_branch = 0;
   if (tree->GetBranch("module_layers") != 0) {
     module_layers_branch = tree->GetBranch("module_layers");
     if (module_layers_branch) {
       module_layers_branch->SetAddress(&module_layers_);
     }
   }
   pT4_eta_branch = 0;
   if (tree->GetBranch("pT4_eta") != 0) {
     pT4_eta_branch = tree->GetBranch("pT4_eta");
     if (pT4_eta_branch) {
       pT4_eta_branch->SetAddress(&pT4_eta_);
     }
   }
   sim_tce_types_branch = 0;
   if (tree->GetBranch("sim_tce_types") != 0) {
     sim_tce_types_branch = tree->GetBranch("sim_tce_types");
     if (sim_tce_types_branch) {
       sim_tce_types_branch->SetAddress(&sim_tce_types_);
     }
   }
   tce_rzChiSquared_branch = 0;
   if (tree->GetBranch("tce_rzChiSquared") != 0) {
     tce_rzChiSquared_branch = tree->GetBranch("tce_rzChiSquared");
     if (tce_rzChiSquared_branch) {
       tce_rzChiSquared_branch->SetAddress(&tce_rzChiSquared_);
     }
   }
   pT3_matched_simIdx_branch = 0;
   if (tree->GetBranch("pT3_matched_simIdx") != 0) {
     pT3_matched_simIdx_branch = tree->GetBranch("pT3_matched_simIdx");
     if (pT3_matched_simIdx_branch) {
       pT3_matched_simIdx_branch->SetAddress(&pT3_matched_simIdx_);
     }
   }
   tree->SetMakeClass(0);
 }

◆ LoadAllBranches()

void LSTEff::LoadAllBranches ( )

Definition at line 1179 of file LSTEff.cc.

                              {
   if (pT5_occupancies_branch != 0)
     pT5_occupancies();
   if (t3_phi_branch != 0)
     t3_phi();
   if (t5_score_rphisum_branch != 0)
     t5_score_rphisum();
   if (pT4_isFake_branch != 0)
     pT4_isFake();
   if (t3_isDuplicate_branch != 0)
     t3_isDuplicate();
   if (sim_event_branch != 0)
     sim_event();
   if (sim_q_branch != 0)
     sim_q();
   if (sim_eta_branch != 0)
     sim_eta();
   if (pT3_foundDuplicate_branch != 0)
     pT3_foundDuplicate();
   if (sim_len_branch != 0)
     sim_len();
   if (pureTCE_isDuplicate_branch != 0)
     pureTCE_isDuplicate();
   if (pT3_score_branch != 0)
     pT3_score();
   if (t5_eta_branch != 0)
     t5_eta();
   if (sim_denom_branch != 0)
     sim_denom();
   if (pT5_isDuplicate_branch != 0)
     pT5_isDuplicate();
   if (sim_tce_matched_branch != 0)
     sim_tce_matched();
   if (pT3_isDuplicate_branch != 0)
     pT3_isDuplicate();
   if (tc_isDuplicate_branch != 0)
     tc_isDuplicate();
   if (pT3_eta_2_branch != 0)
     pT3_eta_2();
   if (sim_pT3_matched_branch != 0)
     sim_pT3_matched();
   if (pureTCE_rzChiSquared_branch != 0)
     pureTCE_rzChiSquared();
   if (t4_isDuplicate_branch != 0)
     t4_isDuplicate();
   if (pureTCE_eta_branch != 0)
     pureTCE_eta();
   if (tce_rPhiChiSquared_branch != 0)
     tce_rPhiChiSquared();
   if (pureTCE_anchorType_branch != 0)
     pureTCE_anchorType();
   if (pureTCE_pt_branch != 0)
     pureTCE_pt();
   if (sim_pt_branch != 0)
     sim_pt();
   if (t5_eta_2_branch != 0)
     t5_eta_2();
   if (pLS_eta_branch != 0)
     pLS_eta();
   if (sim_pdgId_branch != 0)
     sim_pdgId();
   if (t3_eta_branch != 0)
     t3_eta();
   if (tce_layer_binary_branch != 0)
     tce_layer_binary();
   if (sim_TC_matched_nonextended_branch != 0)
     sim_TC_matched_nonextended();
   if (t4_occupancies_branch != 0)
     t4_occupancies();
   if (tce_eta_branch != 0)
     tce_eta();
   if (tce_isDuplicate_branch != 0)
     tce_isDuplicate();
   if (pT5_matched_simIdx_branch != 0)
     pT5_matched_simIdx();
   if (sim_tcIdx_branch != 0)
     sim_tcIdx();
   if (t5_phi_2_branch != 0)
     t5_phi_2();
   if (pureTCE_maxHitMatchedCounts_branch != 0)
     pureTCE_maxHitMatchedCounts();
   if (t5_matched_simIdx_branch != 0)
     t5_matched_simIdx();
   if (module_subdets_branch != 0)
     module_subdets();
   if (tce_anchorType_branch != 0)
     tce_anchorType();
   if (tce_nHitOverlaps_branch != 0)
     tce_nHitOverlaps();
   if (t3_isFake_branch != 0)
     t3_isFake();
   if (tce_phi_branch != 0)
     tce_phi();
   if (t5_isFake_branch != 0)
     t5_isFake();
   if (md_occupancies_branch != 0)
     md_occupancies();
   if (t5_hitIdxs_branch != 0)
     t5_hitIdxs();
   if (sim_pT3_types_branch != 0)
     sim_pT3_types();
   if (sim_pureTCE_types_branch != 0)
     sim_pureTCE_types();
   if (t4_phi_branch != 0)
     t4_phi();
   if (t5_phi_branch != 0)
     t5_phi();
   if (pT5_hitIdxs_branch != 0)
     pT5_hitIdxs();
   if (t5_pt_branch != 0)
     t5_pt();
   if (pT5_phi_branch != 0)
     pT5_phi();
   if (pureTCE_isFake_branch != 0)
     pureTCE_isFake();
   if (tce_pt_branch != 0)
     tce_pt();
   if (tc_isFake_branch != 0)
     tc_isFake();
   if (pT3_isFake_branch != 0)
     pT3_isFake();
   if (tce_nLayerOverlaps_branch != 0)
     tce_nLayerOverlaps();
   if (tc_sim_branch != 0)
     tc_sim();
   if (sim_pLS_types_branch != 0)
     sim_pLS_types();
   if (sim_pca_dxy_branch != 0)
     sim_pca_dxy();
   if (pT4_phi_branch != 0)
     pT4_phi();
   if (sim_hits_branch != 0)
     sim_hits();
   if (pLS_phi_branch != 0)
     pLS_phi();
   if (sim_pureTCE_matched_branch != 0)
     sim_pureTCE_matched();
   if (t3_occupancies_branch != 0)
     t3_occupancies();
   if (t5_foundDuplicate_branch != 0)
     t5_foundDuplicate();
   if (sim_pT4_types_branch != 0)
     sim_pT4_types();
   if (t4_isFake_branch != 0)
     t4_isFake();
   if (simvtx_x_branch != 0)
     simvtx_x();
   if (simvtx_y_branch != 0)
     simvtx_y();
   if (simvtx_z_branch != 0)
     simvtx_z();
   if (sim_T4_matched_branch != 0)
     sim_T4_matched();
   if (sim_isGood_branch != 0)
     sim_isGood();
   if (pT3_pt_branch != 0)
     pT3_pt();
   if (tc_pt_branch != 0)
     tc_pt();
   if (pT3_phi_2_branch != 0)
     pT3_phi_2();
   if (pT5_pt_branch != 0)
     pT5_pt();
   if (pureTCE_rPhiChiSquared_branch != 0)
     pureTCE_rPhiChiSquared();
   if (pT5_score_branch != 0)
     pT5_score();
   if (sim_phi_branch != 0)
     sim_phi();
   if (pT5_isFake_branch != 0)
     pT5_isFake();
   if (tc_maxHitMatchedCounts_branch != 0)
     tc_maxHitMatchedCounts();
   if (pureTCE_nLayerOverlaps_branch != 0)
     pureTCE_nLayerOverlaps();
   if (sim_pca_dz_branch != 0)
     sim_pca_dz();
   if (pureTCE_hitIdxs_branch != 0)
     pureTCE_hitIdxs();
   if (pureTCE_nHitOverlaps_branch != 0)
     pureTCE_nHitOverlaps();
   if (sim_pLS_matched_branch != 0)
     sim_pLS_matched();
   if (tc_matched_simIdx_branch != 0)
     tc_matched_simIdx();
   if (sim_T3_matched_branch != 0)
     sim_T3_matched();
   if (pLS_score_branch != 0)
     pLS_score();
   if (pT3_phi_branch != 0)
     pT3_phi();
   if (pT5_eta_branch != 0)
     pT5_eta();
   if (tc_phi_branch != 0)
     tc_phi();
   if (t4_eta_branch != 0)
     t4_eta();
   if (pLS_isFake_branch != 0)
     pLS_isFake();
   if (pureTCE_matched_simIdx_branch != 0)
     pureTCE_matched_simIdx();
   if (sim_bunchCrossing_branch != 0)
     sim_bunchCrossing();
   if (tc_partOfExtension_branch != 0)
     tc_partOfExtension();
   if (pT3_eta_branch != 0)
     pT3_eta();
   if (sim_parentVtxIdx_branch != 0)
     sim_parentVtxIdx();
   if (pureTCE_layer_binary_branch != 0)
     pureTCE_layer_binary();
   if (sim_pT4_matched_branch != 0)
     sim_pT4_matched();
   if (tc_eta_branch != 0)
     tc_eta();
   if (sim_lengap_branch != 0)
     sim_lengap();
   if (sim_T5_matched_branch != 0)
     sim_T5_matched();
   if (sim_T5_types_branch != 0)
     sim_T5_types();
   if (tce_matched_simIdx_branch != 0)
     tce_matched_simIdx();
   if (t5_isDuplicate_branch != 0)
     t5_isDuplicate();
   if (pT3_hitIdxs_branch != 0)
     pT3_hitIdxs();
   if (tc_hitIdxs_branch != 0)
     tc_hitIdxs();
   if (pT3_occupancies_branch != 0)
     pT3_occupancies();
   if (tc_occupancies_branch != 0)
     tc_occupancies();
   if (sim_TC_matched_branch != 0)
     sim_TC_matched();
   if (sim_TC_matched_mask_branch != 0)
     sim_TC_matched_mask();
   if (pLS_isDuplicate_branch != 0)
     pLS_isDuplicate();
   if (tce_anchorIndex_branch != 0)
     tce_anchorIndex();
   if (t5_occupancies_branch != 0)
     t5_occupancies();
   if (tc_type_branch != 0)
     tc_type();
   if (tce_isFake_branch != 0)
     tce_isFake();
   if (pLS_pt_branch != 0)
     pLS_pt();
   if (pureTCE_anchorIndex_branch != 0)
     pureTCE_anchorIndex();
   if (sim_T4_types_branch != 0)
     sim_T4_types();
   if (pT4_isDuplicate_branch != 0)
     pT4_isDuplicate();
   if (t4_pt_branch != 0)
     t4_pt();
   if (sim_TC_types_branch != 0)
     sim_TC_types();
   if (sg_occupancies_branch != 0)
     sg_occupancies();
   if (pT4_pt_branch != 0)
     pT4_pt();
   if (pureTCE_phi_branch != 0)
     pureTCE_phi();
   if (sim_vx_branch != 0)
     sim_vx();
   if (sim_vy_branch != 0)
     sim_vy();
   if (sim_vz_branch != 0)
     sim_vz();
   if (tce_maxHitMatchedCounts_branch != 0)
     tce_maxHitMatchedCounts();
   if (t3_pt_branch != 0)
     t3_pt();
   if (module_rings_branch != 0)
     module_rings();
   if (sim_T3_types_branch != 0)
     sim_T3_types();
   if (sim_pT5_types_branch != 0)
     sim_pT5_types();
   if (sim_pT5_matched_branch != 0)
     sim_pT5_matched();
   if (module_layers_branch != 0)
     module_layers();
   if (pT4_eta_branch != 0)
     pT4_eta();
   if (sim_tce_types_branch != 0)
     sim_tce_types();
   if (tce_rzChiSquared_branch != 0)
     tce_rzChiSquared();
   if (pT3_matched_simIdx_branch != 0)
     pT3_matched_simIdx();
 }

◆ md_occupancies()

const std::vector< int > & LSTEff::md_occupancies ( )

Definition at line 2037 of file LSTEff.cc.

References beamvalidation::exit(), index, md_occupancies_, md_occupancies_branch, and md_occupancies_isLoaded.

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

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

◆ module_layers()

const std::vector< int > & LSTEff::module_layers ( )

Definition at line 3165 of file LSTEff.cc.

References beamvalidation::exit(), index, module_layers_, module_layers_branch, and module_layers_isLoaded.

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

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

◆ module_rings()

const std::vector< int > & LSTEff::module_rings ( )

Definition at line 3117 of file LSTEff.cc.

References beamvalidation::exit(), index, module_rings_, module_rings_branch, and module_rings_isLoaded.

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

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

◆ module_subdets()

const std::vector< int > & LSTEff::module_subdets ( )

Definition at line 1965 of file LSTEff.cc.

References beamvalidation::exit(), index, module_subdets_, module_subdets_branch, and module_subdets_isLoaded.

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

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

◆ pLS_eta()

const std::vector< float > & LSTEff::pLS_eta ( )

Definition at line 1809 of file LSTEff.cc.

References beamvalidation::exit(), index, pLS_eta_, pLS_eta_branch, and pLS_eta_isLoaded.

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

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

◆ pLS_isDuplicate()

const std::vector< int > & LSTEff::pLS_isDuplicate ( )

Definition at line 2889 of file LSTEff.cc.

References beamvalidation::exit(), index, pLS_isDuplicate_, pLS_isDuplicate_branch, and pLS_isDuplicate_isLoaded.

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

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

◆ pLS_isFake()

const std::vector< int > & LSTEff::pLS_isFake ( )

Definition at line 2649 of file LSTEff.cc.

References beamvalidation::exit(), index, pLS_isFake_, pLS_isFake_branch, and pLS_isFake_isLoaded.

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

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

◆ pLS_phi()

const std::vector< float > & LSTEff::pLS_phi ( )

Definition at line 2265 of file LSTEff.cc.

References beamvalidation::exit(), index, pLS_phi_, pLS_phi_branch, and pLS_phi_isLoaded.

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

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

◆ pLS_pt()

const std::vector< float > & LSTEff::pLS_pt ( )

Definition at line 2949 of file LSTEff.cc.

References beamvalidation::exit(), index, pLS_pt_, pLS_pt_branch, and pLS_pt_isLoaded.

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

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

◆ pLS_score()

const std::vector< float > & LSTEff::pLS_score ( )

Definition at line 2589 of file LSTEff.cc.

References beamvalidation::exit(), index, pLS_score_, pLS_score_branch, and pLS_score_isLoaded.

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

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

◆ progress()

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

static

Definition at line 3225 of file LSTEff.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;
       }
     }
   }
 }

◆ pT3_eta()

const std::vector< float > & LSTEff::pT3_eta ( )

Definition at line 2697 of file LSTEff.cc.

References beamvalidation::exit(), index, pT3_eta_, pT3_eta_branch, and pT3_eta_isLoaded.

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

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

◆ pT3_eta_2()

const std::vector< float > & LSTEff::pT3_eta_2 ( )

Definition at line 1689 of file LSTEff.cc.

References beamvalidation::exit(), index, pT3_eta_2_, pT3_eta_2_branch, and pT3_eta_2_isLoaded.

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

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

◆ pT3_foundDuplicate()

const std::vector< int > & LSTEff::pT3_foundDuplicate ( )

Definition at line 1569 of file LSTEff.cc.

References beamvalidation::exit(), index, pT3_foundDuplicate_, pT3_foundDuplicate_branch, and pT3_foundDuplicate_isLoaded.

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

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

◆ pT3_hitIdxs()

const std::vector< std::vector< int > > & LSTEff::pT3_hitIdxs ( )

Definition at line 2817 of file LSTEff.cc.

References beamvalidation::exit(), index, pT3_hitIdxs_, pT3_hitIdxs_branch, and pT3_hitIdxs_isLoaded.

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

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

◆ pT3_isDuplicate()

const std::vector< int > & LSTEff::pT3_isDuplicate ( )

Definition at line 1665 of file LSTEff.cc.

References beamvalidation::exit(), index, pT3_isDuplicate_, pT3_isDuplicate_branch, and pT3_isDuplicate_isLoaded.

Referenced by LoadAllBranches(), main(), and tas::pT3_isDuplicate().

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

◆ pT3_isFake()

const std::vector< int > & LSTEff::pT3_isFake ( )

Definition at line 2181 of file LSTEff.cc.

References beamvalidation::exit(), index, pT3_isFake_, pT3_isFake_branch, and pT3_isFake_isLoaded.

Referenced by LoadAllBranches(), main(), and tas::pT3_isFake().

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

◆ pT3_matched_simIdx()

const std::vector< std::vector< int > > & LSTEff::pT3_matched_simIdx ( )

Definition at line 3213 of file LSTEff.cc.

References beamvalidation::exit(), index, pT3_matched_simIdx_, pT3_matched_simIdx_branch, and pT3_matched_simIdx_isLoaded.

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

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

◆ pT3_occupancies()

const int & LSTEff::pT3_occupancies ( )

Definition at line 2841 of file LSTEff.cc.

References beamvalidation::exit(), index, pT3_occupancies_, pT3_occupancies_branch, and pT3_occupancies_isLoaded.

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

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

◆ pT3_phi()

const std::vector< float > & LSTEff::pT3_phi ( )

Definition at line 2601 of file LSTEff.cc.

References beamvalidation::exit(), index, pT3_phi_, pT3_phi_branch, and pT3_phi_isLoaded.

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

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

◆ pT3_phi_2()

const std::vector< float > & LSTEff::pT3_phi_2 ( )

Definition at line 2421 of file LSTEff.cc.

References beamvalidation::exit(), index, pT3_phi_2_, pT3_phi_2_branch, and pT3_phi_2_isLoaded.

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

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

◆ pT3_pt()

const std::vector< float > & LSTEff::pT3_pt ( )

Definition at line 2397 of file LSTEff.cc.

References beamvalidation::exit(), index, pT3_pt_, pT3_pt_branch, and pT3_pt_isLoaded.

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

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

◆ pT3_score()

const std::vector< float > & LSTEff::pT3_score ( )

Definition at line 1605 of file LSTEff.cc.

References beamvalidation::exit(), index, pT3_score_, pT3_score_branch, and pT3_score_isLoaded.

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

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

◆ pT4_eta()

const std::vector< float > & LSTEff::pT4_eta ( )

Definition at line 3177 of file LSTEff.cc.

References beamvalidation::exit(), index, pT4_eta_, pT4_eta_branch, and pT4_eta_isLoaded.

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

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

◆ pT4_isDuplicate()

const std::vector< int > & LSTEff::pT4_isDuplicate ( )

Definition at line 2985 of file LSTEff.cc.

References beamvalidation::exit(), index, pT4_isDuplicate_, pT4_isDuplicate_branch, and pT4_isDuplicate_isLoaded.

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

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

◆ pT4_isFake()

const std::vector< int > & LSTEff::pT4_isFake ( )

Definition at line 1509 of file LSTEff.cc.

References beamvalidation::exit(), index, pT4_isFake_, pT4_isFake_branch, and pT4_isFake_isLoaded.

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

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

◆ pT4_phi()

const std::vector< float > & LSTEff::pT4_phi ( )

Definition at line 2241 of file LSTEff.cc.

References beamvalidation::exit(), index, pT4_phi_, pT4_phi_branch, and pT4_phi_isLoaded.

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

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

◆ pT4_pt()

const std::vector< float > & LSTEff::pT4_pt ( )

Definition at line 3033 of file LSTEff.cc.

References beamvalidation::exit(), index, pT4_pt_, pT4_pt_branch, and pT4_pt_isLoaded.

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

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

◆ pT5_eta()

const std::vector< float > & LSTEff::pT5_eta ( )

Definition at line 2613 of file LSTEff.cc.

References beamvalidation::exit(), index, pT5_eta_, pT5_eta_branch, and pT5_eta_isLoaded.

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

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

◆ pT5_hitIdxs()

const std::vector< std::vector< int > > & LSTEff::pT5_hitIdxs ( )

Definition at line 2109 of file LSTEff.cc.

References beamvalidation::exit(), index, pT5_hitIdxs_, pT5_hitIdxs_branch, and pT5_hitIdxs_isLoaded.

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

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

◆ pT5_isDuplicate()

const std::vector< int > & LSTEff::pT5_isDuplicate ( )

Definition at line 1641 of file LSTEff.cc.

References beamvalidation::exit(), index, pT5_isDuplicate_, pT5_isDuplicate_branch, and pT5_isDuplicate_isLoaded.

Referenced by LoadAllBranches(), main(), and tas::pT5_isDuplicate().

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

◆ pT5_isFake()

const std::vector< int > & LSTEff::pT5_isFake ( )

Definition at line 2481 of file LSTEff.cc.

References beamvalidation::exit(), index, pT5_isFake_, pT5_isFake_branch, and pT5_isFake_isLoaded.

Referenced by LoadAllBranches(), main(), and tas::pT5_isFake().

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

◆ pT5_matched_simIdx()

const std::vector< std::vector< int > > & LSTEff::pT5_matched_simIdx ( )

Definition at line 1905 of file LSTEff.cc.

References beamvalidation::exit(), index, pT5_matched_simIdx_, pT5_matched_simIdx_branch, and pT5_matched_simIdx_isLoaded.

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

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

◆ pT5_occupancies()

const int & LSTEff::pT5_occupancies ( )

Definition at line 1473 of file LSTEff.cc.

References beamvalidation::exit(), index, pT5_occupancies_, pT5_occupancies_branch, and pT5_occupancies_isLoaded.

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

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

◆ pT5_phi()

const std::vector< float > & LSTEff::pT5_phi ( )

Definition at line 2133 of file LSTEff.cc.

References beamvalidation::exit(), index, pT5_phi_, pT5_phi_branch, and pT5_phi_isLoaded.

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

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

◆ pT5_pt()

const std::vector< float > & LSTEff::pT5_pt ( )

Definition at line 2433 of file LSTEff.cc.

References beamvalidation::exit(), index, pT5_pt_, pT5_pt_branch, and pT5_pt_isLoaded.

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

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

◆ pT5_score()

const std::vector< int > & LSTEff::pT5_score ( )

Definition at line 2457 of file LSTEff.cc.

References beamvalidation::exit(), index, pT5_score_, pT5_score_branch, and pT5_score_isLoaded.

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

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

◆ pureTCE_anchorIndex()

const std::vector< int > & LSTEff::pureTCE_anchorIndex ( )

Definition at line 2961 of file LSTEff.cc.

References beamvalidation::exit(), index, pureTCE_anchorIndex_, pureTCE_anchorIndex_branch, and pureTCE_anchorIndex_isLoaded.

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

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

◆ pureTCE_anchorType()

const std::vector< int > & LSTEff::pureTCE_anchorType ( )

Definition at line 1761 of file LSTEff.cc.

References beamvalidation::exit(), index, pureTCE_anchorType_, pureTCE_anchorType_branch, and pureTCE_anchorType_isLoaded.

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

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

◆ pureTCE_eta()

const std::vector< float > & LSTEff::pureTCE_eta ( )

Definition at line 1737 of file LSTEff.cc.

References beamvalidation::exit(), index, pureTCE_eta_, pureTCE_eta_branch, and pureTCE_eta_isLoaded.

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

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

◆ pureTCE_hitIdxs()

const std::vector< std::vector< int > > & LSTEff::pureTCE_hitIdxs ( )

Definition at line 2529 of file LSTEff.cc.

References beamvalidation::exit(), index, pureTCE_hitIdxs_, pureTCE_hitIdxs_branch, and pureTCE_hitIdxs_isLoaded.

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

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

◆ pureTCE_isDuplicate()

const std::vector< int > & LSTEff::pureTCE_isDuplicate ( )

Definition at line 1593 of file LSTEff.cc.

References beamvalidation::exit(), index, pureTCE_isDuplicate_, pureTCE_isDuplicate_branch, and pureTCE_isDuplicate_isLoaded.

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

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

◆ pureTCE_isFake()

const std::vector< int > & LSTEff::pureTCE_isFake ( )

Definition at line 2145 of file LSTEff.cc.

References beamvalidation::exit(), index, pureTCE_isFake_, pureTCE_isFake_branch, and pureTCE_isFake_isLoaded.

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

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

◆ pureTCE_layer_binary()

const std::vector< int > & LSTEff::pureTCE_layer_binary ( )

Definition at line 2721 of file LSTEff.cc.

References beamvalidation::exit(), index, pureTCE_layer_binary_, pureTCE_layer_binary_branch, and pureTCE_layer_binary_isLoaded.

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

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

◆ pureTCE_matched_simIdx()

const std::vector< std::vector< int > > & LSTEff::pureTCE_matched_simIdx ( )

Definition at line 2661 of file LSTEff.cc.

References beamvalidation::exit(), index, pureTCE_matched_simIdx_, pureTCE_matched_simIdx_branch, and pureTCE_matched_simIdx_isLoaded.

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

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

◆ pureTCE_maxHitMatchedCounts()

const std::vector< int > & LSTEff::pureTCE_maxHitMatchedCounts ( )

Definition at line 1941 of file LSTEff.cc.

References beamvalidation::exit(), index, pureTCE_maxHitMatchedCounts_, pureTCE_maxHitMatchedCounts_branch, and pureTCE_maxHitMatchedCounts_isLoaded.

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

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

◆ pureTCE_nHitOverlaps()

const std::vector< std::vector< int > > & LSTEff::pureTCE_nHitOverlaps ( )

Definition at line 2541 of file LSTEff.cc.

References beamvalidation::exit(), index, pureTCE_nHitOverlaps_, pureTCE_nHitOverlaps_branch, and pureTCE_nHitOverlaps_isLoaded.

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

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

◆ pureTCE_nLayerOverlaps()

const std::vector< std::vector< int > > & LSTEff::pureTCE_nLayerOverlaps ( )

Definition at line 2505 of file LSTEff.cc.

References beamvalidation::exit(), index, pureTCE_nLayerOverlaps_, pureTCE_nLayerOverlaps_branch, and pureTCE_nLayerOverlaps_isLoaded.

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

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

◆ pureTCE_phi()

const std::vector< float > & LSTEff::pureTCE_phi ( )

Definition at line 3045 of file LSTEff.cc.

References beamvalidation::exit(), index, pureTCE_phi_, pureTCE_phi_branch, and pureTCE_phi_isLoaded.

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

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

◆ pureTCE_pt()

const std::vector< float > & LSTEff::pureTCE_pt ( )

Definition at line 1773 of file LSTEff.cc.

References beamvalidation::exit(), index, pureTCE_pt_, pureTCE_pt_branch, and pureTCE_pt_isLoaded.

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

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

◆ pureTCE_rPhiChiSquared()

const std::vector< float > & LSTEff::pureTCE_rPhiChiSquared ( )

Definition at line 2445 of file LSTEff.cc.

References beamvalidation::exit(), index, pureTCE_rPhiChiSquared_, pureTCE_rPhiChiSquared_branch, and pureTCE_rPhiChiSquared_isLoaded.

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

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

◆ pureTCE_rzChiSquared()

const std::vector< float > & LSTEff::pureTCE_rzChiSquared ( )

Definition at line 1713 of file LSTEff.cc.

References beamvalidation::exit(), index, pureTCE_rzChiSquared_, pureTCE_rzChiSquared_branch, and pureTCE_rzChiSquared_isLoaded.

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

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

◆ sg_occupancies()

const std::vector< int > & LSTEff::sg_occupancies ( )

Definition at line 3021 of file LSTEff.cc.

References beamvalidation::exit(), index, sg_occupancies_, sg_occupancies_branch, and sg_occupancies_isLoaded.

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

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

◆ sim_bunchCrossing()

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

Definition at line 2673 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_bunchCrossing_, sim_bunchCrossing_branch, and sim_bunchCrossing_isLoaded.

Referenced by LoadAllBranches().

                                                 {
   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_denom()

const std::vector< int > & LSTEff::sim_denom ( )

Definition at line 1629 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_denom_, sim_denom_branch, and sim_denom_isLoaded.

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

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

◆ sim_eta()

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

Definition at line 1557 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_eta_, sim_eta_branch, and sim_eta_isLoaded.

Referenced by fillEfficiencySet(), LoadAllBranches(), and main().

                                         {
   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 > & LSTEff::sim_event ( )

Definition at line 1533 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_event_, sim_event_branch, and sim_event_isLoaded.

Referenced by LoadAllBranches().

                                         {
   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_hits()

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

Definition at line 2253 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_hits_, sim_hits_branch, and sim_hits_isLoaded.

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

                                          {
   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_isGood()

const std::vector< bool > & LSTEff::sim_isGood ( )

Definition at line 2385 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_isGood_, sim_isGood_branch, and sim_isGood_isLoaded.

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

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

◆ sim_len()

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

Definition at line 1581 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_len_, sim_len_branch, and sim_len_isLoaded.

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

                                         {
   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 > & LSTEff::sim_lengap ( )

Definition at line 2757 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_lengap_, sim_lengap_branch, and sim_lengap_isLoaded.

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

                                            {
   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_parentVtxIdx()

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

Definition at line 2709 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_parentVtxIdx_, sim_parentVtxIdx_branch, and sim_parentVtxIdx_isLoaded.

Referenced by LoadAllBranches().

                                                {
   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_dxy()

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

Definition at line 2229 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_pca_dxy_, sim_pca_dxy_branch, and sim_pca_dxy_isLoaded.

Referenced by fillEfficiencySet(), and LoadAllBranches().

                                             {
   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 > & LSTEff::sim_pca_dz ( )

Definition at line 2517 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_pca_dz_, sim_pca_dz_branch, and sim_pca_dz_isLoaded.

Referenced by fillEfficiencySet(), and LoadAllBranches().

                                            {
   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_pdgId()

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

Definition at line 1821 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_pdgId_, sim_pdgId_branch, and sim_pdgId_isLoaded.

Referenced by fillEfficiencySet(), and LoadAllBranches().

                                         {
   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 > & LSTEff::sim_phi ( )

Definition at line 2469 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_phi_, sim_phi_branch, and sim_phi_isLoaded.

Referenced by fillEfficiencySet(), and LoadAllBranches().

                                         {
   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_pLS_matched()

const std::vector< int > & LSTEff::sim_pLS_matched ( )

Definition at line 2553 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_pLS_matched_, sim_pLS_matched_branch, and sim_pLS_matched_isLoaded.

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

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

◆ sim_pLS_types()

const std::vector< std::vector< int > > & LSTEff::sim_pLS_types ( )

Definition at line 2217 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_pLS_types_, sim_pLS_types_branch, and sim_pLS_types_isLoaded.

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

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

◆ sim_pt()

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

Definition at line 1785 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_pt_, sim_pt_branch, and sim_pt_isLoaded.

Referenced by fillEfficiencySet(), fillEfficiencySets(), and LoadAllBranches().

                                        {
   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_pT3_matched()

const std::vector< int > & LSTEff::sim_pT3_matched ( )

Definition at line 1701 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_pT3_matched_, sim_pT3_matched_branch, and sim_pT3_matched_isLoaded.

Referenced by LoadAllBranches(), main(), and tas::sim_pT3_matched().

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

◆ sim_pT3_types()

const std::vector< std::vector< int > > & LSTEff::sim_pT3_types ( )

Definition at line 2061 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_pT3_types_, sim_pT3_types_branch, and sim_pT3_types_isLoaded.

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

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

◆ sim_pT4_matched()

const std::vector< int > & LSTEff::sim_pT4_matched ( )

Definition at line 2733 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_pT4_matched_, sim_pT4_matched_branch, and sim_pT4_matched_isLoaded.

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

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

◆ sim_pT4_types()

const std::vector< std::vector< int > > & LSTEff::sim_pT4_types ( )

Definition at line 2313 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_pT4_types_, sim_pT4_types_branch, and sim_pT4_types_isLoaded.

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

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

◆ sim_pT5_matched()

const std::vector< int > & LSTEff::sim_pT5_matched ( )

Definition at line 3153 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_pT5_matched_, sim_pT5_matched_branch, and sim_pT5_matched_isLoaded.

Referenced by LoadAllBranches(), main(), and tas::sim_pT5_matched().

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

◆ sim_pT5_types()

const std::vector< std::vector< int > > & LSTEff::sim_pT5_types ( )

Definition at line 3141 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_pT5_types_, sim_pT5_types_branch, and sim_pT5_types_isLoaded.

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

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

◆ sim_pureTCE_matched()

const std::vector< int > & LSTEff::sim_pureTCE_matched ( )

Definition at line 2277 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_pureTCE_matched_, sim_pureTCE_matched_branch, and sim_pureTCE_matched_isLoaded.

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

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

◆ sim_pureTCE_types()

const std::vector< std::vector< int > > & LSTEff::sim_pureTCE_types ( )

Definition at line 2073 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_pureTCE_types_, sim_pureTCE_types_branch, and sim_pureTCE_types_isLoaded.

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

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

◆ sim_q()

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

Definition at line 1545 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_q_, sim_q_branch, and sim_q_isLoaded.

Referenced by fillEfficiencySet(), and LoadAllBranches().

                                     {
   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_T3_matched()

const std::vector< int > & LSTEff::sim_T3_matched ( )

Definition at line 2577 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_T3_matched_, sim_T3_matched_branch, and sim_T3_matched_isLoaded.

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

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

◆ sim_T3_types()

const std::vector< std::vector< int > > & LSTEff::sim_T3_types ( )

Definition at line 3129 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_T3_types_, sim_T3_types_branch, and sim_T3_types_isLoaded.

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

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

◆ sim_T4_matched()

const std::vector< int > & LSTEff::sim_T4_matched ( )

Definition at line 2373 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_T4_matched_, sim_T4_matched_branch, and sim_T4_matched_isLoaded.

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

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

◆ sim_T4_types()

const std::vector< std::vector< int > > & LSTEff::sim_T4_types ( )

Definition at line 2973 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_T4_types_, sim_T4_types_branch, and sim_T4_types_isLoaded.

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

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

◆ sim_T5_matched()

const std::vector< int > & LSTEff::sim_T5_matched ( )

Definition at line 2769 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_T5_matched_, sim_T5_matched_branch, and sim_T5_matched_isLoaded.

Referenced by LoadAllBranches(), main(), and tas::sim_T5_matched().

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

◆ sim_T5_types()

const std::vector< std::vector< int > > & LSTEff::sim_T5_types ( )

Definition at line 2781 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_T5_types_, sim_T5_types_branch, and sim_T5_types_isLoaded.

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

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

◆ sim_TC_matched()

const std::vector< int > & LSTEff::sim_TC_matched ( )

Definition at line 2865 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_TC_matched_, sim_TC_matched_branch, and sim_TC_matched_isLoaded.

Referenced by LoadAllBranches(), main(), and tas::sim_TC_matched().

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

◆ sim_TC_matched_mask()

const std::vector< int > & LSTEff::sim_TC_matched_mask ( )

Definition at line 2877 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_TC_matched_mask_, sim_TC_matched_mask_branch, and sim_TC_matched_mask_isLoaded.

Referenced by LoadAllBranches(), main(), and tas::sim_TC_matched_mask().

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

◆ sim_TC_matched_nonextended()

const std::vector< int > & LSTEff::sim_TC_matched_nonextended ( )

Definition at line 1857 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_TC_matched_nonextended_, sim_TC_matched_nonextended_branch, and sim_TC_matched_nonextended_isLoaded.

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

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

◆ sim_TC_types()

const std::vector< std::vector< int > > & LSTEff::sim_TC_types ( )

Definition at line 3009 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_TC_types_, sim_TC_types_branch, and sim_TC_types_isLoaded.

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

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

◆ sim_tce_matched()

const std::vector< int > & LSTEff::sim_tce_matched ( )

Definition at line 1653 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_tce_matched_, sim_tce_matched_branch, and sim_tce_matched_isLoaded.

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

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

◆ sim_tce_types()

const std::vector< std::vector< int > > & LSTEff::sim_tce_types ( )

Definition at line 3189 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_tce_types_, sim_tce_types_branch, and sim_tce_types_isLoaded.

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

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

◆ sim_tcIdx()

const std::vector< std::vector< int > > & LSTEff::sim_tcIdx ( )

Definition at line 1917 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_tcIdx_, sim_tcIdx_branch, and sim_tcIdx_isLoaded.

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

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

◆ sim_vx()

const std::vector< float > & LSTEff::sim_vx ( )

Definition at line 3057 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_vx_, sim_vx_branch, and sim_vx_isLoaded.

Referenced by fillEfficiencySet(), LoadAllBranches(), and tas::sim_vx().

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

◆ sim_vy()

const std::vector< float > & LSTEff::sim_vy ( )

Definition at line 3069 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_vy_, sim_vy_branch, and sim_vy_isLoaded.

Referenced by fillEfficiencySet(), LoadAllBranches(), and tas::sim_vy().

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

◆ sim_vz()

const std::vector< float > & LSTEff::sim_vz ( )

Definition at line 3081 of file LSTEff.cc.

References beamvalidation::exit(), index, sim_vz_, sim_vz_branch, and sim_vz_isLoaded.

Referenced by fillEfficiencySet(), LoadAllBranches(), and tas::sim_vz().

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

◆ simvtx_x()

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

Definition at line 2337 of file LSTEff.cc.

References beamvalidation::exit(), index, simvtx_x_, simvtx_x_branch, and simvtx_x_isLoaded.

Referenced by LoadAllBranches().

                                          {
   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 > & LSTEff::simvtx_y ( )

Definition at line 2349 of file LSTEff.cc.

References beamvalidation::exit(), index, simvtx_y_, simvtx_y_branch, and simvtx_y_isLoaded.

Referenced by LoadAllBranches().

                                          {
   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 > & LSTEff::simvtx_z ( )

Definition at line 2361 of file LSTEff.cc.

References beamvalidation::exit(), index, simvtx_z_, simvtx_z_branch, and simvtx_z_isLoaded.

Referenced by LoadAllBranches().

                                          {
   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_;
 }

◆ t3_eta()

const std::vector< float > & LSTEff::t3_eta ( )

Definition at line 1833 of file LSTEff.cc.

References beamvalidation::exit(), index, t3_eta_, t3_eta_branch, and t3_eta_isLoaded.

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

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

◆ t3_isDuplicate()

const std::vector< int > & LSTEff::t3_isDuplicate ( )

Definition at line 1521 of file LSTEff.cc.

References beamvalidation::exit(), index, t3_isDuplicate_, t3_isDuplicate_branch, and t3_isDuplicate_isLoaded.

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

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

◆ t3_isFake()

const std::vector< int > & LSTEff::t3_isFake ( )

Definition at line 2001 of file LSTEff.cc.

References beamvalidation::exit(), index, t3_isFake_, t3_isFake_branch, and t3_isFake_isLoaded.

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

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

◆ t3_occupancies()

const std::vector< int > & LSTEff::t3_occupancies ( )

Definition at line 2289 of file LSTEff.cc.

References beamvalidation::exit(), index, t3_occupancies_, t3_occupancies_branch, and t3_occupancies_isLoaded.

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

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

◆ t3_phi()

const std::vector< float > & LSTEff::t3_phi ( )

Definition at line 1485 of file LSTEff.cc.

References beamvalidation::exit(), index, t3_phi_, t3_phi_branch, and t3_phi_isLoaded.

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

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

◆ t3_pt()

const std::vector< float > & LSTEff::t3_pt ( )

Definition at line 3105 of file LSTEff.cc.

References beamvalidation::exit(), index, t3_pt_, t3_pt_branch, and t3_pt_isLoaded.

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

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

◆ t4_eta()

const std::vector< float > & LSTEff::t4_eta ( )

Definition at line 2637 of file LSTEff.cc.

References beamvalidation::exit(), index, t4_eta_, t4_eta_branch, and t4_eta_isLoaded.

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

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

◆ t4_isDuplicate()

const std::vector< int > & LSTEff::t4_isDuplicate ( )

Definition at line 1725 of file LSTEff.cc.

References beamvalidation::exit(), index, t4_isDuplicate_, t4_isDuplicate_branch, and t4_isDuplicate_isLoaded.

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

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

◆ t4_isFake()

const std::vector< int > & LSTEff::t4_isFake ( )

Definition at line 2325 of file LSTEff.cc.

References beamvalidation::exit(), index, t4_isFake_, t4_isFake_branch, and t4_isFake_isLoaded.

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

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

◆ t4_occupancies()

const std::vector< int > & LSTEff::t4_occupancies ( )

Definition at line 1869 of file LSTEff.cc.

References beamvalidation::exit(), index, t4_occupancies_, t4_occupancies_branch, and t4_occupancies_isLoaded.

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

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

◆ t4_phi()

const std::vector< float > & LSTEff::t4_phi ( )

Definition at line 2085 of file LSTEff.cc.

References beamvalidation::exit(), index, t4_phi_, t4_phi_branch, and t4_phi_isLoaded.

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

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

◆ t4_pt()

const std::vector< float > & LSTEff::t4_pt ( )

Definition at line 2997 of file LSTEff.cc.

References beamvalidation::exit(), index, t4_pt_, t4_pt_branch, and t4_pt_isLoaded.

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

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

◆ t5_eta()

const std::vector< float > & LSTEff::t5_eta ( )

Definition at line 1617 of file LSTEff.cc.

References beamvalidation::exit(), index, t5_eta_, t5_eta_branch, and t5_eta_isLoaded.

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

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

◆ t5_eta_2()

const std::vector< float > & LSTEff::t5_eta_2 ( )

Definition at line 1797 of file LSTEff.cc.

References beamvalidation::exit(), index, t5_eta_2_, t5_eta_2_branch, and t5_eta_2_isLoaded.

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

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

◆ t5_foundDuplicate()

const std::vector< int > & LSTEff::t5_foundDuplicate ( )

Definition at line 2301 of file LSTEff.cc.

References beamvalidation::exit(), index, t5_foundDuplicate_, t5_foundDuplicate_branch, and t5_foundDuplicate_isLoaded.

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

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

◆ t5_hitIdxs()

const std::vector< std::vector< int > > & LSTEff::t5_hitIdxs ( )

Definition at line 2049 of file LSTEff.cc.

References beamvalidation::exit(), index, t5_hitIdxs_, t5_hitIdxs_branch, and t5_hitIdxs_isLoaded.

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

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

◆ t5_isDuplicate()

const std::vector< int > & LSTEff::t5_isDuplicate ( )

Definition at line 2805 of file LSTEff.cc.

References beamvalidation::exit(), index, t5_isDuplicate_, t5_isDuplicate_branch, and t5_isDuplicate_isLoaded.

Referenced by LoadAllBranches(), main(), and tas::t5_isDuplicate().

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

◆ t5_isFake()

const std::vector< int > & LSTEff::t5_isFake ( )

Definition at line 2025 of file LSTEff.cc.

References beamvalidation::exit(), index, t5_isFake_, t5_isFake_branch, and t5_isFake_isLoaded.

Referenced by LoadAllBranches(), main(), and tas::t5_isFake().

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

◆ t5_matched_simIdx()

const std::vector< std::vector< int > > & LSTEff::t5_matched_simIdx ( )

Definition at line 1953 of file LSTEff.cc.

References beamvalidation::exit(), index, t5_matched_simIdx_, t5_matched_simIdx_branch, and t5_matched_simIdx_isLoaded.

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

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

◆ t5_occupancies()

const std::vector< int > & LSTEff::t5_occupancies ( )

Definition at line 2913 of file LSTEff.cc.

References beamvalidation::exit(), index, t5_occupancies_, t5_occupancies_branch, and t5_occupancies_isLoaded.

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

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

◆ t5_phi()

const std::vector< float > & LSTEff::t5_phi ( )

Definition at line 2097 of file LSTEff.cc.

References beamvalidation::exit(), index, t5_phi_, t5_phi_branch, and t5_phi_isLoaded.

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

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

◆ t5_phi_2()

const std::vector< float > & LSTEff::t5_phi_2 ( )

Definition at line 1929 of file LSTEff.cc.

References beamvalidation::exit(), index, t5_phi_2_, t5_phi_2_branch, and t5_phi_2_isLoaded.

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

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

◆ t5_pt()

const std::vector< float > & LSTEff::t5_pt ( )

Definition at line 2121 of file LSTEff.cc.

References beamvalidation::exit(), index, t5_pt_, t5_pt_branch, and t5_pt_isLoaded.

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

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

◆ t5_score_rphisum()

const std::vector< float > & LSTEff::t5_score_rphisum ( )

Definition at line 1497 of file LSTEff.cc.

References beamvalidation::exit(), index, t5_score_rphisum_, t5_score_rphisum_branch, and t5_score_rphisum_isLoaded.

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

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

◆ tc_eta()

const std::vector< float > & LSTEff::tc_eta ( )

Definition at line 2745 of file LSTEff.cc.

References beamvalidation::exit(), index, tc_eta_, tc_eta_branch, and tc_eta_isLoaded.

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

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

◆ tc_hitIdxs()

const std::vector< std::vector< int > > & LSTEff::tc_hitIdxs ( )

Definition at line 2829 of file LSTEff.cc.

References beamvalidation::exit(), index, tc_hitIdxs_, tc_hitIdxs_branch, and tc_hitIdxs_isLoaded.

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

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

◆ tc_isDuplicate()

const std::vector< int > & LSTEff::tc_isDuplicate ( )

Definition at line 1677 of file LSTEff.cc.

References beamvalidation::exit(), index, tc_isDuplicate_, tc_isDuplicate_branch, and tc_isDuplicate_isLoaded.

Referenced by LoadAllBranches(), main(), and tas::tc_isDuplicate().

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

◆ tc_isFake()

const std::vector< int > & LSTEff::tc_isFake ( )

Definition at line 2169 of file LSTEff.cc.

References beamvalidation::exit(), index, tc_isFake_, tc_isFake_branch, and tc_isFake_isLoaded.

Referenced by LoadAllBranches(), main(), and tas::tc_isFake().

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

◆ tc_matched_simIdx()

const std::vector< std::vector< int > > & LSTEff::tc_matched_simIdx ( )

Definition at line 2565 of file LSTEff.cc.

References beamvalidation::exit(), index, tc_matched_simIdx_, tc_matched_simIdx_branch, and tc_matched_simIdx_isLoaded.

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

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

◆ tc_maxHitMatchedCounts()

const std::vector< int > & LSTEff::tc_maxHitMatchedCounts ( )

Definition at line 2493 of file LSTEff.cc.

References beamvalidation::exit(), index, tc_maxHitMatchedCounts_, tc_maxHitMatchedCounts_branch, and tc_maxHitMatchedCounts_isLoaded.

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

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

◆ tc_occupancies()

const int & LSTEff::tc_occupancies ( )

Definition at line 2853 of file LSTEff.cc.

References beamvalidation::exit(), index, tc_occupancies_, tc_occupancies_branch, and tc_occupancies_isLoaded.

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

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

◆ tc_partOfExtension()

const std::vector< int > & LSTEff::tc_partOfExtension ( )

Definition at line 2685 of file LSTEff.cc.

References beamvalidation::exit(), index, tc_partOfExtension_, tc_partOfExtension_branch, and tc_partOfExtension_isLoaded.

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

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

◆ tc_phi()

const std::vector< float > & LSTEff::tc_phi ( )

Definition at line 2625 of file LSTEff.cc.

References beamvalidation::exit(), index, tc_phi_, tc_phi_branch, and tc_phi_isLoaded.

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

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

◆ tc_pt()

const std::vector< float > & LSTEff::tc_pt ( )

Definition at line 2409 of file LSTEff.cc.

References beamvalidation::exit(), index, tc_pt_, tc_pt_branch, and tc_pt_isLoaded.

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

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

◆ tc_sim()

const std::vector< int > & LSTEff::tc_sim ( )

Definition at line 2205 of file LSTEff.cc.

References beamvalidation::exit(), index, tc_sim_, tc_sim_branch, and tc_sim_isLoaded.

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

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

◆ tc_type()

const std::vector< int > & LSTEff::tc_type ( )

Definition at line 2925 of file LSTEff.cc.

References beamvalidation::exit(), index, tc_type_, tc_type_branch, and tc_type_isLoaded.

Referenced by LoadAllBranches(), main(), and tas::tc_type().

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

◆ tce_anchorIndex()

const std::vector< int > & LSTEff::tce_anchorIndex ( )

Definition at line 2901 of file LSTEff.cc.

References beamvalidation::exit(), index, tce_anchorIndex_, tce_anchorIndex_branch, and tce_anchorIndex_isLoaded.

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

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

◆ tce_anchorType()

const std::vector< int > & LSTEff::tce_anchorType ( )

Definition at line 1977 of file LSTEff.cc.

References beamvalidation::exit(), index, tce_anchorType_, tce_anchorType_branch, and tce_anchorType_isLoaded.

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

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

◆ tce_eta()

const std::vector< float > & LSTEff::tce_eta ( )

Definition at line 1881 of file LSTEff.cc.

References beamvalidation::exit(), index, tce_eta_, tce_eta_branch, and tce_eta_isLoaded.

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

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

◆ tce_isDuplicate()

const std::vector< int > & LSTEff::tce_isDuplicate ( )

Definition at line 1893 of file LSTEff.cc.

References beamvalidation::exit(), index, tce_isDuplicate_, tce_isDuplicate_branch, and tce_isDuplicate_isLoaded.

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

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

◆ tce_isFake()

const std::vector< int > & LSTEff::tce_isFake ( )

Definition at line 2937 of file LSTEff.cc.

References beamvalidation::exit(), index, tce_isFake_, tce_isFake_branch, and tce_isFake_isLoaded.

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

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

◆ tce_layer_binary()

const std::vector< int > & LSTEff::tce_layer_binary ( )

Definition at line 1845 of file LSTEff.cc.

References beamvalidation::exit(), index, tce_layer_binary_, tce_layer_binary_branch, and tce_layer_binary_isLoaded.

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

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

◆ tce_matched_simIdx()

const std::vector< std::vector< int > > & LSTEff::tce_matched_simIdx ( )

Definition at line 2793 of file LSTEff.cc.

References beamvalidation::exit(), index, tce_matched_simIdx_, tce_matched_simIdx_branch, and tce_matched_simIdx_isLoaded.

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

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

◆ tce_maxHitMatchedCounts()

const std::vector< int > & LSTEff::tce_maxHitMatchedCounts ( )

Definition at line 3093 of file LSTEff.cc.

References beamvalidation::exit(), index, tce_maxHitMatchedCounts_, tce_maxHitMatchedCounts_branch, and tce_maxHitMatchedCounts_isLoaded.

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

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

◆ tce_nHitOverlaps()

const std::vector< std::vector< int > > & LSTEff::tce_nHitOverlaps ( )

Definition at line 1989 of file LSTEff.cc.

References beamvalidation::exit(), index, tce_nHitOverlaps_, tce_nHitOverlaps_branch, and tce_nHitOverlaps_isLoaded.

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

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

◆ tce_nLayerOverlaps()

const std::vector< std::vector< int > > & LSTEff::tce_nLayerOverlaps ( )

Definition at line 2193 of file LSTEff.cc.

References beamvalidation::exit(), index, tce_nLayerOverlaps_, tce_nLayerOverlaps_branch, and tce_nLayerOverlaps_isLoaded.

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

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

◆ tce_phi()

const std::vector< float > & LSTEff::tce_phi ( )

Definition at line 2013 of file LSTEff.cc.

References beamvalidation::exit(), index, tce_phi_, tce_phi_branch, and tce_phi_isLoaded.

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

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

◆ tce_pt()

const std::vector< float > & LSTEff::tce_pt ( )

Definition at line 2157 of file LSTEff.cc.

References beamvalidation::exit(), index, tce_pt_, tce_pt_branch, and tce_pt_isLoaded.

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

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

◆ tce_rPhiChiSquared()

const std::vector< float > & LSTEff::tce_rPhiChiSquared ( )

Definition at line 1749 of file LSTEff.cc.

References beamvalidation::exit(), index, tce_rPhiChiSquared_, tce_rPhiChiSquared_branch, and tce_rPhiChiSquared_isLoaded.

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

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

◆ tce_rzChiSquared()

const std::vector< float > & LSTEff::tce_rzChiSquared ( )

Definition at line 3201 of file LSTEff.cc.

References beamvalidation::exit(), index, tce_rzChiSquared_, tce_rzChiSquared_branch, and tce_rzChiSquared_isLoaded.

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

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

Member Data Documentation

◆ index

unsigned int LSTEff::index

protected

Definition at line 19 of file LSTEff.h.

Referenced by GetEntry(), md_occupancies(), module_layers(), module_rings(), module_subdets(), pLS_eta(), pLS_isDuplicate(), pLS_isFake(), pLS_phi(), pLS_pt(), pLS_score(), pT3_eta(), pT3_eta_2(), pT3_foundDuplicate(), pT3_hitIdxs(), pT3_isDuplicate(), pT3_isFake(), pT3_matched_simIdx(), pT3_occupancies(), pT3_phi(), pT3_phi_2(), pT3_pt(), pT3_score(), pT4_eta(), pT4_isDuplicate(), pT4_isFake(), pT4_phi(), pT4_pt(), pT5_eta(), pT5_hitIdxs(), pT5_isDuplicate(), pT5_isFake(), pT5_matched_simIdx(), pT5_occupancies(), pT5_phi(), pT5_pt(), pT5_score(), pureTCE_anchorIndex(), pureTCE_anchorType(), pureTCE_eta(), pureTCE_hitIdxs(), pureTCE_isDuplicate(), pureTCE_isFake(), pureTCE_layer_binary(), pureTCE_matched_simIdx(), pureTCE_maxHitMatchedCounts(), pureTCE_nHitOverlaps(), pureTCE_nLayerOverlaps(), pureTCE_phi(), pureTCE_pt(), pureTCE_rPhiChiSquared(), pureTCE_rzChiSquared(), sg_occupancies(), sim_bunchCrossing(), sim_denom(), sim_eta(), sim_event(), sim_hits(), sim_isGood(), sim_len(), sim_lengap(), sim_parentVtxIdx(), sim_pca_dxy(), sim_pca_dz(), sim_pdgId(), sim_phi(), sim_pLS_matched(), sim_pLS_types(), sim_pt(), sim_pT3_matched(), sim_pT3_types(), sim_pT4_matched(), sim_pT4_types(), sim_pT5_matched(), sim_pT5_types(), sim_pureTCE_matched(), sim_pureTCE_types(), sim_q(), sim_T3_matched(), sim_T3_types(), sim_T4_matched(), sim_T4_types(), sim_T5_matched(), sim_T5_types(), sim_TC_matched(), sim_TC_matched_mask(), sim_TC_matched_nonextended(), sim_TC_types(), sim_tce_matched(), sim_tce_types(), sim_tcIdx(), sim_vx(), sim_vy(), sim_vz(), simvtx_x(), simvtx_y(), simvtx_z(), t3_eta(), t3_isDuplicate(), t3_isFake(), t3_occupancies(), t3_phi(), t3_pt(), t4_eta(), t4_isDuplicate(), t4_isFake(), t4_occupancies(), t4_phi(), t4_pt(), t5_eta(), t5_eta_2(), t5_foundDuplicate(), t5_hitIdxs(), t5_isDuplicate(), t5_isFake(), t5_matched_simIdx(), t5_occupancies(), t5_phi(), t5_phi_2(), t5_pt(), t5_score_rphisum(), tc_eta(), tc_hitIdxs(), tc_isDuplicate(), tc_isFake(), tc_matched_simIdx(), tc_maxHitMatchedCounts(), tc_occupancies(), tc_partOfExtension(), tc_phi(), tc_pt(), tc_sim(), tc_type(), tce_anchorIndex(), tce_anchorType(), tce_eta(), tce_isDuplicate(), tce_isFake(), tce_layer_binary(), tce_matched_simIdx(), tce_maxHitMatchedCounts(), tce_nHitOverlaps(), tce_nLayerOverlaps(), tce_phi(), tce_pt(), tce_rPhiChiSquared(), and tce_rzChiSquared().

◆ md_occupancies_

std::vector<int>* LSTEff::md_occupancies_

protected

Definition at line 161 of file LSTEff.h.

Referenced by Init(), and md_occupancies().

◆ md_occupancies_branch

TBranch* LSTEff::md_occupancies_branch

protected

Definition at line 162 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and md_occupancies().

◆ md_occupancies_isLoaded

bool LSTEff::md_occupancies_isLoaded

protected

Definition at line 163 of file LSTEff.h.

Referenced by GetEntry(), and md_occupancies().

◆ module_layers_

std::vector<int>* LSTEff::module_layers_

protected

Definition at line 443 of file LSTEff.h.

Referenced by Init(), and module_layers().

◆ module_layers_branch

TBranch* LSTEff::module_layers_branch

protected

Definition at line 444 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and module_layers().

◆ module_layers_isLoaded

bool LSTEff::module_layers_isLoaded

protected

Definition at line 445 of file LSTEff.h.

Referenced by GetEntry(), and module_layers().

◆ module_rings_

std::vector<int>* LSTEff::module_rings_

protected

Definition at line 431 of file LSTEff.h.

Referenced by Init(), and module_rings().

◆ module_rings_branch

TBranch* LSTEff::module_rings_branch

protected

Definition at line 432 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and module_rings().

◆ module_rings_isLoaded

bool LSTEff::module_rings_isLoaded

protected

Definition at line 433 of file LSTEff.h.

Referenced by GetEntry(), and module_rings().

◆ module_subdets_

std::vector<int>* LSTEff::module_subdets_

protected

Definition at line 143 of file LSTEff.h.

Referenced by Init(), and module_subdets().

◆ module_subdets_branch

TBranch* LSTEff::module_subdets_branch

protected

Definition at line 144 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and module_subdets().

◆ module_subdets_isLoaded

bool LSTEff::module_subdets_isLoaded

protected

Definition at line 145 of file LSTEff.h.

Referenced by GetEntry(), and module_subdets().

◆ pLS_eta_

std::vector<float>* LSTEff::pLS_eta_

protected

Definition at line 104 of file LSTEff.h.

Referenced by Init(), and pLS_eta().

◆ pLS_eta_branch

TBranch* LSTEff::pLS_eta_branch

protected

Definition at line 105 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pLS_eta().

◆ pLS_eta_isLoaded

bool LSTEff::pLS_eta_isLoaded

protected

Definition at line 106 of file LSTEff.h.

Referenced by GetEntry(), and pLS_eta().

◆ pLS_isDuplicate_

std::vector<int>* LSTEff::pLS_isDuplicate_

protected

Definition at line 374 of file LSTEff.h.

Referenced by Init(), and pLS_isDuplicate().

◆ pLS_isDuplicate_branch

TBranch* LSTEff::pLS_isDuplicate_branch

protected

Definition at line 375 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pLS_isDuplicate().

◆ pLS_isDuplicate_isLoaded

bool LSTEff::pLS_isDuplicate_isLoaded

protected

Definition at line 376 of file LSTEff.h.

Referenced by GetEntry(), and pLS_isDuplicate().

◆ pLS_isFake_

std::vector<int>* LSTEff::pLS_isFake_

protected

Definition at line 314 of file LSTEff.h.

Referenced by Init(), and pLS_isFake().

◆ pLS_isFake_branch

TBranch* LSTEff::pLS_isFake_branch

protected

Definition at line 315 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pLS_isFake().

◆ pLS_isFake_isLoaded

bool LSTEff::pLS_isFake_isLoaded

protected

Definition at line 316 of file LSTEff.h.

Referenced by GetEntry(), and pLS_isFake().

◆ pLS_phi_

std::vector<float>* LSTEff::pLS_phi_

protected

Definition at line 218 of file LSTEff.h.

Referenced by Init(), and pLS_phi().

◆ pLS_phi_branch

TBranch* LSTEff::pLS_phi_branch

protected

Definition at line 219 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pLS_phi().

◆ pLS_phi_isLoaded

bool LSTEff::pLS_phi_isLoaded

protected

Definition at line 220 of file LSTEff.h.

Referenced by GetEntry(), and pLS_phi().

◆ pLS_pt_

std::vector<float>* LSTEff::pLS_pt_

protected

Definition at line 389 of file LSTEff.h.

Referenced by Init(), and pLS_pt().

◆ pLS_pt_branch

TBranch* LSTEff::pLS_pt_branch

protected

Definition at line 390 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pLS_pt().

◆ pLS_pt_isLoaded

bool LSTEff::pLS_pt_isLoaded

protected

Definition at line 391 of file LSTEff.h.

Referenced by GetEntry(), and pLS_pt().

◆ pLS_score_

std::vector<float>* LSTEff::pLS_score_

protected

Definition at line 299 of file LSTEff.h.

Referenced by Init(), and pLS_score().

◆ pLS_score_branch

TBranch* LSTEff::pLS_score_branch

protected

Definition at line 300 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pLS_score().

◆ pLS_score_isLoaded

bool LSTEff::pLS_score_isLoaded

protected

Definition at line 301 of file LSTEff.h.

Referenced by GetEntry(), and pLS_score().

◆ pT3_eta_

std::vector<float>* LSTEff::pT3_eta_

protected

Definition at line 326 of file LSTEff.h.

Referenced by Init(), and pT3_eta().

◆ pT3_eta_2_

std::vector<float>* LSTEff::pT3_eta_2_

protected

Definition at line 74 of file LSTEff.h.

Referenced by Init(), and pT3_eta_2().

◆ pT3_eta_2_branch

TBranch* LSTEff::pT3_eta_2_branch

protected

Definition at line 75 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT3_eta_2().

◆ pT3_eta_2_isLoaded

bool LSTEff::pT3_eta_2_isLoaded

protected

Definition at line 76 of file LSTEff.h.

Referenced by GetEntry(), and pT3_eta_2().

◆ pT3_eta_branch

TBranch* LSTEff::pT3_eta_branch

protected

Definition at line 327 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT3_eta().

◆ pT3_eta_isLoaded

bool LSTEff::pT3_eta_isLoaded

protected

Definition at line 328 of file LSTEff.h.

Referenced by GetEntry(), and pT3_eta().

◆ pT3_foundDuplicate_

std::vector<int>* LSTEff::pT3_foundDuplicate_

protected

Definition at line 44 of file LSTEff.h.

Referenced by Init(), and pT3_foundDuplicate().

◆ pT3_foundDuplicate_branch

TBranch* LSTEff::pT3_foundDuplicate_branch

protected

Definition at line 45 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT3_foundDuplicate().

◆ pT3_foundDuplicate_isLoaded

bool LSTEff::pT3_foundDuplicate_isLoaded

protected

Definition at line 46 of file LSTEff.h.

Referenced by GetEntry(), and pT3_foundDuplicate().

◆ pT3_hitIdxs_

std::vector<std::vector<int> >* LSTEff::pT3_hitIdxs_

protected

Definition at line 356 of file LSTEff.h.

Referenced by Init(), and pT3_hitIdxs().

◆ pT3_hitIdxs_branch

TBranch* LSTEff::pT3_hitIdxs_branch

protected

Definition at line 357 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT3_hitIdxs().

◆ pT3_hitIdxs_isLoaded

bool LSTEff::pT3_hitIdxs_isLoaded

protected

Definition at line 358 of file LSTEff.h.

Referenced by GetEntry(), and pT3_hitIdxs().

◆ pT3_isDuplicate_

std::vector<int>* LSTEff::pT3_isDuplicate_

protected

Definition at line 68 of file LSTEff.h.

Referenced by Init(), and pT3_isDuplicate().

◆ pT3_isDuplicate_branch

TBranch* LSTEff::pT3_isDuplicate_branch

protected

Definition at line 69 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT3_isDuplicate().

◆ pT3_isDuplicate_isLoaded

bool LSTEff::pT3_isDuplicate_isLoaded

protected

Definition at line 70 of file LSTEff.h.

Referenced by GetEntry(), and pT3_isDuplicate().

◆ pT3_isFake_

std::vector<int>* LSTEff::pT3_isFake_

protected

Definition at line 197 of file LSTEff.h.

Referenced by Init(), and pT3_isFake().

◆ pT3_isFake_branch

TBranch* LSTEff::pT3_isFake_branch

protected

Definition at line 198 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT3_isFake().

◆ pT3_isFake_isLoaded

bool LSTEff::pT3_isFake_isLoaded

protected

Definition at line 199 of file LSTEff.h.

Referenced by GetEntry(), and pT3_isFake().

◆ pT3_matched_simIdx_

std::vector<std::vector<int> >* LSTEff::pT3_matched_simIdx_

protected

Definition at line 455 of file LSTEff.h.

Referenced by Init(), and pT3_matched_simIdx().

◆ pT3_matched_simIdx_branch

TBranch* LSTEff::pT3_matched_simIdx_branch

protected

Definition at line 456 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT3_matched_simIdx().

◆ pT3_matched_simIdx_isLoaded

bool LSTEff::pT3_matched_simIdx_isLoaded

protected

Definition at line 457 of file LSTEff.h.

Referenced by GetEntry(), and pT3_matched_simIdx().

◆ pT3_occupancies_

int LSTEff::pT3_occupancies_

protected

Definition at line 362 of file LSTEff.h.

Referenced by Init(), and pT3_occupancies().

◆ pT3_occupancies_branch

TBranch* LSTEff::pT3_occupancies_branch

protected

Definition at line 363 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT3_occupancies().

◆ pT3_occupancies_isLoaded

bool LSTEff::pT3_occupancies_isLoaded

protected

Definition at line 364 of file LSTEff.h.

Referenced by GetEntry(), and pT3_occupancies().

◆ pT3_phi_

std::vector<float>* LSTEff::pT3_phi_

protected

Definition at line 302 of file LSTEff.h.

Referenced by Init(), and pT3_phi().

◆ pT3_phi_2_

std::vector<float>* LSTEff::pT3_phi_2_

protected

Definition at line 257 of file LSTEff.h.

Referenced by Init(), and pT3_phi_2().

◆ pT3_phi_2_branch

TBranch* LSTEff::pT3_phi_2_branch

protected

Definition at line 258 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT3_phi_2().

◆ pT3_phi_2_isLoaded

bool LSTEff::pT3_phi_2_isLoaded

protected

Definition at line 259 of file LSTEff.h.

Referenced by GetEntry(), and pT3_phi_2().

◆ pT3_phi_branch

TBranch* LSTEff::pT3_phi_branch

protected

Definition at line 303 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT3_phi().

◆ pT3_phi_isLoaded

bool LSTEff::pT3_phi_isLoaded

protected

Definition at line 304 of file LSTEff.h.

Referenced by GetEntry(), and pT3_phi().

◆ pT3_pt_

std::vector<float>* LSTEff::pT3_pt_

protected

Definition at line 251 of file LSTEff.h.

Referenced by Init(), and pT3_pt().

◆ pT3_pt_branch

TBranch* LSTEff::pT3_pt_branch

protected

Definition at line 252 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT3_pt().

◆ pT3_pt_isLoaded

bool LSTEff::pT3_pt_isLoaded

protected

Definition at line 253 of file LSTEff.h.

Referenced by GetEntry(), and pT3_pt().

◆ pT3_score_

std::vector<float>* LSTEff::pT3_score_

protected

Definition at line 53 of file LSTEff.h.

Referenced by Init(), and pT3_score().

◆ pT3_score_branch

TBranch* LSTEff::pT3_score_branch

protected

Definition at line 54 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT3_score().

◆ pT3_score_isLoaded

bool LSTEff::pT3_score_isLoaded

protected

Definition at line 55 of file LSTEff.h.

Referenced by GetEntry(), and pT3_score().

◆ pT4_eta_

std::vector<float>* LSTEff::pT4_eta_

protected

Definition at line 446 of file LSTEff.h.

Referenced by Init(), and pT4_eta().

◆ pT4_eta_branch

TBranch* LSTEff::pT4_eta_branch

protected

Definition at line 447 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT4_eta().

◆ pT4_eta_isLoaded

bool LSTEff::pT4_eta_isLoaded

protected

Definition at line 448 of file LSTEff.h.

Referenced by GetEntry(), and pT4_eta().

◆ pT4_isDuplicate_

std::vector<int>* LSTEff::pT4_isDuplicate_

protected

Definition at line 398 of file LSTEff.h.

Referenced by Init(), and pT4_isDuplicate().

◆ pT4_isDuplicate_branch

TBranch* LSTEff::pT4_isDuplicate_branch

protected

Definition at line 399 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT4_isDuplicate().

◆ pT4_isDuplicate_isLoaded

bool LSTEff::pT4_isDuplicate_isLoaded

protected

Definition at line 400 of file LSTEff.h.

Referenced by GetEntry(), and pT4_isDuplicate().

◆ pT4_isFake_

std::vector<int>* LSTEff::pT4_isFake_

protected

Definition at line 29 of file LSTEff.h.

Referenced by Init(), and pT4_isFake().

◆ pT4_isFake_branch

TBranch* LSTEff::pT4_isFake_branch

protected

Definition at line 30 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT4_isFake().

◆ pT4_isFake_isLoaded

bool LSTEff::pT4_isFake_isLoaded

protected

Definition at line 31 of file LSTEff.h.

Referenced by GetEntry(), and pT4_isFake().

◆ pT4_phi_

std::vector<float>* LSTEff::pT4_phi_

protected

Definition at line 212 of file LSTEff.h.

Referenced by Init(), and pT4_phi().

◆ pT4_phi_branch

TBranch* LSTEff::pT4_phi_branch

protected

Definition at line 213 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT4_phi().

◆ pT4_phi_isLoaded

bool LSTEff::pT4_phi_isLoaded

protected

Definition at line 214 of file LSTEff.h.

Referenced by GetEntry(), and pT4_phi().

◆ pT4_pt_

std::vector<float>* LSTEff::pT4_pt_

protected

Definition at line 410 of file LSTEff.h.

Referenced by Init(), and pT4_pt().

◆ pT4_pt_branch

TBranch* LSTEff::pT4_pt_branch

protected

Definition at line 411 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT4_pt().

◆ pT4_pt_isLoaded

bool LSTEff::pT4_pt_isLoaded

protected

Definition at line 412 of file LSTEff.h.

Referenced by GetEntry(), and pT4_pt().

◆ pT5_eta_

std::vector<float>* LSTEff::pT5_eta_

protected

Definition at line 305 of file LSTEff.h.

Referenced by Init(), and pT5_eta().

◆ pT5_eta_branch

TBranch* LSTEff::pT5_eta_branch

protected

Definition at line 306 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT5_eta().

◆ pT5_eta_isLoaded

bool LSTEff::pT5_eta_isLoaded

protected

Definition at line 307 of file LSTEff.h.

Referenced by GetEntry(), and pT5_eta().

◆ pT5_hitIdxs_

std::vector<std::vector<int> >* LSTEff::pT5_hitIdxs_

protected

Definition at line 179 of file LSTEff.h.

Referenced by Init(), and pT5_hitIdxs().

◆ pT5_hitIdxs_branch

TBranch* LSTEff::pT5_hitIdxs_branch

protected

Definition at line 180 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT5_hitIdxs().

◆ pT5_hitIdxs_isLoaded

bool LSTEff::pT5_hitIdxs_isLoaded

protected

Definition at line 181 of file LSTEff.h.

Referenced by GetEntry(), and pT5_hitIdxs().

◆ pT5_isDuplicate_

std::vector<int>* LSTEff::pT5_isDuplicate_

protected

Definition at line 62 of file LSTEff.h.

Referenced by Init(), and pT5_isDuplicate().

◆ pT5_isDuplicate_branch

TBranch* LSTEff::pT5_isDuplicate_branch

protected

Definition at line 63 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT5_isDuplicate().

◆ pT5_isDuplicate_isLoaded

bool LSTEff::pT5_isDuplicate_isLoaded

protected

Definition at line 64 of file LSTEff.h.

Referenced by GetEntry(), and pT5_isDuplicate().

◆ pT5_isFake_

std::vector<int>* LSTEff::pT5_isFake_

protected

Definition at line 272 of file LSTEff.h.

Referenced by Init(), and pT5_isFake().

◆ pT5_isFake_branch

TBranch* LSTEff::pT5_isFake_branch

protected

Definition at line 273 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT5_isFake().

◆ pT5_isFake_isLoaded

bool LSTEff::pT5_isFake_isLoaded

protected

Definition at line 274 of file LSTEff.h.

Referenced by GetEntry(), and pT5_isFake().

◆ pT5_matched_simIdx_

std::vector<std::vector<int> >* LSTEff::pT5_matched_simIdx_

protected

Definition at line 128 of file LSTEff.h.

Referenced by Init(), and pT5_matched_simIdx().

◆ pT5_matched_simIdx_branch

TBranch* LSTEff::pT5_matched_simIdx_branch

protected

Definition at line 129 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT5_matched_simIdx().

◆ pT5_matched_simIdx_isLoaded

bool LSTEff::pT5_matched_simIdx_isLoaded

protected

Definition at line 130 of file LSTEff.h.

Referenced by GetEntry(), and pT5_matched_simIdx().

◆ pT5_occupancies_

int LSTEff::pT5_occupancies_

protected

Definition at line 20 of file LSTEff.h.

Referenced by Init(), and pT5_occupancies().

◆ pT5_occupancies_branch

TBranch* LSTEff::pT5_occupancies_branch

protected

Definition at line 21 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT5_occupancies().

◆ pT5_occupancies_isLoaded

bool LSTEff::pT5_occupancies_isLoaded

protected

Definition at line 22 of file LSTEff.h.

Referenced by GetEntry(), and pT5_occupancies().

◆ pT5_phi_

std::vector<float>* LSTEff::pT5_phi_

protected

Definition at line 185 of file LSTEff.h.

Referenced by Init(), and pT5_phi().

◆ pT5_phi_branch

TBranch* LSTEff::pT5_phi_branch

protected

Definition at line 186 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT5_phi().

◆ pT5_phi_isLoaded

bool LSTEff::pT5_phi_isLoaded

protected

Definition at line 187 of file LSTEff.h.

Referenced by GetEntry(), and pT5_phi().

◆ pT5_pt_

std::vector<float>* LSTEff::pT5_pt_

protected

Definition at line 260 of file LSTEff.h.

Referenced by Init(), and pT5_pt().

◆ pT5_pt_branch

TBranch* LSTEff::pT5_pt_branch

protected

Definition at line 261 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT5_pt().

◆ pT5_pt_isLoaded

bool LSTEff::pT5_pt_isLoaded

protected

Definition at line 262 of file LSTEff.h.

Referenced by GetEntry(), and pT5_pt().

◆ pT5_score_

std::vector<int>* LSTEff::pT5_score_

protected

Definition at line 266 of file LSTEff.h.

Referenced by Init(), and pT5_score().

◆ pT5_score_branch

TBranch* LSTEff::pT5_score_branch

protected

Definition at line 267 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pT5_score().

◆ pT5_score_isLoaded

bool LSTEff::pT5_score_isLoaded

protected

Definition at line 268 of file LSTEff.h.

Referenced by GetEntry(), and pT5_score().

◆ pureTCE_anchorIndex_

std::vector<int>* LSTEff::pureTCE_anchorIndex_

protected

Definition at line 392 of file LSTEff.h.

Referenced by Init(), and pureTCE_anchorIndex().

◆ pureTCE_anchorIndex_branch

TBranch* LSTEff::pureTCE_anchorIndex_branch

protected

Definition at line 393 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pureTCE_anchorIndex().

◆ pureTCE_anchorIndex_isLoaded

bool LSTEff::pureTCE_anchorIndex_isLoaded

protected

Definition at line 394 of file LSTEff.h.

Referenced by GetEntry(), and pureTCE_anchorIndex().

◆ pureTCE_anchorType_

std::vector<int>* LSTEff::pureTCE_anchorType_

protected

Definition at line 92 of file LSTEff.h.

Referenced by Init(), and pureTCE_anchorType().

◆ pureTCE_anchorType_branch

TBranch* LSTEff::pureTCE_anchorType_branch

protected

Definition at line 93 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pureTCE_anchorType().

◆ pureTCE_anchorType_isLoaded

bool LSTEff::pureTCE_anchorType_isLoaded

protected

Definition at line 94 of file LSTEff.h.

Referenced by GetEntry(), and pureTCE_anchorType().

◆ pureTCE_eta_

std::vector<float>* LSTEff::pureTCE_eta_

protected

Definition at line 86 of file LSTEff.h.

Referenced by Init(), and pureTCE_eta().

◆ pureTCE_eta_branch

TBranch* LSTEff::pureTCE_eta_branch

protected

Definition at line 87 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pureTCE_eta().

◆ pureTCE_eta_isLoaded

bool LSTEff::pureTCE_eta_isLoaded

protected

Definition at line 88 of file LSTEff.h.

Referenced by GetEntry(), and pureTCE_eta().

◆ pureTCE_hitIdxs_

std::vector<std::vector<int> >* LSTEff::pureTCE_hitIdxs_

protected

Definition at line 284 of file LSTEff.h.

Referenced by Init(), and pureTCE_hitIdxs().

◆ pureTCE_hitIdxs_branch

TBranch* LSTEff::pureTCE_hitIdxs_branch

protected

Definition at line 285 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pureTCE_hitIdxs().

◆ pureTCE_hitIdxs_isLoaded

bool LSTEff::pureTCE_hitIdxs_isLoaded

protected

Definition at line 286 of file LSTEff.h.

Referenced by GetEntry(), and pureTCE_hitIdxs().

◆ pureTCE_isDuplicate_

std::vector<int>* LSTEff::pureTCE_isDuplicate_

protected

Definition at line 50 of file LSTEff.h.

Referenced by Init(), and pureTCE_isDuplicate().

◆ pureTCE_isDuplicate_branch

TBranch* LSTEff::pureTCE_isDuplicate_branch

protected

Definition at line 51 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pureTCE_isDuplicate().

◆ pureTCE_isDuplicate_isLoaded

bool LSTEff::pureTCE_isDuplicate_isLoaded

protected

Definition at line 52 of file LSTEff.h.

Referenced by GetEntry(), and pureTCE_isDuplicate().

◆ pureTCE_isFake_

std::vector<int>* LSTEff::pureTCE_isFake_

protected

Definition at line 188 of file LSTEff.h.

Referenced by Init(), and pureTCE_isFake().

◆ pureTCE_isFake_branch

TBranch* LSTEff::pureTCE_isFake_branch

protected

Definition at line 189 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pureTCE_isFake().

◆ pureTCE_isFake_isLoaded

bool LSTEff::pureTCE_isFake_isLoaded

protected

Definition at line 190 of file LSTEff.h.

Referenced by GetEntry(), and pureTCE_isFake().

◆ pureTCE_layer_binary_

std::vector<int>* LSTEff::pureTCE_layer_binary_

protected

Definition at line 332 of file LSTEff.h.

Referenced by Init(), and pureTCE_layer_binary().

◆ pureTCE_layer_binary_branch

TBranch* LSTEff::pureTCE_layer_binary_branch

protected

Definition at line 333 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pureTCE_layer_binary().

◆ pureTCE_layer_binary_isLoaded

bool LSTEff::pureTCE_layer_binary_isLoaded

protected

Definition at line 334 of file LSTEff.h.

Referenced by GetEntry(), and pureTCE_layer_binary().

◆ pureTCE_matched_simIdx_

std::vector<std::vector<int> >* LSTEff::pureTCE_matched_simIdx_

protected

Definition at line 317 of file LSTEff.h.

Referenced by Init(), and pureTCE_matched_simIdx().

◆ pureTCE_matched_simIdx_branch

TBranch* LSTEff::pureTCE_matched_simIdx_branch

protected

Definition at line 318 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pureTCE_matched_simIdx().

◆ pureTCE_matched_simIdx_isLoaded

bool LSTEff::pureTCE_matched_simIdx_isLoaded

protected

Definition at line 319 of file LSTEff.h.

Referenced by GetEntry(), and pureTCE_matched_simIdx().

◆ pureTCE_maxHitMatchedCounts_

std::vector<int>* LSTEff::pureTCE_maxHitMatchedCounts_

protected

Definition at line 137 of file LSTEff.h.

Referenced by Init(), and pureTCE_maxHitMatchedCounts().

◆ pureTCE_maxHitMatchedCounts_branch

TBranch* LSTEff::pureTCE_maxHitMatchedCounts_branch

protected

Definition at line 138 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pureTCE_maxHitMatchedCounts().

◆ pureTCE_maxHitMatchedCounts_isLoaded

bool LSTEff::pureTCE_maxHitMatchedCounts_isLoaded

protected

Definition at line 139 of file LSTEff.h.

Referenced by GetEntry(), and pureTCE_maxHitMatchedCounts().

◆ pureTCE_nHitOverlaps_

std::vector<std::vector<int> >* LSTEff::pureTCE_nHitOverlaps_

protected

Definition at line 287 of file LSTEff.h.

Referenced by Init(), and pureTCE_nHitOverlaps().

◆ pureTCE_nHitOverlaps_branch

TBranch* LSTEff::pureTCE_nHitOverlaps_branch

protected

Definition at line 288 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pureTCE_nHitOverlaps().

◆ pureTCE_nHitOverlaps_isLoaded

bool LSTEff::pureTCE_nHitOverlaps_isLoaded

protected

Definition at line 289 of file LSTEff.h.

Referenced by GetEntry(), and pureTCE_nHitOverlaps().

◆ pureTCE_nLayerOverlaps_

std::vector<std::vector<int> >* LSTEff::pureTCE_nLayerOverlaps_

protected

Definition at line 278 of file LSTEff.h.

Referenced by Init(), and pureTCE_nLayerOverlaps().

◆ pureTCE_nLayerOverlaps_branch

TBranch* LSTEff::pureTCE_nLayerOverlaps_branch

protected

Definition at line 279 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pureTCE_nLayerOverlaps().

◆ pureTCE_nLayerOverlaps_isLoaded

bool LSTEff::pureTCE_nLayerOverlaps_isLoaded

protected

Definition at line 280 of file LSTEff.h.

Referenced by GetEntry(), and pureTCE_nLayerOverlaps().

◆ pureTCE_phi_

std::vector<float>* LSTEff::pureTCE_phi_

protected

Definition at line 413 of file LSTEff.h.

Referenced by Init(), and pureTCE_phi().

◆ pureTCE_phi_branch

TBranch* LSTEff::pureTCE_phi_branch

protected

Definition at line 414 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pureTCE_phi().

◆ pureTCE_phi_isLoaded

bool LSTEff::pureTCE_phi_isLoaded

protected

Definition at line 415 of file LSTEff.h.

Referenced by GetEntry(), and pureTCE_phi().

◆ pureTCE_pt_

std::vector<float>* LSTEff::pureTCE_pt_

protected

Definition at line 95 of file LSTEff.h.

Referenced by Init(), and pureTCE_pt().

◆ pureTCE_pt_branch

TBranch* LSTEff::pureTCE_pt_branch

protected

Definition at line 96 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pureTCE_pt().

◆ pureTCE_pt_isLoaded

bool LSTEff::pureTCE_pt_isLoaded

protected

Definition at line 97 of file LSTEff.h.

Referenced by GetEntry(), and pureTCE_pt().

◆ pureTCE_rPhiChiSquared_

std::vector<float>* LSTEff::pureTCE_rPhiChiSquared_

protected

Definition at line 263 of file LSTEff.h.

Referenced by Init(), and pureTCE_rPhiChiSquared().

◆ pureTCE_rPhiChiSquared_branch

TBranch* LSTEff::pureTCE_rPhiChiSquared_branch

protected

Definition at line 264 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pureTCE_rPhiChiSquared().

◆ pureTCE_rPhiChiSquared_isLoaded

bool LSTEff::pureTCE_rPhiChiSquared_isLoaded

protected

Definition at line 265 of file LSTEff.h.

Referenced by GetEntry(), and pureTCE_rPhiChiSquared().

◆ pureTCE_rzChiSquared_

std::vector<float>* LSTEff::pureTCE_rzChiSquared_

protected

Definition at line 80 of file LSTEff.h.

Referenced by Init(), and pureTCE_rzChiSquared().

◆ pureTCE_rzChiSquared_branch

TBranch* LSTEff::pureTCE_rzChiSquared_branch

protected

Definition at line 81 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and pureTCE_rzChiSquared().

◆ pureTCE_rzChiSquared_isLoaded

bool LSTEff::pureTCE_rzChiSquared_isLoaded

protected

Definition at line 82 of file LSTEff.h.

Referenced by GetEntry(), and pureTCE_rzChiSquared().

◆ sg_occupancies_

std::vector<int>* LSTEff::sg_occupancies_

protected

Definition at line 407 of file LSTEff.h.

Referenced by Init(), and sg_occupancies().

◆ sg_occupancies_branch

TBranch* LSTEff::sg_occupancies_branch

protected

Definition at line 408 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sg_occupancies().

◆ sg_occupancies_isLoaded

bool LSTEff::sg_occupancies_isLoaded

protected

Definition at line 409 of file LSTEff.h.

Referenced by GetEntry(), and sg_occupancies().

◆ sim_bunchCrossing_

std::vector<int>* LSTEff::sim_bunchCrossing_

protected

Definition at line 320 of file LSTEff.h.

Referenced by Init(), and sim_bunchCrossing().

◆ sim_bunchCrossing_branch

TBranch* LSTEff::sim_bunchCrossing_branch

protected

Definition at line 321 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_bunchCrossing().

◆ sim_bunchCrossing_isLoaded

bool LSTEff::sim_bunchCrossing_isLoaded

protected

Definition at line 322 of file LSTEff.h.

Referenced by GetEntry(), and sim_bunchCrossing().

◆ sim_denom_

std::vector<int>* LSTEff::sim_denom_

protected

Definition at line 59 of file LSTEff.h.

Referenced by Init(), and sim_denom().

◆ sim_denom_branch

TBranch* LSTEff::sim_denom_branch

protected

Definition at line 60 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_denom().

◆ sim_denom_isLoaded

bool LSTEff::sim_denom_isLoaded

protected

Definition at line 61 of file LSTEff.h.

Referenced by GetEntry(), and sim_denom().

◆ sim_eta_

std::vector<float>* LSTEff::sim_eta_

protected

Definition at line 41 of file LSTEff.h.

Referenced by Init(), and sim_eta().

◆ sim_eta_branch

TBranch* LSTEff::sim_eta_branch

protected

Definition at line 42 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_eta().

◆ sim_eta_isLoaded

bool LSTEff::sim_eta_isLoaded

protected

Definition at line 43 of file LSTEff.h.

Referenced by GetEntry(), and sim_eta().

◆ sim_event_

std::vector<int>* LSTEff::sim_event_

protected

Definition at line 35 of file LSTEff.h.

Referenced by Init(), and sim_event().

◆ sim_event_branch

TBranch* LSTEff::sim_event_branch

protected

Definition at line 36 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_event().

◆ sim_event_isLoaded

bool LSTEff::sim_event_isLoaded

protected

Definition at line 37 of file LSTEff.h.

Referenced by GetEntry(), and sim_event().

◆ sim_hits_

std::vector<float>* LSTEff::sim_hits_

protected

Definition at line 215 of file LSTEff.h.

Referenced by Init(), and sim_hits().

◆ sim_hits_branch

TBranch* LSTEff::sim_hits_branch

protected

Definition at line 216 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_hits().

◆ sim_hits_isLoaded

bool LSTEff::sim_hits_isLoaded

protected

Definition at line 217 of file LSTEff.h.

Referenced by GetEntry(), and sim_hits().

◆ sim_isGood_

std::vector<bool>* LSTEff::sim_isGood_

protected

Definition at line 248 of file LSTEff.h.

Referenced by Init(), and sim_isGood().

◆ sim_isGood_branch

TBranch* LSTEff::sim_isGood_branch

protected

Definition at line 249 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_isGood().

◆ sim_isGood_isLoaded

bool LSTEff::sim_isGood_isLoaded

protected

Definition at line 250 of file LSTEff.h.

Referenced by GetEntry(), and sim_isGood().

◆ sim_len_

std::vector<float>* LSTEff::sim_len_

protected

Definition at line 47 of file LSTEff.h.

Referenced by Init(), and sim_len().

◆ sim_len_branch

TBranch* LSTEff::sim_len_branch

protected

Definition at line 48 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_len().

◆ sim_len_isLoaded

bool LSTEff::sim_len_isLoaded

protected

Definition at line 49 of file LSTEff.h.

Referenced by GetEntry(), and sim_len().

◆ sim_lengap_

std::vector<float>* LSTEff::sim_lengap_

protected

Definition at line 341 of file LSTEff.h.

Referenced by Init(), and sim_lengap().

◆ sim_lengap_branch

TBranch* LSTEff::sim_lengap_branch

protected

Definition at line 342 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_lengap().

◆ sim_lengap_isLoaded

bool LSTEff::sim_lengap_isLoaded

protected

Definition at line 343 of file LSTEff.h.

Referenced by GetEntry(), and sim_lengap().

◆ sim_parentVtxIdx_

std::vector<int>* LSTEff::sim_parentVtxIdx_

protected

Definition at line 329 of file LSTEff.h.

Referenced by Init(), and sim_parentVtxIdx().

◆ sim_parentVtxIdx_branch

TBranch* LSTEff::sim_parentVtxIdx_branch

protected

Definition at line 330 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_parentVtxIdx().

◆ sim_parentVtxIdx_isLoaded

bool LSTEff::sim_parentVtxIdx_isLoaded

protected

Definition at line 331 of file LSTEff.h.

Referenced by GetEntry(), and sim_parentVtxIdx().

◆ sim_pca_dxy_

std::vector<float>* LSTEff::sim_pca_dxy_

protected

Definition at line 209 of file LSTEff.h.

Referenced by Init(), and sim_pca_dxy().

◆ sim_pca_dxy_branch

TBranch* LSTEff::sim_pca_dxy_branch

protected

Definition at line 210 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_pca_dxy().

◆ sim_pca_dxy_isLoaded

bool LSTEff::sim_pca_dxy_isLoaded

protected

Definition at line 211 of file LSTEff.h.

Referenced by GetEntry(), and sim_pca_dxy().

◆ sim_pca_dz_

std::vector<float>* LSTEff::sim_pca_dz_

protected

Definition at line 281 of file LSTEff.h.

Referenced by Init(), and sim_pca_dz().

◆ sim_pca_dz_branch

TBranch* LSTEff::sim_pca_dz_branch

protected

Definition at line 282 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_pca_dz().

◆ sim_pca_dz_isLoaded

bool LSTEff::sim_pca_dz_isLoaded

protected

Definition at line 283 of file LSTEff.h.

Referenced by GetEntry(), and sim_pca_dz().

◆ sim_pdgId_

std::vector<int>* LSTEff::sim_pdgId_

protected

Definition at line 107 of file LSTEff.h.

Referenced by Init(), and sim_pdgId().

◆ sim_pdgId_branch

TBranch* LSTEff::sim_pdgId_branch

protected

Definition at line 108 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_pdgId().

◆ sim_pdgId_isLoaded

bool LSTEff::sim_pdgId_isLoaded

protected

Definition at line 109 of file LSTEff.h.

Referenced by GetEntry(), and sim_pdgId().

◆ sim_phi_

std::vector<float>* LSTEff::sim_phi_

protected

Definition at line 269 of file LSTEff.h.

Referenced by Init(), and sim_phi().

◆ sim_phi_branch

TBranch* LSTEff::sim_phi_branch

protected

Definition at line 270 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_phi().

◆ sim_phi_isLoaded

bool LSTEff::sim_phi_isLoaded

protected

Definition at line 271 of file LSTEff.h.

Referenced by GetEntry(), and sim_phi().

◆ sim_pLS_matched_

std::vector<int>* LSTEff::sim_pLS_matched_

protected

Definition at line 290 of file LSTEff.h.

Referenced by Init(), and sim_pLS_matched().

◆ sim_pLS_matched_branch

TBranch* LSTEff::sim_pLS_matched_branch

protected

Definition at line 291 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_pLS_matched().

◆ sim_pLS_matched_isLoaded

bool LSTEff::sim_pLS_matched_isLoaded

protected

Definition at line 292 of file LSTEff.h.

Referenced by GetEntry(), and sim_pLS_matched().

◆ sim_pLS_types_

std::vector<std::vector<int> >* LSTEff::sim_pLS_types_

protected

Definition at line 206 of file LSTEff.h.

Referenced by Init(), and sim_pLS_types().

◆ sim_pLS_types_branch

TBranch* LSTEff::sim_pLS_types_branch

protected

Definition at line 207 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_pLS_types().

◆ sim_pLS_types_isLoaded

bool LSTEff::sim_pLS_types_isLoaded

protected

Definition at line 208 of file LSTEff.h.

Referenced by GetEntry(), and sim_pLS_types().

◆ sim_pT3_matched_

std::vector<int>* LSTEff::sim_pT3_matched_

protected

Definition at line 77 of file LSTEff.h.

Referenced by Init(), and sim_pT3_matched().

◆ sim_pT3_matched_branch

TBranch* LSTEff::sim_pT3_matched_branch

protected

Definition at line 78 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_pT3_matched().

◆ sim_pT3_matched_isLoaded

bool LSTEff::sim_pT3_matched_isLoaded

protected

Definition at line 79 of file LSTEff.h.

Referenced by GetEntry(), and sim_pT3_matched().

◆ sim_pT3_types_

std::vector<std::vector<int> >* LSTEff::sim_pT3_types_

protected

Definition at line 167 of file LSTEff.h.

Referenced by Init(), and sim_pT3_types().

◆ sim_pT3_types_branch

TBranch* LSTEff::sim_pT3_types_branch

protected

Definition at line 168 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_pT3_types().

◆ sim_pT3_types_isLoaded

bool LSTEff::sim_pT3_types_isLoaded

protected

Definition at line 169 of file LSTEff.h.

Referenced by GetEntry(), and sim_pT3_types().

◆ sim_pT4_matched_

std::vector<int>* LSTEff::sim_pT4_matched_

protected

Definition at line 335 of file LSTEff.h.

Referenced by Init(), and sim_pT4_matched().

◆ sim_pT4_matched_branch

TBranch* LSTEff::sim_pT4_matched_branch

protected

Definition at line 336 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_pT4_matched().

◆ sim_pT4_matched_isLoaded

bool LSTEff::sim_pT4_matched_isLoaded

protected

Definition at line 337 of file LSTEff.h.

Referenced by GetEntry(), and sim_pT4_matched().

◆ sim_pT4_types_

std::vector<std::vector<int> >* LSTEff::sim_pT4_types_

protected

Definition at line 230 of file LSTEff.h.

Referenced by Init(), and sim_pT4_types().

◆ sim_pT4_types_branch

TBranch* LSTEff::sim_pT4_types_branch

protected

Definition at line 231 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_pT4_types().

◆ sim_pT4_types_isLoaded

bool LSTEff::sim_pT4_types_isLoaded

protected

Definition at line 232 of file LSTEff.h.

Referenced by GetEntry(), and sim_pT4_types().

◆ sim_pT5_matched_

std::vector<int>* LSTEff::sim_pT5_matched_

protected

Definition at line 440 of file LSTEff.h.

Referenced by Init(), and sim_pT5_matched().

◆ sim_pT5_matched_branch

TBranch* LSTEff::sim_pT5_matched_branch

protected

Definition at line 441 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_pT5_matched().

◆ sim_pT5_matched_isLoaded

bool LSTEff::sim_pT5_matched_isLoaded

protected

Definition at line 442 of file LSTEff.h.

Referenced by GetEntry(), and sim_pT5_matched().

◆ sim_pT5_types_

std::vector<std::vector<int> >* LSTEff::sim_pT5_types_

protected

Definition at line 437 of file LSTEff.h.

Referenced by Init(), and sim_pT5_types().

◆ sim_pT5_types_branch

TBranch* LSTEff::sim_pT5_types_branch

protected

Definition at line 438 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_pT5_types().

◆ sim_pT5_types_isLoaded

bool LSTEff::sim_pT5_types_isLoaded

protected

Definition at line 439 of file LSTEff.h.

Referenced by GetEntry(), and sim_pT5_types().

◆ sim_pt_

std::vector<float>* LSTEff::sim_pt_

protected

Definition at line 98 of file LSTEff.h.

Referenced by Init(), and sim_pt().

◆ sim_pt_branch

TBranch* LSTEff::sim_pt_branch

protected

Definition at line 99 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_pt().

◆ sim_pt_isLoaded

bool LSTEff::sim_pt_isLoaded

protected

Definition at line 100 of file LSTEff.h.

Referenced by GetEntry(), and sim_pt().

◆ sim_pureTCE_matched_

std::vector<int>* LSTEff::sim_pureTCE_matched_

protected

Definition at line 221 of file LSTEff.h.

Referenced by Init(), and sim_pureTCE_matched().

◆ sim_pureTCE_matched_branch

TBranch* LSTEff::sim_pureTCE_matched_branch

protected

Definition at line 222 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_pureTCE_matched().

◆ sim_pureTCE_matched_isLoaded

bool LSTEff::sim_pureTCE_matched_isLoaded

protected

Definition at line 223 of file LSTEff.h.

Referenced by GetEntry(), and sim_pureTCE_matched().

◆ sim_pureTCE_types_

std::vector<std::vector<int> >* LSTEff::sim_pureTCE_types_

protected

Definition at line 170 of file LSTEff.h.

Referenced by Init(), and sim_pureTCE_types().

◆ sim_pureTCE_types_branch

TBranch* LSTEff::sim_pureTCE_types_branch

protected

Definition at line 171 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_pureTCE_types().

◆ sim_pureTCE_types_isLoaded

bool LSTEff::sim_pureTCE_types_isLoaded

protected

Definition at line 172 of file LSTEff.h.

Referenced by GetEntry(), and sim_pureTCE_types().

◆ sim_q_

std::vector<int>* LSTEff::sim_q_

protected

Definition at line 38 of file LSTEff.h.

Referenced by Init(), and sim_q().

◆ sim_q_branch

TBranch* LSTEff::sim_q_branch

protected

Definition at line 39 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_q().

◆ sim_q_isLoaded

bool LSTEff::sim_q_isLoaded

protected

Definition at line 40 of file LSTEff.h.

Referenced by GetEntry(), and sim_q().

◆ sim_T3_matched_

std::vector<int>* LSTEff::sim_T3_matched_

protected

Definition at line 296 of file LSTEff.h.

Referenced by Init(), and sim_T3_matched().

◆ sim_T3_matched_branch

TBranch* LSTEff::sim_T3_matched_branch

protected

Definition at line 297 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_T3_matched().

◆ sim_T3_matched_isLoaded

bool LSTEff::sim_T3_matched_isLoaded

protected

Definition at line 298 of file LSTEff.h.

Referenced by GetEntry(), and sim_T3_matched().

◆ sim_T3_types_

std::vector<std::vector<int> >* LSTEff::sim_T3_types_

protected

Definition at line 434 of file LSTEff.h.

Referenced by Init(), and sim_T3_types().

◆ sim_T3_types_branch

TBranch* LSTEff::sim_T3_types_branch

protected

Definition at line 435 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_T3_types().

◆ sim_T3_types_isLoaded

bool LSTEff::sim_T3_types_isLoaded

protected

Definition at line 436 of file LSTEff.h.

Referenced by GetEntry(), and sim_T3_types().

◆ sim_T4_matched_

std::vector<int>* LSTEff::sim_T4_matched_

protected

Definition at line 245 of file LSTEff.h.

Referenced by Init(), and sim_T4_matched().

◆ sim_T4_matched_branch

TBranch* LSTEff::sim_T4_matched_branch

protected

Definition at line 246 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_T4_matched().

◆ sim_T4_matched_isLoaded

bool LSTEff::sim_T4_matched_isLoaded

protected

Definition at line 247 of file LSTEff.h.

Referenced by GetEntry(), and sim_T4_matched().

◆ sim_T4_types_

std::vector<std::vector<int> >* LSTEff::sim_T4_types_

protected

Definition at line 395 of file LSTEff.h.

Referenced by Init(), and sim_T4_types().

◆ sim_T4_types_branch

TBranch* LSTEff::sim_T4_types_branch

protected

Definition at line 396 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_T4_types().

◆ sim_T4_types_isLoaded

bool LSTEff::sim_T4_types_isLoaded

protected

Definition at line 397 of file LSTEff.h.

Referenced by GetEntry(), and sim_T4_types().

◆ sim_T5_matched_

std::vector<int>* LSTEff::sim_T5_matched_

protected

Definition at line 344 of file LSTEff.h.

Referenced by Init(), and sim_T5_matched().

◆ sim_T5_matched_branch

TBranch* LSTEff::sim_T5_matched_branch

protected

Definition at line 345 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_T5_matched().

◆ sim_T5_matched_isLoaded

bool LSTEff::sim_T5_matched_isLoaded

protected

Definition at line 346 of file LSTEff.h.

Referenced by GetEntry(), and sim_T5_matched().

◆ sim_T5_types_

std::vector<std::vector<int> >* LSTEff::sim_T5_types_

protected

Definition at line 347 of file LSTEff.h.

Referenced by Init(), and sim_T5_types().

◆ sim_T5_types_branch

TBranch* LSTEff::sim_T5_types_branch

protected

Definition at line 348 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_T5_types().

◆ sim_T5_types_isLoaded

bool LSTEff::sim_T5_types_isLoaded

protected

Definition at line 349 of file LSTEff.h.

Referenced by GetEntry(), and sim_T5_types().

◆ sim_TC_matched_

std::vector<int>* LSTEff::sim_TC_matched_

protected

Definition at line 368 of file LSTEff.h.

Referenced by Init(), and sim_TC_matched().

◆ sim_TC_matched_branch

TBranch* LSTEff::sim_TC_matched_branch

protected

Definition at line 369 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_TC_matched().

◆ sim_TC_matched_isLoaded

bool LSTEff::sim_TC_matched_isLoaded

protected

Definition at line 370 of file LSTEff.h.

Referenced by GetEntry(), and sim_TC_matched().

◆ sim_TC_matched_mask_

std::vector<int>* LSTEff::sim_TC_matched_mask_

protected

Definition at line 371 of file LSTEff.h.

Referenced by Init(), and sim_TC_matched_mask().

◆ sim_TC_matched_mask_branch

TBranch* LSTEff::sim_TC_matched_mask_branch

protected

Definition at line 372 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_TC_matched_mask().

◆ sim_TC_matched_mask_isLoaded

bool LSTEff::sim_TC_matched_mask_isLoaded

protected

Definition at line 373 of file LSTEff.h.

Referenced by GetEntry(), and sim_TC_matched_mask().

◆ sim_TC_matched_nonextended_

std::vector<int>* LSTEff::sim_TC_matched_nonextended_

protected

Definition at line 116 of file LSTEff.h.

Referenced by Init(), and sim_TC_matched_nonextended().

◆ sim_TC_matched_nonextended_branch

TBranch* LSTEff::sim_TC_matched_nonextended_branch

protected

Definition at line 117 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_TC_matched_nonextended().

◆ sim_TC_matched_nonextended_isLoaded

bool LSTEff::sim_TC_matched_nonextended_isLoaded

protected

Definition at line 118 of file LSTEff.h.

Referenced by GetEntry(), and sim_TC_matched_nonextended().

◆ sim_TC_types_

std::vector<std::vector<int> >* LSTEff::sim_TC_types_

protected

Definition at line 404 of file LSTEff.h.

Referenced by Init(), and sim_TC_types().

◆ sim_TC_types_branch

TBranch* LSTEff::sim_TC_types_branch

protected

Definition at line 405 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_TC_types().

◆ sim_TC_types_isLoaded

bool LSTEff::sim_TC_types_isLoaded

protected

Definition at line 406 of file LSTEff.h.

Referenced by GetEntry(), and sim_TC_types().

◆ sim_tce_matched_

std::vector<int>* LSTEff::sim_tce_matched_

protected

Definition at line 65 of file LSTEff.h.

Referenced by Init(), and sim_tce_matched().

◆ sim_tce_matched_branch

TBranch* LSTEff::sim_tce_matched_branch

protected

Definition at line 66 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_tce_matched().

◆ sim_tce_matched_isLoaded

bool LSTEff::sim_tce_matched_isLoaded

protected

Definition at line 67 of file LSTEff.h.

Referenced by GetEntry(), and sim_tce_matched().

◆ sim_tce_types_

std::vector<std::vector<int> >* LSTEff::sim_tce_types_

protected

Definition at line 449 of file LSTEff.h.

Referenced by Init(), and sim_tce_types().

◆ sim_tce_types_branch

TBranch* LSTEff::sim_tce_types_branch

protected

Definition at line 450 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_tce_types().

◆ sim_tce_types_isLoaded

bool LSTEff::sim_tce_types_isLoaded

protected

Definition at line 451 of file LSTEff.h.

Referenced by GetEntry(), and sim_tce_types().

◆ sim_tcIdx_

std::vector<std::vector<int> >* LSTEff::sim_tcIdx_

protected

Definition at line 131 of file LSTEff.h.

Referenced by Init(), and sim_tcIdx().

◆ sim_tcIdx_branch

TBranch* LSTEff::sim_tcIdx_branch

protected

Definition at line 132 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_tcIdx().

◆ sim_tcIdx_isLoaded

bool LSTEff::sim_tcIdx_isLoaded

protected

Definition at line 133 of file LSTEff.h.

Referenced by GetEntry(), and sim_tcIdx().

◆ sim_vx_

std::vector<float>* LSTEff::sim_vx_

protected

Definition at line 416 of file LSTEff.h.

Referenced by Init(), and sim_vx().

◆ sim_vx_branch

TBranch* LSTEff::sim_vx_branch

protected

Definition at line 417 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_vx().

◆ sim_vx_isLoaded

bool LSTEff::sim_vx_isLoaded

protected

Definition at line 418 of file LSTEff.h.

Referenced by GetEntry(), and sim_vx().

◆ sim_vy_

std::vector<float>* LSTEff::sim_vy_

protected

Definition at line 419 of file LSTEff.h.

Referenced by Init(), and sim_vy().

◆ sim_vy_branch

TBranch* LSTEff::sim_vy_branch

protected

Definition at line 420 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_vy().

◆ sim_vy_isLoaded

bool LSTEff::sim_vy_isLoaded

protected

Definition at line 421 of file LSTEff.h.

Referenced by GetEntry(), and sim_vy().

◆ sim_vz_

std::vector<float>* LSTEff::sim_vz_

protected

Definition at line 422 of file LSTEff.h.

Referenced by Init(), and sim_vz().

◆ sim_vz_branch

TBranch* LSTEff::sim_vz_branch

protected

Definition at line 423 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and sim_vz().

◆ sim_vz_isLoaded

bool LSTEff::sim_vz_isLoaded

protected

Definition at line 424 of file LSTEff.h.

Referenced by GetEntry(), and sim_vz().

◆ simvtx_x_

std::vector<float>* LSTEff::simvtx_x_

protected

Definition at line 236 of file LSTEff.h.

Referenced by Init(), and simvtx_x().

◆ simvtx_x_branch

TBranch* LSTEff::simvtx_x_branch

protected

Definition at line 237 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and simvtx_x().

◆ simvtx_x_isLoaded

bool LSTEff::simvtx_x_isLoaded

protected

Definition at line 238 of file LSTEff.h.

Referenced by GetEntry(), and simvtx_x().

◆ simvtx_y_

std::vector<float>* LSTEff::simvtx_y_

protected

Definition at line 239 of file LSTEff.h.

Referenced by Init(), and simvtx_y().

◆ simvtx_y_branch

TBranch* LSTEff::simvtx_y_branch

protected

Definition at line 240 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and simvtx_y().

◆ simvtx_y_isLoaded

bool LSTEff::simvtx_y_isLoaded

protected

Definition at line 241 of file LSTEff.h.

Referenced by GetEntry(), and simvtx_y().

◆ simvtx_z_

std::vector<float>* LSTEff::simvtx_z_

protected

Definition at line 242 of file LSTEff.h.

Referenced by Init(), and simvtx_z().

◆ simvtx_z_branch

TBranch* LSTEff::simvtx_z_branch

protected

Definition at line 243 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and simvtx_z().

◆ simvtx_z_isLoaded

bool LSTEff::simvtx_z_isLoaded

protected

Definition at line 244 of file LSTEff.h.

Referenced by GetEntry(), and simvtx_z().

◆ t3_eta_

std::vector<float>* LSTEff::t3_eta_

protected

Definition at line 110 of file LSTEff.h.

Referenced by Init(), and t3_eta().

◆ t3_eta_branch

TBranch* LSTEff::t3_eta_branch

protected

Definition at line 111 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t3_eta().

◆ t3_eta_isLoaded

bool LSTEff::t3_eta_isLoaded

protected

Definition at line 112 of file LSTEff.h.

Referenced by GetEntry(), and t3_eta().

◆ t3_isDuplicate_

std::vector<int>* LSTEff::t3_isDuplicate_

protected

Definition at line 32 of file LSTEff.h.

Referenced by Init(), and t3_isDuplicate().

◆ t3_isDuplicate_branch

TBranch* LSTEff::t3_isDuplicate_branch

protected

Definition at line 33 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t3_isDuplicate().

◆ t3_isDuplicate_isLoaded

bool LSTEff::t3_isDuplicate_isLoaded

protected

Definition at line 34 of file LSTEff.h.

Referenced by GetEntry(), and t3_isDuplicate().

◆ t3_isFake_

std::vector<int>* LSTEff::t3_isFake_

protected

Definition at line 152 of file LSTEff.h.

Referenced by Init(), and t3_isFake().

◆ t3_isFake_branch

TBranch* LSTEff::t3_isFake_branch

protected

Definition at line 153 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t3_isFake().

◆ t3_isFake_isLoaded

bool LSTEff::t3_isFake_isLoaded

protected

Definition at line 154 of file LSTEff.h.

Referenced by GetEntry(), and t3_isFake().

◆ t3_occupancies_

std::vector<int>* LSTEff::t3_occupancies_

protected

Definition at line 224 of file LSTEff.h.

Referenced by Init(), and t3_occupancies().

◆ t3_occupancies_branch

TBranch* LSTEff::t3_occupancies_branch

protected

Definition at line 225 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t3_occupancies().

◆ t3_occupancies_isLoaded

bool LSTEff::t3_occupancies_isLoaded

protected

Definition at line 226 of file LSTEff.h.

Referenced by GetEntry(), and t3_occupancies().

◆ t3_phi_

std::vector<float>* LSTEff::t3_phi_

protected

Definition at line 23 of file LSTEff.h.

Referenced by Init(), and t3_phi().

◆ t3_phi_branch

TBranch* LSTEff::t3_phi_branch

protected

Definition at line 24 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t3_phi().

◆ t3_phi_isLoaded

bool LSTEff::t3_phi_isLoaded

protected

Definition at line 25 of file LSTEff.h.

Referenced by GetEntry(), and t3_phi().

◆ t3_pt_

std::vector<float>* LSTEff::t3_pt_

protected

Definition at line 428 of file LSTEff.h.

Referenced by Init(), and t3_pt().

◆ t3_pt_branch

TBranch* LSTEff::t3_pt_branch

protected

Definition at line 429 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t3_pt().

◆ t3_pt_isLoaded

bool LSTEff::t3_pt_isLoaded

protected

Definition at line 430 of file LSTEff.h.

Referenced by GetEntry(), and t3_pt().

◆ t4_eta_

std::vector<float>* LSTEff::t4_eta_

protected

Definition at line 311 of file LSTEff.h.

Referenced by Init(), and t4_eta().

◆ t4_eta_branch

TBranch* LSTEff::t4_eta_branch

protected

Definition at line 312 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t4_eta().

◆ t4_eta_isLoaded

bool LSTEff::t4_eta_isLoaded

protected

Definition at line 313 of file LSTEff.h.

Referenced by GetEntry(), and t4_eta().

◆ t4_isDuplicate_

std::vector<int>* LSTEff::t4_isDuplicate_

protected

Definition at line 83 of file LSTEff.h.

Referenced by Init(), and t4_isDuplicate().

◆ t4_isDuplicate_branch

TBranch* LSTEff::t4_isDuplicate_branch

protected

Definition at line 84 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t4_isDuplicate().

◆ t4_isDuplicate_isLoaded

bool LSTEff::t4_isDuplicate_isLoaded

protected

Definition at line 85 of file LSTEff.h.

Referenced by GetEntry(), and t4_isDuplicate().

◆ t4_isFake_

std::vector<int>* LSTEff::t4_isFake_

protected

Definition at line 233 of file LSTEff.h.

Referenced by Init(), and t4_isFake().

◆ t4_isFake_branch

TBranch* LSTEff::t4_isFake_branch

protected

Definition at line 234 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t4_isFake().

◆ t4_isFake_isLoaded

bool LSTEff::t4_isFake_isLoaded

protected

Definition at line 235 of file LSTEff.h.

Referenced by GetEntry(), and t4_isFake().

◆ t4_occupancies_

std::vector<int>* LSTEff::t4_occupancies_

protected

Definition at line 119 of file LSTEff.h.

Referenced by Init(), and t4_occupancies().

◆ t4_occupancies_branch

TBranch* LSTEff::t4_occupancies_branch

protected

Definition at line 120 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t4_occupancies().

◆ t4_occupancies_isLoaded

bool LSTEff::t4_occupancies_isLoaded

protected

Definition at line 121 of file LSTEff.h.

Referenced by GetEntry(), and t4_occupancies().

◆ t4_phi_

std::vector<float>* LSTEff::t4_phi_

protected

Definition at line 173 of file LSTEff.h.

Referenced by Init(), and t4_phi().

◆ t4_phi_branch

TBranch* LSTEff::t4_phi_branch

protected

Definition at line 174 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t4_phi().

◆ t4_phi_isLoaded

bool LSTEff::t4_phi_isLoaded

protected

Definition at line 175 of file LSTEff.h.

Referenced by GetEntry(), and t4_phi().

◆ t4_pt_

std::vector<float>* LSTEff::t4_pt_

protected

Definition at line 401 of file LSTEff.h.

Referenced by Init(), and t4_pt().

◆ t4_pt_branch

TBranch* LSTEff::t4_pt_branch

protected

Definition at line 402 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t4_pt().

◆ t4_pt_isLoaded

bool LSTEff::t4_pt_isLoaded

protected

Definition at line 403 of file LSTEff.h.

Referenced by GetEntry(), and t4_pt().

◆ t5_eta_

std::vector<float>* LSTEff::t5_eta_

protected

Definition at line 56 of file LSTEff.h.

Referenced by Init(), and t5_eta().

◆ t5_eta_2_

std::vector<float>* LSTEff::t5_eta_2_

protected

Definition at line 101 of file LSTEff.h.

Referenced by Init(), and t5_eta_2().

◆ t5_eta_2_branch

TBranch* LSTEff::t5_eta_2_branch

protected

Definition at line 102 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t5_eta_2().

◆ t5_eta_2_isLoaded

bool LSTEff::t5_eta_2_isLoaded

protected

Definition at line 103 of file LSTEff.h.

Referenced by GetEntry(), and t5_eta_2().

◆ t5_eta_branch

TBranch* LSTEff::t5_eta_branch

protected

Definition at line 57 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t5_eta().

◆ t5_eta_isLoaded

bool LSTEff::t5_eta_isLoaded

protected

Definition at line 58 of file LSTEff.h.

Referenced by GetEntry(), and t5_eta().

◆ t5_foundDuplicate_

std::vector<int>* LSTEff::t5_foundDuplicate_

protected

Definition at line 227 of file LSTEff.h.

Referenced by Init(), and t5_foundDuplicate().

◆ t5_foundDuplicate_branch

TBranch* LSTEff::t5_foundDuplicate_branch

protected

Definition at line 228 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t5_foundDuplicate().

◆ t5_foundDuplicate_isLoaded

bool LSTEff::t5_foundDuplicate_isLoaded

protected

Definition at line 229 of file LSTEff.h.

Referenced by GetEntry(), and t5_foundDuplicate().

◆ t5_hitIdxs_

std::vector<std::vector<int> >* LSTEff::t5_hitIdxs_

protected

Definition at line 164 of file LSTEff.h.

Referenced by Init(), and t5_hitIdxs().

◆ t5_hitIdxs_branch

TBranch* LSTEff::t5_hitIdxs_branch

protected

Definition at line 165 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t5_hitIdxs().

◆ t5_hitIdxs_isLoaded

bool LSTEff::t5_hitIdxs_isLoaded

protected

Definition at line 166 of file LSTEff.h.

Referenced by GetEntry(), and t5_hitIdxs().

◆ t5_isDuplicate_

std::vector<int>* LSTEff::t5_isDuplicate_

protected

Definition at line 353 of file LSTEff.h.

Referenced by Init(), and t5_isDuplicate().

◆ t5_isDuplicate_branch

TBranch* LSTEff::t5_isDuplicate_branch

protected

Definition at line 354 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t5_isDuplicate().

◆ t5_isDuplicate_isLoaded

bool LSTEff::t5_isDuplicate_isLoaded

protected

Definition at line 355 of file LSTEff.h.

Referenced by GetEntry(), and t5_isDuplicate().

◆ t5_isFake_

std::vector<int>* LSTEff::t5_isFake_

protected

Definition at line 158 of file LSTEff.h.

Referenced by Init(), and t5_isFake().

◆ t5_isFake_branch

TBranch* LSTEff::t5_isFake_branch

protected

Definition at line 159 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t5_isFake().

◆ t5_isFake_isLoaded

bool LSTEff::t5_isFake_isLoaded

protected

Definition at line 160 of file LSTEff.h.

Referenced by GetEntry(), and t5_isFake().

◆ t5_matched_simIdx_

std::vector<std::vector<int> >* LSTEff::t5_matched_simIdx_

protected

Definition at line 140 of file LSTEff.h.

Referenced by Init(), and t5_matched_simIdx().

◆ t5_matched_simIdx_branch

TBranch* LSTEff::t5_matched_simIdx_branch

protected

Definition at line 141 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t5_matched_simIdx().

◆ t5_matched_simIdx_isLoaded

bool LSTEff::t5_matched_simIdx_isLoaded

protected

Definition at line 142 of file LSTEff.h.

Referenced by GetEntry(), and t5_matched_simIdx().

◆ t5_occupancies_

std::vector<int>* LSTEff::t5_occupancies_

protected

Definition at line 380 of file LSTEff.h.

Referenced by Init(), and t5_occupancies().

◆ t5_occupancies_branch

TBranch* LSTEff::t5_occupancies_branch

protected

Definition at line 381 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t5_occupancies().

◆ t5_occupancies_isLoaded

bool LSTEff::t5_occupancies_isLoaded

protected

Definition at line 382 of file LSTEff.h.

Referenced by GetEntry(), and t5_occupancies().

◆ t5_phi_

std::vector<float>* LSTEff::t5_phi_

protected

Definition at line 176 of file LSTEff.h.

Referenced by Init(), and t5_phi().

◆ t5_phi_2_

std::vector<float>* LSTEff::t5_phi_2_

protected

Definition at line 134 of file LSTEff.h.

Referenced by Init(), and t5_phi_2().

◆ t5_phi_2_branch

TBranch* LSTEff::t5_phi_2_branch

protected

Definition at line 135 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t5_phi_2().

◆ t5_phi_2_isLoaded

bool LSTEff::t5_phi_2_isLoaded

protected

Definition at line 136 of file LSTEff.h.

Referenced by GetEntry(), and t5_phi_2().

◆ t5_phi_branch

TBranch* LSTEff::t5_phi_branch

protected

Definition at line 177 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t5_phi().

◆ t5_phi_isLoaded

bool LSTEff::t5_phi_isLoaded

protected

Definition at line 178 of file LSTEff.h.

Referenced by GetEntry(), and t5_phi().

◆ t5_pt_

std::vector<float>* LSTEff::t5_pt_

protected

Definition at line 182 of file LSTEff.h.

Referenced by Init(), and t5_pt().

◆ t5_pt_branch

TBranch* LSTEff::t5_pt_branch

protected

Definition at line 183 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t5_pt().

◆ t5_pt_isLoaded

bool LSTEff::t5_pt_isLoaded

protected

Definition at line 184 of file LSTEff.h.

Referenced by GetEntry(), and t5_pt().

◆ t5_score_rphisum_

std::vector<float>* LSTEff::t5_score_rphisum_

protected

Definition at line 26 of file LSTEff.h.

Referenced by Init(), and t5_score_rphisum().

◆ t5_score_rphisum_branch

TBranch* LSTEff::t5_score_rphisum_branch

protected

Definition at line 27 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and t5_score_rphisum().

◆ t5_score_rphisum_isLoaded

bool LSTEff::t5_score_rphisum_isLoaded

protected

Definition at line 28 of file LSTEff.h.

Referenced by GetEntry(), and t5_score_rphisum().

◆ tc_eta_

std::vector<float>* LSTEff::tc_eta_

protected

Definition at line 338 of file LSTEff.h.

Referenced by Init(), and tc_eta().

◆ tc_eta_branch

TBranch* LSTEff::tc_eta_branch

protected

Definition at line 339 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tc_eta().

◆ tc_eta_isLoaded

bool LSTEff::tc_eta_isLoaded

protected

Definition at line 340 of file LSTEff.h.

Referenced by GetEntry(), and tc_eta().

◆ tc_hitIdxs_

std::vector<std::vector<int> >* LSTEff::tc_hitIdxs_

protected

Definition at line 359 of file LSTEff.h.

Referenced by Init(), and tc_hitIdxs().

◆ tc_hitIdxs_branch

TBranch* LSTEff::tc_hitIdxs_branch

protected

Definition at line 360 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tc_hitIdxs().

◆ tc_hitIdxs_isLoaded

bool LSTEff::tc_hitIdxs_isLoaded

protected

Definition at line 361 of file LSTEff.h.

Referenced by GetEntry(), and tc_hitIdxs().

◆ tc_isDuplicate_

std::vector<int>* LSTEff::tc_isDuplicate_

protected

Definition at line 71 of file LSTEff.h.

Referenced by Init(), and tc_isDuplicate().

◆ tc_isDuplicate_branch

TBranch* LSTEff::tc_isDuplicate_branch

protected

Definition at line 72 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tc_isDuplicate().

◆ tc_isDuplicate_isLoaded

bool LSTEff::tc_isDuplicate_isLoaded

protected

Definition at line 73 of file LSTEff.h.

Referenced by GetEntry(), and tc_isDuplicate().

◆ tc_isFake_

std::vector<int>* LSTEff::tc_isFake_

protected

Definition at line 194 of file LSTEff.h.

Referenced by Init(), and tc_isFake().

◆ tc_isFake_branch

TBranch* LSTEff::tc_isFake_branch

protected

Definition at line 195 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tc_isFake().

◆ tc_isFake_isLoaded

bool LSTEff::tc_isFake_isLoaded

protected

Definition at line 196 of file LSTEff.h.

Referenced by GetEntry(), and tc_isFake().

◆ tc_matched_simIdx_

std::vector<std::vector<int> >* LSTEff::tc_matched_simIdx_

protected

Definition at line 293 of file LSTEff.h.

Referenced by Init(), and tc_matched_simIdx().

◆ tc_matched_simIdx_branch

TBranch* LSTEff::tc_matched_simIdx_branch

protected

Definition at line 294 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tc_matched_simIdx().

◆ tc_matched_simIdx_isLoaded

bool LSTEff::tc_matched_simIdx_isLoaded

protected

Definition at line 295 of file LSTEff.h.

Referenced by GetEntry(), and tc_matched_simIdx().

◆ tc_maxHitMatchedCounts_

std::vector<int>* LSTEff::tc_maxHitMatchedCounts_

protected

Definition at line 275 of file LSTEff.h.

Referenced by Init(), and tc_maxHitMatchedCounts().

◆ tc_maxHitMatchedCounts_branch

TBranch* LSTEff::tc_maxHitMatchedCounts_branch

protected

Definition at line 276 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tc_maxHitMatchedCounts().

◆ tc_maxHitMatchedCounts_isLoaded

bool LSTEff::tc_maxHitMatchedCounts_isLoaded

protected

Definition at line 277 of file LSTEff.h.

Referenced by GetEntry(), and tc_maxHitMatchedCounts().

◆ tc_occupancies_

int LSTEff::tc_occupancies_

protected

Definition at line 365 of file LSTEff.h.

Referenced by Init(), and tc_occupancies().

◆ tc_occupancies_branch

TBranch* LSTEff::tc_occupancies_branch

protected

Definition at line 366 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tc_occupancies().

◆ tc_occupancies_isLoaded

bool LSTEff::tc_occupancies_isLoaded

protected

Definition at line 367 of file LSTEff.h.

Referenced by GetEntry(), and tc_occupancies().

◆ tc_partOfExtension_

std::vector<int>* LSTEff::tc_partOfExtension_

protected

Definition at line 323 of file LSTEff.h.

Referenced by Init(), and tc_partOfExtension().

◆ tc_partOfExtension_branch

TBranch* LSTEff::tc_partOfExtension_branch

protected

Definition at line 324 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tc_partOfExtension().

◆ tc_partOfExtension_isLoaded

bool LSTEff::tc_partOfExtension_isLoaded

protected

Definition at line 325 of file LSTEff.h.

Referenced by GetEntry(), and tc_partOfExtension().

◆ tc_phi_

std::vector<float>* LSTEff::tc_phi_

protected

Definition at line 308 of file LSTEff.h.

Referenced by Init(), and tc_phi().

◆ tc_phi_branch

TBranch* LSTEff::tc_phi_branch

protected

Definition at line 309 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tc_phi().

◆ tc_phi_isLoaded

bool LSTEff::tc_phi_isLoaded

protected

Definition at line 310 of file LSTEff.h.

Referenced by GetEntry(), and tc_phi().

◆ tc_pt_

std::vector<float>* LSTEff::tc_pt_

protected

Definition at line 254 of file LSTEff.h.

Referenced by Init(), and tc_pt().

◆ tc_pt_branch

TBranch* LSTEff::tc_pt_branch

protected

Definition at line 255 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tc_pt().

◆ tc_pt_isLoaded

bool LSTEff::tc_pt_isLoaded

protected

Definition at line 256 of file LSTEff.h.

Referenced by GetEntry(), and tc_pt().

◆ tc_sim_

std::vector<int>* LSTEff::tc_sim_

protected

Definition at line 203 of file LSTEff.h.

Referenced by Init(), and tc_sim().

◆ tc_sim_branch

TBranch* LSTEff::tc_sim_branch

protected

Definition at line 204 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tc_sim().

◆ tc_sim_isLoaded

bool LSTEff::tc_sim_isLoaded

protected

Definition at line 205 of file LSTEff.h.

Referenced by GetEntry(), and tc_sim().

◆ tc_type_

std::vector<int>* LSTEff::tc_type_

protected

Definition at line 383 of file LSTEff.h.

Referenced by Init(), and tc_type().

◆ tc_type_branch

TBranch* LSTEff::tc_type_branch

protected

Definition at line 384 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tc_type().

◆ tc_type_isLoaded

bool LSTEff::tc_type_isLoaded

protected

Definition at line 385 of file LSTEff.h.

Referenced by GetEntry(), and tc_type().

◆ tce_anchorIndex_

std::vector<int>* LSTEff::tce_anchorIndex_

protected

Definition at line 377 of file LSTEff.h.

Referenced by Init(), and tce_anchorIndex().

◆ tce_anchorIndex_branch

TBranch* LSTEff::tce_anchorIndex_branch

protected

Definition at line 378 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tce_anchorIndex().

◆ tce_anchorIndex_isLoaded

bool LSTEff::tce_anchorIndex_isLoaded

protected

Definition at line 379 of file LSTEff.h.

Referenced by GetEntry(), and tce_anchorIndex().

◆ tce_anchorType_

std::vector<int>* LSTEff::tce_anchorType_

protected

Definition at line 146 of file LSTEff.h.

Referenced by Init(), and tce_anchorType().

◆ tce_anchorType_branch

TBranch* LSTEff::tce_anchorType_branch

protected

Definition at line 147 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tce_anchorType().

◆ tce_anchorType_isLoaded

bool LSTEff::tce_anchorType_isLoaded

protected

Definition at line 148 of file LSTEff.h.

Referenced by GetEntry(), and tce_anchorType().

◆ tce_eta_

std::vector<float>* LSTEff::tce_eta_

protected

Definition at line 122 of file LSTEff.h.

Referenced by Init(), and tce_eta().

◆ tce_eta_branch

TBranch* LSTEff::tce_eta_branch

protected

Definition at line 123 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tce_eta().

◆ tce_eta_isLoaded

bool LSTEff::tce_eta_isLoaded

protected

Definition at line 124 of file LSTEff.h.

Referenced by GetEntry(), and tce_eta().

◆ tce_isDuplicate_

std::vector<int>* LSTEff::tce_isDuplicate_

protected

Definition at line 125 of file LSTEff.h.

Referenced by Init(), and tce_isDuplicate().

◆ tce_isDuplicate_branch

TBranch* LSTEff::tce_isDuplicate_branch

protected

Definition at line 126 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tce_isDuplicate().

◆ tce_isDuplicate_isLoaded

bool LSTEff::tce_isDuplicate_isLoaded

protected

Definition at line 127 of file LSTEff.h.

Referenced by GetEntry(), and tce_isDuplicate().

◆ tce_isFake_

std::vector<int>* LSTEff::tce_isFake_

protected

Definition at line 386 of file LSTEff.h.

Referenced by Init(), and tce_isFake().

◆ tce_isFake_branch

TBranch* LSTEff::tce_isFake_branch

protected

Definition at line 387 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tce_isFake().

◆ tce_isFake_isLoaded

bool LSTEff::tce_isFake_isLoaded

protected

Definition at line 388 of file LSTEff.h.

Referenced by GetEntry(), and tce_isFake().

◆ tce_layer_binary_

std::vector<int>* LSTEff::tce_layer_binary_

protected

Definition at line 113 of file LSTEff.h.

Referenced by Init(), and tce_layer_binary().

◆ tce_layer_binary_branch

TBranch* LSTEff::tce_layer_binary_branch

protected

Definition at line 114 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tce_layer_binary().

◆ tce_layer_binary_isLoaded

bool LSTEff::tce_layer_binary_isLoaded

protected

Definition at line 115 of file LSTEff.h.

Referenced by GetEntry(), and tce_layer_binary().

◆ tce_matched_simIdx_

std::vector<std::vector<int> >* LSTEff::tce_matched_simIdx_

protected

Definition at line 350 of file LSTEff.h.

Referenced by Init(), and tce_matched_simIdx().

◆ tce_matched_simIdx_branch

TBranch* LSTEff::tce_matched_simIdx_branch

protected

Definition at line 351 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tce_matched_simIdx().

◆ tce_matched_simIdx_isLoaded

bool LSTEff::tce_matched_simIdx_isLoaded

protected

Definition at line 352 of file LSTEff.h.

Referenced by GetEntry(), and tce_matched_simIdx().

◆ tce_maxHitMatchedCounts_

std::vector<int>* LSTEff::tce_maxHitMatchedCounts_

protected

Definition at line 425 of file LSTEff.h.

Referenced by Init(), and tce_maxHitMatchedCounts().

◆ tce_maxHitMatchedCounts_branch

TBranch* LSTEff::tce_maxHitMatchedCounts_branch

protected

Definition at line 426 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tce_maxHitMatchedCounts().

◆ tce_maxHitMatchedCounts_isLoaded

bool LSTEff::tce_maxHitMatchedCounts_isLoaded

protected

Definition at line 427 of file LSTEff.h.

Referenced by GetEntry(), and tce_maxHitMatchedCounts().

◆ tce_nHitOverlaps_

std::vector<std::vector<int> >* LSTEff::tce_nHitOverlaps_

protected

Definition at line 149 of file LSTEff.h.

Referenced by Init(), and tce_nHitOverlaps().

◆ tce_nHitOverlaps_branch

TBranch* LSTEff::tce_nHitOverlaps_branch

protected

Definition at line 150 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tce_nHitOverlaps().

◆ tce_nHitOverlaps_isLoaded

bool LSTEff::tce_nHitOverlaps_isLoaded

protected

Definition at line 151 of file LSTEff.h.

Referenced by GetEntry(), and tce_nHitOverlaps().

◆ tce_nLayerOverlaps_

std::vector<std::vector<int> >* LSTEff::tce_nLayerOverlaps_

protected

Definition at line 200 of file LSTEff.h.

Referenced by Init(), and tce_nLayerOverlaps().

◆ tce_nLayerOverlaps_branch

TBranch* LSTEff::tce_nLayerOverlaps_branch

protected

Definition at line 201 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tce_nLayerOverlaps().

◆ tce_nLayerOverlaps_isLoaded

bool LSTEff::tce_nLayerOverlaps_isLoaded

protected

Definition at line 202 of file LSTEff.h.

Referenced by GetEntry(), and tce_nLayerOverlaps().

◆ tce_phi_

std::vector<float>* LSTEff::tce_phi_

protected

Definition at line 155 of file LSTEff.h.

Referenced by Init(), and tce_phi().

◆ tce_phi_branch

TBranch* LSTEff::tce_phi_branch

protected

Definition at line 156 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tce_phi().

◆ tce_phi_isLoaded

bool LSTEff::tce_phi_isLoaded

protected

Definition at line 157 of file LSTEff.h.

Referenced by GetEntry(), and tce_phi().

◆ tce_pt_

std::vector<float>* LSTEff::tce_pt_

protected

Definition at line 191 of file LSTEff.h.

Referenced by Init(), and tce_pt().

◆ tce_pt_branch

TBranch* LSTEff::tce_pt_branch

protected

Definition at line 192 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tce_pt().

◆ tce_pt_isLoaded

bool LSTEff::tce_pt_isLoaded

protected

Definition at line 193 of file LSTEff.h.

Referenced by GetEntry(), and tce_pt().

◆ tce_rPhiChiSquared_

std::vector<float>* LSTEff::tce_rPhiChiSquared_

protected

Definition at line 89 of file LSTEff.h.

Referenced by Init(), and tce_rPhiChiSquared().

◆ tce_rPhiChiSquared_branch

TBranch* LSTEff::tce_rPhiChiSquared_branch

protected

Definition at line 90 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tce_rPhiChiSquared().

◆ tce_rPhiChiSquared_isLoaded

bool LSTEff::tce_rPhiChiSquared_isLoaded

protected

Definition at line 91 of file LSTEff.h.

Referenced by GetEntry(), and tce_rPhiChiSquared().

◆ tce_rzChiSquared_

std::vector<float>* LSTEff::tce_rzChiSquared_

protected

Definition at line 452 of file LSTEff.h.

Referenced by Init(), and tce_rzChiSquared().

◆ tce_rzChiSquared_branch

TBranch* LSTEff::tce_rzChiSquared_branch

protected

Definition at line 453 of file LSTEff.h.

Referenced by Init(), LoadAllBranches(), and tce_rzChiSquared().

◆ tce_rzChiSquared_isLoaded

bool LSTEff::tce_rzChiSquared_isLoaded

protected

Definition at line 454 of file LSTEff.h.

Referenced by GetEntry(), and tce_rzChiSquared().

Public Member Functions

Static Public Member Functions

Protected Attributes

Detailed Description

Member Function Documentation

◆ GetEntry()

◆ Init()

◆ LoadAllBranches()

◆ md_occupancies()

◆ module_layers()

◆ module_rings()

◆ module_subdets()

◆ pLS_eta()

◆ pLS_isDuplicate()

◆ pLS_isFake()

◆ pLS_phi()

◆ pLS_pt()

◆ pLS_score()

◆ progress()

◆ pT3_eta()

◆ pT3_eta_2()

◆ pT3_foundDuplicate()

◆ pT3_hitIdxs()

◆ pT3_isDuplicate()

◆ pT3_isFake()

◆ pT3_matched_simIdx()

◆ pT3_occupancies()

◆ pT3_phi()

◆ pT3_phi_2()

◆ pT3_pt()

◆ pT3_score()

◆ pT4_eta()

◆ pT4_isDuplicate()

◆ pT4_isFake()

◆ pT4_phi()

◆ pT4_pt()

◆ pT5_eta()

◆ pT5_hitIdxs()

◆ pT5_isDuplicate()

◆ pT5_isFake()

◆ pT5_matched_simIdx()

◆ pT5_occupancies()

◆ pT5_phi()

◆ pT5_pt()

◆ pT5_score()

◆ pureTCE_anchorIndex()

◆ pureTCE_anchorType()

◆ pureTCE_eta()

◆ pureTCE_hitIdxs()

◆ pureTCE_isDuplicate()

◆ pureTCE_isFake()

◆ pureTCE_layer_binary()

◆ pureTCE_matched_simIdx()

◆ pureTCE_maxHitMatchedCounts()

◆ pureTCE_nHitOverlaps()

◆ pureTCE_nLayerOverlaps()

◆ pureTCE_phi()

◆ pureTCE_pt()

◆ pureTCE_rPhiChiSquared()

◆ pureTCE_rzChiSquared()

◆ sg_occupancies()

◆ sim_bunchCrossing()

◆ sim_denom()

◆ sim_eta()

◆ sim_event()

◆ sim_hits()

◆ sim_isGood()

◆ sim_len()

◆ sim_lengap()

◆ sim_parentVtxIdx()

◆ sim_pca_dxy()

◆ sim_pca_dz()

◆ sim_pdgId()

◆ sim_phi()

◆ sim_pLS_matched()

◆ sim_pLS_types()

◆ sim_pt()

◆ sim_pT3_matched()

◆ sim_pT3_types()

◆ sim_pT4_matched()