code/core/Trktree.cc

0001 #include "Trktree.h"
0002 Trktree trk;
0003
0004 void Trktree::Init(TTree *tree) {
0005   tree->SetMakeClass(1);
0006   see_stateCcov01_branch = 0;
0007   if (tree->GetBranch("see_stateCcov01") != 0) {
0008     see_stateCcov01_branch = tree->GetBranch("see_stateCcov01");
0009     if (see_stateCcov01_branch) {
0010       see_stateCcov01_branch->SetAddress(&see_stateCcov01_);
0011     }
0012   }
0013   simhit_rod_branch = 0;
0014   if (tree->GetBranch("simhit_rod") != 0) {
0015     simhit_rod_branch = tree->GetBranch("simhit_rod");
0016     if (simhit_rod_branch) {
0017       simhit_rod_branch->SetAddress(&simhit_rod_);
0018     }
0019   }
0020   trk_phi_branch = 0;
0021   if (tree->GetBranch("trk_phi") != 0) {
0022     trk_phi_branch = tree->GetBranch("trk_phi");
0023     if (trk_phi_branch) {
0024       trk_phi_branch->SetAddress(&trk_phi_);
0025     }
0026   }
0027   bsp_x_branch = 0;
0028   if (tree->GetBranch("bsp_x") != 0) {
0029     bsp_x_branch = tree->GetBranch("bsp_x");
0030     if (bsp_x_branch) {
0031       bsp_x_branch->SetAddress(&bsp_x_);
0032     }
0033   }
0034   see_stateCcov05_branch = 0;
0035   if (tree->GetBranch("see_stateCcov05") != 0) {
0036     see_stateCcov05_branch = tree->GetBranch("see_stateCcov05");
0037     if (see_stateCcov05_branch) {
0038       see_stateCcov05_branch->SetAddress(&see_stateCcov05_);
0039     }
0040   }
0041   see_stateCcov04_branch = 0;
0042   if (tree->GetBranch("see_stateCcov04") != 0) {
0043     see_stateCcov04_branch = tree->GetBranch("see_stateCcov04");
0044     if (see_stateCcov04_branch) {
0045       see_stateCcov04_branch->SetAddress(&see_stateCcov04_);
0046     }
0047   }
0048   trk_dxyPV_branch = 0;
0049   if (tree->GetBranch("trk_dxyPV") != 0) {
0050     trk_dxyPV_branch = tree->GetBranch("trk_dxyPV");
0051     if (trk_dxyPV_branch) {
0052       trk_dxyPV_branch->SetAddress(&trk_dxyPV_);
0053     }
0054   }
0055   simhit_tof_branch = 0;
0056   if (tree->GetBranch("simhit_tof") != 0) {
0057     simhit_tof_branch = tree->GetBranch("simhit_tof");
0058     if (simhit_tof_branch) {
0059       simhit_tof_branch->SetAddress(&simhit_tof_);
0060     }
0061   }
0062   sim_event_branch = 0;
0063   if (tree->GetBranch("sim_event") != 0) {
0064     sim_event_branch = tree->GetBranch("sim_event");
0065     if (sim_event_branch) {
0066       sim_event_branch->SetAddress(&sim_event_);
0067     }
0068   }
0069   simhit_isStack_branch = 0;
0070   if (tree->GetBranch("simhit_isStack") != 0) {
0071     simhit_isStack_branch = tree->GetBranch("simhit_isStack");
0072     if (simhit_isStack_branch) {
0073       simhit_isStack_branch->SetAddress(&simhit_isStack_);
0074     }
0075   }
0076   trk_dz_branch = 0;
0077   if (tree->GetBranch("trk_dz") != 0) {
0078     trk_dz_branch = tree->GetBranch("trk_dz");
0079     if (trk_dz_branch) {
0080       trk_dz_branch->SetAddress(&trk_dz_);
0081     }
0082   }
0083   see_stateCcov03_branch = 0;
0084   if (tree->GetBranch("see_stateCcov03") != 0) {
0085     see_stateCcov03_branch = tree->GetBranch("see_stateCcov03");
0086     if (see_stateCcov03_branch) {
0087       see_stateCcov03_branch->SetAddress(&see_stateCcov03_);
0088     }
0089   }
0090   sim_eta_branch = 0;
0091   if (tree->GetBranch("sim_eta") != 0) {
0092     sim_eta_branch = tree->GetBranch("sim_eta");
0093     if (sim_eta_branch) {
0094       sim_eta_branch->SetAddress(&sim_eta_);
0095     }
0096   }
0097   simvtx_processType_branch = 0;
0098   if (tree->GetBranch("simvtx_processType") != 0) {
0099     simvtx_processType_branch = tree->GetBranch("simvtx_processType");
0100     if (simvtx_processType_branch) {
0101       simvtx_processType_branch->SetAddress(&simvtx_processType_);
0102     }
0103   }
0104   pix_radL_branch = 0;
0105   if (tree->GetBranch("pix_radL") != 0) {
0106     pix_radL_branch = tree->GetBranch("pix_radL");
0107     if (pix_radL_branch) {
0108       pix_radL_branch->SetAddress(&pix_radL_);
0109     }
0110   }
0111   see_stateCcov02_branch = 0;
0112   if (tree->GetBranch("see_stateCcov02") != 0) {
0113     see_stateCcov02_branch = tree->GetBranch("see_stateCcov02");
0114     if (see_stateCcov02_branch) {
0115       see_stateCcov02_branch->SetAddress(&see_stateCcov02_);
0116     }
0117   }
0118   see_nGlued_branch = 0;
0119   if (tree->GetBranch("see_nGlued") != 0) {
0120     see_nGlued_branch = tree->GetBranch("see_nGlued");
0121     if (see_nGlued_branch) {
0122       see_nGlued_branch->SetAddress(&see_nGlued_);
0123     }
0124   }
0125   trk_bestSimTrkIdx_branch = 0;
0126   if (tree->GetBranch("trk_bestSimTrkIdx") != 0) {
0127     trk_bestSimTrkIdx_branch = tree->GetBranch("trk_bestSimTrkIdx");
0128     if (trk_bestSimTrkIdx_branch) {
0129       trk_bestSimTrkIdx_branch->SetAddress(&trk_bestSimTrkIdx_);
0130     }
0131   }
0132   see_stateTrajGlbPz_branch = 0;
0133   if (tree->GetBranch("see_stateTrajGlbPz") != 0) {
0134     see_stateTrajGlbPz_branch = tree->GetBranch("see_stateTrajGlbPz");
0135     if (see_stateTrajGlbPz_branch) {
0136       see_stateTrajGlbPz_branch->SetAddress(&see_stateTrajGlbPz_);
0137     }
0138   }
0139   pix_yz_branch = 0;
0140   if (tree->GetBranch("pix_yz") != 0) {
0141     pix_yz_branch = tree->GetBranch("pix_yz");
0142     if (pix_yz_branch) {
0143       pix_yz_branch->SetAddress(&pix_yz_);
0144     }
0145   }
0146   pix_yy_branch = 0;
0147   if (tree->GetBranch("pix_yy") != 0) {
0148     pix_yy_branch = tree->GetBranch("pix_yy");
0149     if (pix_yy_branch) {
0150       pix_yy_branch->SetAddress(&pix_yy_);
0151     }
0152   }
0153   simhit_process_branch = 0;
0154   if (tree->GetBranch("simhit_process") != 0) {
0155     simhit_process_branch = tree->GetBranch("simhit_process");
0156     if (simhit_process_branch) {
0157       simhit_process_branch->SetAddress(&simhit_process_);
0158     }
0159   }
0160   see_stateCcov34_branch = 0;
0161   if (tree->GetBranch("see_stateCcov34") != 0) {
0162     see_stateCcov34_branch = tree->GetBranch("see_stateCcov34");
0163     if (see_stateCcov34_branch) {
0164       see_stateCcov34_branch->SetAddress(&see_stateCcov34_);
0165     }
0166   }
0167   trk_nInnerLost_branch = 0;
0168   if (tree->GetBranch("trk_nInnerLost") != 0) {
0169     trk_nInnerLost_branch = tree->GetBranch("trk_nInnerLost");
0170     if (trk_nInnerLost_branch) {
0171       trk_nInnerLost_branch->SetAddress(&trk_nInnerLost_);
0172     }
0173   }
0174   see_py_branch = 0;
0175   if (tree->GetBranch("see_py") != 0) {
0176     see_py_branch = tree->GetBranch("see_py");
0177     if (see_py_branch) {
0178       see_py_branch->SetAddress(&see_py_);
0179     }
0180   }
0181   sim_trkIdx_branch = 0;
0182   if (tree->GetBranch("sim_trkIdx") != 0) {
0183     sim_trkIdx_branch = tree->GetBranch("sim_trkIdx");
0184     if (sim_trkIdx_branch) {
0185       sim_trkIdx_branch->SetAddress(&sim_trkIdx_);
0186     }
0187   }
0188   trk_nLost_branch = 0;
0189   if (tree->GetBranch("trk_nLost") != 0) {
0190     trk_nLost_branch = tree->GetBranch("trk_nLost");
0191     if (trk_nLost_branch) {
0192       trk_nLost_branch->SetAddress(&trk_nLost_);
0193     }
0194   }
0195   pix_isBarrel_branch = 0;
0196   if (tree->GetBranch("pix_isBarrel") != 0) {
0197     pix_isBarrel_branch = tree->GetBranch("pix_isBarrel");
0198     if (pix_isBarrel_branch) {
0199       pix_isBarrel_branch->SetAddress(&pix_isBarrel_);
0200     }
0201   }
0202   see_dxyErr_branch = 0;
0203   if (tree->GetBranch("see_dxyErr") != 0) {
0204     see_dxyErr_branch = tree->GetBranch("see_dxyErr");
0205     if (see_dxyErr_branch) {
0206       see_dxyErr_branch->SetAddress(&see_dxyErr_);
0207     }
0208   }
0209   simhit_detId_branch = 0;
0210   if (tree->GetBranch("simhit_detId") != 0) {
0211     simhit_detId_branch = tree->GetBranch("simhit_detId");
0212     if (simhit_detId_branch) {
0213       simhit_detId_branch->SetAddress(&simhit_detId_);
0214     }
0215   }
0216   simhit_subdet_branch = 0;
0217   if (tree->GetBranch("simhit_subdet") != 0) {
0218     simhit_subdet_branch = tree->GetBranch("simhit_subdet");
0219     if (simhit_subdet_branch) {
0220       simhit_subdet_branch->SetAddress(&simhit_subdet_);
0221     }
0222   }
0223   see_hitIdx_branch = 0;
0224   if (tree->GetBranch("see_hitIdx") != 0) {
0225     see_hitIdx_branch = tree->GetBranch("see_hitIdx");
0226     if (see_hitIdx_branch) {
0227       see_hitIdx_branch->SetAddress(&see_hitIdx_);
0228     }
0229   }
0230   see_pt_branch = 0;
0231   if (tree->GetBranch("see_pt") != 0) {
0232     see_pt_branch = tree->GetBranch("see_pt");
0233     if (see_pt_branch) {
0234       see_pt_branch->SetAddress(&see_pt_);
0235     }
0236   }
0237   ph2_detId_branch = 0;
0238   if (tree->GetBranch("ph2_detId") != 0) {
0239     ph2_detId_branch = tree->GetBranch("ph2_detId");
0240     if (ph2_detId_branch) {
0241       ph2_detId_branch->SetAddress(&ph2_detId_);
0242     }
0243   }
0244   trk_nStripLay_branch = 0;
0245   if (tree->GetBranch("trk_nStripLay") != 0) {
0246     trk_nStripLay_branch = tree->GetBranch("trk_nStripLay");
0247     if (trk_nStripLay_branch) {
0248       trk_nStripLay_branch->SetAddress(&trk_nStripLay_);
0249     }
0250   }
0251   see_bestFromFirstHitSimTrkIdx_branch = 0;
0252   if (tree->GetBranch("see_bestFromFirstHitSimTrkIdx") != 0) {
0253     see_bestFromFirstHitSimTrkIdx_branch = tree->GetBranch("see_bestFromFirstHitSimTrkIdx");
0254     if (see_bestFromFirstHitSimTrkIdx_branch) {
0255       see_bestFromFirstHitSimTrkIdx_branch->SetAddress(&see_bestFromFirstHitSimTrkIdx_);
0256     }
0257   }
0258   sim_pca_pt_branch = 0;
0259   if (tree->GetBranch("sim_pca_pt") != 0) {
0260     sim_pca_pt_branch = tree->GetBranch("sim_pca_pt");
0261     if (sim_pca_pt_branch) {
0262       sim_pca_pt_branch->SetAddress(&sim_pca_pt_);
0263     }
0264   }
0265   see_trkIdx_branch = 0;
0266   if (tree->GetBranch("see_trkIdx") != 0) {
0267     see_trkIdx_branch = tree->GetBranch("see_trkIdx");
0268     if (see_trkIdx_branch) {
0269       see_trkIdx_branch->SetAddress(&see_trkIdx_);
0270     }
0271   }
0272   trk_nCluster_branch = 0;
0273   if (tree->GetBranch("trk_nCluster") != 0) {
0274     trk_nCluster_branch = tree->GetBranch("trk_nCluster");
0275     if (trk_nCluster_branch) {
0276       trk_nCluster_branch->SetAddress(&trk_nCluster_);
0277     }
0278   }
0279   trk_bestFromFirstHitSimTrkNChi2_branch = 0;
0280   if (tree->GetBranch("trk_bestFromFirstHitSimTrkNChi2") != 0) {
0281     trk_bestFromFirstHitSimTrkNChi2_branch = tree->GetBranch("trk_bestFromFirstHitSimTrkNChi2");
0282     if (trk_bestFromFirstHitSimTrkNChi2_branch) {
0283       trk_bestFromFirstHitSimTrkNChi2_branch->SetAddress(&trk_bestFromFirstHitSimTrkNChi2_);
0284     }
0285   }
0286   trk_isHP_branch = 0;
0287   if (tree->GetBranch("trk_isHP") != 0) {
0288     trk_isHP_branch = tree->GetBranch("trk_isHP");
0289     if (trk_isHP_branch) {
0290       trk_isHP_branch->SetAddress(&trk_isHP_);
0291     }
0292   }
0293   simhit_hitType_branch = 0;
0294   if (tree->GetBranch("simhit_hitType") != 0) {
0295     simhit_hitType_branch = tree->GetBranch("simhit_hitType");
0296     if (simhit_hitType_branch) {
0297       simhit_hitType_branch->SetAddress(&simhit_hitType_);
0298     }
0299   }
0300   ph2_isUpper_branch = 0;
0301   if (tree->GetBranch("ph2_isUpper") != 0) {
0302     ph2_isUpper_branch = tree->GetBranch("ph2_isUpper");
0303     if (ph2_isUpper_branch) {
0304       ph2_isUpper_branch->SetAddress(&ph2_isUpper_);
0305     }
0306   }
0307   see_nStrip_branch = 0;
0308   if (tree->GetBranch("see_nStrip") != 0) {
0309     see_nStrip_branch = tree->GetBranch("see_nStrip");
0310     if (see_nStrip_branch) {
0311       see_nStrip_branch->SetAddress(&see_nStrip_);
0312     }
0313   }
0314   trk_bestSimTrkShareFracSimClusterDenom_branch = 0;
0315   if (tree->GetBranch("trk_bestSimTrkShareFracSimClusterDenom") != 0) {
0316     trk_bestSimTrkShareFracSimClusterDenom_branch = tree->GetBranch("trk_bestSimTrkShareFracSimClusterDenom");
0317     if (trk_bestSimTrkShareFracSimClusterDenom_branch) {
0318       trk_bestSimTrkShareFracSimClusterDenom_branch->SetAddress(&trk_bestSimTrkShareFracSimClusterDenom_);
0319     }
0320   }
0321   simhit_side_branch = 0;
0322   if (tree->GetBranch("simhit_side") != 0) {
0323     simhit_side_branch = tree->GetBranch("simhit_side");
0324     if (simhit_side_branch) {
0325       simhit_side_branch->SetAddress(&simhit_side_);
0326     }
0327   }
0328   simhit_x_branch = 0;
0329   if (tree->GetBranch("simhit_x") != 0) {
0330     simhit_x_branch = tree->GetBranch("simhit_x");
0331     if (simhit_x_branch) {
0332       simhit_x_branch->SetAddress(&simhit_x_);
0333     }
0334   }
0335   see_q_branch = 0;
0336   if (tree->GetBranch("see_q") != 0) {
0337     see_q_branch = tree->GetBranch("see_q");
0338     if (see_q_branch) {
0339       see_q_branch->SetAddress(&see_q_);
0340     }
0341   }
0342   simhit_z_branch = 0;
0343   if (tree->GetBranch("simhit_z") != 0) {
0344     simhit_z_branch = tree->GetBranch("simhit_z");
0345     if (simhit_z_branch) {
0346       simhit_z_branch->SetAddress(&simhit_z_);
0347     }
0348   }
0349   sim_pca_lambda_branch = 0;
0350   if (tree->GetBranch("sim_pca_lambda") != 0) {
0351     sim_pca_lambda_branch = tree->GetBranch("sim_pca_lambda");
0352     if (sim_pca_lambda_branch) {
0353       sim_pca_lambda_branch->SetAddress(&sim_pca_lambda_);
0354     }
0355   }
0356   sim_q_branch = 0;
0357   if (tree->GetBranch("sim_q") != 0) {
0358     sim_q_branch = tree->GetBranch("sim_q");
0359     if (sim_q_branch) {
0360       sim_q_branch->SetAddress(&sim_q_);
0361     }
0362   }
0363   pix_bbxi_branch = 0;
0364   if (tree->GetBranch("pix_bbxi") != 0) {
0365     pix_bbxi_branch = tree->GetBranch("pix_bbxi");
0366     if (pix_bbxi_branch) {
0367       pix_bbxi_branch->SetAddress(&pix_bbxi_);
0368     }
0369   }
0370   ph2_order_branch = 0;
0371   if (tree->GetBranch("ph2_order") != 0) {
0372     ph2_order_branch = tree->GetBranch("ph2_order");
0373     if (ph2_order_branch) {
0374       ph2_order_branch->SetAddress(&ph2_order_);
0375     }
0376   }
0377   ph2_module_branch = 0;
0378   if (tree->GetBranch("ph2_module") != 0) {
0379     ph2_module_branch = tree->GetBranch("ph2_module");
0380     if (ph2_module_branch) {
0381       ph2_module_branch->SetAddress(&ph2_module_);
0382     }
0383   }
0384   inv_order_branch = 0;
0385   if (tree->GetBranch("inv_order") != 0) {
0386     inv_order_branch = tree->GetBranch("inv_order");
0387     if (inv_order_branch) {
0388       inv_order_branch->SetAddress(&inv_order_);
0389     }
0390   }
0391   trk_dzErr_branch = 0;
0392   if (tree->GetBranch("trk_dzErr") != 0) {
0393     trk_dzErr_branch = tree->GetBranch("trk_dzErr");
0394     if (trk_dzErr_branch) {
0395       trk_dzErr_branch->SetAddress(&trk_dzErr_);
0396     }
0397   }
0398   trk_nInnerInactive_branch = 0;
0399   if (tree->GetBranch("trk_nInnerInactive") != 0) {
0400     trk_nInnerInactive_branch = tree->GetBranch("trk_nInnerInactive");
0401     if (trk_nInnerInactive_branch) {
0402       trk_nInnerInactive_branch->SetAddress(&trk_nInnerInactive_);
0403     }
0404   }
0405   see_fitok_branch = 0;
0406   if (tree->GetBranch("see_fitok") != 0) {
0407     see_fitok_branch = tree->GetBranch("see_fitok");
0408     if (see_fitok_branch) {
0409       see_fitok_branch->SetAddress(&see_fitok_);
0410     }
0411   }
0412   simhit_blade_branch = 0;
0413   if (tree->GetBranch("simhit_blade") != 0) {
0414     simhit_blade_branch = tree->GetBranch("simhit_blade");
0415     if (simhit_blade_branch) {
0416       simhit_blade_branch->SetAddress(&simhit_blade_);
0417     }
0418   }
0419   inv_subdet_branch = 0;
0420   if (tree->GetBranch("inv_subdet") != 0) {
0421     inv_subdet_branch = tree->GetBranch("inv_subdet");
0422     if (inv_subdet_branch) {
0423       inv_subdet_branch->SetAddress(&inv_subdet_);
0424     }
0425   }
0426   pix_blade_branch = 0;
0427   if (tree->GetBranch("pix_blade") != 0) {
0428     pix_blade_branch = tree->GetBranch("pix_blade");
0429     if (pix_blade_branch) {
0430       pix_blade_branch->SetAddress(&pix_blade_);
0431     }
0432   }
0433   pix_xx_branch = 0;
0434   if (tree->GetBranch("pix_xx") != 0) {
0435     pix_xx_branch = tree->GetBranch("pix_xx");
0436     if (pix_xx_branch) {
0437       pix_xx_branch->SetAddress(&pix_xx_);
0438     }
0439   }
0440   pix_xy_branch = 0;
0441   if (tree->GetBranch("pix_xy") != 0) {
0442     pix_xy_branch = tree->GetBranch("pix_xy");
0443     if (pix_xy_branch) {
0444       pix_xy_branch->SetAddress(&pix_xy_);
0445     }
0446   }
0447   simhit_panel_branch = 0;
0448   if (tree->GetBranch("simhit_panel") != 0) {
0449     simhit_panel_branch = tree->GetBranch("simhit_panel");
0450     if (simhit_panel_branch) {
0451       simhit_panel_branch->SetAddress(&simhit_panel_);
0452     }
0453   }
0454   sim_pz_branch = 0;
0455   if (tree->GetBranch("sim_pz") != 0) {
0456     sim_pz_branch = tree->GetBranch("sim_pz");
0457     if (sim_pz_branch) {
0458       sim_pz_branch->SetAddress(&sim_pz_);
0459     }
0460   }
0461   trk_dxy_branch = 0;
0462   if (tree->GetBranch("trk_dxy") != 0) {
0463     trk_dxy_branch = tree->GetBranch("trk_dxy");
0464     if (trk_dxy_branch) {
0465       trk_dxy_branch->SetAddress(&trk_dxy_);
0466     }
0467   }
0468   sim_px_branch = 0;
0469   if (tree->GetBranch("sim_px") != 0) {
0470     sim_px_branch = tree->GetBranch("sim_px");
0471     if (sim_px_branch) {
0472       sim_px_branch->SetAddress(&sim_px_);
0473     }
0474   }
0475   trk_lambda_branch = 0;
0476   if (tree->GetBranch("trk_lambda") != 0) {
0477     trk_lambda_branch = tree->GetBranch("trk_lambda");
0478     if (trk_lambda_branch) {
0479       trk_lambda_branch->SetAddress(&trk_lambda_);
0480     }
0481   }
0482   see_stateCcov12_branch = 0;
0483   if (tree->GetBranch("see_stateCcov12") != 0) {
0484     see_stateCcov12_branch = tree->GetBranch("see_stateCcov12");
0485     if (see_stateCcov12_branch) {
0486       see_stateCcov12_branch->SetAddress(&see_stateCcov12_);
0487     }
0488   }
0489   sim_pt_branch = 0;
0490   if (tree->GetBranch("sim_pt") != 0) {
0491     sim_pt_branch = tree->GetBranch("sim_pt");
0492     if (sim_pt_branch) {
0493       sim_pt_branch->SetAddress(&sim_pt_);
0494     }
0495   }
0496   sim_py_branch = 0;
0497   if (tree->GetBranch("sim_py") != 0) {
0498     sim_py_branch = tree->GetBranch("sim_py");
0499     if (sim_py_branch) {
0500       sim_py_branch->SetAddress(&sim_py_);
0501     }
0502   }
0503   sim_decayVtxIdx_branch = 0;
0504   if (tree->GetBranch("sim_decayVtxIdx") != 0) {
0505     sim_decayVtxIdx_branch = tree->GetBranch("sim_decayVtxIdx");
0506     if (sim_decayVtxIdx_branch) {
0507       sim_decayVtxIdx_branch->SetAddress(&sim_decayVtxIdx_);
0508     }
0509   }
0510   pix_detId_branch = 0;
0511   if (tree->GetBranch("pix_detId") != 0) {
0512     pix_detId_branch = tree->GetBranch("pix_detId");
0513     if (pix_detId_branch) {
0514       pix_detId_branch->SetAddress(&pix_detId_);
0515     }
0516   }
0517   trk_eta_branch = 0;
0518   if (tree->GetBranch("trk_eta") != 0) {
0519     trk_eta_branch = tree->GetBranch("trk_eta");
0520     if (trk_eta_branch) {
0521       trk_eta_branch->SetAddress(&trk_eta_);
0522     }
0523   }
0524   see_dxy_branch = 0;
0525   if (tree->GetBranch("see_dxy") != 0) {
0526     see_dxy_branch = tree->GetBranch("see_dxy");
0527     if (see_dxy_branch) {
0528       see_dxy_branch->SetAddress(&see_dxy_);
0529     }
0530   }
0531   sim_isFromBHadron_branch = 0;
0532   if (tree->GetBranch("sim_isFromBHadron") != 0) {
0533     sim_isFromBHadron_branch = tree->GetBranch("sim_isFromBHadron");
0534     if (sim_isFromBHadron_branch) {
0535       sim_isFromBHadron_branch->SetAddress(&sim_isFromBHadron_);
0536     }
0537   }
0538   simhit_eloss_branch = 0;
0539   if (tree->GetBranch("simhit_eloss") != 0) {
0540     simhit_eloss_branch = tree->GetBranch("simhit_eloss");
0541     if (simhit_eloss_branch) {
0542       simhit_eloss_branch->SetAddress(&simhit_eloss_);
0543     }
0544   }
0545   see_stateCcov11_branch = 0;
0546   if (tree->GetBranch("see_stateCcov11") != 0) {
0547     see_stateCcov11_branch = tree->GetBranch("see_stateCcov11");
0548     if (see_stateCcov11_branch) {
0549       see_stateCcov11_branch->SetAddress(&see_stateCcov11_);
0550     }
0551   }
0552   simhit_pz_branch = 0;
0553   if (tree->GetBranch("simhit_pz") != 0) {
0554     simhit_pz_branch = tree->GetBranch("simhit_pz");
0555     if (simhit_pz_branch) {
0556       simhit_pz_branch->SetAddress(&simhit_pz_);
0557     }
0558   }
0559   sim_pdgId_branch = 0;
0560   if (tree->GetBranch("sim_pdgId") != 0) {
0561     sim_pdgId_branch = tree->GetBranch("sim_pdgId");
0562     if (sim_pdgId_branch) {
0563       sim_pdgId_branch->SetAddress(&sim_pdgId_);
0564     }
0565   }
0566   trk_stopReason_branch = 0;
0567   if (tree->GetBranch("trk_stopReason") != 0) {
0568     trk_stopReason_branch = tree->GetBranch("trk_stopReason");
0569     if (trk_stopReason_branch) {
0570       trk_stopReason_branch->SetAddress(&trk_stopReason_);
0571     }
0572   }
0573   sim_pca_phi_branch = 0;
0574   if (tree->GetBranch("sim_pca_phi") != 0) {
0575     sim_pca_phi_branch = tree->GetBranch("sim_pca_phi");
0576     if (sim_pca_phi_branch) {
0577       sim_pca_phi_branch->SetAddress(&sim_pca_phi_);
0578     }
0579   }
0580   simhit_isLower_branch = 0;
0581   if (tree->GetBranch("simhit_isLower") != 0) {
0582     simhit_isLower_branch = tree->GetBranch("simhit_isLower");
0583     if (simhit_isLower_branch) {
0584       simhit_isLower_branch->SetAddress(&simhit_isLower_);
0585     }
0586   }
0587   inv_ring_branch = 0;
0588   if (tree->GetBranch("inv_ring") != 0) {
0589     inv_ring_branch = tree->GetBranch("inv_ring");
0590     if (inv_ring_branch) {
0591       inv_ring_branch->SetAddress(&inv_ring_);
0592     }
0593   }
0594   ph2_simHitIdx_branch = 0;
0595   if (tree->GetBranch("ph2_simHitIdx") != 0) {
0596     ph2_simHitIdx_branch = tree->GetBranch("ph2_simHitIdx");
0597     if (ph2_simHitIdx_branch) {
0598       ph2_simHitIdx_branch->SetAddress(&ph2_simHitIdx_);
0599     }
0600   }
0601   simhit_order_branch = 0;
0602   if (tree->GetBranch("simhit_order") != 0) {
0603     simhit_order_branch = tree->GetBranch("simhit_order");
0604     if (simhit_order_branch) {
0605       simhit_order_branch->SetAddress(&simhit_order_);
0606     }
0607   }
0608   trk_dxyClosestPV_branch = 0;
0609   if (tree->GetBranch("trk_dxyClosestPV") != 0) {
0610     trk_dxyClosestPV_branch = tree->GetBranch("trk_dxyClosestPV");
0611     if (trk_dxyClosestPV_branch) {
0612       trk_dxyClosestPV_branch->SetAddress(&trk_dxyClosestPV_);
0613     }
0614   }
0615   pix_z_branch = 0;
0616   if (tree->GetBranch("pix_z") != 0) {
0617     pix_z_branch = tree->GetBranch("pix_z");
0618     if (pix_z_branch) {
0619       pix_z_branch->SetAddress(&pix_z_);
0620     }
0621   }
0622   pix_y_branch = 0;
0623   if (tree->GetBranch("pix_y") != 0) {
0624     pix_y_branch = tree->GetBranch("pix_y");
0625     if (pix_y_branch) {
0626       pix_y_branch->SetAddress(&pix_y_);
0627     }
0628   }
0629   pix_x_branch = 0;
0630   if (tree->GetBranch("pix_x") != 0) {
0631     pix_x_branch = tree->GetBranch("pix_x");
0632     if (pix_x_branch) {
0633       pix_x_branch->SetAddress(&pix_x_);
0634     }
0635   }
0636   see_hitType_branch = 0;
0637   if (tree->GetBranch("see_hitType") != 0) {
0638     see_hitType_branch = tree->GetBranch("see_hitType");
0639     if (see_hitType_branch) {
0640       see_hitType_branch->SetAddress(&see_hitType_);
0641     }
0642   }
0643   see_statePt_branch = 0;
0644   if (tree->GetBranch("see_statePt") != 0) {
0645     see_statePt_branch = tree->GetBranch("see_statePt");
0646     if (see_statePt_branch) {
0647       see_statePt_branch->SetAddress(&see_statePt_);
0648     }
0649   }
0650   simvtx_sourceSimIdx_branch = 0;
0651   if (tree->GetBranch("simvtx_sourceSimIdx") != 0) {
0652     simvtx_sourceSimIdx_branch = tree->GetBranch("simvtx_sourceSimIdx");
0653     if (simvtx_sourceSimIdx_branch) {
0654       simvtx_sourceSimIdx_branch->SetAddress(&simvtx_sourceSimIdx_);
0655     }
0656   }
0657   event_branch = 0;
0658   if (tree->GetBranch("event") != 0) {
0659     event_branch = tree->GetBranch("event");
0660     if (event_branch) {
0661       event_branch->SetAddress(&event_);
0662     }
0663   }
0664   pix_module_branch = 0;
0665   if (tree->GetBranch("pix_module") != 0) {
0666     pix_module_branch = tree->GetBranch("pix_module");
0667     if (pix_module_branch) {
0668       pix_module_branch->SetAddress(&pix_module_);
0669     }
0670   }
0671   ph2_side_branch = 0;
0672   if (tree->GetBranch("ph2_side") != 0) {
0673     ph2_side_branch = tree->GetBranch("ph2_side");
0674     if (ph2_side_branch) {
0675       ph2_side_branch->SetAddress(&ph2_side_);
0676     }
0677   }
0678   trk_bestSimTrkNChi2_branch = 0;
0679   if (tree->GetBranch("trk_bestSimTrkNChi2") != 0) {
0680     trk_bestSimTrkNChi2_branch = tree->GetBranch("trk_bestSimTrkNChi2");
0681     if (trk_bestSimTrkNChi2_branch) {
0682       trk_bestSimTrkNChi2_branch->SetAddress(&trk_bestSimTrkNChi2_);
0683     }
0684   }
0685   see_stateTrajPy_branch = 0;
0686   if (tree->GetBranch("see_stateTrajPy") != 0) {
0687     see_stateTrajPy_branch = tree->GetBranch("see_stateTrajPy");
0688     if (see_stateTrajPy_branch) {
0689       see_stateTrajPy_branch->SetAddress(&see_stateTrajPy_);
0690     }
0691   }
0692   inv_type_branch = 0;
0693   if (tree->GetBranch("inv_type") != 0) {
0694     inv_type_branch = tree->GetBranch("inv_type");
0695     if (inv_type_branch) {
0696       inv_type_branch->SetAddress(&inv_type_);
0697     }
0698   }
0699   bsp_z_branch = 0;
0700   if (tree->GetBranch("bsp_z") != 0) {
0701     bsp_z_branch = tree->GetBranch("bsp_z");
0702     if (bsp_z_branch) {
0703       bsp_z_branch->SetAddress(&bsp_z_);
0704     }
0705   }
0706   bsp_y_branch = 0;
0707   if (tree->GetBranch("bsp_y") != 0) {
0708     bsp_y_branch = tree->GetBranch("bsp_y");
0709     if (bsp_y_branch) {
0710       bsp_y_branch->SetAddress(&bsp_y_);
0711     }
0712   }
0713   simhit_py_branch = 0;
0714   if (tree->GetBranch("simhit_py") != 0) {
0715     simhit_py_branch = tree->GetBranch("simhit_py");
0716     if (simhit_py_branch) {
0717       simhit_py_branch->SetAddress(&simhit_py_);
0718     }
0719   }
0720   see_simTrkIdx_branch = 0;
0721   if (tree->GetBranch("see_simTrkIdx") != 0) {
0722     see_simTrkIdx_branch = tree->GetBranch("see_simTrkIdx");
0723     if (see_simTrkIdx_branch) {
0724       see_simTrkIdx_branch->SetAddress(&see_simTrkIdx_);
0725     }
0726   }
0727   see_stateTrajGlbZ_branch = 0;
0728   if (tree->GetBranch("see_stateTrajGlbZ") != 0) {
0729     see_stateTrajGlbZ_branch = tree->GetBranch("see_stateTrajGlbZ");
0730     if (see_stateTrajGlbZ_branch) {
0731       see_stateTrajGlbZ_branch->SetAddress(&see_stateTrajGlbZ_);
0732     }
0733   }
0734   see_stateTrajGlbX_branch = 0;
0735   if (tree->GetBranch("see_stateTrajGlbX") != 0) {
0736     see_stateTrajGlbX_branch = tree->GetBranch("see_stateTrajGlbX");
0737     if (see_stateTrajGlbX_branch) {
0738       see_stateTrajGlbX_branch->SetAddress(&see_stateTrajGlbX_);
0739     }
0740   }
0741   see_stateTrajGlbY_branch = 0;
0742   if (tree->GetBranch("see_stateTrajGlbY") != 0) {
0743     see_stateTrajGlbY_branch = tree->GetBranch("see_stateTrajGlbY");
0744     if (see_stateTrajGlbY_branch) {
0745       see_stateTrajGlbY_branch->SetAddress(&see_stateTrajGlbY_);
0746     }
0747   }
0748   trk_originalAlgo_branch = 0;
0749   if (tree->GetBranch("trk_originalAlgo") != 0) {
0750     trk_originalAlgo_branch = tree->GetBranch("trk_originalAlgo");
0751     if (trk_originalAlgo_branch) {
0752       trk_originalAlgo_branch->SetAddress(&trk_originalAlgo_);
0753     }
0754   }
0755   trk_nPixel_branch = 0;
0756   if (tree->GetBranch("trk_nPixel") != 0) {
0757     trk_nPixel_branch = tree->GetBranch("trk_nPixel");
0758     if (trk_nPixel_branch) {
0759       trk_nPixel_branch->SetAddress(&trk_nPixel_);
0760     }
0761   }
0762   see_stateCcov14_branch = 0;
0763   if (tree->GetBranch("see_stateCcov14") != 0) {
0764     see_stateCcov14_branch = tree->GetBranch("see_stateCcov14");
0765     if (see_stateCcov14_branch) {
0766       see_stateCcov14_branch->SetAddress(&see_stateCcov14_);
0767     }
0768   }
0769   see_stateCcov15_branch = 0;
0770   if (tree->GetBranch("see_stateCcov15") != 0) {
0771     see_stateCcov15_branch = tree->GetBranch("see_stateCcov15");
0772     if (see_stateCcov15_branch) {
0773       see_stateCcov15_branch->SetAddress(&see_stateCcov15_);
0774     }
0775   }
0776   trk_phiErr_branch = 0;
0777   if (tree->GetBranch("trk_phiErr") != 0) {
0778     trk_phiErr_branch = tree->GetBranch("trk_phiErr");
0779     if (trk_phiErr_branch) {
0780       trk_phiErr_branch->SetAddress(&trk_phiErr_);
0781     }
0782   }
0783   see_stateCcov13_branch = 0;
0784   if (tree->GetBranch("see_stateCcov13") != 0) {
0785     see_stateCcov13_branch = tree->GetBranch("see_stateCcov13");
0786     if (see_stateCcov13_branch) {
0787       see_stateCcov13_branch->SetAddress(&see_stateCcov13_);
0788     }
0789   }
0790   pix_chargeFraction_branch = 0;
0791   if (tree->GetBranch("pix_chargeFraction") != 0) {
0792     pix_chargeFraction_branch = tree->GetBranch("pix_chargeFraction");
0793     if (pix_chargeFraction_branch) {
0794       pix_chargeFraction_branch->SetAddress(&pix_chargeFraction_);
0795     }
0796   }
0797   trk_q_branch = 0;
0798   if (tree->GetBranch("trk_q") != 0) {
0799     trk_q_branch = tree->GetBranch("trk_q");
0800     if (trk_q_branch) {
0801       trk_q_branch->SetAddress(&trk_q_);
0802     }
0803   }
0804   sim_seedIdx_branch = 0;
0805   if (tree->GetBranch("sim_seedIdx") != 0) {
0806     sim_seedIdx_branch = tree->GetBranch("sim_seedIdx");
0807     if (sim_seedIdx_branch) {
0808       sim_seedIdx_branch->SetAddress(&sim_seedIdx_);
0809     }
0810   }
0811   see_dzErr_branch = 0;
0812   if (tree->GetBranch("see_dzErr") != 0) {
0813     see_dzErr_branch = tree->GetBranch("see_dzErr");
0814     if (see_dzErr_branch) {
0815       see_dzErr_branch->SetAddress(&see_dzErr_);
0816     }
0817   }
0818   sim_nRecoClusters_branch = 0;
0819   if (tree->GetBranch("sim_nRecoClusters") != 0) {
0820     sim_nRecoClusters_branch = tree->GetBranch("sim_nRecoClusters");
0821     if (sim_nRecoClusters_branch) {
0822       sim_nRecoClusters_branch->SetAddress(&sim_nRecoClusters_);
0823     }
0824   }
0825   run_branch = 0;
0826   if (tree->GetBranch("run") != 0) {
0827     run_branch = tree->GetBranch("run");
0828     if (run_branch) {
0829       run_branch->SetAddress(&run_);
0830     }
0831   }
0832   ph2_xySignificance_branch = 0;
0833   if (tree->GetBranch("ph2_xySignificance") != 0) {
0834     ph2_xySignificance_branch = tree->GetBranch("ph2_xySignificance");
0835     if (ph2_xySignificance_branch) {
0836       ph2_xySignificance_branch->SetAddress(&ph2_xySignificance_);
0837     }
0838   }
0839   trk_nChi2_branch = 0;
0840   if (tree->GetBranch("trk_nChi2") != 0) {
0841     trk_nChi2_branch = tree->GetBranch("trk_nChi2");
0842     if (trk_nChi2_branch) {
0843       trk_nChi2_branch->SetAddress(&trk_nChi2_);
0844     }
0845   }
0846   pix_layer_branch = 0;
0847   if (tree->GetBranch("pix_layer") != 0) {
0848     pix_layer_branch = tree->GetBranch("pix_layer");
0849     if (pix_layer_branch) {
0850       pix_layer_branch->SetAddress(&pix_layer_);
0851     }
0852   }
0853   pix_xySignificance_branch = 0;
0854   if (tree->GetBranch("pix_xySignificance") != 0) {
0855     pix_xySignificance_branch = tree->GetBranch("pix_xySignificance");
0856     if (pix_xySignificance_branch) {
0857       pix_xySignificance_branch->SetAddress(&pix_xySignificance_);
0858     }
0859   }
0860   sim_pca_eta_branch = 0;
0861   if (tree->GetBranch("sim_pca_eta") != 0) {
0862     sim_pca_eta_branch = tree->GetBranch("sim_pca_eta");
0863     if (sim_pca_eta_branch) {
0864       sim_pca_eta_branch->SetAddress(&sim_pca_eta_);
0865     }
0866   }
0867   see_bestSimTrkShareFrac_branch = 0;
0868   if (tree->GetBranch("see_bestSimTrkShareFrac") != 0) {
0869     see_bestSimTrkShareFrac_branch = tree->GetBranch("see_bestSimTrkShareFrac");
0870     if (see_bestSimTrkShareFrac_branch) {
0871       see_bestSimTrkShareFrac_branch->SetAddress(&see_bestSimTrkShareFrac_);
0872     }
0873   }
0874   see_etaErr_branch = 0;
0875   if (tree->GetBranch("see_etaErr") != 0) {
0876     see_etaErr_branch = tree->GetBranch("see_etaErr");
0877     if (see_etaErr_branch) {
0878       see_etaErr_branch->SetAddress(&see_etaErr_);
0879     }
0880   }
0881   trk_bestSimTrkShareFracSimDenom_branch = 0;
0882   if (tree->GetBranch("trk_bestSimTrkShareFracSimDenom") != 0) {
0883     trk_bestSimTrkShareFracSimDenom_branch = tree->GetBranch("trk_bestSimTrkShareFracSimDenom");
0884     if (trk_bestSimTrkShareFracSimDenom_branch) {
0885       trk_bestSimTrkShareFracSimDenom_branch->SetAddress(&trk_bestSimTrkShareFracSimDenom_);
0886     }
0887   }
0888   bsp_sigmaz_branch = 0;
0889   if (tree->GetBranch("bsp_sigmaz") != 0) {
0890     bsp_sigmaz_branch = tree->GetBranch("bsp_sigmaz");
0891     if (bsp_sigmaz_branch) {
0892       bsp_sigmaz_branch->SetAddress(&bsp_sigmaz_);
0893     }
0894   }
0895   bsp_sigmay_branch = 0;
0896   if (tree->GetBranch("bsp_sigmay") != 0) {
0897     bsp_sigmay_branch = tree->GetBranch("bsp_sigmay");
0898     if (bsp_sigmay_branch) {
0899       bsp_sigmay_branch->SetAddress(&bsp_sigmay_);
0900     }
0901   }
0902   bsp_sigmax_branch = 0;
0903   if (tree->GetBranch("bsp_sigmax") != 0) {
0904     bsp_sigmax_branch = tree->GetBranch("bsp_sigmax");
0905     if (bsp_sigmax_branch) {
0906       bsp_sigmax_branch->SetAddress(&bsp_sigmax_);
0907     }
0908   }
0909   pix_ladder_branch = 0;
0910   if (tree->GetBranch("pix_ladder") != 0) {
0911     pix_ladder_branch = tree->GetBranch("pix_ladder");
0912     if (pix_ladder_branch) {
0913       pix_ladder_branch->SetAddress(&pix_ladder_);
0914     }
0915   }
0916   trk_qualityMask_branch = 0;
0917   if (tree->GetBranch("trk_qualityMask") != 0) {
0918     trk_qualityMask_branch = tree->GetBranch("trk_qualityMask");
0919     if (trk_qualityMask_branch) {
0920       trk_qualityMask_branch->SetAddress(&trk_qualityMask_);
0921     }
0922   }
0923   trk_ndof_branch = 0;
0924   if (tree->GetBranch("trk_ndof") != 0) {
0925     trk_ndof_branch = tree->GetBranch("trk_ndof");
0926     if (trk_ndof_branch) {
0927       trk_ndof_branch->SetAddress(&trk_ndof_);
0928     }
0929   }
0930   pix_subdet_branch = 0;
0931   if (tree->GetBranch("pix_subdet") != 0) {
0932     pix_subdet_branch = tree->GetBranch("pix_subdet");
0933     if (pix_subdet_branch) {
0934       pix_subdet_branch->SetAddress(&pix_subdet_);
0935     }
0936   }
0937   ph2_seeIdx_branch = 0;
0938   if (tree->GetBranch("ph2_seeIdx") != 0) {
0939     ph2_seeIdx_branch = tree->GetBranch("ph2_seeIdx");
0940     if (ph2_seeIdx_branch) {
0941       ph2_seeIdx_branch->SetAddress(&ph2_seeIdx_);
0942     }
0943   }
0944   inv_isUpper_branch = 0;
0945   if (tree->GetBranch("inv_isUpper") != 0) {
0946     inv_isUpper_branch = tree->GetBranch("inv_isUpper");
0947     if (inv_isUpper_branch) {
0948       inv_isUpper_branch->SetAddress(&inv_isUpper_);
0949     }
0950   }
0951   ph2_zx_branch = 0;
0952   if (tree->GetBranch("ph2_zx") != 0) {
0953     ph2_zx_branch = tree->GetBranch("ph2_zx");
0954     if (ph2_zx_branch) {
0955       ph2_zx_branch->SetAddress(&ph2_zx_);
0956     }
0957   }
0958   pix_trkIdx_branch = 0;
0959   if (tree->GetBranch("pix_trkIdx") != 0) {
0960     pix_trkIdx_branch = tree->GetBranch("pix_trkIdx");
0961     if (pix_trkIdx_branch) {
0962       pix_trkIdx_branch->SetAddress(&pix_trkIdx_);
0963     }
0964   }
0965   trk_nOuterLost_branch = 0;
0966   if (tree->GetBranch("trk_nOuterLost") != 0) {
0967     trk_nOuterLost_branch = tree->GetBranch("trk_nOuterLost");
0968     if (trk_nOuterLost_branch) {
0969       trk_nOuterLost_branch->SetAddress(&trk_nOuterLost_);
0970     }
0971   }
0972   inv_panel_branch = 0;
0973   if (tree->GetBranch("inv_panel") != 0) {
0974     inv_panel_branch = tree->GetBranch("inv_panel");
0975     if (inv_panel_branch) {
0976       inv_panel_branch->SetAddress(&inv_panel_);
0977     }
0978   }
0979   vtx_z_branch = 0;
0980   if (tree->GetBranch("vtx_z") != 0) {
0981     vtx_z_branch = tree->GetBranch("vtx_z");
0982     if (vtx_z_branch) {
0983       vtx_z_branch->SetAddress(&vtx_z_);
0984     }
0985   }
0986   simhit_layer_branch = 0;
0987   if (tree->GetBranch("simhit_layer") != 0) {
0988     simhit_layer_branch = tree->GetBranch("simhit_layer");
0989     if (simhit_layer_branch) {
0990       simhit_layer_branch->SetAddress(&simhit_layer_);
0991     }
0992   }
0993   vtx_y_branch = 0;
0994   if (tree->GetBranch("vtx_y") != 0) {
0995     vtx_y_branch = tree->GetBranch("vtx_y");
0996     if (vtx_y_branch) {
0997       vtx_y_branch->SetAddress(&vtx_y_);
0998     }
0999   }
1000   ph2_isBarrel_branch = 0;
1001   if (tree->GetBranch("ph2_isBarrel") != 0) {
1002     ph2_isBarrel_branch = tree->GetBranch("ph2_isBarrel");
1003     if (ph2_isBarrel_branch) {
1004       ph2_isBarrel_branch->SetAddress(&ph2_isBarrel_);
1005     }
1006   }
1007   pix_seeIdx_branch = 0;
1008   if (tree->GetBranch("pix_seeIdx") != 0) {
1009     pix_seeIdx_branch = tree->GetBranch("pix_seeIdx");
1010     if (pix_seeIdx_branch) {
1011       pix_seeIdx_branch->SetAddress(&pix_seeIdx_);
1012     }
1013   }
1014   trk_bestFromFirstHitSimTrkIdx_branch = 0;
1015   if (tree->GetBranch("trk_bestFromFirstHitSimTrkIdx") != 0) {
1016     trk_bestFromFirstHitSimTrkIdx_branch = tree->GetBranch("trk_bestFromFirstHitSimTrkIdx");
1017     if (trk_bestFromFirstHitSimTrkIdx_branch) {
1018       trk_bestFromFirstHitSimTrkIdx_branch->SetAddress(&trk_bestFromFirstHitSimTrkIdx_);
1019     }
1020   }
1021   simhit_px_branch = 0;
1022   if (tree->GetBranch("simhit_px") != 0) {
1023     simhit_px_branch = tree->GetBranch("simhit_px");
1024     if (simhit_px_branch) {
1025       simhit_px_branch->SetAddress(&simhit_px_);
1026     }
1027   }
1028   see_stateTrajX_branch = 0;
1029   if (tree->GetBranch("see_stateTrajX") != 0) {
1030     see_stateTrajX_branch = tree->GetBranch("see_stateTrajX");
1031     if (see_stateTrajX_branch) {
1032       see_stateTrajX_branch->SetAddress(&see_stateTrajX_);
1033     }
1034   }
1035   see_stateTrajY_branch = 0;
1036   if (tree->GetBranch("see_stateTrajY") != 0) {
1037     see_stateTrajY_branch = tree->GetBranch("see_stateTrajY");
1038     if (see_stateTrajY_branch) {
1039       see_stateTrajY_branch->SetAddress(&see_stateTrajY_);
1040     }
1041   }
1042   trk_nOuterInactive_branch = 0;
1043   if (tree->GetBranch("trk_nOuterInactive") != 0) {
1044     trk_nOuterInactive_branch = tree->GetBranch("trk_nOuterInactive");
1045     if (trk_nOuterInactive_branch) {
1046       trk_nOuterInactive_branch->SetAddress(&trk_nOuterInactive_);
1047     }
1048   }
1049   sim_pca_dxy_branch = 0;
1050   if (tree->GetBranch("sim_pca_dxy") != 0) {
1051     sim_pca_dxy_branch = tree->GetBranch("sim_pca_dxy");
1052     if (sim_pca_dxy_branch) {
1053       sim_pca_dxy_branch->SetAddress(&sim_pca_dxy_);
1054     }
1055   }
1056   trk_algo_branch = 0;
1057   if (tree->GetBranch("trk_algo") != 0) {
1058     trk_algo_branch = tree->GetBranch("trk_algo");
1059     if (trk_algo_branch) {
1060       trk_algo_branch->SetAddress(&trk_algo_);
1061     }
1062   }
1063   trk_hitType_branch = 0;
1064   if (tree->GetBranch("trk_hitType") != 0) {
1065     trk_hitType_branch = tree->GetBranch("trk_hitType");
1066     if (trk_hitType_branch) {
1067       trk_hitType_branch->SetAddress(&trk_hitType_);
1068     }
1069   }
1070   trk_bestFromFirstHitSimTrkShareFrac_branch = 0;
1071   if (tree->GetBranch("trk_bestFromFirstHitSimTrkShareFrac") != 0) {
1072     trk_bestFromFirstHitSimTrkShareFrac_branch = tree->GetBranch("trk_bestFromFirstHitSimTrkShareFrac");
1073     if (trk_bestFromFirstHitSimTrkShareFrac_branch) {
1074       trk_bestFromFirstHitSimTrkShareFrac_branch->SetAddress(&trk_bestFromFirstHitSimTrkShareFrac_);
1075     }
1076   }
1077   inv_isBarrel_branch = 0;
1078   if (tree->GetBranch("inv_isBarrel") != 0) {
1079     inv_isBarrel_branch = tree->GetBranch("inv_isBarrel");
1080     if (inv_isBarrel_branch) {
1081       inv_isBarrel_branch->SetAddress(&inv_isBarrel_);
1082     }
1083   }
1084   simvtx_event_branch = 0;
1085   if (tree->GetBranch("simvtx_event") != 0) {
1086     simvtx_event_branch = tree->GetBranch("simvtx_event");
1087     if (simvtx_event_branch) {
1088       simvtx_event_branch->SetAddress(&simvtx_event_);
1089     }
1090   }
1091   ph2_z_branch = 0;
1092   if (tree->GetBranch("ph2_z") != 0) {
1093     ph2_z_branch = tree->GetBranch("ph2_z");
1094     if (ph2_z_branch) {
1095       ph2_z_branch->SetAddress(&ph2_z_);
1096     }
1097   }
1098   ph2_x_branch = 0;
1099   if (tree->GetBranch("ph2_x") != 0) {
1100     ph2_x_branch = tree->GetBranch("ph2_x");
1101     if (ph2_x_branch) {
1102       ph2_x_branch->SetAddress(&ph2_x_);
1103     }
1104   }
1105   ph2_y_branch = 0;
1106   if (tree->GetBranch("ph2_y") != 0) {
1107     ph2_y_branch = tree->GetBranch("ph2_y");
1108     if (ph2_y_branch) {
1109       ph2_y_branch->SetAddress(&ph2_y_);
1110     }
1111   }
1112   sim_genPdgIds_branch = 0;
1113   if (tree->GetBranch("sim_genPdgIds") != 0) {
1114     sim_genPdgIds_branch = tree->GetBranch("sim_genPdgIds");
1115     if (sim_genPdgIds_branch) {
1116       sim_genPdgIds_branch->SetAddress(&sim_genPdgIds_);
1117     }
1118   }
1119   trk_mva_branch = 0;
1120   if (tree->GetBranch("trk_mva") != 0) {
1121     trk_mva_branch = tree->GetBranch("trk_mva");
1122     if (trk_mva_branch) {
1123       trk_mva_branch->SetAddress(&trk_mva_);
1124     }
1125   }
1126   see_stateCcov24_branch = 0;
1127   if (tree->GetBranch("see_stateCcov24") != 0) {
1128     see_stateCcov24_branch = tree->GetBranch("see_stateCcov24");
1129     if (see_stateCcov24_branch) {
1130       see_stateCcov24_branch->SetAddress(&see_stateCcov24_);
1131     }
1132   }
1133   trk_dzClosestPV_branch = 0;
1134   if (tree->GetBranch("trk_dzClosestPV") != 0) {
1135     trk_dzClosestPV_branch = tree->GetBranch("trk_dzClosestPV");
1136     if (trk_dzClosestPV_branch) {
1137       trk_dzClosestPV_branch->SetAddress(&trk_dzClosestPV_);
1138     }
1139   }
1140   see_nCluster_branch = 0;
1141   if (tree->GetBranch("see_nCluster") != 0) {
1142     see_nCluster_branch = tree->GetBranch("see_nCluster");
1143     if (see_nCluster_branch) {
1144       see_nCluster_branch->SetAddress(&see_nCluster_);
1145     }
1146   }
1147   inv_rod_branch = 0;
1148   if (tree->GetBranch("inv_rod") != 0) {
1149     inv_rod_branch = tree->GetBranch("inv_rod");
1150     if (inv_rod_branch) {
1151       inv_rod_branch->SetAddress(&inv_rod_);
1152     }
1153   }
1154   trk_hitIdx_branch = 0;
1155   if (tree->GetBranch("trk_hitIdx") != 0) {
1156     trk_hitIdx_branch = tree->GetBranch("trk_hitIdx");
1157     if (trk_hitIdx_branch) {
1158       trk_hitIdx_branch->SetAddress(&trk_hitIdx_);
1159     }
1160   }
1161   see_stateCcov22_branch = 0;
1162   if (tree->GetBranch("see_stateCcov22") != 0) {
1163     see_stateCcov22_branch = tree->GetBranch("see_stateCcov22");
1164     if (see_stateCcov22_branch) {
1165       see_stateCcov22_branch->SetAddress(&see_stateCcov22_);
1166     }
1167   }
1168   pix_simType_branch = 0;
1169   if (tree->GetBranch("pix_simType") != 0) {
1170     pix_simType_branch = tree->GetBranch("pix_simType");
1171     if (pix_simType_branch) {
1172       pix_simType_branch->SetAddress(&pix_simType_);
1173     }
1174   }
1175   simhit_ring_branch = 0;
1176   if (tree->GetBranch("simhit_ring") != 0) {
1177     simhit_ring_branch = tree->GetBranch("simhit_ring");
1178     if (simhit_ring_branch) {
1179       simhit_ring_branch->SetAddress(&simhit_ring_);
1180     }
1181   }
1182   trk_outer_px_branch = 0;
1183   if (tree->GetBranch("trk_outer_px") != 0) {
1184     trk_outer_px_branch = tree->GetBranch("trk_outer_px");
1185     if (trk_outer_px_branch) {
1186       trk_outer_px_branch->SetAddress(&trk_outer_px_);
1187     }
1188   }
1189   trk_outer_py_branch = 0;
1190   if (tree->GetBranch("trk_outer_py") != 0) {
1191     trk_outer_py_branch = tree->GetBranch("trk_outer_py");
1192     if (trk_outer_py_branch) {
1193       trk_outer_py_branch->SetAddress(&trk_outer_py_);
1194     }
1195   }
1196   trk_outer_pz_branch = 0;
1197   if (tree->GetBranch("trk_outer_pz") != 0) {
1198     trk_outer_pz_branch = tree->GetBranch("trk_outer_pz");
1199     if (trk_outer_pz_branch) {
1200       trk_outer_pz_branch->SetAddress(&trk_outer_pz_);
1201     }
1202   }
1203   ph2_zz_branch = 0;
1204   if (tree->GetBranch("ph2_zz") != 0) {
1205     ph2_zz_branch = tree->GetBranch("ph2_zz");
1206     if (ph2_zz_branch) {
1207       ph2_zz_branch->SetAddress(&ph2_zz_);
1208     }
1209   }
1210   trk_outer_pt_branch = 0;
1211   if (tree->GetBranch("trk_outer_pt") != 0) {
1212     trk_outer_pt_branch = tree->GetBranch("trk_outer_pt");
1213     if (trk_outer_pt_branch) {
1214       trk_outer_pt_branch->SetAddress(&trk_outer_pt_);
1215     }
1216   }
1217   trk_n3DLay_branch = 0;
1218   if (tree->GetBranch("trk_n3DLay") != 0) {
1219     trk_n3DLay_branch = tree->GetBranch("trk_n3DLay");
1220     if (trk_n3DLay_branch) {
1221       trk_n3DLay_branch->SetAddress(&trk_n3DLay_);
1222     }
1223   }
1224   trk_nValid_branch = 0;
1225   if (tree->GetBranch("trk_nValid") != 0) {
1226     trk_nValid_branch = tree->GetBranch("trk_nValid");
1227     if (trk_nValid_branch) {
1228       trk_nValid_branch->SetAddress(&trk_nValid_);
1229     }
1230   }
1231   see_ptErr_branch = 0;
1232   if (tree->GetBranch("see_ptErr") != 0) {
1233     see_ptErr_branch = tree->GetBranch("see_ptErr");
1234     if (see_ptErr_branch) {
1235       see_ptErr_branch->SetAddress(&see_ptErr_);
1236     }
1237   }
1238   see_stateTrajGlbPx_branch = 0;
1239   if (tree->GetBranch("see_stateTrajGlbPx") != 0) {
1240     see_stateTrajGlbPx_branch = tree->GetBranch("see_stateTrajGlbPx");
1241     if (see_stateTrajGlbPx_branch) {
1242       see_stateTrajGlbPx_branch->SetAddress(&see_stateTrajGlbPx_);
1243     }
1244   }
1245   ph2_simType_branch = 0;
1246   if (tree->GetBranch("ph2_simType") != 0) {
1247     ph2_simType_branch = tree->GetBranch("ph2_simType");
1248     if (ph2_simType_branch) {
1249       ph2_simType_branch->SetAddress(&ph2_simType_);
1250     }
1251   }
1252   trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch = 0;
1253   if (tree->GetBranch("trk_bestFromFirstHitSimTrkShareFracSimClusterDenom") != 0) {
1254     trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch =
1255         tree->GetBranch("trk_bestFromFirstHitSimTrkShareFracSimClusterDenom");
1256     if (trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch) {
1257       trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch->SetAddress(
1258           &trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_);
1259     }
1260   }
1261   sim_hits_branch = 0;
1262   if (tree->GetBranch("sim_hits") != 0) {
1263     sim_hits_branch = tree->GetBranch("sim_hits");
1264     if (sim_hits_branch) {
1265       sim_hits_branch->SetAddress(&sim_hits_);
1266     }
1267   }
1268   sim_len_branch = 0;
1269   if (tree->GetBranch("sim_len") != 0) {
1270     sim_len_branch = tree->GetBranch("sim_len");
1271     if (sim_len_branch) {
1272       sim_len_branch->SetAddress(&sim_len_);
1273     }
1274   }
1275   sim_lengap_branch = 0;
1276   if (tree->GetBranch("sim_lengap") != 0) {
1277     sim_lengap_branch = tree->GetBranch("sim_lengap");
1278     if (sim_lengap_branch) {
1279       sim_lengap_branch->SetAddress(&sim_lengap_);
1280     }
1281   }
1282   simvtx_x_branch = 0;
1283   if (tree->GetBranch("simvtx_x") != 0) {
1284     simvtx_x_branch = tree->GetBranch("simvtx_x");
1285     if (simvtx_x_branch) {
1286       simvtx_x_branch->SetAddress(&simvtx_x_);
1287     }
1288   }
1289   trk_pz_branch = 0;
1290   if (tree->GetBranch("trk_pz") != 0) {
1291     trk_pz_branch = tree->GetBranch("trk_pz");
1292     if (trk_pz_branch) {
1293       trk_pz_branch->SetAddress(&trk_pz_);
1294     }
1295   }
1296   see_bestFromFirstHitSimTrkShareFrac_branch = 0;
1297   if (tree->GetBranch("see_bestFromFirstHitSimTrkShareFrac") != 0) {
1298     see_bestFromFirstHitSimTrkShareFrac_branch = tree->GetBranch("see_bestFromFirstHitSimTrkShareFrac");
1299     if (see_bestFromFirstHitSimTrkShareFrac_branch) {
1300       see_bestFromFirstHitSimTrkShareFrac_branch->SetAddress(&see_bestFromFirstHitSimTrkShareFrac_);
1301     }
1302   }
1303   trk_px_branch = 0;
1304   if (tree->GetBranch("trk_px") != 0) {
1305     trk_px_branch = tree->GetBranch("trk_px");
1306     if (trk_px_branch) {
1307       trk_px_branch->SetAddress(&trk_px_);
1308     }
1309   }
1310   trk_py_branch = 0;
1311   if (tree->GetBranch("trk_py") != 0) {
1312     trk_py_branch = tree->GetBranch("trk_py");
1313     if (trk_py_branch) {
1314       trk_py_branch->SetAddress(&trk_py_);
1315     }
1316   }
1317   trk_vtxIdx_branch = 0;
1318   if (tree->GetBranch("trk_vtxIdx") != 0) {
1319     trk_vtxIdx_branch = tree->GetBranch("trk_vtxIdx");
1320     if (trk_vtxIdx_branch) {
1321       trk_vtxIdx_branch->SetAddress(&trk_vtxIdx_);
1322     }
1323   }
1324   sim_nPixel_branch = 0;
1325   if (tree->GetBranch("sim_nPixel") != 0) {
1326     sim_nPixel_branch = tree->GetBranch("sim_nPixel");
1327     if (sim_nPixel_branch) {
1328       sim_nPixel_branch->SetAddress(&sim_nPixel_);
1329     }
1330   }
1331   vtx_chi2_branch = 0;
1332   if (tree->GetBranch("vtx_chi2") != 0) {
1333     vtx_chi2_branch = tree->GetBranch("vtx_chi2");
1334     if (vtx_chi2_branch) {
1335       vtx_chi2_branch->SetAddress(&vtx_chi2_);
1336     }
1337   }
1338   ph2_ring_branch = 0;
1339   if (tree->GetBranch("ph2_ring") != 0) {
1340     ph2_ring_branch = tree->GetBranch("ph2_ring");
1341     if (ph2_ring_branch) {
1342       ph2_ring_branch->SetAddress(&ph2_ring_);
1343     }
1344   }
1345   trk_pt_branch = 0;
1346   if (tree->GetBranch("trk_pt") != 0) {
1347     trk_pt_branch = tree->GetBranch("trk_pt");
1348     if (trk_pt_branch) {
1349       trk_pt_branch->SetAddress(&trk_pt_);
1350     }
1351   }
1352   see_stateCcov44_branch = 0;
1353   if (tree->GetBranch("see_stateCcov44") != 0) {
1354     see_stateCcov44_branch = tree->GetBranch("see_stateCcov44");
1355     if (see_stateCcov44_branch) {
1356       see_stateCcov44_branch->SetAddress(&see_stateCcov44_);
1357     }
1358   }
1359   ph2_radL_branch = 0;
1360   if (tree->GetBranch("ph2_radL") != 0) {
1361     ph2_radL_branch = tree->GetBranch("ph2_radL");
1362     if (ph2_radL_branch) {
1363       ph2_radL_branch->SetAddress(&ph2_radL_);
1364     }
1365   }
1366   vtx_zErr_branch = 0;
1367   if (tree->GetBranch("vtx_zErr") != 0) {
1368     vtx_zErr_branch = tree->GetBranch("vtx_zErr");
1369     if (vtx_zErr_branch) {
1370       vtx_zErr_branch->SetAddress(&vtx_zErr_);
1371     }
1372   }
1373   see_px_branch = 0;
1374   if (tree->GetBranch("see_px") != 0) {
1375     see_px_branch = tree->GetBranch("see_px");
1376     if (see_px_branch) {
1377       see_px_branch->SetAddress(&see_px_);
1378     }
1379   }
1380   see_pz_branch = 0;
1381   if (tree->GetBranch("see_pz") != 0) {
1382     see_pz_branch = tree->GetBranch("see_pz");
1383     if (see_pz_branch) {
1384       see_pz_branch->SetAddress(&see_pz_);
1385     }
1386   }
1387   see_eta_branch = 0;
1388   if (tree->GetBranch("see_eta") != 0) {
1389     see_eta_branch = tree->GetBranch("see_eta");
1390     if (see_eta_branch) {
1391       see_eta_branch->SetAddress(&see_eta_);
1392     }
1393   }
1394   simvtx_bunchCrossing_branch = 0;
1395   if (tree->GetBranch("simvtx_bunchCrossing") != 0) {
1396     simvtx_bunchCrossing_branch = tree->GetBranch("simvtx_bunchCrossing");
1397     if (simvtx_bunchCrossing_branch) {
1398       simvtx_bunchCrossing_branch->SetAddress(&simvtx_bunchCrossing_);
1399     }
1400   }
1401   sim_pca_dz_branch = 0;
1402   if (tree->GetBranch("sim_pca_dz") != 0) {
1403     sim_pca_dz_branch = tree->GetBranch("sim_pca_dz");
1404     if (sim_pca_dz_branch) {
1405       sim_pca_dz_branch->SetAddress(&sim_pca_dz_);
1406     }
1407   }
1408   simvtx_y_branch = 0;
1409   if (tree->GetBranch("simvtx_y") != 0) {
1410     simvtx_y_branch = tree->GetBranch("simvtx_y");
1411     if (simvtx_y_branch) {
1412       simvtx_y_branch->SetAddress(&simvtx_y_);
1413     }
1414   }
1415   inv_isStack_branch = 0;
1416   if (tree->GetBranch("inv_isStack") != 0) {
1417     inv_isStack_branch = tree->GetBranch("inv_isStack");
1418     if (inv_isStack_branch) {
1419       inv_isStack_branch->SetAddress(&inv_isStack_);
1420     }
1421   }
1422   trk_nStrip_branch = 0;
1423   if (tree->GetBranch("trk_nStrip") != 0) {
1424     trk_nStrip_branch = tree->GetBranch("trk_nStrip");
1425     if (trk_nStrip_branch) {
1426       trk_nStrip_branch->SetAddress(&trk_nStrip_);
1427     }
1428   }
1429   trk_etaErr_branch = 0;
1430   if (tree->GetBranch("trk_etaErr") != 0) {
1431     trk_etaErr_branch = tree->GetBranch("trk_etaErr");
1432     if (trk_etaErr_branch) {
1433       trk_etaErr_branch->SetAddress(&trk_etaErr_);
1434     }
1435   }
1436   trk_simTrkNChi2_branch = 0;
1437   if (tree->GetBranch("trk_simTrkNChi2") != 0) {
1438     trk_simTrkNChi2_branch = tree->GetBranch("trk_simTrkNChi2");
1439     if (trk_simTrkNChi2_branch) {
1440       trk_simTrkNChi2_branch->SetAddress(&trk_simTrkNChi2_);
1441     }
1442   }
1443   pix_zz_branch = 0;
1444   if (tree->GetBranch("pix_zz") != 0) {
1445     pix_zz_branch = tree->GetBranch("pix_zz");
1446     if (pix_zz_branch) {
1447       pix_zz_branch->SetAddress(&pix_zz_);
1448     }
1449   }
1450   simhit_particle_branch = 0;
1451   if (tree->GetBranch("simhit_particle") != 0) {
1452     simhit_particle_branch = tree->GetBranch("simhit_particle");
1453     if (simhit_particle_branch) {
1454       simhit_particle_branch->SetAddress(&simhit_particle_);
1455     }
1456   }
1457   see_dz_branch = 0;
1458   if (tree->GetBranch("see_dz") != 0) {
1459     see_dz_branch = tree->GetBranch("see_dz");
1460     if (see_dz_branch) {
1461       see_dz_branch->SetAddress(&see_dz_);
1462     }
1463   }
1464   see_stateTrajPz_branch = 0;
1465   if (tree->GetBranch("see_stateTrajPz") != 0) {
1466     see_stateTrajPz_branch = tree->GetBranch("see_stateTrajPz");
1467     if (see_stateTrajPz_branch) {
1468       see_stateTrajPz_branch->SetAddress(&see_stateTrajPz_);
1469     }
1470   }
1471   trk_bestSimTrkShareFrac_branch = 0;
1472   if (tree->GetBranch("trk_bestSimTrkShareFrac") != 0) {
1473     trk_bestSimTrkShareFrac_branch = tree->GetBranch("trk_bestSimTrkShareFrac");
1474     if (trk_bestSimTrkShareFrac_branch) {
1475       trk_bestSimTrkShareFrac_branch->SetAddress(&trk_bestSimTrkShareFrac_);
1476     }
1477   }
1478   trk_lambdaErr_branch = 0;
1479   if (tree->GetBranch("trk_lambdaErr") != 0) {
1480     trk_lambdaErr_branch = tree->GetBranch("trk_lambdaErr");
1481     if (trk_lambdaErr_branch) {
1482       trk_lambdaErr_branch->SetAddress(&trk_lambdaErr_);
1483     }
1484   }
1485   see_simTrkShareFrac_branch = 0;
1486   if (tree->GetBranch("see_simTrkShareFrac") != 0) {
1487     see_simTrkShareFrac_branch = tree->GetBranch("see_simTrkShareFrac");
1488     if (see_simTrkShareFrac_branch) {
1489       see_simTrkShareFrac_branch->SetAddress(&see_simTrkShareFrac_);
1490     }
1491   }
1492   pix_simHitIdx_branch = 0;
1493   if (tree->GetBranch("pix_simHitIdx") != 0) {
1494     pix_simHitIdx_branch = tree->GetBranch("pix_simHitIdx");
1495     if (pix_simHitIdx_branch) {
1496       pix_simHitIdx_branch->SetAddress(&pix_simHitIdx_);
1497     }
1498   }
1499   vtx_trkIdx_branch = 0;
1500   if (tree->GetBranch("vtx_trkIdx") != 0) {
1501     vtx_trkIdx_branch = tree->GetBranch("vtx_trkIdx");
1502     if (vtx_trkIdx_branch) {
1503       vtx_trkIdx_branch->SetAddress(&vtx_trkIdx_);
1504     }
1505   }
1506   ph2_rod_branch = 0;
1507   if (tree->GetBranch("ph2_rod") != 0) {
1508     ph2_rod_branch = tree->GetBranch("ph2_rod");
1509     if (ph2_rod_branch) {
1510       ph2_rod_branch->SetAddress(&ph2_rod_);
1511     }
1512   }
1513   vtx_ndof_branch = 0;
1514   if (tree->GetBranch("vtx_ndof") != 0) {
1515     vtx_ndof_branch = tree->GetBranch("vtx_ndof");
1516     if (vtx_ndof_branch) {
1517       vtx_ndof_branch->SetAddress(&vtx_ndof_);
1518     }
1519   }
1520   see_nPixel_branch = 0;
1521   if (tree->GetBranch("see_nPixel") != 0) {
1522     see_nPixel_branch = tree->GetBranch("see_nPixel");
1523     if (see_nPixel_branch) {
1524       see_nPixel_branch->SetAddress(&see_nPixel_);
1525     }
1526   }
1527   sim_nStrip_branch = 0;
1528   if (tree->GetBranch("sim_nStrip") != 0) {
1529     sim_nStrip_branch = tree->GetBranch("sim_nStrip");
1530     if (sim_nStrip_branch) {
1531       sim_nStrip_branch->SetAddress(&sim_nStrip_);
1532     }
1533   }
1534   sim_bunchCrossing_branch = 0;
1535   if (tree->GetBranch("sim_bunchCrossing") != 0) {
1536     sim_bunchCrossing_branch = tree->GetBranch("sim_bunchCrossing");
1537     if (sim_bunchCrossing_branch) {
1538       sim_bunchCrossing_branch->SetAddress(&sim_bunchCrossing_);
1539     }
1540   }
1541   see_stateCcov45_branch = 0;
1542   if (tree->GetBranch("see_stateCcov45") != 0) {
1543     see_stateCcov45_branch = tree->GetBranch("see_stateCcov45");
1544     if (see_stateCcov45_branch) {
1545       see_stateCcov45_branch->SetAddress(&see_stateCcov45_);
1546     }
1547   }
1548   ph2_isStack_branch = 0;
1549   if (tree->GetBranch("ph2_isStack") != 0) {
1550     ph2_isStack_branch = tree->GetBranch("ph2_isStack");
1551     if (ph2_isStack_branch) {
1552       ph2_isStack_branch->SetAddress(&ph2_isStack_);
1553     }
1554   }
1555   sim_trkShareFrac_branch = 0;
1556   if (tree->GetBranch("sim_trkShareFrac") != 0) {
1557     sim_trkShareFrac_branch = tree->GetBranch("sim_trkShareFrac");
1558     if (sim_trkShareFrac_branch) {
1559       sim_trkShareFrac_branch->SetAddress(&sim_trkShareFrac_);
1560     }
1561   }
1562   trk_simTrkShareFrac_branch = 0;
1563   if (tree->GetBranch("trk_simTrkShareFrac") != 0) {
1564     trk_simTrkShareFrac_branch = tree->GetBranch("trk_simTrkShareFrac");
1565     if (trk_simTrkShareFrac_branch) {
1566       trk_simTrkShareFrac_branch->SetAddress(&trk_simTrkShareFrac_);
1567     }
1568   }
1569   sim_phi_branch = 0;
1570   if (tree->GetBranch("sim_phi") != 0) {
1571     sim_phi_branch = tree->GetBranch("sim_phi");
1572     if (sim_phi_branch) {
1573       sim_phi_branch->SetAddress(&sim_phi_);
1574     }
1575   }
1576   inv_side_branch = 0;
1577   if (tree->GetBranch("inv_side") != 0) {
1578     inv_side_branch = tree->GetBranch("inv_side");
1579     if (inv_side_branch) {
1580       inv_side_branch->SetAddress(&inv_side_);
1581     }
1582   }
1583   vtx_fake_branch = 0;
1584   if (tree->GetBranch("vtx_fake") != 0) {
1585     vtx_fake_branch = tree->GetBranch("vtx_fake");
1586     if (vtx_fake_branch) {
1587       vtx_fake_branch->SetAddress(&vtx_fake_);
1588     }
1589   }
1590   trk_nInactive_branch = 0;
1591   if (tree->GetBranch("trk_nInactive") != 0) {
1592     trk_nInactive_branch = tree->GetBranch("trk_nInactive");
1593     if (trk_nInactive_branch) {
1594       trk_nInactive_branch->SetAddress(&trk_nInactive_);
1595     }
1596   }
1597   trk_nPixelLay_branch = 0;
1598   if (tree->GetBranch("trk_nPixelLay") != 0) {
1599     trk_nPixelLay_branch = tree->GetBranch("trk_nPixelLay");
1600     if (trk_nPixelLay_branch) {
1601       trk_nPixelLay_branch->SetAddress(&trk_nPixelLay_);
1602     }
1603   }
1604   ph2_bbxi_branch = 0;
1605   if (tree->GetBranch("ph2_bbxi") != 0) {
1606     ph2_bbxi_branch = tree->GetBranch("ph2_bbxi");
1607     if (ph2_bbxi_branch) {
1608       ph2_bbxi_branch->SetAddress(&ph2_bbxi_);
1609     }
1610   }
1611   vtx_xErr_branch = 0;
1612   if (tree->GetBranch("vtx_xErr") != 0) {
1613     vtx_xErr_branch = tree->GetBranch("vtx_xErr");
1614     if (vtx_xErr_branch) {
1615       vtx_xErr_branch->SetAddress(&vtx_xErr_);
1616     }
1617   }
1618   see_stateCcov25_branch = 0;
1619   if (tree->GetBranch("see_stateCcov25") != 0) {
1620     see_stateCcov25_branch = tree->GetBranch("see_stateCcov25");
1621     if (see_stateCcov25_branch) {
1622       see_stateCcov25_branch->SetAddress(&see_stateCcov25_);
1623     }
1624   }
1625   sim_parentVtxIdx_branch = 0;
1626   if (tree->GetBranch("sim_parentVtxIdx") != 0) {
1627     sim_parentVtxIdx_branch = tree->GetBranch("sim_parentVtxIdx");
1628     if (sim_parentVtxIdx_branch) {
1629       sim_parentVtxIdx_branch->SetAddress(&sim_parentVtxIdx_);
1630     }
1631   }
1632   see_stateCcov23_branch = 0;
1633   if (tree->GetBranch("see_stateCcov23") != 0) {
1634     see_stateCcov23_branch = tree->GetBranch("see_stateCcov23");
1635     if (see_stateCcov23_branch) {
1636       see_stateCcov23_branch->SetAddress(&see_stateCcov23_);
1637     }
1638   }
1639   trk_algoMask_branch = 0;
1640   if (tree->GetBranch("trk_algoMask") != 0) {
1641     trk_algoMask_branch = tree->GetBranch("trk_algoMask");
1642     if (trk_algoMask_branch) {
1643       trk_algoMask_branch->SetAddress(&trk_algoMask_);
1644     }
1645   }
1646   trk_simTrkIdx_branch = 0;
1647   if (tree->GetBranch("trk_simTrkIdx") != 0) {
1648     trk_simTrkIdx_branch = tree->GetBranch("trk_simTrkIdx");
1649     if (trk_simTrkIdx_branch) {
1650       trk_simTrkIdx_branch->SetAddress(&trk_simTrkIdx_);
1651     }
1652   }
1653   see_phiErr_branch = 0;
1654   if (tree->GetBranch("see_phiErr") != 0) {
1655     see_phiErr_branch = tree->GetBranch("see_phiErr");
1656     if (see_phiErr_branch) {
1657       see_phiErr_branch->SetAddress(&see_phiErr_);
1658     }
1659   }
1660   trk_cotTheta_branch = 0;
1661   if (tree->GetBranch("trk_cotTheta") != 0) {
1662     trk_cotTheta_branch = tree->GetBranch("trk_cotTheta");
1663     if (trk_cotTheta_branch) {
1664       trk_cotTheta_branch->SetAddress(&trk_cotTheta_);
1665     }
1666   }
1667   see_algo_branch = 0;
1668   if (tree->GetBranch("see_algo") != 0) {
1669     see_algo_branch = tree->GetBranch("see_algo");
1670     if (see_algo_branch) {
1671       see_algo_branch->SetAddress(&see_algo_);
1672     }
1673   }
1674   simhit_module_branch = 0;
1675   if (tree->GetBranch("simhit_module") != 0) {
1676     simhit_module_branch = tree->GetBranch("simhit_module");
1677     if (simhit_module_branch) {
1678       simhit_module_branch->SetAddress(&simhit_module_);
1679     }
1680   }
1681   simvtx_daughterSimIdx_branch = 0;
1682   if (tree->GetBranch("simvtx_daughterSimIdx") != 0) {
1683     simvtx_daughterSimIdx_branch = tree->GetBranch("simvtx_daughterSimIdx");
1684     if (simvtx_daughterSimIdx_branch) {
1685       simvtx_daughterSimIdx_branch->SetAddress(&simvtx_daughterSimIdx_);
1686     }
1687   }
1688   vtx_x_branch = 0;
1689   if (tree->GetBranch("vtx_x") != 0) {
1690     vtx_x_branch = tree->GetBranch("vtx_x");
1691     if (vtx_x_branch) {
1692       vtx_x_branch->SetAddress(&vtx_x_);
1693     }
1694   }
1695   trk_seedIdx_branch = 0;
1696   if (tree->GetBranch("trk_seedIdx") != 0) {
1697     trk_seedIdx_branch = tree->GetBranch("trk_seedIdx");
1698     if (trk_seedIdx_branch) {
1699       trk_seedIdx_branch->SetAddress(&trk_seedIdx_);
1700     }
1701   }
1702   simhit_y_branch = 0;
1703   if (tree->GetBranch("simhit_y") != 0) {
1704     simhit_y_branch = tree->GetBranch("simhit_y");
1705     if (simhit_y_branch) {
1706       simhit_y_branch->SetAddress(&simhit_y_);
1707     }
1708   }
1709   inv_layer_branch = 0;
1710   if (tree->GetBranch("inv_layer") != 0) {
1711     inv_layer_branch = tree->GetBranch("inv_layer");
1712     if (inv_layer_branch) {
1713       inv_layer_branch->SetAddress(&inv_layer_);
1714     }
1715   }
1716   trk_nLostLay_branch = 0;
1717   if (tree->GetBranch("trk_nLostLay") != 0) {
1718     trk_nLostLay_branch = tree->GetBranch("trk_nLostLay");
1719     if (trk_nLostLay_branch) {
1720       trk_nLostLay_branch->SetAddress(&trk_nLostLay_);
1721     }
1722   }
1723   ph2_isLower_branch = 0;
1724   if (tree->GetBranch("ph2_isLower") != 0) {
1725     ph2_isLower_branch = tree->GetBranch("ph2_isLower");
1726     if (ph2_isLower_branch) {
1727       ph2_isLower_branch->SetAddress(&ph2_isLower_);
1728     }
1729   }
1730   pix_side_branch = 0;
1731   if (tree->GetBranch("pix_side") != 0) {
1732     pix_side_branch = tree->GetBranch("pix_side");
1733     if (pix_side_branch) {
1734       pix_side_branch->SetAddress(&pix_side_);
1735     }
1736   }
1737   inv_isLower_branch = 0;
1738   if (tree->GetBranch("inv_isLower") != 0) {
1739     inv_isLower_branch = tree->GetBranch("inv_isLower");
1740     if (inv_isLower_branch) {
1741       inv_isLower_branch->SetAddress(&inv_isLower_);
1742     }
1743   }
1744   ph2_trkIdx_branch = 0;
1745   if (tree->GetBranch("ph2_trkIdx") != 0) {
1746     ph2_trkIdx_branch = tree->GetBranch("ph2_trkIdx");
1747     if (ph2_trkIdx_branch) {
1748       ph2_trkIdx_branch->SetAddress(&ph2_trkIdx_);
1749     }
1750   }
1751   sim_nValid_branch = 0;
1752   if (tree->GetBranch("sim_nValid") != 0) {
1753     sim_nValid_branch = tree->GetBranch("sim_nValid");
1754     if (sim_nValid_branch) {
1755       sim_nValid_branch->SetAddress(&sim_nValid_);
1756     }
1757   }
1758   simhit_simTrkIdx_branch = 0;
1759   if (tree->GetBranch("simhit_simTrkIdx") != 0) {
1760     simhit_simTrkIdx_branch = tree->GetBranch("simhit_simTrkIdx");
1761     if (simhit_simTrkIdx_branch) {
1762       simhit_simTrkIdx_branch->SetAddress(&simhit_simTrkIdx_);
1763     }
1764   }
1765   see_nCands_branch = 0;
1766   if (tree->GetBranch("see_nCands") != 0) {
1767     see_nCands_branch = tree->GetBranch("see_nCands");
1768     if (see_nCands_branch) {
1769       see_nCands_branch->SetAddress(&see_nCands_);
1770     }
1771   }
1772   see_bestSimTrkIdx_branch = 0;
1773   if (tree->GetBranch("see_bestSimTrkIdx") != 0) {
1774     see_bestSimTrkIdx_branch = tree->GetBranch("see_bestSimTrkIdx");
1775     if (see_bestSimTrkIdx_branch) {
1776       see_bestSimTrkIdx_branch->SetAddress(&see_bestSimTrkIdx_);
1777     }
1778   }
1779   vtx_yErr_branch = 0;
1780   if (tree->GetBranch("vtx_yErr") != 0) {
1781     vtx_yErr_branch = tree->GetBranch("vtx_yErr");
1782     if (vtx_yErr_branch) {
1783       vtx_yErr_branch->SetAddress(&vtx_yErr_);
1784     }
1785   }
1786   trk_dzPV_branch = 0;
1787   if (tree->GetBranch("trk_dzPV") != 0) {
1788     trk_dzPV_branch = tree->GetBranch("trk_dzPV");
1789     if (trk_dzPV_branch) {
1790       trk_dzPV_branch->SetAddress(&trk_dzPV_);
1791     }
1792   }
1793   ph2_xy_branch = 0;
1794   if (tree->GetBranch("ph2_xy") != 0) {
1795     ph2_xy_branch = tree->GetBranch("ph2_xy");
1796     if (ph2_xy_branch) {
1797       ph2_xy_branch->SetAddress(&ph2_xy_);
1798     }
1799   }
1800   inv_module_branch = 0;
1801   if (tree->GetBranch("inv_module") != 0) {
1802     inv_module_branch = tree->GetBranch("inv_module");
1803     if (inv_module_branch) {
1804       inv_module_branch->SetAddress(&inv_module_);
1805     }
1806   }
1807   see_stateCcov55_branch = 0;
1808   if (tree->GetBranch("see_stateCcov55") != 0) {
1809     see_stateCcov55_branch = tree->GetBranch("see_stateCcov55");
1810     if (see_stateCcov55_branch) {
1811       see_stateCcov55_branch->SetAddress(&see_stateCcov55_);
1812     }
1813   }
1814   pix_panel_branch = 0;
1815   if (tree->GetBranch("pix_panel") != 0) {
1816     pix_panel_branch = tree->GetBranch("pix_panel");
1817     if (pix_panel_branch) {
1818       pix_panel_branch->SetAddress(&pix_panel_);
1819     }
1820   }
1821   inv_ladder_branch = 0;
1822   if (tree->GetBranch("inv_ladder") != 0) {
1823     inv_ladder_branch = tree->GetBranch("inv_ladder");
1824     if (inv_ladder_branch) {
1825       inv_ladder_branch->SetAddress(&inv_ladder_);
1826     }
1827   }
1828   ph2_xx_branch = 0;
1829   if (tree->GetBranch("ph2_xx") != 0) {
1830     ph2_xx_branch = tree->GetBranch("ph2_xx");
1831     if (ph2_xx_branch) {
1832       ph2_xx_branch->SetAddress(&ph2_xx_);
1833     }
1834   }
1835   sim_pca_cotTheta_branch = 0;
1836   if (tree->GetBranch("sim_pca_cotTheta") != 0) {
1837     sim_pca_cotTheta_branch = tree->GetBranch("sim_pca_cotTheta");
1838     if (sim_pca_cotTheta_branch) {
1839       sim_pca_cotTheta_branch->SetAddress(&sim_pca_cotTheta_);
1840     }
1841   }
1842   simpv_idx_branch = 0;
1843   if (tree->GetBranch("simpv_idx") != 0) {
1844     simpv_idx_branch = tree->GetBranch("simpv_idx");
1845     if (simpv_idx_branch) {
1846       simpv_idx_branch->SetAddress(&simpv_idx_);
1847     }
1848   }
1849   trk_inner_pz_branch = 0;
1850   if (tree->GetBranch("trk_inner_pz") != 0) {
1851     trk_inner_pz_branch = tree->GetBranch("trk_inner_pz");
1852     if (trk_inner_pz_branch) {
1853       trk_inner_pz_branch->SetAddress(&trk_inner_pz_);
1854     }
1855   }
1856   see_chi2_branch = 0;
1857   if (tree->GetBranch("see_chi2") != 0) {
1858     see_chi2_branch = tree->GetBranch("see_chi2");
1859     if (see_chi2_branch) {
1860       see_chi2_branch->SetAddress(&see_chi2_);
1861     }
1862   }
1863   see_stateCcov35_branch = 0;
1864   if (tree->GetBranch("see_stateCcov35") != 0) {
1865     see_stateCcov35_branch = tree->GetBranch("see_stateCcov35");
1866     if (see_stateCcov35_branch) {
1867       see_stateCcov35_branch->SetAddress(&see_stateCcov35_);
1868     }
1869   }
1870   see_stateCcov33_branch = 0;
1871   if (tree->GetBranch("see_stateCcov33") != 0) {
1872     see_stateCcov33_branch = tree->GetBranch("see_stateCcov33");
1873     if (see_stateCcov33_branch) {
1874       see_stateCcov33_branch->SetAddress(&see_stateCcov33_);
1875     }
1876   }
1877   inv_detId_branch = 0;
1878   if (tree->GetBranch("inv_detId") != 0) {
1879     inv_detId_branch = tree->GetBranch("inv_detId");
1880     if (inv_detId_branch) {
1881       inv_detId_branch->SetAddress(&inv_detId_);
1882     }
1883   }
1884   see_offset_branch = 0;
1885   if (tree->GetBranch("see_offset") != 0) {
1886     see_offset_branch = tree->GetBranch("see_offset");
1887     if (see_offset_branch) {
1888       see_offset_branch->SetAddress(&see_offset_);
1889     }
1890   }
1891   sim_nLay_branch = 0;
1892   if (tree->GetBranch("sim_nLay") != 0) {
1893     sim_nLay_branch = tree->GetBranch("sim_nLay");
1894     if (sim_nLay_branch) {
1895       sim_nLay_branch->SetAddress(&sim_nLay_);
1896     }
1897   }
1898   sim_simHitIdx_branch = 0;
1899   if (tree->GetBranch("sim_simHitIdx") != 0) {
1900     sim_simHitIdx_branch = tree->GetBranch("sim_simHitIdx");
1901     if (sim_simHitIdx_branch) {
1902       sim_simHitIdx_branch->SetAddress(&sim_simHitIdx_);
1903     }
1904   }
1905   simhit_isUpper_branch = 0;
1906   if (tree->GetBranch("simhit_isUpper") != 0) {
1907     simhit_isUpper_branch = tree->GetBranch("simhit_isUpper");
1908     if (simhit_isUpper_branch) {
1909       simhit_isUpper_branch->SetAddress(&simhit_isUpper_);
1910     }
1911   }
1912   see_stateCcov00_branch = 0;
1913   if (tree->GetBranch("see_stateCcov00") != 0) {
1914     see_stateCcov00_branch = tree->GetBranch("see_stateCcov00");
1915     if (see_stateCcov00_branch) {
1916       see_stateCcov00_branch->SetAddress(&see_stateCcov00_);
1917     }
1918   }
1919   see_stopReason_branch = 0;
1920   if (tree->GetBranch("see_stopReason") != 0) {
1921     see_stopReason_branch = tree->GetBranch("see_stopReason");
1922     if (see_stopReason_branch) {
1923       see_stopReason_branch->SetAddress(&see_stopReason_);
1924     }
1925   }
1926   vtx_valid_branch = 0;
1927   if (tree->GetBranch("vtx_valid") != 0) {
1928     vtx_valid_branch = tree->GetBranch("vtx_valid");
1929     if (vtx_valid_branch) {
1930       vtx_valid_branch->SetAddress(&vtx_valid_);
1931     }
1932   }
1933   lumi_branch = 0;
1934   if (tree->GetBranch("lumi") != 0) {
1935     lumi_branch = tree->GetBranch("lumi");
1936     if (lumi_branch) {
1937       lumi_branch->SetAddress(&lumi_);
1938     }
1939   }
1940   trk_refpoint_x_branch = 0;
1941   if (tree->GetBranch("trk_refpoint_x") != 0) {
1942     trk_refpoint_x_branch = tree->GetBranch("trk_refpoint_x");
1943     if (trk_refpoint_x_branch) {
1944       trk_refpoint_x_branch->SetAddress(&trk_refpoint_x_);
1945     }
1946   }
1947   trk_refpoint_y_branch = 0;
1948   if (tree->GetBranch("trk_refpoint_y") != 0) {
1949     trk_refpoint_y_branch = tree->GetBranch("trk_refpoint_y");
1950     if (trk_refpoint_y_branch) {
1951       trk_refpoint_y_branch->SetAddress(&trk_refpoint_y_);
1952     }
1953   }
1954   trk_refpoint_z_branch = 0;
1955   if (tree->GetBranch("trk_refpoint_z") != 0) {
1956     trk_refpoint_z_branch = tree->GetBranch("trk_refpoint_z");
1957     if (trk_refpoint_z_branch) {
1958       trk_refpoint_z_branch->SetAddress(&trk_refpoint_z_);
1959     }
1960   }
1961   sim_n3DLay_branch = 0;
1962   if (tree->GetBranch("sim_n3DLay") != 0) {
1963     sim_n3DLay_branch = tree->GetBranch("sim_n3DLay");
1964     if (sim_n3DLay_branch) {
1965       sim_n3DLay_branch->SetAddress(&sim_n3DLay_);
1966     }
1967   }
1968   see_nPhase2OT_branch = 0;
1969   if (tree->GetBranch("see_nPhase2OT") != 0) {
1970     see_nPhase2OT_branch = tree->GetBranch("see_nPhase2OT");
1971     if (see_nPhase2OT_branch) {
1972       see_nPhase2OT_branch->SetAddress(&see_nPhase2OT_);
1973     }
1974   }
1975   trk_bestFromFirstHitSimTrkShareFracSimDenom_branch = 0;
1976   if (tree->GetBranch("trk_bestFromFirstHitSimTrkShareFracSimDenom") != 0) {
1977     trk_bestFromFirstHitSimTrkShareFracSimDenom_branch = tree->GetBranch("trk_bestFromFirstHitSimTrkShareFracSimDenom");
1978     if (trk_bestFromFirstHitSimTrkShareFracSimDenom_branch) {
1979       trk_bestFromFirstHitSimTrkShareFracSimDenom_branch->SetAddress(&trk_bestFromFirstHitSimTrkShareFracSimDenom_);
1980     }
1981   }
1982   ph2_yy_branch = 0;
1983   if (tree->GetBranch("ph2_yy") != 0) {
1984     ph2_yy_branch = tree->GetBranch("ph2_yy");
1985     if (ph2_yy_branch) {
1986       ph2_yy_branch->SetAddress(&ph2_yy_);
1987     }
1988   }
1989   ph2_yz_branch = 0;
1990   if (tree->GetBranch("ph2_yz") != 0) {
1991     ph2_yz_branch = tree->GetBranch("ph2_yz");
1992     if (ph2_yz_branch) {
1993       ph2_yz_branch->SetAddress(&ph2_yz_);
1994     }
1995   }
1996   inv_blade_branch = 0;
1997   if (tree->GetBranch("inv_blade") != 0) {
1998     inv_blade_branch = tree->GetBranch("inv_blade");
1999     if (inv_blade_branch) {
2000       inv_blade_branch->SetAddress(&inv_blade_);
2001     }
2002   }
2003   trk_ptErr_branch = 0;
2004   if (tree->GetBranch("trk_ptErr") != 0) {
2005     trk_ptErr_branch = tree->GetBranch("trk_ptErr");
2006     if (trk_ptErr_branch) {
2007       trk_ptErr_branch->SetAddress(&trk_ptErr_);
2008     }
2009   }
2010   pix_zx_branch = 0;
2011   if (tree->GetBranch("pix_zx") != 0) {
2012     pix_zx_branch = tree->GetBranch("pix_zx");
2013     if (pix_zx_branch) {
2014       pix_zx_branch->SetAddress(&pix_zx_);
2015     }
2016   }
2017   simvtx_z_branch = 0;
2018   if (tree->GetBranch("simvtx_z") != 0) {
2019     simvtx_z_branch = tree->GetBranch("simvtx_z");
2020     if (simvtx_z_branch) {
2021       simvtx_z_branch->SetAddress(&simvtx_z_);
2022     }
2023   }
2024   sim_nTrackerHits_branch = 0;
2025   if (tree->GetBranch("sim_nTrackerHits") != 0) {
2026     sim_nTrackerHits_branch = tree->GetBranch("sim_nTrackerHits");
2027     if (sim_nTrackerHits_branch) {
2028       sim_nTrackerHits_branch->SetAddress(&sim_nTrackerHits_);
2029     }
2030   }
2031   ph2_subdet_branch = 0;
2032   if (tree->GetBranch("ph2_subdet") != 0) {
2033     ph2_subdet_branch = tree->GetBranch("ph2_subdet");
2034     if (ph2_subdet_branch) {
2035       ph2_subdet_branch->SetAddress(&ph2_subdet_);
2036     }
2037   }
2038   see_stateTrajPx_branch = 0;
2039   if (tree->GetBranch("see_stateTrajPx") != 0) {
2040     see_stateTrajPx_branch = tree->GetBranch("see_stateTrajPx");
2041     if (see_stateTrajPx_branch) {
2042       see_stateTrajPx_branch->SetAddress(&see_stateTrajPx_);
2043     }
2044   }
2045   simhit_hitIdx_branch = 0;
2046   if (tree->GetBranch("simhit_hitIdx") != 0) {
2047     simhit_hitIdx_branch = tree->GetBranch("simhit_hitIdx");
2048     if (simhit_hitIdx_branch) {
2049       simhit_hitIdx_branch->SetAddress(&simhit_hitIdx_);
2050     }
2051   }
2052   simhit_ladder_branch = 0;
2053   if (tree->GetBranch("simhit_ladder") != 0) {
2054     simhit_ladder_branch = tree->GetBranch("simhit_ladder");
2055     if (simhit_ladder_branch) {
2056       simhit_ladder_branch->SetAddress(&simhit_ladder_);
2057     }
2058   }
2059   ph2_layer_branch = 0;
2060   if (tree->GetBranch("ph2_layer") != 0) {
2061     ph2_layer_branch = tree->GetBranch("ph2_layer");
2062     if (ph2_layer_branch) {
2063       ph2_layer_branch->SetAddress(&ph2_layer_);
2064     }
2065   }
2066   see_phi_branch = 0;
2067   if (tree->GetBranch("see_phi") != 0) {
2068     see_phi_branch = tree->GetBranch("see_phi");
2069     if (see_phi_branch) {
2070       see_phi_branch->SetAddress(&see_phi_);
2071     }
2072   }
2073   trk_nChi2_1Dmod_branch = 0;
2074   if (tree->GetBranch("trk_nChi2_1Dmod") != 0) {
2075     trk_nChi2_1Dmod_branch = tree->GetBranch("trk_nChi2_1Dmod");
2076     if (trk_nChi2_1Dmod_branch) {
2077       trk_nChi2_1Dmod_branch->SetAddress(&trk_nChi2_1Dmod_);
2078     }
2079   }
2080   trk_inner_py_branch = 0;
2081   if (tree->GetBranch("trk_inner_py") != 0) {
2082     trk_inner_py_branch = tree->GetBranch("trk_inner_py");
2083     if (trk_inner_py_branch) {
2084       trk_inner_py_branch->SetAddress(&trk_inner_py_);
2085     }
2086   }
2087   trk_inner_px_branch = 0;
2088   if (tree->GetBranch("trk_inner_px") != 0) {
2089     trk_inner_px_branch = tree->GetBranch("trk_inner_px");
2090     if (trk_inner_px_branch) {
2091       trk_inner_px_branch->SetAddress(&trk_inner_px_);
2092     }
2093   }
2094   trk_dxyErr_branch = 0;
2095   if (tree->GetBranch("trk_dxyErr") != 0) {
2096     trk_dxyErr_branch = tree->GetBranch("trk_dxyErr");
2097     if (trk_dxyErr_branch) {
2098       trk_dxyErr_branch->SetAddress(&trk_dxyErr_);
2099     }
2100   }
2101   sim_nPixelLay_branch = 0;
2102   if (tree->GetBranch("sim_nPixelLay") != 0) {
2103     sim_nPixelLay_branch = tree->GetBranch("sim_nPixelLay");
2104     if (sim_nPixelLay_branch) {
2105       sim_nPixelLay_branch->SetAddress(&sim_nPixelLay_);
2106     }
2107   }
2108   see_nValid_branch = 0;
2109   if (tree->GetBranch("see_nValid") != 0) {
2110     see_nValid_branch = tree->GetBranch("see_nValid");
2111     if (see_nValid_branch) {
2112       see_nValid_branch->SetAddress(&see_nValid_);
2113     }
2114   }
2115   trk_inner_pt_branch = 0;
2116   if (tree->GetBranch("trk_inner_pt") != 0) {
2117     trk_inner_pt_branch = tree->GetBranch("trk_inner_pt");
2118     if (trk_inner_pt_branch) {
2119       trk_inner_pt_branch->SetAddress(&trk_inner_pt_);
2120     }
2121   }
2122   see_stateTrajGlbPy_branch = 0;
2123   if (tree->GetBranch("see_stateTrajGlbPy") != 0) {
2124     see_stateTrajGlbPy_branch = tree->GetBranch("see_stateTrajGlbPy");
2125     if (see_stateTrajGlbPy_branch) {
2126       see_stateTrajGlbPy_branch->SetAddress(&see_stateTrajGlbPy_);
2127     }
2128   }
2129   tree->SetMakeClass(0);
2130 }
2131 void Trktree::GetEntry(unsigned int idx) {
2132   index = idx;
2133   see_stateCcov01_isLoaded = false;
2134   simhit_rod_isLoaded = false;
2135   trk_phi_isLoaded = false;
2136   bsp_x_isLoaded = false;
2137   see_stateCcov05_isLoaded = false;
2138   see_stateCcov04_isLoaded = false;
2139   trk_dxyPV_isLoaded = false;
2140   simhit_tof_isLoaded = false;
2141   sim_event_isLoaded = false;
2142   simhit_isStack_isLoaded = false;
2143   trk_dz_isLoaded = false;
2144   see_stateCcov03_isLoaded = false;
2145   sim_eta_isLoaded = false;
2146   simvtx_processType_isLoaded = false;
2147   pix_radL_isLoaded = false;
2148   see_stateCcov02_isLoaded = false;
2149   see_nGlued_isLoaded = false;
2150   trk_bestSimTrkIdx_isLoaded = false;
2151   see_stateTrajGlbPz_isLoaded = false;
2152   pix_yz_isLoaded = false;
2153   pix_yy_isLoaded = false;
2154   simhit_process_isLoaded = false;
2155   see_stateCcov34_isLoaded = false;
2156   trk_nInnerLost_isLoaded = false;
2157   see_py_isLoaded = false;
2158   sim_trkIdx_isLoaded = false;
2159   trk_nLost_isLoaded = false;
2160   pix_isBarrel_isLoaded = false;
2161   see_dxyErr_isLoaded = false;
2162   simhit_detId_isLoaded = false;
2163   simhit_subdet_isLoaded = false;
2164   see_hitIdx_isLoaded = false;
2165   see_pt_isLoaded = false;
2166   ph2_detId_isLoaded = false;
2167   trk_nStripLay_isLoaded = false;
2168   see_bestFromFirstHitSimTrkIdx_isLoaded = false;
2169   sim_pca_pt_isLoaded = false;
2170   see_trkIdx_isLoaded = false;
2171   trk_nCluster_isLoaded = false;
2172   trk_bestFromFirstHitSimTrkNChi2_isLoaded = false;
2173   trk_isHP_isLoaded = false;
2174   simhit_hitType_isLoaded = false;
2175   ph2_isUpper_isLoaded = false;
2176   see_nStrip_isLoaded = false;
2177   trk_bestSimTrkShareFracSimClusterDenom_isLoaded = false;
2178   simhit_side_isLoaded = false;
2179   simhit_x_isLoaded = false;
2180   see_q_isLoaded = false;
2181   simhit_z_isLoaded = false;
2182   sim_pca_lambda_isLoaded = false;
2183   sim_q_isLoaded = false;
2184   pix_bbxi_isLoaded = false;
2185   ph2_order_isLoaded = false;
2186   ph2_module_isLoaded = false;
2187   inv_order_isLoaded = false;
2188   trk_dzErr_isLoaded = false;
2189   trk_nInnerInactive_isLoaded = false;
2190   see_fitok_isLoaded = false;
2191   simhit_blade_isLoaded = false;
2192   inv_subdet_isLoaded = false;
2193   pix_blade_isLoaded = false;
2194   pix_xx_isLoaded = false;
2195   pix_xy_isLoaded = false;
2196   simhit_panel_isLoaded = false;
2197   sim_pz_isLoaded = false;
2198   trk_dxy_isLoaded = false;
2199   sim_px_isLoaded = false;
2200   trk_lambda_isLoaded = false;
2201   see_stateCcov12_isLoaded = false;
2202   sim_pt_isLoaded = false;
2203   sim_py_isLoaded = false;
2204   sim_decayVtxIdx_isLoaded = false;
2205   pix_detId_isLoaded = false;
2206   trk_eta_isLoaded = false;
2207   see_dxy_isLoaded = false;
2208   sim_isFromBHadron_isLoaded = false;
2209   simhit_eloss_isLoaded = false;
2210   see_stateCcov11_isLoaded = false;
2211   simhit_pz_isLoaded = false;
2212   sim_pdgId_isLoaded = false;
2213   trk_stopReason_isLoaded = false;
2214   sim_pca_phi_isLoaded = false;
2215   simhit_isLower_isLoaded = false;
2216   inv_ring_isLoaded = false;
2217   ph2_simHitIdx_isLoaded = false;
2218   simhit_order_isLoaded = false;
2219   trk_dxyClosestPV_isLoaded = false;
2220   pix_z_isLoaded = false;
2221   pix_y_isLoaded = false;
2222   pix_x_isLoaded = false;
2223   see_hitType_isLoaded = false;
2224   see_statePt_isLoaded = false;
2225   simvtx_sourceSimIdx_isLoaded = false;
2226   event_isLoaded = false;
2227   pix_module_isLoaded = false;
2228   ph2_side_isLoaded = false;
2229   trk_bestSimTrkNChi2_isLoaded = false;
2230   see_stateTrajPy_isLoaded = false;
2231   inv_type_isLoaded = false;
2232   bsp_z_isLoaded = false;
2233   bsp_y_isLoaded = false;
2234   simhit_py_isLoaded = false;
2235   see_simTrkIdx_isLoaded = false;
2236   see_stateTrajGlbZ_isLoaded = false;
2237   see_stateTrajGlbX_isLoaded = false;
2238   see_stateTrajGlbY_isLoaded = false;
2239   trk_originalAlgo_isLoaded = false;
2240   trk_nPixel_isLoaded = false;
2241   see_stateCcov14_isLoaded = false;
2242   see_stateCcov15_isLoaded = false;
2243   trk_phiErr_isLoaded = false;
2244   see_stateCcov13_isLoaded = false;
2245   pix_chargeFraction_isLoaded = false;
2246   trk_q_isLoaded = false;
2247   sim_seedIdx_isLoaded = false;
2248   see_dzErr_isLoaded = false;
2249   sim_nRecoClusters_isLoaded = false;
2250   run_isLoaded = false;
2251   ph2_xySignificance_isLoaded = false;
2252   trk_nChi2_isLoaded = false;
2253   pix_layer_isLoaded = false;
2254   pix_xySignificance_isLoaded = false;
2255   sim_pca_eta_isLoaded = false;
2256   see_bestSimTrkShareFrac_isLoaded = false;
2257   see_etaErr_isLoaded = false;
2258   trk_bestSimTrkShareFracSimDenom_isLoaded = false;
2259   bsp_sigmaz_isLoaded = false;
2260   bsp_sigmay_isLoaded = false;
2261   bsp_sigmax_isLoaded = false;
2262   pix_ladder_isLoaded = false;
2263   trk_qualityMask_isLoaded = false;
2264   trk_ndof_isLoaded = false;
2265   pix_subdet_isLoaded = false;
2266   ph2_seeIdx_isLoaded = false;
2267   inv_isUpper_isLoaded = false;
2268   ph2_zx_isLoaded = false;
2269   pix_trkIdx_isLoaded = false;
2270   trk_nOuterLost_isLoaded = false;
2271   inv_panel_isLoaded = false;
2272   vtx_z_isLoaded = false;
2273   simhit_layer_isLoaded = false;
2274   vtx_y_isLoaded = false;
2275   ph2_isBarrel_isLoaded = false;
2276   pix_seeIdx_isLoaded = false;
2277   trk_bestFromFirstHitSimTrkIdx_isLoaded = false;
2278   simhit_px_isLoaded = false;
2279   see_stateTrajX_isLoaded = false;
2280   see_stateTrajY_isLoaded = false;
2281   trk_nOuterInactive_isLoaded = false;
2282   sim_pca_dxy_isLoaded = false;
2283   trk_algo_isLoaded = false;
2284   trk_hitType_isLoaded = false;
2285   trk_bestFromFirstHitSimTrkShareFrac_isLoaded = false;
2286   inv_isBarrel_isLoaded = false;
2287   simvtx_event_isLoaded = false;
2288   ph2_z_isLoaded = false;
2289   ph2_x_isLoaded = false;
2290   ph2_y_isLoaded = false;
2291   sim_genPdgIds_isLoaded = false;
2292   trk_mva_isLoaded = false;
2293   see_stateCcov24_isLoaded = false;
2294   trk_dzClosestPV_isLoaded = false;
2295   see_nCluster_isLoaded = false;
2296   inv_rod_isLoaded = false;
2297   trk_hitIdx_isLoaded = false;
2298   see_stateCcov22_isLoaded = false;
2299   pix_simType_isLoaded = false;
2300   simhit_ring_isLoaded = false;
2301   trk_outer_px_isLoaded = false;
2302   trk_outer_py_isLoaded = false;
2303   trk_outer_pz_isLoaded = false;
2304   ph2_zz_isLoaded = false;
2305   trk_outer_pt_isLoaded = false;
2306   trk_n3DLay_isLoaded = false;
2307   trk_nValid_isLoaded = false;
2308   see_ptErr_isLoaded = false;
2309   see_stateTrajGlbPx_isLoaded = false;
2310   ph2_simType_isLoaded = false;
2311   trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_isLoaded = false;
2312   sim_hits_isLoaded = false;
2313   sim_len_isLoaded = false;
2314   sim_lengap_isLoaded = false;
2315   simvtx_x_isLoaded = false;
2316   trk_pz_isLoaded = false;
2317   see_bestFromFirstHitSimTrkShareFrac_isLoaded = false;
2318   trk_px_isLoaded = false;
2319   trk_py_isLoaded = false;
2320   trk_vtxIdx_isLoaded = false;
2321   sim_nPixel_isLoaded = false;
2322   vtx_chi2_isLoaded = false;
2323   ph2_ring_isLoaded = false;
2324   trk_pt_isLoaded = false;
2325   see_stateCcov44_isLoaded = false;
2326   ph2_radL_isLoaded = false;
2327   vtx_zErr_isLoaded = false;
2328   see_px_isLoaded = false;
2329   see_pz_isLoaded = false;
2330   see_eta_isLoaded = false;
2331   simvtx_bunchCrossing_isLoaded = false;
2332   sim_pca_dz_isLoaded = false;
2333   simvtx_y_isLoaded = false;
2334   inv_isStack_isLoaded = false;
2335   trk_nStrip_isLoaded = false;
2336   trk_etaErr_isLoaded = false;
2337   trk_simTrkNChi2_isLoaded = false;
2338   pix_zz_isLoaded = false;
2339   simhit_particle_isLoaded = false;
2340   see_dz_isLoaded = false;
2341   see_stateTrajPz_isLoaded = false;
2342   trk_bestSimTrkShareFrac_isLoaded = false;
2343   trk_lambdaErr_isLoaded = false;
2344   see_simTrkShareFrac_isLoaded = false;
2345   pix_simHitIdx_isLoaded = false;
2346   vtx_trkIdx_isLoaded = false;
2347   ph2_rod_isLoaded = false;
2348   vtx_ndof_isLoaded = false;
2349   see_nPixel_isLoaded = false;
2350   sim_nStrip_isLoaded = false;
2351   sim_bunchCrossing_isLoaded = false;
2352   see_stateCcov45_isLoaded = false;
2353   ph2_isStack_isLoaded = false;
2354   sim_trkShareFrac_isLoaded = false;
2355   trk_simTrkShareFrac_isLoaded = false;
2356   sim_phi_isLoaded = false;
2357   inv_side_isLoaded = false;
2358   vtx_fake_isLoaded = false;
2359   trk_nInactive_isLoaded = false;
2360   trk_nPixelLay_isLoaded = false;
2361   ph2_bbxi_isLoaded = false;
2362   vtx_xErr_isLoaded = false;
2363   see_stateCcov25_isLoaded = false;
2364   sim_parentVtxIdx_isLoaded = false;
2365   see_stateCcov23_isLoaded = false;
2366   trk_algoMask_isLoaded = false;
2367   trk_simTrkIdx_isLoaded = false;
2368   see_phiErr_isLoaded = false;
2369   trk_cotTheta_isLoaded = false;
2370   see_algo_isLoaded = false;
2371   simhit_module_isLoaded = false;
2372   simvtx_daughterSimIdx_isLoaded = false;
2373   vtx_x_isLoaded = false;
2374   trk_seedIdx_isLoaded = false;
2375   simhit_y_isLoaded = false;
2376   inv_layer_isLoaded = false;
2377   trk_nLostLay_isLoaded = false;
2378   ph2_isLower_isLoaded = false;
2379   pix_side_isLoaded = false;
2380   inv_isLower_isLoaded = false;
2381   ph2_trkIdx_isLoaded = false;
2382   sim_nValid_isLoaded = false;
2383   simhit_simTrkIdx_isLoaded = false;
2384   see_nCands_isLoaded = false;
2385   see_bestSimTrkIdx_isLoaded = false;
2386   vtx_yErr_isLoaded = false;
2387   trk_dzPV_isLoaded = false;
2388   ph2_xy_isLoaded = false;
2389   inv_module_isLoaded = false;
2390   see_stateCcov55_isLoaded = false;
2391   pix_panel_isLoaded = false;
2392   inv_ladder_isLoaded = false;
2393   ph2_xx_isLoaded = false;
2394   sim_pca_cotTheta_isLoaded = false;
2395   simpv_idx_isLoaded = false;
2396   trk_inner_pz_isLoaded = false;
2397   see_chi2_isLoaded = false;
2398   see_stateCcov35_isLoaded = false;
2399   see_stateCcov33_isLoaded = false;
2400   inv_detId_isLoaded = false;
2401   see_offset_isLoaded = false;
2402   sim_nLay_isLoaded = false;
2403   sim_simHitIdx_isLoaded = false;
2404   simhit_isUpper_isLoaded = false;
2405   see_stateCcov00_isLoaded = false;
2406   see_stopReason_isLoaded = false;
2407   vtx_valid_isLoaded = false;
2408   lumi_isLoaded = false;
2409   trk_refpoint_x_isLoaded = false;
2410   trk_refpoint_y_isLoaded = false;
2411   trk_refpoint_z_isLoaded = false;
2412   sim_n3DLay_isLoaded = false;
2413   see_nPhase2OT_isLoaded = false;
2414   trk_bestFromFirstHitSimTrkShareFracSimDenom_isLoaded = false;
2415   ph2_yy_isLoaded = false;
2416   ph2_yz_isLoaded = false;
2417   inv_blade_isLoaded = false;
2418   trk_ptErr_isLoaded = false;
2419   pix_zx_isLoaded = false;
2420   simvtx_z_isLoaded = false;
2421   sim_nTrackerHits_isLoaded = false;
2422   ph2_subdet_isLoaded = false;
2423   see_stateTrajPx_isLoaded = false;
2424   simhit_hitIdx_isLoaded = false;
2425   simhit_ladder_isLoaded = false;
2426   ph2_layer_isLoaded = false;
2427   see_phi_isLoaded = false;
2428   trk_nChi2_1Dmod_isLoaded = false;
2429   trk_inner_py_isLoaded = false;
2430   trk_inner_px_isLoaded = false;
2431   trk_dxyErr_isLoaded = false;
2432   sim_nPixelLay_isLoaded = false;
2433   see_nValid_isLoaded = false;
2434   trk_inner_pt_isLoaded = false;
2435   see_stateTrajGlbPy_isLoaded = false;
2436 }
2437 void Trktree::LoadAllBranches() {
2438   if (see_stateCcov01_branch != 0)
2439     see_stateCcov01();
2440   if (simhit_rod_branch != 0)
2441     simhit_rod();
2442   if (trk_phi_branch != 0)
2443     trk_phi();
2444   if (bsp_x_branch != 0)
2445     bsp_x();
2446   if (see_stateCcov05_branch != 0)
2447     see_stateCcov05();
2448   if (see_stateCcov04_branch != 0)
2449     see_stateCcov04();
2450   if (trk_dxyPV_branch != 0)
2451     trk_dxyPV();
2452   if (simhit_tof_branch != 0)
2453     simhit_tof();
2454   if (sim_event_branch != 0)
2455     sim_event();
2456   if (simhit_isStack_branch != 0)
2457     simhit_isStack();
2458   if (trk_dz_branch != 0)
2459     trk_dz();
2460   if (see_stateCcov03_branch != 0)
2461     see_stateCcov03();
2462   if (sim_eta_branch != 0)
2463     sim_eta();
2464   if (simvtx_processType_branch != 0)
2465     simvtx_processType();
2466   if (pix_radL_branch != 0)
2467     pix_radL();
2468   if (see_stateCcov02_branch != 0)
2469     see_stateCcov02();
2470   if (see_nGlued_branch != 0)
2471     see_nGlued();
2472   if (trk_bestSimTrkIdx_branch != 0)
2473     trk_bestSimTrkIdx();
2474   if (see_stateTrajGlbPz_branch != 0)
2475     see_stateTrajGlbPz();
2476   if (pix_yz_branch != 0)
2477     pix_yz();
2478   if (pix_yy_branch != 0)
2479     pix_yy();
2480   if (simhit_process_branch != 0)
2481     simhit_process();
2482   if (see_stateCcov34_branch != 0)
2483     see_stateCcov34();
2484   if (trk_nInnerLost_branch != 0)
2485     trk_nInnerLost();
2486   if (see_py_branch != 0)
2487     see_py();
2488   if (sim_trkIdx_branch != 0)
2489     sim_trkIdx();
2490   if (trk_nLost_branch != 0)
2491     trk_nLost();
2492   if (pix_isBarrel_branch != 0)
2493     pix_isBarrel();
2494   if (see_dxyErr_branch != 0)
2495     see_dxyErr();
2496   if (simhit_detId_branch != 0)
2497     simhit_detId();
2498   if (simhit_subdet_branch != 0)
2499     simhit_subdet();
2500   if (see_hitIdx_branch != 0)
2501     see_hitIdx();
2502   if (see_pt_branch != 0)
2503     see_pt();
2504   if (ph2_detId_branch != 0)
2505     ph2_detId();
2506   if (trk_nStripLay_branch != 0)
2507     trk_nStripLay();
2508   if (see_bestFromFirstHitSimTrkIdx_branch != 0)
2509     see_bestFromFirstHitSimTrkIdx();
2510   if (sim_pca_pt_branch != 0)
2511     sim_pca_pt();
2512   if (see_trkIdx_branch != 0)
2513     see_trkIdx();
2514   if (trk_nCluster_branch != 0)
2515     trk_nCluster();
2516   if (trk_bestFromFirstHitSimTrkNChi2_branch != 0)
2517     trk_bestFromFirstHitSimTrkNChi2();
2518   if (trk_isHP_branch != 0)
2519     trk_isHP();
2520   if (simhit_hitType_branch != 0)
2521     simhit_hitType();
2522   if (ph2_isUpper_branch != 0)
2523     ph2_isUpper();
2524   if (see_nStrip_branch != 0)
2525     see_nStrip();
2526   if (trk_bestSimTrkShareFracSimClusterDenom_branch != 0)
2527     trk_bestSimTrkShareFracSimClusterDenom();
2528   if (simhit_side_branch != 0)
2529     simhit_side();
2530   if (simhit_x_branch != 0)
2531     simhit_x();
2532   if (see_q_branch != 0)
2533     see_q();
2534   if (simhit_z_branch != 0)
2535     simhit_z();
2536   if (sim_pca_lambda_branch != 0)
2537     sim_pca_lambda();
2538   if (sim_q_branch != 0)
2539     sim_q();
2540   if (pix_bbxi_branch != 0)
2541     pix_bbxi();
2542   if (ph2_order_branch != 0)
2543     ph2_order();
2544   if (ph2_module_branch != 0)
2545     ph2_module();
2546   if (inv_order_branch != 0)
2547     inv_order();
2548   if (trk_dzErr_branch != 0)
2549     trk_dzErr();
2550   if (trk_nInnerInactive_branch != 0)
2551     trk_nInnerInactive();
2552   if (see_fitok_branch != 0)
2553     see_fitok();
2554   if (simhit_blade_branch != 0)
2555     simhit_blade();
2556   if (inv_subdet_branch != 0)
2557     inv_subdet();
2558   if (pix_blade_branch != 0)
2559     pix_blade();
2560   if (pix_xx_branch != 0)
2561     pix_xx();
2562   if (pix_xy_branch != 0)
2563     pix_xy();
2564   if (simhit_panel_branch != 0)
2565     simhit_panel();
2566   if (sim_pz_branch != 0)
2567     sim_pz();
2568   if (trk_dxy_branch != 0)
2569     trk_dxy();
2570   if (sim_px_branch != 0)
2571     sim_px();
2572   if (trk_lambda_branch != 0)
2573     trk_lambda();
2574   if (see_stateCcov12_branch != 0)
2575     see_stateCcov12();
2576   if (sim_pt_branch != 0)
2577     sim_pt();
2578   if (sim_py_branch != 0)
2579     sim_py();
2580   if (sim_decayVtxIdx_branch != 0)
2581     sim_decayVtxIdx();
2582   if (pix_detId_branch != 0)
2583     pix_detId();
2584   if (trk_eta_branch != 0)
2585     trk_eta();
2586   if (see_dxy_branch != 0)
2587     see_dxy();
2588   if (sim_isFromBHadron_branch != 0)
2589     sim_isFromBHadron();
2590   if (simhit_eloss_branch != 0)
2591     simhit_eloss();
2592   if (see_stateCcov11_branch != 0)
2593     see_stateCcov11();
2594   if (simhit_pz_branch != 0)
2595     simhit_pz();
2596   if (sim_pdgId_branch != 0)
2597     sim_pdgId();
2598   if (trk_stopReason_branch != 0)
2599     trk_stopReason();
2600   if (sim_pca_phi_branch != 0)
2601     sim_pca_phi();
2602   if (simhit_isLower_branch != 0)
2603     simhit_isLower();
2604   if (inv_ring_branch != 0)
2605     inv_ring();
2606   if (ph2_simHitIdx_branch != 0)
2607     ph2_simHitIdx();
2608   if (simhit_order_branch != 0)
2609     simhit_order();
2610   if (trk_dxyClosestPV_branch != 0)
2611     trk_dxyClosestPV();
2612   if (pix_z_branch != 0)
2613     pix_z();
2614   if (pix_y_branch != 0)
2615     pix_y();
2616   if (pix_x_branch != 0)
2617     pix_x();
2618   if (see_hitType_branch != 0)
2619     see_hitType();
2620   if (see_statePt_branch != 0)
2621     see_statePt();
2622   if (simvtx_sourceSimIdx_branch != 0)
2623     simvtx_sourceSimIdx();
2624   if (event_branch != 0)
2625     event();
2626   if (pix_module_branch != 0)
2627     pix_module();
2628   if (ph2_side_branch != 0)
2629     ph2_side();
2630   if (trk_bestSimTrkNChi2_branch != 0)
2631     trk_bestSimTrkNChi2();
2632   if (see_stateTrajPy_branch != 0)
2633     see_stateTrajPy();
2634   if (inv_type_branch != 0)
2635     inv_type();
2636   if (bsp_z_branch != 0)
2637     bsp_z();
2638   if (bsp_y_branch != 0)
2639     bsp_y();
2640   if (simhit_py_branch != 0)
2641     simhit_py();
2642   if (see_simTrkIdx_branch != 0)
2643     see_simTrkIdx();
2644   if (see_stateTrajGlbZ_branch != 0)
2645     see_stateTrajGlbZ();
2646   if (see_stateTrajGlbX_branch != 0)
2647     see_stateTrajGlbX();
2648   if (see_stateTrajGlbY_branch != 0)
2649     see_stateTrajGlbY();
2650   if (trk_originalAlgo_branch != 0)
2651     trk_originalAlgo();
2652   if (trk_nPixel_branch != 0)
2653     trk_nPixel();
2654   if (see_stateCcov14_branch != 0)
2655     see_stateCcov14();
2656   if (see_stateCcov15_branch != 0)
2657     see_stateCcov15();
2658   if (trk_phiErr_branch != 0)
2659     trk_phiErr();
2660   if (see_stateCcov13_branch != 0)
2661     see_stateCcov13();
2662   if (pix_chargeFraction_branch != 0)
2663     pix_chargeFraction();
2664   if (trk_q_branch != 0)
2665     trk_q();
2666   if (sim_seedIdx_branch != 0)
2667     sim_seedIdx();
2668   if (see_dzErr_branch != 0)
2669     see_dzErr();
2670   if (sim_nRecoClusters_branch != 0)
2671     sim_nRecoClusters();
2672   if (run_branch != 0)
2673     run();
2674   if (ph2_xySignificance_branch != 0)
2675     ph2_xySignificance();
2676   if (trk_nChi2_branch != 0)
2677     trk_nChi2();
2678   if (pix_layer_branch != 0)
2679     pix_layer();
2680   if (pix_xySignificance_branch != 0)
2681     pix_xySignificance();
2682   if (sim_pca_eta_branch != 0)
2683     sim_pca_eta();
2684   if (see_bestSimTrkShareFrac_branch != 0)
2685     see_bestSimTrkShareFrac();
2686   if (see_etaErr_branch != 0)
2687     see_etaErr();
2688   if (trk_bestSimTrkShareFracSimDenom_branch != 0)
2689     trk_bestSimTrkShareFracSimDenom();
2690   if (bsp_sigmaz_branch != 0)
2691     bsp_sigmaz();
2692   if (bsp_sigmay_branch != 0)
2693     bsp_sigmay();
2694   if (bsp_sigmax_branch != 0)
2695     bsp_sigmax();
2696   if (pix_ladder_branch != 0)
2697     pix_ladder();
2698   if (trk_qualityMask_branch != 0)
2699     trk_qualityMask();
2700   if (trk_ndof_branch != 0)
2701     trk_ndof();
2702   if (pix_subdet_branch != 0)
2703     pix_subdet();
2704   if (ph2_seeIdx_branch != 0)
2705     ph2_seeIdx();
2706   if (inv_isUpper_branch != 0)
2707     inv_isUpper();
2708   if (ph2_zx_branch != 0)
2709     ph2_zx();
2710   if (pix_trkIdx_branch != 0)
2711     pix_trkIdx();
2712   if (trk_nOuterLost_branch != 0)
2713     trk_nOuterLost();
2714   if (inv_panel_branch != 0)
2715     inv_panel();
2716   if (vtx_z_branch != 0)
2717     vtx_z();
2718   if (simhit_layer_branch != 0)
2719     simhit_layer();
2720   if (vtx_y_branch != 0)
2721     vtx_y();
2722   if (ph2_isBarrel_branch != 0)
2723     ph2_isBarrel();
2724   if (pix_seeIdx_branch != 0)
2725     pix_seeIdx();
2726   if (trk_bestFromFirstHitSimTrkIdx_branch != 0)
2727     trk_bestFromFirstHitSimTrkIdx();
2728   if (simhit_px_branch != 0)
2729     simhit_px();
2730   if (see_stateTrajX_branch != 0)
2731     see_stateTrajX();
2732   if (see_stateTrajY_branch != 0)
2733     see_stateTrajY();
2734   if (trk_nOuterInactive_branch != 0)
2735     trk_nOuterInactive();
2736   if (sim_pca_dxy_branch != 0)
2737     sim_pca_dxy();
2738   if (trk_algo_branch != 0)
2739     trk_algo();
2740   if (trk_hitType_branch != 0)
2741     trk_hitType();
2742   if (trk_bestFromFirstHitSimTrkShareFrac_branch != 0)
2743     trk_bestFromFirstHitSimTrkShareFrac();
2744   if (inv_isBarrel_branch != 0)
2745     inv_isBarrel();
2746   if (simvtx_event_branch != 0)
2747     simvtx_event();
2748   if (ph2_z_branch != 0)
2749     ph2_z();
2750   if (ph2_x_branch != 0)
2751     ph2_x();
2752   if (ph2_y_branch != 0)
2753     ph2_y();
2754   if (sim_genPdgIds_branch != 0)
2755     sim_genPdgIds();
2756   if (trk_mva_branch != 0)
2757     trk_mva();
2758   if (see_stateCcov24_branch != 0)
2759     see_stateCcov24();
2760   if (trk_dzClosestPV_branch != 0)
2761     trk_dzClosestPV();
2762   if (see_nCluster_branch != 0)
2763     see_nCluster();
2764   if (inv_rod_branch != 0)
2765     inv_rod();
2766   if (trk_hitIdx_branch != 0)
2767     trk_hitIdx();
2768   if (see_stateCcov22_branch != 0)
2769     see_stateCcov22();
2770   if (pix_simType_branch != 0)
2771     pix_simType();
2772   if (simhit_ring_branch != 0)
2773     simhit_ring();
2774   if (trk_outer_px_branch != 0)
2775     trk_outer_px();
2776   if (trk_outer_py_branch != 0)
2777     trk_outer_py();
2778   if (trk_outer_pz_branch != 0)
2779     trk_outer_pz();
2780   if (ph2_zz_branch != 0)
2781     ph2_zz();
2782   if (trk_outer_pt_branch != 0)
2783     trk_outer_pt();
2784   if (trk_n3DLay_branch != 0)
2785     trk_n3DLay();
2786   if (trk_nValid_branch != 0)
2787     trk_nValid();
2788   if (see_ptErr_branch != 0)
2789     see_ptErr();
2790   if (see_stateTrajGlbPx_branch != 0)
2791     see_stateTrajGlbPx();
2792   if (ph2_simType_branch != 0)
2793     ph2_simType();
2794   if (trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch != 0)
2795     trk_bestFromFirstHitSimTrkShareFracSimClusterDenom();
2796   if (sim_hits_branch != 0)
2797     sim_hits();
2798   if (sim_len_branch != 0)
2799     sim_len();
2800   if (sim_lengap_branch != 0)
2801     sim_lengap();
2802   if (simvtx_x_branch != 0)
2803     simvtx_x();
2804   if (trk_pz_branch != 0)
2805     trk_pz();
2806   if (see_bestFromFirstHitSimTrkShareFrac_branch != 0)
2807     see_bestFromFirstHitSimTrkShareFrac();
2808   if (trk_px_branch != 0)
2809     trk_px();
2810   if (trk_py_branch != 0)
2811     trk_py();
2812   if (trk_vtxIdx_branch != 0)
2813     trk_vtxIdx();
2814   if (sim_nPixel_branch != 0)
2815     sim_nPixel();
2816   if (vtx_chi2_branch != 0)
2817     vtx_chi2();
2818   if (ph2_ring_branch != 0)
2819     ph2_ring();
2820   if (trk_pt_branch != 0)
2821     trk_pt();
2822   if (see_stateCcov44_branch != 0)
2823     see_stateCcov44();
2824   if (ph2_radL_branch != 0)
2825     ph2_radL();
2826   if (vtx_zErr_branch != 0)
2827     vtx_zErr();
2828   if (see_px_branch != 0)
2829     see_px();
2830   if (see_pz_branch != 0)
2831     see_pz();
2832   if (see_eta_branch != 0)
2833     see_eta();
2834   if (simvtx_bunchCrossing_branch != 0)
2835     simvtx_bunchCrossing();
2836   if (sim_pca_dz_branch != 0)
2837     sim_pca_dz();
2838   if (simvtx_y_branch != 0)
2839     simvtx_y();
2840   if (inv_isStack_branch != 0)
2841     inv_isStack();
2842   if (trk_nStrip_branch != 0)
2843     trk_nStrip();
2844   if (trk_etaErr_branch != 0)
2845     trk_etaErr();
2846   if (trk_simTrkNChi2_branch != 0)
2847     trk_simTrkNChi2();
2848   if (pix_zz_branch != 0)
2849     pix_zz();
2850   if (simhit_particle_branch != 0)
2851     simhit_particle();
2852   if (see_dz_branch != 0)
2853     see_dz();
2854   if (see_stateTrajPz_branch != 0)
2855     see_stateTrajPz();
2856   if (trk_bestSimTrkShareFrac_branch != 0)
2857     trk_bestSimTrkShareFrac();
2858   if (trk_lambdaErr_branch != 0)
2859     trk_lambdaErr();
2860   if (see_simTrkShareFrac_branch != 0)
2861     see_simTrkShareFrac();
2862   if (pix_simHitIdx_branch != 0)
2863     pix_simHitIdx();
2864   if (vtx_trkIdx_branch != 0)
2865     vtx_trkIdx();
2866   if (ph2_rod_branch != 0)
2867     ph2_rod();
2868   if (vtx_ndof_branch != 0)
2869     vtx_ndof();
2870   if (see_nPixel_branch != 0)
2871     see_nPixel();
2872   if (sim_nStrip_branch != 0)
2873     sim_nStrip();
2874   if (sim_bunchCrossing_branch != 0)
2875     sim_bunchCrossing();
2876   if (see_stateCcov45_branch != 0)
2877     see_stateCcov45();
2878   if (ph2_isStack_branch != 0)
2879     ph2_isStack();
2880   if (sim_trkShareFrac_branch != 0)
2881     sim_trkShareFrac();
2882   if (trk_simTrkShareFrac_branch != 0)
2883     trk_simTrkShareFrac();
2884   if (sim_phi_branch != 0)
2885     sim_phi();
2886   if (inv_side_branch != 0)
2887     inv_side();
2888   if (vtx_fake_branch != 0)
2889     vtx_fake();
2890   if (trk_nInactive_branch != 0)
2891     trk_nInactive();
2892   if (trk_nPixelLay_branch != 0)
2893     trk_nPixelLay();
2894   if (ph2_bbxi_branch != 0)
2895     ph2_bbxi();
2896   if (vtx_xErr_branch != 0)
2897     vtx_xErr();
2898   if (see_stateCcov25_branch != 0)
2899     see_stateCcov25();
2900   if (sim_parentVtxIdx_branch != 0)
2901     sim_parentVtxIdx();
2902   if (see_stateCcov23_branch != 0)
2903     see_stateCcov23();
2904   if (trk_algoMask_branch != 0)
2905     trk_algoMask();
2906   if (trk_simTrkIdx_branch != 0)
2907     trk_simTrkIdx();
2908   if (see_phiErr_branch != 0)
2909     see_phiErr();
2910   if (trk_cotTheta_branch != 0)
2911     trk_cotTheta();
2912   if (see_algo_branch != 0)
2913     see_algo();
2914   if (simhit_module_branch != 0)
2915     simhit_module();
2916   if (simvtx_daughterSimIdx_branch != 0)
2917     simvtx_daughterSimIdx();
2918   if (vtx_x_branch != 0)
2919     vtx_x();
2920   if (trk_seedIdx_branch != 0)
2921     trk_seedIdx();
2922   if (simhit_y_branch != 0)
2923     simhit_y();
2924   if (inv_layer_branch != 0)
2925     inv_layer();
2926   if (trk_nLostLay_branch != 0)
2927     trk_nLostLay();
2928   if (ph2_isLower_branch != 0)
2929     ph2_isLower();
2930   if (pix_side_branch != 0)
2931     pix_side();
2932   if (inv_isLower_branch != 0)
2933     inv_isLower();
2934   if (ph2_trkIdx_branch != 0)
2935     ph2_trkIdx();
2936   if (sim_nValid_branch != 0)
2937     sim_nValid();
2938   if (simhit_simTrkIdx_branch != 0)
2939     simhit_simTrkIdx();
2940   if (see_nCands_branch != 0)
2941     see_nCands();
2942   if (see_bestSimTrkIdx_branch != 0)
2943     see_bestSimTrkIdx();
2944   if (vtx_yErr_branch != 0)
2945     vtx_yErr();
2946   if (trk_dzPV_branch != 0)
2947     trk_dzPV();
2948   if (ph2_xy_branch != 0)
2949     ph2_xy();
2950   if (inv_module_branch != 0)
2951     inv_module();
2952   if (see_stateCcov55_branch != 0)
2953     see_stateCcov55();
2954   if (pix_panel_branch != 0)
2955     pix_panel();
2956   if (inv_ladder_branch != 0)
2957     inv_ladder();
2958   if (ph2_xx_branch != 0)
2959     ph2_xx();
2960   if (sim_pca_cotTheta_branch != 0)
2961     sim_pca_cotTheta();
2962   if (simpv_idx_branch != 0)
2963     simpv_idx();
2964   if (trk_inner_pz_branch != 0)
2965     trk_inner_pz();
2966   if (see_chi2_branch != 0)
2967     see_chi2();
2968   if (see_stateCcov35_branch != 0)
2969     see_stateCcov35();
2970   if (see_stateCcov33_branch != 0)
2971     see_stateCcov33();
2972   if (inv_detId_branch != 0)
2973     inv_detId();
2974   if (see_offset_branch != 0)
2975     see_offset();
2976   if (sim_nLay_branch != 0)
2977     sim_nLay();
2978   if (sim_simHitIdx_branch != 0)
2979     sim_simHitIdx();
2980   if (simhit_isUpper_branch != 0)
2981     simhit_isUpper();
2982   if (see_stateCcov00_branch != 0)
2983     see_stateCcov00();
2984   if (see_stopReason_branch != 0)
2985     see_stopReason();
2986   if (vtx_valid_branch != 0)
2987     vtx_valid();
2988   if (lumi_branch != 0)
2989     lumi();
2990   if (trk_refpoint_x_branch != 0)
2991     trk_refpoint_x();
2992   if (trk_refpoint_y_branch != 0)
2993     trk_refpoint_y();
2994   if (trk_refpoint_z_branch != 0)
2995     trk_refpoint_z();
2996   if (sim_n3DLay_branch != 0)
2997     sim_n3DLay();
2998   if (see_nPhase2OT_branch != 0)
2999     see_nPhase2OT();
3000   if (trk_bestFromFirstHitSimTrkShareFracSimDenom_branch != 0)
3001     trk_bestFromFirstHitSimTrkShareFracSimDenom();
3002   if (ph2_yy_branch != 0)
3003     ph2_yy();
3004   if (ph2_yz_branch != 0)
3005     ph2_yz();
3006   if (inv_blade_branch != 0)
3007     inv_blade();
3008   if (trk_ptErr_branch != 0)
3009     trk_ptErr();
3010   if (pix_zx_branch != 0)
3011     pix_zx();
3012   if (simvtx_z_branch != 0)
3013     simvtx_z();
3014   if (sim_nTrackerHits_branch != 0)
3015     sim_nTrackerHits();
3016   if (ph2_subdet_branch != 0)
3017     ph2_subdet();
3018   if (see_stateTrajPx_branch != 0)
3019     see_stateTrajPx();
3020   if (simhit_hitIdx_branch != 0)
3021     simhit_hitIdx();
3022   if (simhit_ladder_branch != 0)
3023     simhit_ladder();
3024   if (ph2_layer_branch != 0)
3025     ph2_layer();
3026   if (see_phi_branch != 0)
3027     see_phi();
3028   if (trk_nChi2_1Dmod_branch != 0)
3029     trk_nChi2_1Dmod();
3030   if (trk_inner_py_branch != 0)
3031     trk_inner_py();
3032   if (trk_inner_px_branch != 0)
3033     trk_inner_px();
3034   if (trk_dxyErr_branch != 0)
3035     trk_dxyErr();
3036   if (sim_nPixelLay_branch != 0)
3037     sim_nPixelLay();
3038   if (see_nValid_branch != 0)
3039     see_nValid();
3040   if (trk_inner_pt_branch != 0)
3041     trk_inner_pt();
3042   if (see_stateTrajGlbPy_branch != 0)
3043     see_stateTrajGlbPy();
3044 }
3045 const std::vector<float> &Trktree::see_stateCcov01() {
3046   if (not see_stateCcov01_isLoaded) {
3047     if (see_stateCcov01_branch != 0) {
3048       see_stateCcov01_branch->GetEntry(index);
3049     } else {
3050       printf("branch see_stateCcov01_branch does not exist!\n");
3051       exit(1);
3052     }
3053     see_stateCcov01_isLoaded = true;
3054   }
3055   return *see_stateCcov01_;
3056 }
3057 const std::vector<unsigned short> &Trktree::simhit_rod() {
3058   if (not simhit_rod_isLoaded) {
3059     if (simhit_rod_branch != 0) {
3060       simhit_rod_branch->GetEntry(index);
3061     } else {
3062       printf("branch simhit_rod_branch does not exist!\n");
3063       exit(1);
3064     }
3065     simhit_rod_isLoaded = true;
3066   }
3067   return *simhit_rod_;
3068 }
3069 const std::vector<float> &Trktree::trk_phi() {
3070   if (not trk_phi_isLoaded) {
3071     if (trk_phi_branch != 0) {
3072       trk_phi_branch->GetEntry(index);
3073     } else {
3074       printf("branch trk_phi_branch does not exist!\n");
3075       exit(1);
3076     }
3077     trk_phi_isLoaded = true;
3078   }
3079   return *trk_phi_;
3080 }
3081 const float &Trktree::bsp_x() {
3082   if (not bsp_x_isLoaded) {
3083     if (bsp_x_branch != 0) {
3084       bsp_x_branch->GetEntry(index);
3085     } else {
3086       printf("branch bsp_x_branch does not exist!\n");
3087       exit(1);
3088     }
3089     bsp_x_isLoaded = true;
3090   }
3091   return bsp_x_;
3092 }
3093 const std::vector<float> &Trktree::see_stateCcov05() {
3094   if (not see_stateCcov05_isLoaded) {
3095     if (see_stateCcov05_branch != 0) {
3096       see_stateCcov05_branch->GetEntry(index);
3097     } else {
3098       printf("branch see_stateCcov05_branch does not exist!\n");
3099       exit(1);
3100     }
3101     see_stateCcov05_isLoaded = true;
3102   }
3103   return *see_stateCcov05_;
3104 }
3105 const std::vector<float> &Trktree::see_stateCcov04() {
3106   if (not see_stateCcov04_isLoaded) {
3107     if (see_stateCcov04_branch != 0) {
3108       see_stateCcov04_branch->GetEntry(index);
3109     } else {
3110       printf("branch see_stateCcov04_branch does not exist!\n");
3111       exit(1);
3112     }
3113     see_stateCcov04_isLoaded = true;
3114   }
3115   return *see_stateCcov04_;
3116 }
3117 const std::vector<float> &Trktree::trk_dxyPV() {
3118   if (not trk_dxyPV_isLoaded) {
3119     if (trk_dxyPV_branch != 0) {
3120       trk_dxyPV_branch->GetEntry(index);
3121     } else {
3122       printf("branch trk_dxyPV_branch does not exist!\n");
3123       exit(1);
3124     }
3125     trk_dxyPV_isLoaded = true;
3126   }
3127   return *trk_dxyPV_;
3128 }
3129 const std::vector<float> &Trktree::simhit_tof() {
3130   if (not simhit_tof_isLoaded) {
3131     if (simhit_tof_branch != 0) {
3132       simhit_tof_branch->GetEntry(index);
3133     } else {
3134       printf("branch simhit_tof_branch does not exist!\n");
3135       exit(1);
3136     }
3137     simhit_tof_isLoaded = true;
3138   }
3139   return *simhit_tof_;
3140 }
3141 const std::vector<int> &Trktree::sim_event() {
3142   if (not sim_event_isLoaded) {
3143     if (sim_event_branch != 0) {
3144       sim_event_branch->GetEntry(index);
3145     } else {
3146       printf("branch sim_event_branch does not exist!\n");
3147       exit(1);
3148     }
3149     sim_event_isLoaded = true;
3150   }
3151   return *sim_event_;
3152 }
3153 const std::vector<unsigned short> &Trktree::simhit_isStack() {
3154   if (not simhit_isStack_isLoaded) {
3155     if (simhit_isStack_branch != 0) {
3156       simhit_isStack_branch->GetEntry(index);
3157     } else {
3158       printf("branch simhit_isStack_branch does not exist!\n");
3159       exit(1);
3160     }
3161     simhit_isStack_isLoaded = true;
3162   }
3163   return *simhit_isStack_;
3164 }
3165 const std::vector<float> &Trktree::trk_dz() {
3166   if (not trk_dz_isLoaded) {
3167     if (trk_dz_branch != 0) {
3168       trk_dz_branch->GetEntry(index);
3169     } else {
3170       printf("branch trk_dz_branch does not exist!\n");
3171       exit(1);
3172     }
3173     trk_dz_isLoaded = true;
3174   }
3175   return *trk_dz_;
3176 }
3177 const std::vector<float> &Trktree::see_stateCcov03() {
3178   if (not see_stateCcov03_isLoaded) {
3179     if (see_stateCcov03_branch != 0) {
3180       see_stateCcov03_branch->GetEntry(index);
3181     } else {
3182       printf("branch see_stateCcov03_branch does not exist!\n");
3183       exit(1);
3184     }
3185     see_stateCcov03_isLoaded = true;
3186   }
3187   return *see_stateCcov03_;
3188 }
3189 const std::vector<float> &Trktree::sim_eta() {
3190   if (not sim_eta_isLoaded) {
3191     if (sim_eta_branch != 0) {
3192       sim_eta_branch->GetEntry(index);
3193     } else {
3194       printf("branch sim_eta_branch does not exist!\n");
3195       exit(1);
3196     }
3197     sim_eta_isLoaded = true;
3198   }
3199   return *sim_eta_;
3200 }
3201 const std::vector<unsigned int> &Trktree::simvtx_processType() {
3202   if (not simvtx_processType_isLoaded) {
3203     if (simvtx_processType_branch != 0) {
3204       simvtx_processType_branch->GetEntry(index);
3205     } else {
3206       printf("branch simvtx_processType_branch does not exist!\n");
3207       exit(1);
3208     }
3209     simvtx_processType_isLoaded = true;
3210   }
3211   return *simvtx_processType_;
3212 }
3213 const std::vector<float> &Trktree::pix_radL() {
3214   if (not pix_radL_isLoaded) {
3215     if (pix_radL_branch != 0) {
3216       pix_radL_branch->GetEntry(index);
3217     } else {
3218       printf("branch pix_radL_branch does not exist!\n");
3219       exit(1);
3220     }
3221     pix_radL_isLoaded = true;
3222   }
3223   return *pix_radL_;
3224 }
3225 const std::vector<float> &Trktree::see_stateCcov02() {
3226   if (not see_stateCcov02_isLoaded) {
3227     if (see_stateCcov02_branch != 0) {
3228       see_stateCcov02_branch->GetEntry(index);
3229     } else {
3230       printf("branch see_stateCcov02_branch does not exist!\n");
3231       exit(1);
3232     }
3233     see_stateCcov02_isLoaded = true;
3234   }
3235   return *see_stateCcov02_;
3236 }
3237 const std::vector<unsigned int> &Trktree::see_nGlued() {
3238   if (not see_nGlued_isLoaded) {
3239     if (see_nGlued_branch != 0) {
3240       see_nGlued_branch->GetEntry(index);
3241     } else {
3242       printf("branch see_nGlued_branch does not exist!\n");
3243       exit(1);
3244     }
3245     see_nGlued_isLoaded = true;
3246   }
3247   return *see_nGlued_;
3248 }
3249 const std::vector<int> &Trktree::trk_bestSimTrkIdx() {
3250   if (not trk_bestSimTrkIdx_isLoaded) {
3251     if (trk_bestSimTrkIdx_branch != 0) {
3252       trk_bestSimTrkIdx_branch->GetEntry(index);
3253     } else {
3254       printf("branch trk_bestSimTrkIdx_branch does not exist!\n");
3255       exit(1);
3256     }
3257     trk_bestSimTrkIdx_isLoaded = true;
3258   }
3259   return *trk_bestSimTrkIdx_;
3260 }
3261 const std::vector<float> &Trktree::see_stateTrajGlbPz() {
3262   if (not see_stateTrajGlbPz_isLoaded) {
3263     if (see_stateTrajGlbPz_branch != 0) {
3264       see_stateTrajGlbPz_branch->GetEntry(index);
3265     } else {
3266       printf("branch see_stateTrajGlbPz_branch does not exist!\n");
3267       exit(1);
3268     }
3269     see_stateTrajGlbPz_isLoaded = true;
3270   }
3271   return *see_stateTrajGlbPz_;
3272 }
3273 const std::vector<float> &Trktree::pix_yz() {
3274   if (not pix_yz_isLoaded) {
3275     if (pix_yz_branch != 0) {
3276       pix_yz_branch->GetEntry(index);
3277     } else {
3278       printf("branch pix_yz_branch does not exist!\n");
3279       exit(1);
3280     }
3281     pix_yz_isLoaded = true;
3282   }
3283   return *pix_yz_;
3284 }
3285 const std::vector<float> &Trktree::pix_yy() {
3286   if (not pix_yy_isLoaded) {
3287     if (pix_yy_branch != 0) {
3288       pix_yy_branch->GetEntry(index);
3289     } else {
3290       printf("branch pix_yy_branch does not exist!\n");
3291       exit(1);
3292     }
3293     pix_yy_isLoaded = true;
3294   }
3295   return *pix_yy_;
3296 }
3297 const std::vector<short> &Trktree::simhit_process() {
3298   if (not simhit_process_isLoaded) {
3299     if (simhit_process_branch != 0) {
3300       simhit_process_branch->GetEntry(index);
3301     } else {
3302       printf("branch simhit_process_branch does not exist!\n");
3303       exit(1);
3304     }
3305     simhit_process_isLoaded = true;
3306   }
3307   return *simhit_process_;
3308 }
3309 const std::vector<float> &Trktree::see_stateCcov34() {
3310   if (not see_stateCcov34_isLoaded) {
3311     if (see_stateCcov34_branch != 0) {
3312       see_stateCcov34_branch->GetEntry(index);
3313     } else {
3314       printf("branch see_stateCcov34_branch does not exist!\n");
3315       exit(1);
3316     }
3317     see_stateCcov34_isLoaded = true;
3318   }
3319   return *see_stateCcov34_;
3320 }
3321 const std::vector<unsigned int> &Trktree::trk_nInnerLost() {
3322   if (not trk_nInnerLost_isLoaded) {
3323     if (trk_nInnerLost_branch != 0) {
3324       trk_nInnerLost_branch->GetEntry(index);
3325     } else {
3326       printf("branch trk_nInnerLost_branch does not exist!\n");
3327       exit(1);
3328     }
3329     trk_nInnerLost_isLoaded = true;
3330   }
3331   return *trk_nInnerLost_;
3332 }
3333 const std::vector<float> &Trktree::see_py() {
3334   if (not see_py_isLoaded) {
3335     if (see_py_branch != 0) {
3336       see_py_branch->GetEntry(index);
3337     } else {
3338       printf("branch see_py_branch does not exist!\n");
3339       exit(1);
3340     }
3341     see_py_isLoaded = true;
3342   }
3343   return *see_py_;
3344 }
3345 const std::vector<std::vector<int> > &Trktree::sim_trkIdx() {
3346   if (not sim_trkIdx_isLoaded) {
3347     if (sim_trkIdx_branch != 0) {
3348       sim_trkIdx_branch->GetEntry(index);
3349     } else {
3350       printf("branch sim_trkIdx_branch does not exist!\n");
3351       exit(1);
3352     }
3353     sim_trkIdx_isLoaded = true;
3354   }
3355   return *sim_trkIdx_;
3356 }
3357 const std::vector<unsigned int> &Trktree::trk_nLost() {
3358   if (not trk_nLost_isLoaded) {
3359     if (trk_nLost_branch != 0) {
3360       trk_nLost_branch->GetEntry(index);
3361     } else {
3362       printf("branch trk_nLost_branch does not exist!\n");
3363       exit(1);
3364     }
3365     trk_nLost_isLoaded = true;
3366   }
3367   return *trk_nLost_;
3368 }
3369 const std::vector<short> &Trktree::pix_isBarrel() {
3370   if (not pix_isBarrel_isLoaded) {
3371     if (pix_isBarrel_branch != 0) {
3372       pix_isBarrel_branch->GetEntry(index);
3373     } else {
3374       printf("branch pix_isBarrel_branch does not exist!\n");
3375       exit(1);
3376     }
3377     pix_isBarrel_isLoaded = true;
3378   }
3379   return *pix_isBarrel_;
3380 }
3381 const std::vector<float> &Trktree::see_dxyErr() {
3382   if (not see_dxyErr_isLoaded) {
3383     if (see_dxyErr_branch != 0) {
3384       see_dxyErr_branch->GetEntry(index);
3385     } else {
3386       printf("branch see_dxyErr_branch does not exist!\n");
3387       exit(1);
3388     }
3389     see_dxyErr_isLoaded = true;
3390   }
3391   return *see_dxyErr_;
3392 }
3393 const std::vector<unsigned int> &Trktree::simhit_detId() {
3394   if (not simhit_detId_isLoaded) {
3395     if (simhit_detId_branch != 0) {
3396       simhit_detId_branch->GetEntry(index);
3397     } else {
3398       printf("branch simhit_detId_branch does not exist!\n");
3399       exit(1);
3400     }
3401     simhit_detId_isLoaded = true;
3402   }
3403   return *simhit_detId_;
3404 }
3405 const std::vector<unsigned short> &Trktree::simhit_subdet() {
3406   if (not simhit_subdet_isLoaded) {
3407     if (simhit_subdet_branch != 0) {
3408       simhit_subdet_branch->GetEntry(index);
3409     } else {
3410       printf("branch simhit_subdet_branch does not exist!\n");
3411       exit(1);
3412     }
3413     simhit_subdet_isLoaded = true;
3414   }
3415   return *simhit_subdet_;
3416 }
3417 const std::vector<std::vector<int> > &Trktree::see_hitIdx() {
3418   if (not see_hitIdx_isLoaded) {
3419     if (see_hitIdx_branch != 0) {
3420       see_hitIdx_branch->GetEntry(index);
3421     } else {
3422       printf("branch see_hitIdx_branch does not exist!\n");
3423       exit(1);
3424     }
3425     see_hitIdx_isLoaded = true;
3426   }
3427   return *see_hitIdx_;
3428 }
3429 const std::vector<float> &Trktree::see_pt() {
3430   if (not see_pt_isLoaded) {
3431     if (see_pt_branch != 0) {
3432       see_pt_branch->GetEntry(index);
3433     } else {
3434       printf("branch see_pt_branch does not exist!\n");
3435       exit(1);
3436     }
3437     see_pt_isLoaded = true;
3438   }
3439   return *see_pt_;
3440 }
3441 const std::vector<unsigned int> &Trktree::ph2_detId() {
3442   if (not ph2_detId_isLoaded) {
3443     if (ph2_detId_branch != 0) {
3444       ph2_detId_branch->GetEntry(index);
3445     } else {
3446       printf("branch ph2_detId_branch does not exist!\n");
3447       exit(1);
3448     }
3449     ph2_detId_isLoaded = true;
3450   }
3451   return *ph2_detId_;
3452 }
3453 const std::vector<unsigned int> &Trktree::trk_nStripLay() {
3454   if (not trk_nStripLay_isLoaded) {
3455     if (trk_nStripLay_branch != 0) {
3456       trk_nStripLay_branch->GetEntry(index);
3457     } else {
3458       printf("branch trk_nStripLay_branch does not exist!\n");
3459       exit(1);
3460     }
3461     trk_nStripLay_isLoaded = true;
3462   }
3463   return *trk_nStripLay_;
3464 }
3465 const std::vector<int> &Trktree::see_bestFromFirstHitSimTrkIdx() {
3466   if (not see_bestFromFirstHitSimTrkIdx_isLoaded) {
3467     if (see_bestFromFirstHitSimTrkIdx_branch != 0) {
3468       see_bestFromFirstHitSimTrkIdx_branch->GetEntry(index);
3469     } else {
3470       printf("branch see_bestFromFirstHitSimTrkIdx_branch does not exist!\n");
3471       exit(1);
3472     }
3473     see_bestFromFirstHitSimTrkIdx_isLoaded = true;
3474   }
3475   return *see_bestFromFirstHitSimTrkIdx_;
3476 }
3477 const std::vector<float> &Trktree::sim_pca_pt() {
3478   if (not sim_pca_pt_isLoaded) {
3479     if (sim_pca_pt_branch != 0) {
3480       sim_pca_pt_branch->GetEntry(index);
3481     } else {
3482       printf("branch sim_pca_pt_branch does not exist!\n");
3483       exit(1);
3484     }
3485     sim_pca_pt_isLoaded = true;
3486   }
3487   return *sim_pca_pt_;
3488 }
3489 const std::vector<int> &Trktree::see_trkIdx() {
3490   if (not see_trkIdx_isLoaded) {
3491     if (see_trkIdx_branch != 0) {
3492       see_trkIdx_branch->GetEntry(index);
3493     } else {
3494       printf("branch see_trkIdx_branch does not exist!\n");
3495       exit(1);
3496     }
3497     see_trkIdx_isLoaded = true;
3498   }
3499   return *see_trkIdx_;
3500 }
3501 const std::vector<unsigned int> &Trktree::trk_nCluster() {
3502   if (not trk_nCluster_isLoaded) {
3503     if (trk_nCluster_branch != 0) {
3504       trk_nCluster_branch->GetEntry(index);
3505     } else {
3506       printf("branch trk_nCluster_branch does not exist!\n");
3507       exit(1);
3508     }
3509     trk_nCluster_isLoaded = true;
3510   }
3511   return *trk_nCluster_;
3512 }
3513 const std::vector<float> &Trktree::trk_bestFromFirstHitSimTrkNChi2() {
3514   if (not trk_bestFromFirstHitSimTrkNChi2_isLoaded) {
3515     if (trk_bestFromFirstHitSimTrkNChi2_branch != 0) {
3516       trk_bestFromFirstHitSimTrkNChi2_branch->GetEntry(index);
3517     } else {
3518       printf("branch trk_bestFromFirstHitSimTrkNChi2_branch does not exist!\n");
3519       exit(1);
3520     }
3521     trk_bestFromFirstHitSimTrkNChi2_isLoaded = true;
3522   }
3523   return *trk_bestFromFirstHitSimTrkNChi2_;
3524 }
3525 const std::vector<short> &Trktree::trk_isHP() {
3526   if (not trk_isHP_isLoaded) {
3527     if (trk_isHP_branch != 0) {
3528       trk_isHP_branch->GetEntry(index);
3529     } else {
3530       printf("branch trk_isHP_branch does not exist!\n");
3531       exit(1);
3532     }
3533     trk_isHP_isLoaded = true;
3534   }
3535   return *trk_isHP_;
3536 }
3537 const std::vector<std::vector<int> > &Trktree::simhit_hitType() {
3538   if (not simhit_hitType_isLoaded) {
3539     if (simhit_hitType_branch != 0) {
3540       simhit_hitType_branch->GetEntry(index);
3541     } else {
3542       printf("branch simhit_hitType_branch does not exist!\n");
3543       exit(1);
3544     }
3545     simhit_hitType_isLoaded = true;
3546   }
3547   return *simhit_hitType_;
3548 }
3549 const std::vector<unsigned short> &Trktree::ph2_isUpper() {
3550   if (not ph2_isUpper_isLoaded) {
3551     if (ph2_isUpper_branch != 0) {
3552       ph2_isUpper_branch->GetEntry(index);
3553     } else {
3554       printf("branch ph2_isUpper_branch does not exist!\n");
3555       exit(1);
3556     }
3557     ph2_isUpper_isLoaded = true;
3558   }
3559   return *ph2_isUpper_;
3560 }
3561 const std::vector<unsigned int> &Trktree::see_nStrip() {
3562   if (not see_nStrip_isLoaded) {
3563     if (see_nStrip_branch != 0) {
3564       see_nStrip_branch->GetEntry(index);
3565     } else {
3566       printf("branch see_nStrip_branch does not exist!\n");
3567       exit(1);
3568     }
3569     see_nStrip_isLoaded = true;
3570   }
3571   return *see_nStrip_;
3572 }
3573 const std::vector<float> &Trktree::trk_bestSimTrkShareFracSimClusterDenom() {
3574   if (not trk_bestSimTrkShareFracSimClusterDenom_isLoaded) {
3575     if (trk_bestSimTrkShareFracSimClusterDenom_branch != 0) {
3576       trk_bestSimTrkShareFracSimClusterDenom_branch->GetEntry(index);
3577     } else {
3578       printf("branch trk_bestSimTrkShareFracSimClusterDenom_branch does not exist!\n");
3579       exit(1);
3580     }
3581     trk_bestSimTrkShareFracSimClusterDenom_isLoaded = true;
3582   }
3583   return *trk_bestSimTrkShareFracSimClusterDenom_;
3584 }
3585 const std::vector<unsigned short> &Trktree::simhit_side() {
3586   if (not simhit_side_isLoaded) {
3587     if (simhit_side_branch != 0) {
3588       simhit_side_branch->GetEntry(index);
3589     } else {
3590       printf("branch simhit_side_branch does not exist!\n");
3591       exit(1);
3592     }
3593     simhit_side_isLoaded = true;
3594   }
3595   return *simhit_side_;
3596 }
3597 const std::vector<float> &Trktree::simhit_x() {
3598   if (not simhit_x_isLoaded) {
3599     if (simhit_x_branch != 0) {
3600       simhit_x_branch->GetEntry(index);
3601     } else {
3602       printf("branch simhit_x_branch does not exist!\n");
3603       exit(1);
3604     }
3605     simhit_x_isLoaded = true;
3606   }
3607   return *simhit_x_;
3608 }
3609 const std::vector<int> &Trktree::see_q() {
3610   if (not see_q_isLoaded) {
3611     if (see_q_branch != 0) {
3612       see_q_branch->GetEntry(index);
3613     } else {
3614       printf("branch see_q_branch does not exist!\n");
3615       exit(1);
3616     }
3617     see_q_isLoaded = true;
3618   }
3619   return *see_q_;
3620 }
3621 const std::vector<float> &Trktree::simhit_z() {
3622   if (not simhit_z_isLoaded) {
3623     if (simhit_z_branch != 0) {
3624       simhit_z_branch->GetEntry(index);
3625     } else {
3626       printf("branch simhit_z_branch does not exist!\n");
3627       exit(1);
3628     }
3629     simhit_z_isLoaded = true;
3630   }
3631   return *simhit_z_;
3632 }
3633 const std::vector<float> &Trktree::sim_pca_lambda() {
3634   if (not sim_pca_lambda_isLoaded) {
3635     if (sim_pca_lambda_branch != 0) {
3636       sim_pca_lambda_branch->GetEntry(index);
3637     } else {
3638       printf("branch sim_pca_lambda_branch does not exist!\n");
3639       exit(1);
3640     }
3641     sim_pca_lambda_isLoaded = true;
3642   }
3643   return *sim_pca_lambda_;
3644 }
3645 const std::vector<int> &Trktree::sim_q() {
3646   if (not sim_q_isLoaded) {
3647     if (sim_q_branch != 0) {
3648       sim_q_branch->GetEntry(index);
3649     } else {
3650       printf("branch sim_q_branch does not exist!\n");
3651       exit(1);
3652     }
3653     sim_q_isLoaded = true;
3654   }
3655   return *sim_q_;
3656 }
3657 const std::vector<float> &Trktree::pix_bbxi() {
3658   if (not pix_bbxi_isLoaded) {
3659     if (pix_bbxi_branch != 0) {
3660       pix_bbxi_branch->GetEntry(index);
3661     } else {
3662       printf("branch pix_bbxi_branch does not exist!\n");
3663       exit(1);
3664     }
3665     pix_bbxi_isLoaded = true;
3666   }
3667   return *pix_bbxi_;
3668 }
3669 const std::vector<unsigned short> &Trktree::ph2_order() {
3670   if (not ph2_order_isLoaded) {
3671     if (ph2_order_branch != 0) {
3672       ph2_order_branch->GetEntry(index);
3673     } else {
3674       printf("branch ph2_order_branch does not exist!\n");
3675       exit(1);
3676     }
3677     ph2_order_isLoaded = true;
3678   }
3679   return *ph2_order_;
3680 }
3681 const std::vector<unsigned short> &Trktree::ph2_module() {
3682   if (not ph2_module_isLoaded) {
3683     if (ph2_module_branch != 0) {
3684       ph2_module_branch->GetEntry(index);
3685     } else {
3686       printf("branch ph2_module_branch does not exist!\n");
3687       exit(1);
3688     }
3689     ph2_module_isLoaded = true;
3690   }
3691   return *ph2_module_;
3692 }
3693 const std::vector<unsigned short> &Trktree::inv_order() {
3694   if (not inv_order_isLoaded) {
3695     if (inv_order_branch != 0) {
3696       inv_order_branch->GetEntry(index);
3697     } else {
3698       printf("branch inv_order_branch does not exist!\n");
3699       exit(1);
3700     }
3701     inv_order_isLoaded = true;
3702   }
3703   return *inv_order_;
3704 }
3705 const std::vector<float> &Trktree::trk_dzErr() {
3706   if (not trk_dzErr_isLoaded) {
3707     if (trk_dzErr_branch != 0) {
3708       trk_dzErr_branch->GetEntry(index);
3709     } else {
3710       printf("branch trk_dzErr_branch does not exist!\n");
3711       exit(1);
3712     }
3713     trk_dzErr_isLoaded = true;
3714   }
3715   return *trk_dzErr_;
3716 }
3717 const std::vector<unsigned int> &Trktree::trk_nInnerInactive() {
3718   if (not trk_nInnerInactive_isLoaded) {
3719     if (trk_nInnerInactive_branch != 0) {
3720       trk_nInnerInactive_branch->GetEntry(index);
3721     } else {
3722       printf("branch trk_nInnerInactive_branch does not exist!\n");
3723       exit(1);
3724     }
3725     trk_nInnerInactive_isLoaded = true;
3726   }
3727   return *trk_nInnerInactive_;
3728 }
3729 const std::vector<short> &Trktree::see_fitok() {
3730   if (not see_fitok_isLoaded) {
3731     if (see_fitok_branch != 0) {
3732       see_fitok_branch->GetEntry(index);
3733     } else {
3734       printf("branch see_fitok_branch does not exist!\n");
3735       exit(1);
3736     }
3737     see_fitok_isLoaded = true;
3738   }
3739   return *see_fitok_;
3740 }
3741 const std::vector<unsigned short> &Trktree::simhit_blade() {
3742   if (not simhit_blade_isLoaded) {
3743     if (simhit_blade_branch != 0) {
3744       simhit_blade_branch->GetEntry(index);
3745     } else {
3746       printf("branch simhit_blade_branch does not exist!\n");
3747       exit(1);
3748     }
3749     simhit_blade_isLoaded = true;
3750   }
3751   return *simhit_blade_;
3752 }
3753 const std::vector<unsigned short> &Trktree::inv_subdet() {
3754   if (not inv_subdet_isLoaded) {
3755     if (inv_subdet_branch != 0) {
3756       inv_subdet_branch->GetEntry(index);
3757     } else {
3758       printf("branch inv_subdet_branch does not exist!\n");
3759       exit(1);
3760     }
3761     inv_subdet_isLoaded = true;
3762   }
3763   return *inv_subdet_;
3764 }
3765 const std::vector<unsigned short> &Trktree::pix_blade() {
3766   if (not pix_blade_isLoaded) {
3767     if (pix_blade_branch != 0) {
3768       pix_blade_branch->GetEntry(index);
3769     } else {
3770       printf("branch pix_blade_branch does not exist!\n");
3771       exit(1);
3772     }
3773     pix_blade_isLoaded = true;
3774   }
3775   return *pix_blade_;
3776 }
3777 const std::vector<float> &Trktree::pix_xx() {
3778   if (not pix_xx_isLoaded) {
3779     if (pix_xx_branch != 0) {
3780       pix_xx_branch->GetEntry(index);
3781     } else {
3782       printf("branch pix_xx_branch does not exist!\n");
3783       exit(1);
3784     }
3785     pix_xx_isLoaded = true;
3786   }
3787   return *pix_xx_;
3788 }
3789 const std::vector<float> &Trktree::pix_xy() {
3790   if (not pix_xy_isLoaded) {
3791     if (pix_xy_branch != 0) {
3792       pix_xy_branch->GetEntry(index);
3793     } else {
3794       printf("branch pix_xy_branch does not exist!\n");
3795       exit(1);
3796     }
3797     pix_xy_isLoaded = true;
3798   }
3799   return *pix_xy_;
3800 }
3801 const std::vector<unsigned short> &Trktree::simhit_panel() {
3802   if (not simhit_panel_isLoaded) {
3803     if (simhit_panel_branch != 0) {
3804       simhit_panel_branch->GetEntry(index);
3805     } else {
3806       printf("branch simhit_panel_branch does not exist!\n");
3807       exit(1);
3808     }
3809     simhit_panel_isLoaded = true;
3810   }
3811   return *simhit_panel_;
3812 }
3813 const std::vector<float> &Trktree::sim_pz() {
3814   if (not sim_pz_isLoaded) {
3815     if (sim_pz_branch != 0) {
3816       sim_pz_branch->GetEntry(index);
3817     } else {
3818       printf("branch sim_pz_branch does not exist!\n");
3819       exit(1);
3820     }
3821     sim_pz_isLoaded = true;
3822   }
3823   return *sim_pz_;
3824 }
3825 const std::vector<float> &Trktree::trk_dxy() {
3826   if (not trk_dxy_isLoaded) {
3827     if (trk_dxy_branch != 0) {
3828       trk_dxy_branch->GetEntry(index);
3829     } else {
3830       printf("branch trk_dxy_branch does not exist!\n");
3831       exit(1);
3832     }
3833     trk_dxy_isLoaded = true;
3834   }
3835   return *trk_dxy_;
3836 }
3837 const std::vector<float> &Trktree::sim_px() {
3838   if (not sim_px_isLoaded) {
3839     if (sim_px_branch != 0) {
3840       sim_px_branch->GetEntry(index);
3841     } else {
3842       printf("branch sim_px_branch does not exist!\n");
3843       exit(1);
3844     }
3845     sim_px_isLoaded = true;
3846   }
3847   return *sim_px_;
3848 }
3849 const std::vector<float> &Trktree::trk_lambda() {
3850   if (not trk_lambda_isLoaded) {
3851     if (trk_lambda_branch != 0) {
3852       trk_lambda_branch->GetEntry(index);
3853     } else {
3854       printf("branch trk_lambda_branch does not exist!\n");
3855       exit(1);
3856     }
3857     trk_lambda_isLoaded = true;
3858   }
3859   return *trk_lambda_;
3860 }
3861 const std::vector<float> &Trktree::see_stateCcov12() {
3862   if (not see_stateCcov12_isLoaded) {
3863     if (see_stateCcov12_branch != 0) {
3864       see_stateCcov12_branch->GetEntry(index);
3865     } else {
3866       printf("branch see_stateCcov12_branch does not exist!\n");
3867       exit(1);
3868     }
3869     see_stateCcov12_isLoaded = true;
3870   }
3871   return *see_stateCcov12_;
3872 }
3873 const std::vector<float> &Trktree::sim_pt() {
3874   if (not sim_pt_isLoaded) {
3875     if (sim_pt_branch != 0) {
3876       sim_pt_branch->GetEntry(index);
3877     } else {
3878       printf("branch sim_pt_branch does not exist!\n");
3879       exit(1);
3880     }
3881     sim_pt_isLoaded = true;
3882   }
3883   return *sim_pt_;
3884 }
3885 const std::vector<float> &Trktree::sim_py() {
3886   if (not sim_py_isLoaded) {
3887     if (sim_py_branch != 0) {
3888       sim_py_branch->GetEntry(index);
3889     } else {
3890       printf("branch sim_py_branch does not exist!\n");
3891       exit(1);
3892     }
3893     sim_py_isLoaded = true;
3894   }
3895   return *sim_py_;
3896 }
3897 const std::vector<std::vector<int> > &Trktree::sim_decayVtxIdx() {
3898   if (not sim_decayVtxIdx_isLoaded) {
3899     if (sim_decayVtxIdx_branch != 0) {
3900       sim_decayVtxIdx_branch->GetEntry(index);
3901     } else {
3902       printf("branch sim_decayVtxIdx_branch does not exist!\n");
3903       exit(1);
3904     }
3905     sim_decayVtxIdx_isLoaded = true;
3906   }
3907   return *sim_decayVtxIdx_;
3908 }
3909 const std::vector<unsigned int> &Trktree::pix_detId() {
3910   if (not pix_detId_isLoaded) {
3911     if (pix_detId_branch != 0) {
3912       pix_detId_branch->GetEntry(index);
3913     } else {
3914       printf("branch pix_detId_branch does not exist!\n");
3915       exit(1);
3916     }
3917     pix_detId_isLoaded = true;
3918   }
3919   return *pix_detId_;
3920 }
3921 const std::vector<float> &Trktree::trk_eta() {
3922   if (not trk_eta_isLoaded) {
3923     if (trk_eta_branch != 0) {
3924       trk_eta_branch->GetEntry(index);
3925     } else {
3926       printf("branch trk_eta_branch does not exist!\n");
3927       exit(1);
3928     }
3929     trk_eta_isLoaded = true;
3930   }
3931   return *trk_eta_;
3932 }
3933 const std::vector<float> &Trktree::see_dxy() {
3934   if (not see_dxy_isLoaded) {
3935     if (see_dxy_branch != 0) {
3936       see_dxy_branch->GetEntry(index);
3937     } else {
3938       printf("branch see_dxy_branch does not exist!\n");
3939       exit(1);
3940     }
3941     see_dxy_isLoaded = true;
3942   }
3943   return *see_dxy_;
3944 }
3945 const std::vector<int> &Trktree::sim_isFromBHadron() {
3946   if (not sim_isFromBHadron_isLoaded) {
3947     if (sim_isFromBHadron_branch != 0) {
3948       sim_isFromBHadron_branch->GetEntry(index);
3949     } else {
3950       printf("branch sim_isFromBHadron_branch does not exist!\n");
3951       exit(1);
3952     }
3953     sim_isFromBHadron_isLoaded = true;
3954   }
3955   return *sim_isFromBHadron_;
3956 }
3957 const std::vector<float> &Trktree::simhit_eloss() {
3958   if (not simhit_eloss_isLoaded) {
3959     if (simhit_eloss_branch != 0) {
3960       simhit_eloss_branch->GetEntry(index);
3961     } else {
3962       printf("branch simhit_eloss_branch does not exist!\n");
3963       exit(1);
3964     }
3965     simhit_eloss_isLoaded = true;
3966   }
3967   return *simhit_eloss_;
3968 }
3969 const std::vector<float> &Trktree::see_stateCcov11() {
3970   if (not see_stateCcov11_isLoaded) {
3971     if (see_stateCcov11_branch != 0) {
3972       see_stateCcov11_branch->GetEntry(index);
3973     } else {
3974       printf("branch see_stateCcov11_branch does not exist!\n");
3975       exit(1);
3976     }
3977     see_stateCcov11_isLoaded = true;
3978   }
3979   return *see_stateCcov11_;
3980 }
3981 const std::vector<float> &Trktree::simhit_pz() {
3982   if (not simhit_pz_isLoaded) {
3983     if (simhit_pz_branch != 0) {
3984       simhit_pz_branch->GetEntry(index);
3985     } else {
3986       printf("branch simhit_pz_branch does not exist!\n");
3987       exit(1);
3988     }
3989     simhit_pz_isLoaded = true;
3990   }
3991   return *simhit_pz_;
3992 }
3993 const std::vector<int> &Trktree::sim_pdgId() {
3994   if (not sim_pdgId_isLoaded) {
3995     if (sim_pdgId_branch != 0) {
3996       sim_pdgId_branch->GetEntry(index);
3997     } else {
3998       printf("branch sim_pdgId_branch does not exist!\n");
3999       exit(1);
4000     }
4001     sim_pdgId_isLoaded = true;
4002   }
4003   return *sim_pdgId_;
4004 }
4005 const std::vector<unsigned short> &Trktree::trk_stopReason() {
4006   if (not trk_stopReason_isLoaded) {
4007     if (trk_stopReason_branch != 0) {
4008       trk_stopReason_branch->GetEntry(index);
4009     } else {
4010       printf("branch trk_stopReason_branch does not exist!\n");
4011       exit(1);
4012     }
4013     trk_stopReason_isLoaded = true;
4014   }
4015   return *trk_stopReason_;
4016 }
4017 const std::vector<float> &Trktree::sim_pca_phi() {
4018   if (not sim_pca_phi_isLoaded) {
4019     if (sim_pca_phi_branch != 0) {
4020       sim_pca_phi_branch->GetEntry(index);
4021     } else {
4022       printf("branch sim_pca_phi_branch does not exist!\n");
4023       exit(1);
4024     }
4025     sim_pca_phi_isLoaded = true;
4026   }
4027   return *sim_pca_phi_;
4028 }
4029 const std::vector<unsigned short> &Trktree::simhit_isLower() {
4030   if (not simhit_isLower_isLoaded) {
4031     if (simhit_isLower_branch != 0) {
4032       simhit_isLower_branch->GetEntry(index);
4033     } else {
4034       printf("branch simhit_isLower_branch does not exist!\n");
4035       exit(1);
4036     }
4037     simhit_isLower_isLoaded = true;
4038   }
4039   return *simhit_isLower_;
4040 }
4041 const std::vector<unsigned short> &Trktree::inv_ring() {
4042   if (not inv_ring_isLoaded) {
4043     if (inv_ring_branch != 0) {
4044       inv_ring_branch->GetEntry(index);
4045     } else {
4046       printf("branch inv_ring_branch does not exist!\n");
4047       exit(1);
4048     }
4049     inv_ring_isLoaded = true;
4050   }
4051   return *inv_ring_;
4052 }
4053 const std::vector<std::vector<int> > &Trktree::ph2_simHitIdx() {
4054   if (not ph2_simHitIdx_isLoaded) {
4055     if (ph2_simHitIdx_branch != 0) {
4056       ph2_simHitIdx_branch->GetEntry(index);
4057     } else {
4058       printf("branch ph2_simHitIdx_branch does not exist!\n");
4059       exit(1);
4060     }
4061     ph2_simHitIdx_isLoaded = true;
4062   }
4063   return *ph2_simHitIdx_;
4064 }
4065 const std::vector<unsigned short> &Trktree::simhit_order() {
4066   if (not simhit_order_isLoaded) {
4067     if (simhit_order_branch != 0) {
4068       simhit_order_branch->GetEntry(index);
4069     } else {
4070       printf("branch simhit_order_branch does not exist!\n");
4071       exit(1);
4072     }
4073     simhit_order_isLoaded = true;
4074   }
4075   return *simhit_order_;
4076 }
4077 const std::vector<float> &Trktree::trk_dxyClosestPV() {
4078   if (not trk_dxyClosestPV_isLoaded) {
4079     if (trk_dxyClosestPV_branch != 0) {
4080       trk_dxyClosestPV_branch->GetEntry(index);
4081     } else {
4082       printf("branch trk_dxyClosestPV_branch does not exist!\n");
4083       exit(1);
4084     }
4085     trk_dxyClosestPV_isLoaded = true;
4086   }
4087   return *trk_dxyClosestPV_;
4088 }
4089 const std::vector<float> &Trktree::pix_z() {
4090   if (not pix_z_isLoaded) {
4091     if (pix_z_branch != 0) {
4092       pix_z_branch->GetEntry(index);
4093     } else {
4094       printf("branch pix_z_branch does not exist!\n");
4095       exit(1);
4096     }
4097     pix_z_isLoaded = true;
4098   }
4099   return *pix_z_;
4100 }
4101 const std::vector<float> &Trktree::pix_y() {
4102   if (not pix_y_isLoaded) {
4103     if (pix_y_branch != 0) {
4104       pix_y_branch->GetEntry(index);
4105     } else {
4106       printf("branch pix_y_branch does not exist!\n");
4107       exit(1);
4108     }
4109     pix_y_isLoaded = true;
4110   }
4111   return *pix_y_;
4112 }
4113 const std::vector<float> &Trktree::pix_x() {
4114   if (not pix_x_isLoaded) {
4115     if (pix_x_branch != 0) {
4116       pix_x_branch->GetEntry(index);
4117     } else {
4118       printf("branch pix_x_branch does not exist!\n");
4119       exit(1);
4120     }
4121     pix_x_isLoaded = true;
4122   }
4123   return *pix_x_;
4124 }
4125 const std::vector<std::vector<int> > &Trktree::see_hitType() {
4126   if (not see_hitType_isLoaded) {
4127     if (see_hitType_branch != 0) {
4128       see_hitType_branch->GetEntry(index);
4129     } else {
4130       printf("branch see_hitType_branch does not exist!\n");
4131       exit(1);
4132     }
4133     see_hitType_isLoaded = true;
4134   }
4135   return *see_hitType_;
4136 }
4137 const std::vector<float> &Trktree::see_statePt() {
4138   if (not see_statePt_isLoaded) {
4139     if (see_statePt_branch != 0) {
4140       see_statePt_branch->GetEntry(index);
4141     } else {
4142       printf("branch see_statePt_branch does not exist!\n");
4143       exit(1);
4144     }
4145     see_statePt_isLoaded = true;
4146   }
4147   return *see_statePt_;
4148 }
4149 const std::vector<std::vector<int> > &Trktree::simvtx_sourceSimIdx() {
4150   if (not simvtx_sourceSimIdx_isLoaded) {
4151     if (simvtx_sourceSimIdx_branch != 0) {
4152       simvtx_sourceSimIdx_branch->GetEntry(index);
4153     } else {
4154       printf("branch simvtx_sourceSimIdx_branch does not exist!\n");
4155       exit(1);
4156     }
4157     simvtx_sourceSimIdx_isLoaded = true;
4158   }
4159   return *simvtx_sourceSimIdx_;
4160 }
4161 const unsigned long long &Trktree::event() {
4162   if (not event_isLoaded) {
4163     if (event_branch != 0) {
4164       event_branch->GetEntry(index);
4165     } else {
4166       printf("branch event_branch does not exist!\n");
4167       exit(1);
4168     }
4169     event_isLoaded = true;
4170   }
4171   return event_;
4172 }
4173 const std::vector<unsigned short> &Trktree::pix_module() {
4174   if (not pix_module_isLoaded) {
4175     if (pix_module_branch != 0) {
4176       pix_module_branch->GetEntry(index);
4177     } else {
4178       printf("branch pix_module_branch does not exist!\n");
4179       exit(1);
4180     }
4181     pix_module_isLoaded = true;
4182   }
4183   return *pix_module_;
4184 }
4185 const std::vector<unsigned short> &Trktree::ph2_side() {
4186   if (not ph2_side_isLoaded) {
4187     if (ph2_side_branch != 0) {
4188       ph2_side_branch->GetEntry(index);
4189     } else {
4190       printf("branch ph2_side_branch does not exist!\n");
4191       exit(1);
4192     }
4193     ph2_side_isLoaded = true;
4194   }
4195   return *ph2_side_;
4196 }
4197 const std::vector<float> &Trktree::trk_bestSimTrkNChi2() {
4198   if (not trk_bestSimTrkNChi2_isLoaded) {
4199     if (trk_bestSimTrkNChi2_branch != 0) {
4200       trk_bestSimTrkNChi2_branch->GetEntry(index);
4201     } else {
4202       printf("branch trk_bestSimTrkNChi2_branch does not exist!\n");
4203       exit(1);
4204     }
4205     trk_bestSimTrkNChi2_isLoaded = true;
4206   }
4207   return *trk_bestSimTrkNChi2_;
4208 }
4209 const std::vector<float> &Trktree::see_stateTrajPy() {
4210   if (not see_stateTrajPy_isLoaded) {
4211     if (see_stateTrajPy_branch != 0) {
4212       see_stateTrajPy_branch->GetEntry(index);
4213     } else {
4214       printf("branch see_stateTrajPy_branch does not exist!\n");
4215       exit(1);
4216     }
4217     see_stateTrajPy_isLoaded = true;
4218   }
4219   return *see_stateTrajPy_;
4220 }
4221 const std::vector<unsigned short> &Trktree::inv_type() {
4222   if (not inv_type_isLoaded) {
4223     if (inv_type_branch != 0) {
4224       inv_type_branch->GetEntry(index);
4225     } else {
4226       printf("branch inv_type_branch does not exist!\n");
4227       exit(1);
4228     }
4229     inv_type_isLoaded = true;
4230   }
4231   return *inv_type_;
4232 }
4233 const float &Trktree::bsp_z() {
4234   if (not bsp_z_isLoaded) {
4235     if (bsp_z_branch != 0) {
4236       bsp_z_branch->GetEntry(index);
4237     } else {
4238       printf("branch bsp_z_branch does not exist!\n");
4239       exit(1);
4240     }
4241     bsp_z_isLoaded = true;
4242   }
4243   return bsp_z_;
4244 }
4245 const float &Trktree::bsp_y() {
4246   if (not bsp_y_isLoaded) {
4247     if (bsp_y_branch != 0) {
4248       bsp_y_branch->GetEntry(index);
4249     } else {
4250       printf("branch bsp_y_branch does not exist!\n");
4251       exit(1);
4252     }
4253     bsp_y_isLoaded = true;
4254   }
4255   return bsp_y_;
4256 }
4257 const std::vector<float> &Trktree::simhit_py() {
4258   if (not simhit_py_isLoaded) {
4259     if (simhit_py_branch != 0) {
4260       simhit_py_branch->GetEntry(index);
4261     } else {
4262       printf("branch simhit_py_branch does not exist!\n");
4263       exit(1);
4264     }
4265     simhit_py_isLoaded = true;
4266   }
4267   return *simhit_py_;
4268 }
4269 const std::vector<std::vector<int> > &Trktree::see_simTrkIdx() {
4270   if (not see_simTrkIdx_isLoaded) {
4271     if (see_simTrkIdx_branch != 0) {
4272       see_simTrkIdx_branch->GetEntry(index);
4273     } else {
4274       printf("branch see_simTrkIdx_branch does not exist!\n");
4275       exit(1);
4276     }
4277     see_simTrkIdx_isLoaded = true;
4278   }
4279   return *see_simTrkIdx_;
4280 }
4281 const std::vector<float> &Trktree::see_stateTrajGlbZ() {
4282   if (not see_stateTrajGlbZ_isLoaded) {
4283     if (see_stateTrajGlbZ_branch != 0) {
4284       see_stateTrajGlbZ_branch->GetEntry(index);
4285     } else {
4286       printf("branch see_stateTrajGlbZ_branch does not exist!\n");
4287       exit(1);
4288     }
4289     see_stateTrajGlbZ_isLoaded = true;
4290   }
4291   return *see_stateTrajGlbZ_;
4292 }
4293 const std::vector<float> &Trktree::see_stateTrajGlbX() {
4294   if (not see_stateTrajGlbX_isLoaded) {
4295     if (see_stateTrajGlbX_branch != 0) {
4296       see_stateTrajGlbX_branch->GetEntry(index);
4297     } else {
4298       printf("branch see_stateTrajGlbX_branch does not exist!\n");
4299       exit(1);
4300     }
4301     see_stateTrajGlbX_isLoaded = true;
4302   }
4303   return *see_stateTrajGlbX_;
4304 }
4305 const std::vector<float> &Trktree::see_stateTrajGlbY() {
4306   if (not see_stateTrajGlbY_isLoaded) {
4307     if (see_stateTrajGlbY_branch != 0) {
4308       see_stateTrajGlbY_branch->GetEntry(index);
4309     } else {
4310       printf("branch see_stateTrajGlbY_branch does not exist!\n");
4311       exit(1);
4312     }
4313     see_stateTrajGlbY_isLoaded = true;
4314   }
4315   return *see_stateTrajGlbY_;
4316 }
4317 const std::vector<unsigned int> &Trktree::trk_originalAlgo() {
4318   if (not trk_originalAlgo_isLoaded) {
4319     if (trk_originalAlgo_branch != 0) {
4320       trk_originalAlgo_branch->GetEntry(index);
4321     } else {
4322       printf("branch trk_originalAlgo_branch does not exist!\n");
4323       exit(1);
4324     }
4325     trk_originalAlgo_isLoaded = true;
4326   }
4327   return *trk_originalAlgo_;
4328 }
4329 const std::vector<unsigned int> &Trktree::trk_nPixel() {
4330   if (not trk_nPixel_isLoaded) {
4331     if (trk_nPixel_branch != 0) {
4332       trk_nPixel_branch->GetEntry(index);
4333     } else {
4334       printf("branch trk_nPixel_branch does not exist!\n");
4335       exit(1);
4336     }
4337     trk_nPixel_isLoaded = true;
4338   }
4339   return *trk_nPixel_;
4340 }
4341 const std::vector<float> &Trktree::see_stateCcov14() {
4342   if (not see_stateCcov14_isLoaded) {
4343     if (see_stateCcov14_branch != 0) {
4344       see_stateCcov14_branch->GetEntry(index);
4345     } else {
4346       printf("branch see_stateCcov14_branch does not exist!\n");
4347       exit(1);
4348     }
4349     see_stateCcov14_isLoaded = true;
4350   }
4351   return *see_stateCcov14_;
4352 }
4353 const std::vector<float> &Trktree::see_stateCcov15() {
4354   if (not see_stateCcov15_isLoaded) {
4355     if (see_stateCcov15_branch != 0) {
4356       see_stateCcov15_branch->GetEntry(index);
4357     } else {
4358       printf("branch see_stateCcov15_branch does not exist!\n");
4359       exit(1);
4360     }
4361     see_stateCcov15_isLoaded = true;
4362   }
4363   return *see_stateCcov15_;
4364 }
4365 const std::vector<float> &Trktree::trk_phiErr() {
4366   if (not trk_phiErr_isLoaded) {
4367     if (trk_phiErr_branch != 0) {
4368       trk_phiErr_branch->GetEntry(index);
4369     } else {
4370       printf("branch trk_phiErr_branch does not exist!\n");
4371       exit(1);
4372     }
4373     trk_phiErr_isLoaded = true;
4374   }
4375   return *trk_phiErr_;
4376 }
4377 const std::vector<float> &Trktree::see_stateCcov13() {
4378   if (not see_stateCcov13_isLoaded) {
4379     if (see_stateCcov13_branch != 0) {
4380       see_stateCcov13_branch->GetEntry(index);
4381     } else {
4382       printf("branch see_stateCcov13_branch does not exist!\n");
4383       exit(1);
4384     }
4385     see_stateCcov13_isLoaded = true;
4386   }
4387   return *see_stateCcov13_;
4388 }
4389 const std::vector<std::vector<float> > &Trktree::pix_chargeFraction() {
4390   if (not pix_chargeFraction_isLoaded) {
4391     if (pix_chargeFraction_branch != 0) {
4392       pix_chargeFraction_branch->GetEntry(index);
4393     } else {
4394       printf("branch pix_chargeFraction_branch does not exist!\n");
4395       exit(1);
4396     }
4397     pix_chargeFraction_isLoaded = true;
4398   }
4399   return *pix_chargeFraction_;
4400 }
4401 const std::vector<int> &Trktree::trk_q() {
4402   if (not trk_q_isLoaded) {
4403     if (trk_q_branch != 0) {
4404       trk_q_branch->GetEntry(index);
4405     } else {
4406       printf("branch trk_q_branch does not exist!\n");
4407       exit(1);
4408     }
4409     trk_q_isLoaded = true;
4410   }
4411   return *trk_q_;
4412 }
4413 const std::vector<std::vector<int> > &Trktree::sim_seedIdx() {
4414   if (not sim_seedIdx_isLoaded) {
4415     if (sim_seedIdx_branch != 0) {
4416       sim_seedIdx_branch->GetEntry(index);
4417     } else {
4418       printf("branch sim_seedIdx_branch does not exist!\n");
4419       exit(1);
4420     }
4421     sim_seedIdx_isLoaded = true;
4422   }
4423   return *sim_seedIdx_;
4424 }
4425 const std::vector<float> &Trktree::see_dzErr() {
4426   if (not see_dzErr_isLoaded) {
4427     if (see_dzErr_branch != 0) {
4428       see_dzErr_branch->GetEntry(index);
4429     } else {
4430       printf("branch see_dzErr_branch does not exist!\n");
4431       exit(1);
4432     }
4433     see_dzErr_isLoaded = true;
4434   }
4435   return *see_dzErr_;
4436 }
4437 const std::vector<unsigned int> &Trktree::sim_nRecoClusters() {
4438   if (not sim_nRecoClusters_isLoaded) {
4439     if (sim_nRecoClusters_branch != 0) {
4440       sim_nRecoClusters_branch->GetEntry(index);
4441     } else {
4442       printf("branch sim_nRecoClusters_branch does not exist!\n");
4443       exit(1);
4444     }
4445     sim_nRecoClusters_isLoaded = true;
4446   }
4447   return *sim_nRecoClusters_;
4448 }
4449 const unsigned int &Trktree::run() {
4450   if (not run_isLoaded) {
4451     if (run_branch != 0) {
4452       run_branch->GetEntry(index);
4453     } else {
4454       printf("branch run_branch does not exist!\n");
4455       exit(1);
4456     }
4457     run_isLoaded = true;
4458   }
4459   return run_;
4460 }
4461 const std::vector<std::vector<float> > &Trktree::ph2_xySignificance() {
4462   if (not ph2_xySignificance_isLoaded) {
4463     if (ph2_xySignificance_branch != 0) {
4464       ph2_xySignificance_branch->GetEntry(index);
4465     } else {
4466       printf("branch ph2_xySignificance_branch does not exist!\n");
4467       exit(1);
4468     }
4469     ph2_xySignificance_isLoaded = true;
4470   }
4471   return *ph2_xySignificance_;
4472 }
4473 const std::vector<float> &Trktree::trk_nChi2() {
4474   if (not trk_nChi2_isLoaded) {
4475     if (trk_nChi2_branch != 0) {
4476       trk_nChi2_branch->GetEntry(index);
4477     } else {
4478       printf("branch trk_nChi2_branch does not exist!\n");
4479       exit(1);
4480     }
4481     trk_nChi2_isLoaded = true;
4482   }
4483   return *trk_nChi2_;
4484 }
4485 const std::vector<unsigned short> &Trktree::pix_layer() {
4486   if (not pix_layer_isLoaded) {
4487     if (pix_layer_branch != 0) {
4488       pix_layer_branch->GetEntry(index);
4489     } else {
4490       printf("branch pix_layer_branch does not exist!\n");
4491       exit(1);
4492     }
4493     pix_layer_isLoaded = true;
4494   }
4495   return *pix_layer_;
4496 }
4497 const std::vector<std::vector<float> > &Trktree::pix_xySignificance() {
4498   if (not pix_xySignificance_isLoaded) {
4499     if (pix_xySignificance_branch != 0) {
4500       pix_xySignificance_branch->GetEntry(index);
4501     } else {
4502       printf("branch pix_xySignificance_branch does not exist!\n");
4503       exit(1);
4504     }
4505     pix_xySignificance_isLoaded = true;
4506   }
4507   return *pix_xySignificance_;
4508 }
4509 const std::vector<float> &Trktree::sim_pca_eta() {
4510   if (not sim_pca_eta_isLoaded) {
4511     if (sim_pca_eta_branch != 0) {
4512       sim_pca_eta_branch->GetEntry(index);
4513     } else {
4514       printf("branch sim_pca_eta_branch does not exist!\n");
4515       exit(1);
4516     }
4517     sim_pca_eta_isLoaded = true;
4518   }
4519   return *sim_pca_eta_;
4520 }
4521 const std::vector<float> &Trktree::see_bestSimTrkShareFrac() {
4522   if (not see_bestSimTrkShareFrac_isLoaded) {
4523     if (see_bestSimTrkShareFrac_branch != 0) {
4524       see_bestSimTrkShareFrac_branch->GetEntry(index);
4525     } else {
4526       printf("branch see_bestSimTrkShareFrac_branch does not exist!\n");
4527       exit(1);
4528     }
4529     see_bestSimTrkShareFrac_isLoaded = true;
4530   }
4531   return *see_bestSimTrkShareFrac_;
4532 }
4533 const std::vector<float> &Trktree::see_etaErr() {
4534   if (not see_etaErr_isLoaded) {
4535     if (see_etaErr_branch != 0) {
4536       see_etaErr_branch->GetEntry(index);
4537     } else {
4538       printf("branch see_etaErr_branch does not exist!\n");
4539       exit(1);
4540     }
4541     see_etaErr_isLoaded = true;
4542   }
4543   return *see_etaErr_;
4544 }
4545 const std::vector<float> &Trktree::trk_bestSimTrkShareFracSimDenom() {
4546   if (not trk_bestSimTrkShareFracSimDenom_isLoaded) {
4547     if (trk_bestSimTrkShareFracSimDenom_branch != 0) {
4548       trk_bestSimTrkShareFracSimDenom_branch->GetEntry(index);
4549     } else {
4550       printf("branch trk_bestSimTrkShareFracSimDenom_branch does not exist!\n");
4551       exit(1);
4552     }
4553     trk_bestSimTrkShareFracSimDenom_isLoaded = true;
4554   }
4555   return *trk_bestSimTrkShareFracSimDenom_;
4556 }
4557 const float &Trktree::bsp_sigmaz() {
4558   if (not bsp_sigmaz_isLoaded) {
4559     if (bsp_sigmaz_branch != 0) {
4560       bsp_sigmaz_branch->GetEntry(index);
4561     } else {
4562       printf("branch bsp_sigmaz_branch does not exist!\n");
4563       exit(1);
4564     }
4565     bsp_sigmaz_isLoaded = true;
4566   }
4567   return bsp_sigmaz_;
4568 }
4569 const float &Trktree::bsp_sigmay() {
4570   if (not bsp_sigmay_isLoaded) {
4571     if (bsp_sigmay_branch != 0) {
4572       bsp_sigmay_branch->GetEntry(index);
4573     } else {
4574       printf("branch bsp_sigmay_branch does not exist!\n");
4575       exit(1);
4576     }
4577     bsp_sigmay_isLoaded = true;
4578   }
4579   return bsp_sigmay_;
4580 }
4581 const float &Trktree::bsp_sigmax() {
4582   if (not bsp_sigmax_isLoaded) {
4583     if (bsp_sigmax_branch != 0) {
4584       bsp_sigmax_branch->GetEntry(index);
4585     } else {
4586       printf("branch bsp_sigmax_branch does not exist!\n");
4587       exit(1);
4588     }
4589     bsp_sigmax_isLoaded = true;
4590   }
4591   return bsp_sigmax_;
4592 }
4593 const std::vector<unsigned short> &Trktree::pix_ladder() {
4594   if (not pix_ladder_isLoaded) {
4595     if (pix_ladder_branch != 0) {
4596       pix_ladder_branch->GetEntry(index);
4597     } else {
4598       printf("branch pix_ladder_branch does not exist!\n");
4599       exit(1);
4600     }
4601     pix_ladder_isLoaded = true;
4602   }
4603   return *pix_ladder_;
4604 }
4605 const std::vector<unsigned short> &Trktree::trk_qualityMask() {
4606   if (not trk_qualityMask_isLoaded) {
4607     if (trk_qualityMask_branch != 0) {
4608       trk_qualityMask_branch->GetEntry(index);
4609     } else {
4610       printf("branch trk_qualityMask_branch does not exist!\n");
4611       exit(1);
4612     }
4613     trk_qualityMask_isLoaded = true;
4614   }
4615   return *trk_qualityMask_;
4616 }
4617 const std::vector<float> &Trktree::trk_ndof() {
4618   if (not trk_ndof_isLoaded) {
4619     if (trk_ndof_branch != 0) {
4620       trk_ndof_branch->GetEntry(index);
4621     } else {
4622       printf("branch trk_ndof_branch does not exist!\n");
4623       exit(1);
4624     }
4625     trk_ndof_isLoaded = true;
4626   }
4627   return *trk_ndof_;
4628 }
4629 const std::vector<unsigned short> &Trktree::pix_subdet() {
4630   if (not pix_subdet_isLoaded) {
4631     if (pix_subdet_branch != 0) {
4632       pix_subdet_branch->GetEntry(index);
4633     } else {
4634       printf("branch pix_subdet_branch does not exist!\n");
4635       exit(1);
4636     }
4637     pix_subdet_isLoaded = true;
4638   }
4639   return *pix_subdet_;
4640 }
4641 const std::vector<std::vector<int> > &Trktree::ph2_seeIdx() {
4642   if (not ph2_seeIdx_isLoaded) {
4643     if (ph2_seeIdx_branch != 0) {
4644       ph2_seeIdx_branch->GetEntry(index);
4645     } else {
4646       printf("branch ph2_seeIdx_branch does not exist!\n");
4647       exit(1);
4648     }
4649     ph2_seeIdx_isLoaded = true;
4650   }
4651   return *ph2_seeIdx_;
4652 }
4653 const std::vector<unsigned short> &Trktree::inv_isUpper() {
4654   if (not inv_isUpper_isLoaded) {
4655     if (inv_isUpper_branch != 0) {
4656       inv_isUpper_branch->GetEntry(index);
4657     } else {
4658       printf("branch inv_isUpper_branch does not exist!\n");
4659       exit(1);
4660     }
4661     inv_isUpper_isLoaded = true;
4662   }
4663   return *inv_isUpper_;
4664 }
4665 const std::vector<float> &Trktree::ph2_zx() {
4666   if (not ph2_zx_isLoaded) {
4667     if (ph2_zx_branch != 0) {
4668       ph2_zx_branch->GetEntry(index);
4669     } else {
4670       printf("branch ph2_zx_branch does not exist!\n");
4671       exit(1);
4672     }
4673     ph2_zx_isLoaded = true;
4674   }
4675   return *ph2_zx_;
4676 }
4677 const std::vector<std::vector<int> > &Trktree::pix_trkIdx() {
4678   if (not pix_trkIdx_isLoaded) {
4679     if (pix_trkIdx_branch != 0) {
4680       pix_trkIdx_branch->GetEntry(index);
4681     } else {
4682       printf("branch pix_trkIdx_branch does not exist!\n");
4683       exit(1);
4684     }
4685     pix_trkIdx_isLoaded = true;
4686   }
4687   return *pix_trkIdx_;
4688 }
4689 const std::vector<unsigned int> &Trktree::trk_nOuterLost() {
4690   if (not trk_nOuterLost_isLoaded) {
4691     if (trk_nOuterLost_branch != 0) {
4692       trk_nOuterLost_branch->GetEntry(index);
4693     } else {
4694       printf("branch trk_nOuterLost_branch does not exist!\n");
4695       exit(1);
4696     }
4697     trk_nOuterLost_isLoaded = true;
4698   }
4699   return *trk_nOuterLost_;
4700 }
4701 const std::vector<unsigned short> &Trktree::inv_panel() {
4702   if (not inv_panel_isLoaded) {
4703     if (inv_panel_branch != 0) {
4704       inv_panel_branch->GetEntry(index);
4705     } else {
4706       printf("branch inv_panel_branch does not exist!\n");
4707       exit(1);
4708     }
4709     inv_panel_isLoaded = true;
4710   }
4711   return *inv_panel_;
4712 }
4713 const std::vector<float> &Trktree::vtx_z() {
4714   if (not vtx_z_isLoaded) {
4715     if (vtx_z_branch != 0) {
4716       vtx_z_branch->GetEntry(index);
4717     } else {
4718       printf("branch vtx_z_branch does not exist!\n");
4719       exit(1);
4720     }
4721     vtx_z_isLoaded = true;
4722   }
4723   return *vtx_z_;
4724 }
4725 const std::vector<unsigned short> &Trktree::simhit_layer() {
4726   if (not simhit_layer_isLoaded) {
4727     if (simhit_layer_branch != 0) {
4728       simhit_layer_branch->GetEntry(index);
4729     } else {
4730       printf("branch simhit_layer_branch does not exist!\n");
4731       exit(1);
4732     }
4733     simhit_layer_isLoaded = true;
4734   }
4735   return *simhit_layer_;
4736 }
4737 const std::vector<float> &Trktree::vtx_y() {
4738   if (not vtx_y_isLoaded) {
4739     if (vtx_y_branch != 0) {
4740       vtx_y_branch->GetEntry(index);
4741     } else {
4742       printf("branch vtx_y_branch does not exist!\n");
4743       exit(1);
4744     }
4745     vtx_y_isLoaded = true;
4746   }
4747   return *vtx_y_;
4748 }
4749 const std::vector<short> &Trktree::ph2_isBarrel() {
4750   if (not ph2_isBarrel_isLoaded) {
4751     if (ph2_isBarrel_branch != 0) {
4752       ph2_isBarrel_branch->GetEntry(index);
4753     } else {
4754       printf("branch ph2_isBarrel_branch does not exist!\n");
4755       exit(1);
4756     }
4757     ph2_isBarrel_isLoaded = true;
4758   }
4759   return *ph2_isBarrel_;
4760 }
4761 const std::vector<std::vector<int> > &Trktree::pix_seeIdx() {
4762   if (not pix_seeIdx_isLoaded) {
4763     if (pix_seeIdx_branch != 0) {
4764       pix_seeIdx_branch->GetEntry(index);
4765     } else {
4766       printf("branch pix_seeIdx_branch does not exist!\n");
4767       exit(1);
4768     }
4769     pix_seeIdx_isLoaded = true;
4770   }
4771   return *pix_seeIdx_;
4772 }
4773 const std::vector<int> &Trktree::trk_bestFromFirstHitSimTrkIdx() {
4774   if (not trk_bestFromFirstHitSimTrkIdx_isLoaded) {
4775     if (trk_bestFromFirstHitSimTrkIdx_branch != 0) {
4776       trk_bestFromFirstHitSimTrkIdx_branch->GetEntry(index);
4777     } else {
4778       printf("branch trk_bestFromFirstHitSimTrkIdx_branch does not exist!\n");
4779       exit(1);
4780     }
4781     trk_bestFromFirstHitSimTrkIdx_isLoaded = true;
4782   }
4783   return *trk_bestFromFirstHitSimTrkIdx_;
4784 }
4785 const std::vector<float> &Trktree::simhit_px() {
4786   if (not simhit_px_isLoaded) {
4787     if (simhit_px_branch != 0) {
4788       simhit_px_branch->GetEntry(index);
4789     } else {
4790       printf("branch simhit_px_branch does not exist!\n");
4791       exit(1);
4792     }
4793     simhit_px_isLoaded = true;
4794   }
4795   return *simhit_px_;
4796 }
4797 const std::vector<float> &Trktree::see_stateTrajX() {
4798   if (not see_stateTrajX_isLoaded) {
4799     if (see_stateTrajX_branch != 0) {
4800       see_stateTrajX_branch->GetEntry(index);
4801     } else {
4802       printf("branch see_stateTrajX_branch does not exist!\n");
4803       exit(1);
4804     }
4805     see_stateTrajX_isLoaded = true;
4806   }
4807   return *see_stateTrajX_;
4808 }
4809 const std::vector<float> &Trktree::see_stateTrajY() {
4810   if (not see_stateTrajY_isLoaded) {
4811     if (see_stateTrajY_branch != 0) {
4812       see_stateTrajY_branch->GetEntry(index);
4813     } else {
4814       printf("branch see_stateTrajY_branch does not exist!\n");
4815       exit(1);
4816     }
4817     see_stateTrajY_isLoaded = true;
4818   }
4819   return *see_stateTrajY_;
4820 }
4821 const std::vector<unsigned int> &Trktree::trk_nOuterInactive() {
4822   if (not trk_nOuterInactive_isLoaded) {
4823     if (trk_nOuterInactive_branch != 0) {
4824       trk_nOuterInactive_branch->GetEntry(index);
4825     } else {
4826       printf("branch trk_nOuterInactive_branch does not exist!\n");
4827       exit(1);
4828     }
4829     trk_nOuterInactive_isLoaded = true;
4830   }
4831   return *trk_nOuterInactive_;
4832 }
4833 const std::vector<float> &Trktree::sim_pca_dxy() {
4834   if (not sim_pca_dxy_isLoaded) {
4835     if (sim_pca_dxy_branch != 0) {
4836       sim_pca_dxy_branch->GetEntry(index);
4837     } else {
4838       printf("branch sim_pca_dxy_branch does not exist!\n");
4839       exit(1);
4840     }
4841     sim_pca_dxy_isLoaded = true;
4842   }
4843   return *sim_pca_dxy_;
4844 }
4845 const std::vector<unsigned int> &Trktree::trk_algo() {
4846   if (not trk_algo_isLoaded) {
4847     if (trk_algo_branch != 0) {
4848       trk_algo_branch->GetEntry(index);
4849     } else {
4850       printf("branch trk_algo_branch does not exist!\n");
4851       exit(1);
4852     }
4853     trk_algo_isLoaded = true;
4854   }
4855   return *trk_algo_;
4856 }
4857 const std::vector<std::vector<int> > &Trktree::trk_hitType() {
4858   if (not trk_hitType_isLoaded) {
4859     if (trk_hitType_branch != 0) {
4860       trk_hitType_branch->GetEntry(index);
4861     } else {
4862       printf("branch trk_hitType_branch does not exist!\n");
4863       exit(1);
4864     }
4865     trk_hitType_isLoaded = true;
4866   }
4867   return *trk_hitType_;
4868 }
4869 const std::vector<float> &Trktree::trk_bestFromFirstHitSimTrkShareFrac() {
4870   if (not trk_bestFromFirstHitSimTrkShareFrac_isLoaded) {
4871     if (trk_bestFromFirstHitSimTrkShareFrac_branch != 0) {
4872       trk_bestFromFirstHitSimTrkShareFrac_branch->GetEntry(index);
4873     } else {
4874       printf("branch trk_bestFromFirstHitSimTrkShareFrac_branch does not exist!\n");
4875       exit(1);
4876     }
4877     trk_bestFromFirstHitSimTrkShareFrac_isLoaded = true;
4878   }
4879   return *trk_bestFromFirstHitSimTrkShareFrac_;
4880 }
4881 const std::vector<short> &Trktree::inv_isBarrel() {
4882   if (not inv_isBarrel_isLoaded) {
4883     if (inv_isBarrel_branch != 0) {
4884       inv_isBarrel_branch->GetEntry(index);
4885     } else {
4886       printf("branch inv_isBarrel_branch does not exist!\n");
4887       exit(1);
4888     }
4889     inv_isBarrel_isLoaded = true;
4890   }
4891   return *inv_isBarrel_;
4892 }
4893 const std::vector<int> &Trktree::simvtx_event() {
4894   if (not simvtx_event_isLoaded) {
4895     if (simvtx_event_branch != 0) {
4896       simvtx_event_branch->GetEntry(index);
4897     } else {
4898       printf("branch simvtx_event_branch does not exist!\n");
4899       exit(1);
4900     }
4901     simvtx_event_isLoaded = true;
4902   }
4903   return *simvtx_event_;
4904 }
4905 const std::vector<float> &Trktree::ph2_z() {
4906   if (not ph2_z_isLoaded) {
4907     if (ph2_z_branch != 0) {
4908       ph2_z_branch->GetEntry(index);
4909     } else {
4910       printf("branch ph2_z_branch does not exist!\n");
4911       exit(1);
4912     }
4913     ph2_z_isLoaded = true;
4914   }
4915   return *ph2_z_;
4916 }
4917 const std::vector<float> &Trktree::ph2_x() {
4918   if (not ph2_x_isLoaded) {
4919     if (ph2_x_branch != 0) {
4920       ph2_x_branch->GetEntry(index);
4921     } else {
4922       printf("branch ph2_x_branch does not exist!\n");
4923       exit(1);
4924     }
4925     ph2_x_isLoaded = true;
4926   }
4927   return *ph2_x_;
4928 }
4929 const std::vector<float> &Trktree::ph2_y() {
4930   if (not ph2_y_isLoaded) {
4931     if (ph2_y_branch != 0) {
4932       ph2_y_branch->GetEntry(index);
4933     } else {
4934       printf("branch ph2_y_branch does not exist!\n");
4935       exit(1);
4936     }
4937     ph2_y_isLoaded = true;
4938   }
4939   return *ph2_y_;
4940 }
4941 const std::vector<std::vector<int> > &Trktree::sim_genPdgIds() {
4942   if (not sim_genPdgIds_isLoaded) {
4943     if (sim_genPdgIds_branch != 0) {
4944       sim_genPdgIds_branch->GetEntry(index);
4945     } else {
4946       printf("branch sim_genPdgIds_branch does not exist!\n");
4947       exit(1);
4948     }
4949     sim_genPdgIds_isLoaded = true;
4950   }
4951   return *sim_genPdgIds_;
4952 }
4953 const std::vector<float> &Trktree::trk_mva() {
4954   if (not trk_mva_isLoaded) {
4955     if (trk_mva_branch != 0) {
4956       trk_mva_branch->GetEntry(index);
4957     } else {
4958       printf("branch trk_mva_branch does not exist!\n");
4959       exit(1);
4960     }
4961     trk_mva_isLoaded = true;
4962   }
4963   return *trk_mva_;
4964 }
4965 const std::vector<float> &Trktree::see_stateCcov24() {
4966   if (not see_stateCcov24_isLoaded) {
4967     if (see_stateCcov24_branch != 0) {
4968       see_stateCcov24_branch->GetEntry(index);
4969     } else {
4970       printf("branch see_stateCcov24_branch does not exist!\n");
4971       exit(1);
4972     }
4973     see_stateCcov24_isLoaded = true;
4974   }
4975   return *see_stateCcov24_;
4976 }
4977 const std::vector<float> &Trktree::trk_dzClosestPV() {
4978   if (not trk_dzClosestPV_isLoaded) {
4979     if (trk_dzClosestPV_branch != 0) {
4980       trk_dzClosestPV_branch->GetEntry(index);
4981     } else {
4982       printf("branch trk_dzClosestPV_branch does not exist!\n");
4983       exit(1);
4984     }
4985     trk_dzClosestPV_isLoaded = true;
4986   }
4987   return *trk_dzClosestPV_;
4988 }
4989 const std::vector<unsigned int> &Trktree::see_nCluster() {
4990   if (not see_nCluster_isLoaded) {
4991     if (see_nCluster_branch != 0) {
4992       see_nCluster_branch->GetEntry(index);
4993     } else {
4994       printf("branch see_nCluster_branch does not exist!\n");
4995       exit(1);
4996     }
4997     see_nCluster_isLoaded = true;
4998   }
4999   return *see_nCluster_;
5000 }
5001 const std::vector<unsigned short> &Trktree::inv_rod() {
5002   if (not inv_rod_isLoaded) {
5003     if (inv_rod_branch != 0) {
5004       inv_rod_branch->GetEntry(index);
5005     } else {
5006       printf("branch inv_rod_branch does not exist!\n");
5007       exit(1);
5008     }
5009     inv_rod_isLoaded = true;
5010   }
5011   return *inv_rod_;
5012 }
5013 const std::vector<std::vector<int> > &Trktree::trk_hitIdx() {
5014   if (not trk_hitIdx_isLoaded) {
5015     if (trk_hitIdx_branch != 0) {
5016       trk_hitIdx_branch->GetEntry(index);
5017     } else {
5018       printf("branch trk_hitIdx_branch does not exist!\n");
5019       exit(1);
5020     }
5021     trk_hitIdx_isLoaded = true;
5022   }
5023   return *trk_hitIdx_;
5024 }
5025 const std::vector<float> &Trktree::see_stateCcov22() {
5026   if (not see_stateCcov22_isLoaded) {
5027     if (see_stateCcov22_branch != 0) {
5028       see_stateCcov22_branch->GetEntry(index);
5029     } else {
5030       printf("branch see_stateCcov22_branch does not exist!\n");
5031       exit(1);
5032     }
5033     see_stateCcov22_isLoaded = true;
5034   }
5035   return *see_stateCcov22_;
5036 }
5037 const std::vector<unsigned short> &Trktree::pix_simType() {
5038   if (not pix_simType_isLoaded) {
5039     if (pix_simType_branch != 0) {
5040       pix_simType_branch->GetEntry(index);
5041     } else {
5042       printf("branch pix_simType_branch does not exist!\n");
5043       exit(1);
5044     }
5045     pix_simType_isLoaded = true;
5046   }
5047   return *pix_simType_;
5048 }
5049 const std::vector<unsigned short> &Trktree::simhit_ring() {
5050   if (not simhit_ring_isLoaded) {
5051     if (simhit_ring_branch != 0) {
5052       simhit_ring_branch->GetEntry(index);
5053     } else {
5054       printf("branch simhit_ring_branch does not exist!\n");
5055       exit(1);
5056     }
5057     simhit_ring_isLoaded = true;
5058   }
5059   return *simhit_ring_;
5060 }
5061 const std::vector<float> &Trktree::trk_outer_px() {
5062   if (not trk_outer_px_isLoaded) {
5063     if (trk_outer_px_branch != 0) {
5064       trk_outer_px_branch->GetEntry(index);
5065     } else {
5066       printf("branch trk_outer_px_branch does not exist!\n");
5067       exit(1);
5068     }
5069     trk_outer_px_isLoaded = true;
5070   }
5071   return *trk_outer_px_;
5072 }
5073 const std::vector<float> &Trktree::trk_outer_py() {
5074   if (not trk_outer_py_isLoaded) {
5075     if (trk_outer_py_branch != 0) {
5076       trk_outer_py_branch->GetEntry(index);
5077     } else {
5078       printf("branch trk_outer_py_branch does not exist!\n");
5079       exit(1);
5080     }
5081     trk_outer_py_isLoaded = true;
5082   }
5083   return *trk_outer_py_;
5084 }
5085 const std::vector<float> &Trktree::trk_outer_pz() {
5086   if (not trk_outer_pz_isLoaded) {
5087     if (trk_outer_pz_branch != 0) {
5088       trk_outer_pz_branch->GetEntry(index);
5089     } else {
5090       printf("branch trk_outer_pz_branch does not exist!\n");
5091       exit(1);
5092     }
5093     trk_outer_pz_isLoaded = true;
5094   }
5095   return *trk_outer_pz_;
5096 }
5097 const std::vector<float> &Trktree::ph2_zz() {
5098   if (not ph2_zz_isLoaded) {
5099     if (ph2_zz_branch != 0) {
5100       ph2_zz_branch->GetEntry(index);
5101     } else {
5102       printf("branch ph2_zz_branch does not exist!\n");
5103       exit(1);
5104     }
5105     ph2_zz_isLoaded = true;
5106   }
5107   return *ph2_zz_;
5108 }
5109 const std::vector<float> &Trktree::trk_outer_pt() {
5110   if (not trk_outer_pt_isLoaded) {
5111     if (trk_outer_pt_branch != 0) {
5112       trk_outer_pt_branch->GetEntry(index);
5113     } else {
5114       printf("branch trk_outer_pt_branch does not exist!\n");
5115       exit(1);
5116     }
5117     trk_outer_pt_isLoaded = true;
5118   }
5119   return *trk_outer_pt_;
5120 }
5121 const std::vector<unsigned int> &Trktree::trk_n3DLay() {
5122   if (not trk_n3DLay_isLoaded) {
5123     if (trk_n3DLay_branch != 0) {
5124       trk_n3DLay_branch->GetEntry(index);
5125     } else {
5126       printf("branch trk_n3DLay_branch does not exist!\n");
5127       exit(1);
5128     }
5129     trk_n3DLay_isLoaded = true;
5130   }
5131   return *trk_n3DLay_;
5132 }
5133 const std::vector<unsigned int> &Trktree::trk_nValid() {
5134   if (not trk_nValid_isLoaded) {
5135     if (trk_nValid_branch != 0) {
5136       trk_nValid_branch->GetEntry(index);
5137     } else {
5138       printf("branch trk_nValid_branch does not exist!\n");
5139       exit(1);
5140     }
5141     trk_nValid_isLoaded = true;
5142   }
5143   return *trk_nValid_;
5144 }
5145 const std::vector<float> &Trktree::see_ptErr() {
5146   if (not see_ptErr_isLoaded) {
5147     if (see_ptErr_branch != 0) {
5148       see_ptErr_branch->GetEntry(index);
5149     } else {
5150       printf("branch see_ptErr_branch does not exist!\n");
5151       exit(1);
5152     }
5153     see_ptErr_isLoaded = true;
5154   }
5155   return *see_ptErr_;
5156 }
5157 const std::vector<float> &Trktree::see_stateTrajGlbPx() {
5158   if (not see_stateTrajGlbPx_isLoaded) {
5159     if (see_stateTrajGlbPx_branch != 0) {
5160       see_stateTrajGlbPx_branch->GetEntry(index);
5161     } else {
5162       printf("branch see_stateTrajGlbPx_branch does not exist!\n");
5163       exit(1);
5164     }
5165     see_stateTrajGlbPx_isLoaded = true;
5166   }
5167   return *see_stateTrajGlbPx_;
5168 }
5169 const std::vector<unsigned short> &Trktree::ph2_simType() {
5170   if (not ph2_simType_isLoaded) {
5171     if (ph2_simType_branch != 0) {
5172       ph2_simType_branch->GetEntry(index);
5173     } else {
5174       printf("branch ph2_simType_branch does not exist!\n");
5175       exit(1);
5176     }
5177     ph2_simType_isLoaded = true;
5178   }
5179   return *ph2_simType_;
5180 }
5181 const std::vector<float> &Trktree::trk_bestFromFirstHitSimTrkShareFracSimClusterDenom() {
5182   if (not trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_isLoaded) {
5183     if (trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch != 0) {
5184       trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch->GetEntry(index);
5185     } else {
5186       printf("branch trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_branch does not exist!\n");
5187       exit(1);
5188     }
5189     trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_isLoaded = true;
5190   }
5191   return *trk_bestFromFirstHitSimTrkShareFracSimClusterDenom_;
5192 }
5193 const std::vector<float> &Trktree::sim_hits() {
5194   if (not sim_hits_isLoaded) {
5195     if (sim_hits_branch != 0) {
5196       sim_hits_branch->GetEntry(index);
5197     } else {
5198       printf("branch sim_hits_branch does not exist!\n");
5199       exit(1);
5200     }
5201     sim_hits_isLoaded = true;
5202   }
5203   return *sim_hits_;
5204 }
5205 const std::vector<float> &Trktree::sim_len() {
5206   if (not sim_len_isLoaded) {
5207     if (sim_len_branch != 0) {
5208       sim_len_branch->GetEntry(index);
5209     } else {
5210       printf("branch sim_len_branch does not exist!\n");
5211       exit(1);
5212     }
5213     sim_len_isLoaded = true;
5214   }
5215   return *sim_len_;
5216 }
5217 const std::vector<float> &Trktree::sim_lengap() {
5218   if (not sim_lengap_isLoaded) {
5219     if (sim_lengap_branch != 0) {
5220       sim_lengap_branch->GetEntry(index);
5221     } else {
5222       printf("branch sim_lengap_branch does not exist!\n");
5223       exit(1);
5224     }
5225     sim_lengap_isLoaded = true;
5226   }
5227   return *sim_lengap_;
5228 }
5229 const std::vector<float> &Trktree::simvtx_x() {
5230   if (not simvtx_x_isLoaded) {
5231     if (simvtx_x_branch != 0) {
5232       simvtx_x_branch->GetEntry(index);
5233     } else {
5234       printf("branch simvtx_x_branch does not exist!\n");
5235       exit(1);
5236     }
5237     simvtx_x_isLoaded = true;
5238   }
5239   return *simvtx_x_;
5240 }
5241 const std::vector<float> &Trktree::trk_pz() {
5242   if (not trk_pz_isLoaded) {
5243     if (trk_pz_branch != 0) {
5244       trk_pz_branch->GetEntry(index);
5245     } else {
5246       printf("branch trk_pz_branch does not exist!\n");
5247       exit(1);
5248     }
5249     trk_pz_isLoaded = true;
5250   }
5251   return *trk_pz_;
5252 }
5253 const std::vector<float> &Trktree::see_bestFromFirstHitSimTrkShareFrac() {
5254   if (not see_bestFromFirstHitSimTrkShareFrac_isLoaded) {
5255     if (see_bestFromFirstHitSimTrkShareFrac_branch != 0) {
5256       see_bestFromFirstHitSimTrkShareFrac_branch->GetEntry(index);
5257     } else {
5258       printf("branch see_bestFromFirstHitSimTrkShareFrac_branch does not exist!\n");
5259       exit(1);
5260     }
5261     see_bestFromFirstHitSimTrkShareFrac_isLoaded = true;
5262   }
5263   return *see_bestFromFirstHitSimTrkShareFrac_;
5264 }
5265 const std::vector<float> &Trktree::trk_px() {
5266   if (not trk_px_isLoaded) {
5267     if (trk_px_branch != 0) {
5268       trk_px_branch->GetEntry(index);
5269     } else {
5270       printf("branch trk_px_branch does not exist!\n");
5271       exit(1);
5272     }
5273     trk_px_isLoaded = true;
5274   }
5275   return *trk_px_;
5276 }
5277 const std::vector<float> &Trktree::trk_py() {
5278   if (not trk_py_isLoaded) {
5279     if (trk_py_branch != 0) {
5280       trk_py_branch->GetEntry(index);
5281     } else {
5282       printf("branch trk_py_branch does not exist!\n");
5283       exit(1);
5284     }
5285     trk_py_isLoaded = true;
5286   }
5287   return *trk_py_;
5288 }
5289 const std::vector<int> &Trktree::trk_vtxIdx() {
5290   if (not trk_vtxIdx_isLoaded) {
5291     if (trk_vtxIdx_branch != 0) {
5292       trk_vtxIdx_branch->GetEntry(index);
5293     } else {
5294       printf("branch trk_vtxIdx_branch does not exist!\n");
5295       exit(1);
5296     }
5297     trk_vtxIdx_isLoaded = true;
5298   }
5299   return *trk_vtxIdx_;
5300 }
5301 const std::vector<unsigned int> &Trktree::sim_nPixel() {
5302   if (not sim_nPixel_isLoaded) {
5303     if (sim_nPixel_branch != 0) {
5304       sim_nPixel_branch->GetEntry(index);
5305     } else {
5306       printf("branch sim_nPixel_branch does not exist!\n");
5307       exit(1);
5308     }
5309     sim_nPixel_isLoaded = true;
5310   }
5311   return *sim_nPixel_;
5312 }
5313 const std::vector<float> &Trktree::vtx_chi2() {
5314   if (not vtx_chi2_isLoaded) {
5315     if (vtx_chi2_branch != 0) {
5316       vtx_chi2_branch->GetEntry(index);
5317     } else {
5318       printf("branch vtx_chi2_branch does not exist!\n");
5319       exit(1);
5320     }
5321     vtx_chi2_isLoaded = true;
5322   }
5323   return *vtx_chi2_;
5324 }
5325 const std::vector<unsigned short> &Trktree::ph2_ring() {
5326   if (not ph2_ring_isLoaded) {
5327     if (ph2_ring_branch != 0) {
5328       ph2_ring_branch->GetEntry(index);
5329     } else {
5330       printf("branch ph2_ring_branch does not exist!\n");
5331       exit(1);
5332     }
5333     ph2_ring_isLoaded = true;
5334   }
5335   return *ph2_ring_;
5336 }
5337 const std::vector<float> &Trktree::trk_pt() {
5338   if (not trk_pt_isLoaded) {
5339     if (trk_pt_branch != 0) {
5340       trk_pt_branch->GetEntry(index);
5341     } else {
5342       printf("branch trk_pt_branch does not exist!\n");
5343       exit(1);
5344     }
5345     trk_pt_isLoaded = true;
5346   }
5347   return *trk_pt_;
5348 }
5349 const std::vector<float> &Trktree::see_stateCcov44() {
5350   if (not see_stateCcov44_isLoaded) {
5351     if (see_stateCcov44_branch != 0) {
5352       see_stateCcov44_branch->GetEntry(index);
5353     } else {
5354       printf("branch see_stateCcov44_branch does not exist!\n");
5355       exit(1);
5356     }
5357     see_stateCcov44_isLoaded = true;
5358   }
5359   return *see_stateCcov44_;
5360 }
5361 const std::vector<float> &Trktree::ph2_radL() {
5362   if (not ph2_radL_isLoaded) {
5363     if (ph2_radL_branch != 0) {
5364       ph2_radL_branch->GetEntry(index);
5365     } else {
5366       printf("branch ph2_radL_branch does not exist!\n");
5367       exit(1);
5368     }
5369     ph2_radL_isLoaded = true;
5370   }
5371   return *ph2_radL_;
5372 }
5373 const std::vector<float> &Trktree::vtx_zErr() {
5374   if (not vtx_zErr_isLoaded) {
5375     if (vtx_zErr_branch != 0) {
5376       vtx_zErr_branch->GetEntry(index);
5377     } else {
5378       printf("branch vtx_zErr_branch does not exist!\n");
5379       exit(1);
5380     }
5381     vtx_zErr_isLoaded = true;
5382   }
5383   return *vtx_zErr_;
5384 }
5385 const std::vector<float> &Trktree::see_px() {
5386   if (not see_px_isLoaded) {
5387     if (see_px_branch != 0) {
5388       see_px_branch->GetEntry(index);
5389     } else {
5390       printf("branch see_px_branch does not exist!\n");
5391       exit(1);
5392     }
5393     see_px_isLoaded = true;
5394   }
5395   return *see_px_;
5396 }
5397 const std::vector<float> &Trktree::see_pz() {
5398   if (not see_pz_isLoaded) {
5399     if (see_pz_branch != 0) {
5400       see_pz_branch->GetEntry(index);
5401     } else {
5402       printf("branch see_pz_branch does not exist!\n");
5403       exit(1);
5404     }
5405     see_pz_isLoaded = true;
5406   }
5407   return *see_pz_;
5408 }
5409 const std::vector<float> &Trktree::see_eta() {
5410   if (not see_eta_isLoaded) {
5411     if (see_eta_branch != 0) {
5412       see_eta_branch->GetEntry(index);
5413     } else {
5414       printf("branch see_eta_branch does not exist!\n");
5415       exit(1);
5416     }
5417     see_eta_isLoaded = true;
5418   }
5419   return *see_eta_;
5420 }
5421 const std::vector<int> &Trktree::simvtx_bunchCrossing() {
5422   if (not simvtx_bunchCrossing_isLoaded) {
5423     if (simvtx_bunchCrossing_branch != 0) {
5424       simvtx_bunchCrossing_branch->GetEntry(index);
5425     } else {
5426       printf("branch simvtx_bunchCrossing_branch does not exist!\n");
5427       exit(1);
5428     }
5429     simvtx_bunchCrossing_isLoaded = true;
5430   }
5431   return *simvtx_bunchCrossing_;
5432 }
5433 const std::vector<float> &Trktree::sim_pca_dz() {
5434   if (not sim_pca_dz_isLoaded) {
5435     if (sim_pca_dz_branch != 0) {
5436       sim_pca_dz_branch->GetEntry(index);
5437     } else {
5438       printf("branch sim_pca_dz_branch does not exist!\n");
5439       exit(1);
5440     }
5441     sim_pca_dz_isLoaded = true;
5442   }
5443   return *sim_pca_dz_;
5444 }
5445 const std::vector<float> &Trktree::simvtx_y() {
5446   if (not simvtx_y_isLoaded) {
5447     if (simvtx_y_branch != 0) {
5448       simvtx_y_branch->GetEntry(index);
5449     } else {
5450       printf("branch simvtx_y_branch does not exist!\n");
5451       exit(1);
5452     }
5453     simvtx_y_isLoaded = true;
5454   }
5455   return *simvtx_y_;
5456 }
5457 const std::vector<unsigned short> &Trktree::inv_isStack() {
5458   if (not inv_isStack_isLoaded) {
5459     if (inv_isStack_branch != 0) {
5460       inv_isStack_branch->GetEntry(index);
5461     } else {
5462       printf("branch inv_isStack_branch does not exist!\n");
5463       exit(1);
5464     }
5465     inv_isStack_isLoaded = true;
5466   }
5467   return *inv_isStack_;
5468 }
5469 const std::vector<unsigned int> &Trktree::trk_nStrip() {
5470   if (not trk_nStrip_isLoaded) {
5471     if (trk_nStrip_branch != 0) {
5472       trk_nStrip_branch->GetEntry(index);
5473     } else {
5474       printf("branch trk_nStrip_branch does not exist!\n");
5475       exit(1);
5476     }
5477     trk_nStrip_isLoaded = true;
5478   }
5479   return *trk_nStrip_;
5480 }
5481 const std::vector<float> &Trktree::trk_etaErr() {
5482   if (not trk_etaErr_isLoaded) {
5483     if (trk_etaErr_branch != 0) {
5484       trk_etaErr_branch->GetEntry(index);
5485     } else {
5486       printf("branch trk_etaErr_branch does not exist!\n");
5487       exit(1);
5488     }
5489     trk_etaErr_isLoaded = true;
5490   }
5491   return *trk_etaErr_;
5492 }
5493 const std::vector<std::vector<float> > &Trktree::trk_simTrkNChi2() {
5494   if (not trk_simTrkNChi2_isLoaded) {
5495     if (trk_simTrkNChi2_branch != 0) {
5496       trk_simTrkNChi2_branch->GetEntry(index);
5497     } else {
5498       printf("branch trk_simTrkNChi2_branch does not exist!\n");
5499       exit(1);
5500     }
5501     trk_simTrkNChi2_isLoaded = true;
5502   }
5503   return *trk_simTrkNChi2_;
5504 }
5505 const std::vector<float> &Trktree::pix_zz() {
5506   if (not pix_zz_isLoaded) {
5507     if (pix_zz_branch != 0) {
5508       pix_zz_branch->GetEntry(index);
5509     } else {
5510       printf("branch pix_zz_branch does not exist!\n");
5511       exit(1);
5512     }
5513     pix_zz_isLoaded = true;
5514   }
5515   return *pix_zz_;
5516 }
5517 const std::vector<int> &Trktree::simhit_particle() {
5518   if (not simhit_particle_isLoaded) {
5519     if (simhit_particle_branch != 0) {
5520       simhit_particle_branch->GetEntry(index);
5521     } else {
5522       printf("branch simhit_particle_branch does not exist!\n");
5523       exit(1);
5524     }
5525     simhit_particle_isLoaded = true;
5526   }
5527   return *simhit_particle_;
5528 }
5529 const std::vector<float> &Trktree::see_dz() {
5530   if (not see_dz_isLoaded) {
5531     if (see_dz_branch != 0) {
5532       see_dz_branch->GetEntry(index);
5533     } else {
5534       printf("branch see_dz_branch does not exist!\n");
5535       exit(1);
5536     }
5537     see_dz_isLoaded = true;
5538   }
5539   return *see_dz_;
5540 }
5541 const std::vector<float> &Trktree::see_stateTrajPz() {
5542   if (not see_stateTrajPz_isLoaded) {
5543     if (see_stateTrajPz_branch != 0) {
5544       see_stateTrajPz_branch->GetEntry(index);
5545     } else {
5546       printf("branch see_stateTrajPz_branch does not exist!\n");
5547       exit(1);
5548     }
5549     see_stateTrajPz_isLoaded = true;
5550   }
5551   return *see_stateTrajPz_;
5552 }
5553 const std::vector<float> &Trktree::trk_bestSimTrkShareFrac() {
5554   if (not trk_bestSimTrkShareFrac_isLoaded) {
5555     if (trk_bestSimTrkShareFrac_branch != 0) {
5556       trk_bestSimTrkShareFrac_branch->GetEntry(index);
5557     } else {
5558       printf("branch trk_bestSimTrkShareFrac_branch does not exist!\n");
5559       exit(1);
5560     }
5561     trk_bestSimTrkShareFrac_isLoaded = true;
5562   }
5563   return *trk_bestSimTrkShareFrac_;
5564 }
5565 const std::vector<float> &Trktree::trk_lambdaErr() {
5566   if (not trk_lambdaErr_isLoaded) {
5567     if (trk_lambdaErr_branch != 0) {
5568       trk_lambdaErr_branch->GetEntry(index);
5569     } else {
5570       printf("branch trk_lambdaErr_branch does not exist!\n");
5571       exit(1);
5572     }
5573     trk_lambdaErr_isLoaded = true;
5574   }
5575   return *trk_lambdaErr_;
5576 }
5577 const std::vector<std::vector<float> > &Trktree::see_simTrkShareFrac() {
5578   if (not see_simTrkShareFrac_isLoaded) {
5579     if (see_simTrkShareFrac_branch != 0) {
5580       see_simTrkShareFrac_branch->GetEntry(index);
5581     } else {
5582       printf("branch see_simTrkShareFrac_branch does not exist!\n");
5583       exit(1);
5584     }
5585     see_simTrkShareFrac_isLoaded = true;
5586   }
5587   return *see_simTrkShareFrac_;
5588 }
5589 const std::vector<std::vector<int> > &Trktree::pix_simHitIdx() {
5590   if (not pix_simHitIdx_isLoaded) {
5591     if (pix_simHitIdx_branch != 0) {
5592       pix_simHitIdx_branch->GetEntry(index);
5593     } else {
5594       printf("branch pix_simHitIdx_branch does not exist!\n");
5595       exit(1);
5596     }
5597     pix_simHitIdx_isLoaded = true;
5598   }
5599   return *pix_simHitIdx_;
5600 }
5601 const std::vector<std::vector<int> > &Trktree::vtx_trkIdx() {
5602   if (not vtx_trkIdx_isLoaded) {
5603     if (vtx_trkIdx_branch != 0) {
5604       vtx_trkIdx_branch->GetEntry(index);
5605     } else {
5606       printf("branch vtx_trkIdx_branch does not exist!\n");
5607       exit(1);
5608     }
5609     vtx_trkIdx_isLoaded = true;
5610   }
5611   return *vtx_trkIdx_;
5612 }
5613 const std::vector<unsigned short> &Trktree::ph2_rod() {
5614   if (not ph2_rod_isLoaded) {
5615     if (ph2_rod_branch != 0) {
5616       ph2_rod_branch->GetEntry(index);
5617     } else {
5618       printf("branch ph2_rod_branch does not exist!\n");
5619       exit(1);
5620     }
5621     ph2_rod_isLoaded = true;
5622   }
5623   return *ph2_rod_;
5624 }
5625 const std::vector<float> &Trktree::vtx_ndof() {
5626   if (not vtx_ndof_isLoaded) {
5627     if (vtx_ndof_branch != 0) {
5628       vtx_ndof_branch->GetEntry(index);
5629     } else {
5630       printf("branch vtx_ndof_branch does not exist!\n");
5631       exit(1);
5632     }
5633     vtx_ndof_isLoaded = true;
5634   }
5635   return *vtx_ndof_;
5636 }
5637 const std::vector<unsigned int> &Trktree::see_nPixel() {
5638   if (not see_nPixel_isLoaded) {
5639     if (see_nPixel_branch != 0) {
5640       see_nPixel_branch->GetEntry(index);
5641     } else {
5642       printf("branch see_nPixel_branch does not exist!\n");
5643       exit(1);
5644     }
5645     see_nPixel_isLoaded = true;
5646   }
5647   return *see_nPixel_;
5648 }
5649 const std::vector<unsigned int> &Trktree::sim_nStrip() {
5650   if (not sim_nStrip_isLoaded) {
5651     if (sim_nStrip_branch != 0) {
5652       sim_nStrip_branch->GetEntry(index);
5653     } else {
5654       printf("branch sim_nStrip_branch does not exist!\n");
5655       exit(1);
5656     }
5657     sim_nStrip_isLoaded = true;
5658   }
5659   return *sim_nStrip_;
5660 }
5661 const std::vector<int> &Trktree::sim_bunchCrossing() {
5662   if (not sim_bunchCrossing_isLoaded) {
5663     if (sim_bunchCrossing_branch != 0) {
5664       sim_bunchCrossing_branch->GetEntry(index);
5665     } else {
5666       printf("branch sim_bunchCrossing_branch does not exist!\n");
5667       exit(1);
5668     }
5669     sim_bunchCrossing_isLoaded = true;
5670   }
5671   return *sim_bunchCrossing_;
5672 }
5673 const std::vector<float> &Trktree::see_stateCcov45() {
5674   if (not see_stateCcov45_isLoaded) {
5675     if (see_stateCcov45_branch != 0) {
5676       see_stateCcov45_branch->GetEntry(index);
5677     } else {
5678       printf("branch see_stateCcov45_branch does not exist!\n");
5679       exit(1);
5680     }
5681     see_stateCcov45_isLoaded = true;
5682   }
5683   return *see_stateCcov45_;
5684 }
5685 const std::vector<unsigned short> &Trktree::ph2_isStack() {
5686   if (not ph2_isStack_isLoaded) {
5687     if (ph2_isStack_branch != 0) {
5688       ph2_isStack_branch->GetEntry(index);
5689     } else {
5690       printf("branch ph2_isStack_branch does not exist!\n");
5691       exit(1);
5692     }
5693     ph2_isStack_isLoaded = true;
5694   }
5695   return *ph2_isStack_;
5696 }
5697 const std::vector<std::vector<float> > &Trktree::sim_trkShareFrac() {
5698   if (not sim_trkShareFrac_isLoaded) {
5699     if (sim_trkShareFrac_branch != 0) {
5700       sim_trkShareFrac_branch->GetEntry(index);
5701     } else {
5702       printf("branch sim_trkShareFrac_branch does not exist!\n");
5703       exit(1);
5704     }
5705     sim_trkShareFrac_isLoaded = true;
5706   }
5707   return *sim_trkShareFrac_;
5708 }
5709 const std::vector<std::vector<float> > &Trktree::trk_simTrkShareFrac() {
5710   if (not trk_simTrkShareFrac_isLoaded) {
5711     if (trk_simTrkShareFrac_branch != 0) {
5712       trk_simTrkShareFrac_branch->GetEntry(index);
5713     } else {
5714       printf("branch trk_simTrkShareFrac_branch does not exist!\n");
5715       exit(1);
5716     }
5717     trk_simTrkShareFrac_isLoaded = true;
5718   }
5719   return *trk_simTrkShareFrac_;
5720 }
5721 const std::vector<float> &Trktree::sim_phi() {
5722   if (not sim_phi_isLoaded) {
5723     if (sim_phi_branch != 0) {
5724       sim_phi_branch->GetEntry(index);
5725     } else {
5726       printf("branch sim_phi_branch does not exist!\n");
5727       exit(1);
5728     }
5729     sim_phi_isLoaded = true;
5730   }
5731   return *sim_phi_;
5732 }
5733 const std::vector<unsigned short> &Trktree::inv_side() {
5734   if (not inv_side_isLoaded) {
5735     if (inv_side_branch != 0) {
5736       inv_side_branch->GetEntry(index);
5737     } else {
5738       printf("branch inv_side_branch does not exist!\n");
5739       exit(1);
5740     }
5741     inv_side_isLoaded = true;
5742   }
5743   return *inv_side_;
5744 }
5745 const std::vector<short> &Trktree::vtx_fake() {
5746   if (not vtx_fake_isLoaded) {
5747     if (vtx_fake_branch != 0) {
5748       vtx_fake_branch->GetEntry(index);
5749     } else {
5750       printf("branch vtx_fake_branch does not exist!\n");
5751       exit(1);
5752     }
5753     vtx_fake_isLoaded = true;
5754   }
5755   return *vtx_fake_;
5756 }
5757 const std::vector<unsigned int> &Trktree::trk_nInactive() {
5758   if (not trk_nInactive_isLoaded) {
5759     if (trk_nInactive_branch != 0) {
5760       trk_nInactive_branch->GetEntry(index);
5761     } else {
5762       printf("branch trk_nInactive_branch does not exist!\n");
5763       exit(1);
5764     }
5765     trk_nInactive_isLoaded = true;
5766   }
5767   return *trk_nInactive_;
5768 }
5769 const std::vector<unsigned int> &Trktree::trk_nPixelLay() {
5770   if (not trk_nPixelLay_isLoaded) {
5771     if (trk_nPixelLay_branch != 0) {
5772       trk_nPixelLay_branch->GetEntry(index);
5773     } else {
5774       printf("branch trk_nPixelLay_branch does not exist!\n");
5775       exit(1);
5776     }
5777     trk_nPixelLay_isLoaded = true;
5778   }
5779   return *trk_nPixelLay_;
5780 }
5781 const std::vector<float> &Trktree::ph2_bbxi() {
5782   if (not ph2_bbxi_isLoaded) {
5783     if (ph2_bbxi_branch != 0) {
5784       ph2_bbxi_branch->GetEntry(index);
5785     } else {
5786       printf("branch ph2_bbxi_branch does not exist!\n");
5787       exit(1);
5788     }
5789     ph2_bbxi_isLoaded = true;
5790   }
5791   return *ph2_bbxi_;
5792 }
5793 const std::vector<float> &Trktree::vtx_xErr() {
5794   if (not vtx_xErr_isLoaded) {
5795     if (vtx_xErr_branch != 0) {
5796       vtx_xErr_branch->GetEntry(index);
5797     } else {
5798       printf("branch vtx_xErr_branch does not exist!\n");
5799       exit(1);
5800     }
5801     vtx_xErr_isLoaded = true;
5802   }
5803   return *vtx_xErr_;
5804 }
5805 const std::vector<float> &Trktree::see_stateCcov25() {
5806   if (not see_stateCcov25_isLoaded) {
5807     if (see_stateCcov25_branch != 0) {
5808       see_stateCcov25_branch->GetEntry(index);
5809     } else {
5810       printf("branch see_stateCcov25_branch does not exist!\n");
5811       exit(1);
5812     }
5813     see_stateCcov25_isLoaded = true;
5814   }
5815   return *see_stateCcov25_;
5816 }
5817 const std::vector<int> &Trktree::sim_parentVtxIdx() {
5818   if (not sim_parentVtxIdx_isLoaded) {
5819     if (sim_parentVtxIdx_branch != 0) {
5820       sim_parentVtxIdx_branch->GetEntry(index);
5821     } else {
5822       printf("branch sim_parentVtxIdx_branch does not exist!\n");
5823       exit(1);
5824     }
5825     sim_parentVtxIdx_isLoaded = true;
5826   }
5827   return *sim_parentVtxIdx_;
5828 }
5829 const std::vector<float> &Trktree::see_stateCcov23() {
5830   if (not see_stateCcov23_isLoaded) {
5831     if (see_stateCcov23_branch != 0) {
5832       see_stateCcov23_branch->GetEntry(index);
5833     } else {
5834       printf("branch see_stateCcov23_branch does not exist!\n");
5835       exit(1);
5836     }
5837     see_stateCcov23_isLoaded = true;
5838   }
5839   return *see_stateCcov23_;
5840 }
5841 const std::vector<ULong64_t> &Trktree::trk_algoMask() {
5842   if (not trk_algoMask_isLoaded) {
5843     if (trk_algoMask_branch != 0) {
5844       trk_algoMask_branch->GetEntry(index);
5845     } else {
5846       printf("branch trk_algoMask_branch does not exist!\n");
5847       exit(1);
5848     }
5849     trk_algoMask_isLoaded = true;
5850   }
5851   return *trk_algoMask_;
5852 }
5853 const std::vector<std::vector<int> > &Trktree::trk_simTrkIdx() {
5854   if (not trk_simTrkIdx_isLoaded) {
5855     if (trk_simTrkIdx_branch != 0) {
5856       trk_simTrkIdx_branch->GetEntry(index);
5857     } else {
5858       printf("branch trk_simTrkIdx_branch does not exist!\n");
5859       exit(1);
5860     }
5861     trk_simTrkIdx_isLoaded = true;
5862   }
5863   return *trk_simTrkIdx_;
5864 }
5865 const std::vector<float> &Trktree::see_phiErr() {
5866   if (not see_phiErr_isLoaded) {
5867     if (see_phiErr_branch != 0) {
5868       see_phiErr_branch->GetEntry(index);
5869     } else {
5870       printf("branch see_phiErr_branch does not exist!\n");
5871       exit(1);
5872     }
5873     see_phiErr_isLoaded = true;
5874   }
5875   return *see_phiErr_;
5876 }
5877 const std::vector<float> &Trktree::trk_cotTheta() {
5878   if (not trk_cotTheta_isLoaded) {
5879     if (trk_cotTheta_branch != 0) {
5880       trk_cotTheta_branch->GetEntry(index);
5881     } else {
5882       printf("branch trk_cotTheta_branch does not exist!\n");
5883       exit(1);
5884     }
5885     trk_cotTheta_isLoaded = true;
5886   }
5887   return *trk_cotTheta_;
5888 }
5889 const std::vector<unsigned int> &Trktree::see_algo() {
5890   if (not see_algo_isLoaded) {
5891     if (see_algo_branch != 0) {
5892       see_algo_branch->GetEntry(index);
5893     } else {
5894       printf("branch see_algo_branch does not exist!\n");
5895       exit(1);
5896     }
5897     see_algo_isLoaded = true;
5898   }
5899   return *see_algo_;
5900 }
5901 const std::vector<unsigned short> &Trktree::simhit_module() {
5902   if (not simhit_module_isLoaded) {
5903     if (simhit_module_branch != 0) {
5904       simhit_module_branch->GetEntry(index);
5905     } else {
5906       printf("branch simhit_module_branch does not exist!\n");
5907       exit(1);
5908     }
5909     simhit_module_isLoaded = true;
5910   }
5911   return *simhit_module_;
5912 }
5913 const std::vector<std::vector<int> > &Trktree::simvtx_daughterSimIdx() {
5914   if (not simvtx_daughterSimIdx_isLoaded) {
5915     if (simvtx_daughterSimIdx_branch != 0) {
5916       simvtx_daughterSimIdx_branch->GetEntry(index);
5917     } else {
5918       printf("branch simvtx_daughterSimIdx_branch does not exist!\n");
5919       exit(1);
5920     }
5921     simvtx_daughterSimIdx_isLoaded = true;
5922   }
5923   return *simvtx_daughterSimIdx_;
5924 }
5925 const std::vector<float> &Trktree::vtx_x() {
5926   if (not vtx_x_isLoaded) {
5927     if (vtx_x_branch != 0) {
5928       vtx_x_branch->GetEntry(index);
5929     } else {
5930       printf("branch vtx_x_branch does not exist!\n");
5931       exit(1);
5932     }
5933     vtx_x_isLoaded = true;
5934   }
5935   return *vtx_x_;
5936 }
5937 const std::vector<int> &Trktree::trk_seedIdx() {
5938   if (not trk_seedIdx_isLoaded) {
5939     if (trk_seedIdx_branch != 0) {
5940       trk_seedIdx_branch->GetEntry(index);
5941     } else {
5942       printf("branch trk_seedIdx_branch does not exist!\n");
5943       exit(1);
5944     }
5945     trk_seedIdx_isLoaded = true;
5946   }
5947   return *trk_seedIdx_;
5948 }
5949 const std::vector<float> &Trktree::simhit_y() {
5950   if (not simhit_y_isLoaded) {
5951     if (simhit_y_branch != 0) {
5952       simhit_y_branch->GetEntry(index);
5953     } else {
5954       printf("branch simhit_y_branch does not exist!\n");
5955       exit(1);
5956     }
5957     simhit_y_isLoaded = true;
5958   }
5959   return *simhit_y_;
5960 }
5961 const std::vector<unsigned short> &Trktree::inv_layer() {
5962   if (not inv_layer_isLoaded) {
5963     if (inv_layer_branch != 0) {
5964       inv_layer_branch->GetEntry(index);
5965     } else {
5966       printf("branch inv_layer_branch does not exist!\n");
5967       exit(1);
5968     }
5969     inv_layer_isLoaded = true;
5970   }
5971   return *inv_layer_;
5972 }
5973 const std::vector<unsigned int> &Trktree::trk_nLostLay() {
5974   if (not trk_nLostLay_isLoaded) {
5975     if (trk_nLostLay_branch != 0) {
5976       trk_nLostLay_branch->GetEntry(index);
5977     } else {
5978       printf("branch trk_nLostLay_branch does not exist!\n");
5979       exit(1);
5980     }
5981     trk_nLostLay_isLoaded = true;
5982   }
5983   return *trk_nLostLay_;
5984 }
5985 const std::vector<unsigned short> &Trktree::ph2_isLower() {
5986   if (not ph2_isLower_isLoaded) {
5987     if (ph2_isLower_branch != 0) {
5988       ph2_isLower_branch->GetEntry(index);
5989     } else {
5990       printf("branch ph2_isLower_branch does not exist!\n");
5991       exit(1);
5992     }
5993     ph2_isLower_isLoaded = true;
5994   }
5995   return *ph2_isLower_;
5996 }
5997 const std::vector<unsigned short> &Trktree::pix_side() {
5998   if (not pix_side_isLoaded) {
5999     if (pix_side_branch != 0) {
6000       pix_side_branch->GetEntry(index);
6001     } else {
6002       printf("branch pix_side_branch does not exist!\n");
6003       exit(1);
6004     }
6005     pix_side_isLoaded = true;
6006   }
6007   return *pix_side_;
6008 }
6009 const std::vector<unsigned short> &Trktree::inv_isLower() {
6010   if (not inv_isLower_isLoaded) {
6011     if (inv_isLower_branch != 0) {
6012       inv_isLower_branch->GetEntry(index);
6013     } else {
6014       printf("branch inv_isLower_branch does not exist!\n");
6015       exit(1);
6016     }
6017     inv_isLower_isLoaded = true;
6018   }
6019   return *inv_isLower_;
6020 }
6021 const std::vector<std::vector<int> > &Trktree::ph2_trkIdx() {
6022   if (not ph2_trkIdx_isLoaded) {
6023     if (ph2_trkIdx_branch != 0) {
6024       ph2_trkIdx_branch->GetEntry(index);
6025     } else {
6026       printf("branch ph2_trkIdx_branch does not exist!\n");
6027       exit(1);
6028     }
6029     ph2_trkIdx_isLoaded = true;
6030   }
6031   return *ph2_trkIdx_;
6032 }
6033 const std::vector<unsigned int> &Trktree::sim_nValid() {
6034   if (not sim_nValid_isLoaded) {
6035     if (sim_nValid_branch != 0) {
6036       sim_nValid_branch->GetEntry(index);
6037     } else {
6038       printf("branch sim_nValid_branch does not exist!\n");
6039       exit(1);
6040     }
6041     sim_nValid_isLoaded = true;
6042   }
6043   return *sim_nValid_;
6044 }
6045 const std::vector<int> &Trktree::simhit_simTrkIdx() {
6046   if (not simhit_simTrkIdx_isLoaded) {
6047     if (simhit_simTrkIdx_branch != 0) {
6048       simhit_simTrkIdx_branch->GetEntry(index);
6049     } else {
6050       printf("branch simhit_simTrkIdx_branch does not exist!\n");
6051       exit(1);
6052     }
6053     simhit_simTrkIdx_isLoaded = true;
6054   }
6055   return *simhit_simTrkIdx_;
6056 }
6057 const std::vector<unsigned short> &Trktree::see_nCands() {
6058   if (not see_nCands_isLoaded) {
6059     if (see_nCands_branch != 0) {
6060       see_nCands_branch->GetEntry(index);
6061     } else {
6062       printf("branch see_nCands_branch does not exist!\n");
6063       exit(1);
6064     }
6065     see_nCands_isLoaded = true;
6066   }
6067   return *see_nCands_;
6068 }
6069 const std::vector<int> &Trktree::see_bestSimTrkIdx() {
6070   if (not see_bestSimTrkIdx_isLoaded) {
6071     if (see_bestSimTrkIdx_branch != 0) {
6072       see_bestSimTrkIdx_branch->GetEntry(index);
6073     } else {
6074       printf("branch see_bestSimTrkIdx_branch does not exist!\n");
6075       exit(1);
6076     }
6077     see_bestSimTrkIdx_isLoaded = true;
6078   }
6079   return *see_bestSimTrkIdx_;
6080 }
6081 const std::vector<float> &Trktree::vtx_yErr() {
6082   if (not vtx_yErr_isLoaded) {
6083     if (vtx_yErr_branch != 0) {
6084       vtx_yErr_branch->GetEntry(index);
6085     } else {
6086       printf("branch vtx_yErr_branch does not exist!\n");
6087       exit(1);
6088     }
6089     vtx_yErr_isLoaded = true;
6090   }
6091   return *vtx_yErr_;
6092 }
6093 const std::vector<float> &Trktree::trk_dzPV() {
6094   if (not trk_dzPV_isLoaded) {
6095     if (trk_dzPV_branch != 0) {
6096       trk_dzPV_branch->GetEntry(index);
6097     } else {
6098       printf("branch trk_dzPV_branch does not exist!\n");
6099       exit(1);
6100     }
6101     trk_dzPV_isLoaded = true;
6102   }
6103   return *trk_dzPV_;
6104 }
6105 const std::vector<float> &Trktree::ph2_xy() {
6106   if (not ph2_xy_isLoaded) {
6107     if (ph2_xy_branch != 0) {
6108       ph2_xy_branch->GetEntry(index);
6109     } else {
6110       printf("branch ph2_xy_branch does not exist!\n");
6111       exit(1);
6112     }
6113     ph2_xy_isLoaded = true;
6114   }
6115   return *ph2_xy_;
6116 }
6117 const std::vector<unsigned short> &Trktree::inv_module() {
6118   if (not inv_module_isLoaded) {
6119     if (inv_module_branch != 0) {
6120       inv_module_branch->GetEntry(index);
6121     } else {
6122       printf("branch inv_module_branch does not exist!\n");
6123       exit(1);
6124     }
6125     inv_module_isLoaded = true;
6126   }
6127   return *inv_module_;
6128 }
6129 const std::vector<float> &Trktree::see_stateCcov55() {
6130   if (not see_stateCcov55_isLoaded) {
6131     if (see_stateCcov55_branch != 0) {
6132       see_stateCcov55_branch->GetEntry(index);
6133     } else {
6134       printf("branch see_stateCcov55_branch does not exist!\n");
6135       exit(1);
6136     }
6137     see_stateCcov55_isLoaded = true;
6138   }
6139   return *see_stateCcov55_;
6140 }
6141 const std::vector<unsigned short> &Trktree::pix_panel() {
6142   if (not pix_panel_isLoaded) {
6143     if (pix_panel_branch != 0) {
6144       pix_panel_branch->GetEntry(index);
6145     } else {
6146       printf("branch pix_panel_branch does not exist!\n");
6147       exit(1);
6148     }
6149     pix_panel_isLoaded = true;
6150   }
6151   return *pix_panel_;
6152 }
6153 const std::vector<unsigned short> &Trktree::inv_ladder() {
6154   if (not inv_ladder_isLoaded) {
6155     if (inv_ladder_branch != 0) {
6156       inv_ladder_branch->GetEntry(index);
6157     } else {
6158       printf("branch inv_ladder_branch does not exist!\n");
6159       exit(1);
6160     }
6161     inv_ladder_isLoaded = true;
6162   }
6163   return *inv_ladder_;
6164 }
6165 const std::vector<float> &Trktree::ph2_xx() {
6166   if (not ph2_xx_isLoaded) {
6167     if (ph2_xx_branch != 0) {
6168       ph2_xx_branch->GetEntry(index);
6169     } else {
6170       printf("branch ph2_xx_branch does not exist!\n");
6171       exit(1);
6172     }
6173     ph2_xx_isLoaded = true;
6174   }
6175   return *ph2_xx_;
6176 }
6177 const std::vector<float> &Trktree::sim_pca_cotTheta() {
6178   if (not sim_pca_cotTheta_isLoaded) {
6179     if (sim_pca_cotTheta_branch != 0) {
6180       sim_pca_cotTheta_branch->GetEntry(index);
6181     } else {
6182       printf("branch sim_pca_cotTheta_branch does not exist!\n");
6183       exit(1);
6184     }
6185     sim_pca_cotTheta_isLoaded = true;
6186   }
6187   return *sim_pca_cotTheta_;
6188 }
6189 const std::vector<int> &Trktree::simpv_idx() {
6190   if (not simpv_idx_isLoaded) {
6191     if (simpv_idx_branch != 0) {
6192       simpv_idx_branch->GetEntry(index);
6193     } else {
6194       printf("branch simpv_idx_branch does not exist!\n");
6195       exit(1);
6196     }
6197     simpv_idx_isLoaded = true;
6198   }
6199   return *simpv_idx_;
6200 }
6201 const std::vector<float> &Trktree::trk_inner_pz() {
6202   if (not trk_inner_pz_isLoaded) {
6203     if (trk_inner_pz_branch != 0) {
6204       trk_inner_pz_branch->GetEntry(index);
6205     } else {
6206       printf("branch trk_inner_pz_branch does not exist!\n");
6207       exit(1);
6208     }
6209     trk_inner_pz_isLoaded = true;
6210   }
6211   return *trk_inner_pz_;
6212 }
6213 const std::vector<float> &Trktree::see_chi2() {
6214   if (not see_chi2_isLoaded) {
6215     if (see_chi2_branch != 0) {
6216       see_chi2_branch->GetEntry(index);
6217     } else {
6218       printf("branch see_chi2_branch does not exist!\n");
6219       exit(1);
6220     }
6221     see_chi2_isLoaded = true;
6222   }
6223   return *see_chi2_;
6224 }
6225 const std::vector<float> &Trktree::see_stateCcov35() {
6226   if (not see_stateCcov35_isLoaded) {
6227     if (see_stateCcov35_branch != 0) {
6228       see_stateCcov35_branch->GetEntry(index);
6229     } else {
6230       printf("branch see_stateCcov35_branch does not exist!\n");
6231       exit(1);
6232     }
6233     see_stateCcov35_isLoaded = true;
6234   }
6235   return *see_stateCcov35_;
6236 }
6237 const std::vector<float> &Trktree::see_stateCcov33() {
6238   if (not see_stateCcov33_isLoaded) {
6239     if (see_stateCcov33_branch != 0) {
6240       see_stateCcov33_branch->GetEntry(index);
6241     } else {
6242       printf("branch see_stateCcov33_branch does not exist!\n");
6243       exit(1);
6244     }
6245     see_stateCcov33_isLoaded = true;
6246   }
6247   return *see_stateCcov33_;
6248 }
6249 const std::vector<unsigned int> &Trktree::inv_detId() {
6250   if (not inv_detId_isLoaded) {
6251     if (inv_detId_branch != 0) {
6252       inv_detId_branch->GetEntry(index);
6253     } else {
6254       printf("branch inv_detId_branch does not exist!\n");
6255       exit(1);
6256     }
6257     inv_detId_isLoaded = true;
6258   }
6259   return *inv_detId_;
6260 }
6261 const std::vector<unsigned int> &Trktree::see_offset() {
6262   if (not see_offset_isLoaded) {
6263     if (see_offset_branch != 0) {
6264       see_offset_branch->GetEntry(index);
6265     } else {
6266       printf("branch see_offset_branch does not exist!\n");
6267       exit(1);
6268     }
6269     see_offset_isLoaded = true;
6270   }
6271   return *see_offset_;
6272 }
6273 const std::vector<unsigned int> &Trktree::sim_nLay() {
6274   if (not sim_nLay_isLoaded) {
6275     if (sim_nLay_branch != 0) {
6276       sim_nLay_branch->GetEntry(index);
6277     } else {
6278       printf("branch sim_nLay_branch does not exist!\n");
6279       exit(1);
6280     }
6281     sim_nLay_isLoaded = true;
6282   }
6283   return *sim_nLay_;
6284 }
6285 const std::vector<std::vector<int> > &Trktree::sim_simHitIdx() {
6286   if (not sim_simHitIdx_isLoaded) {
6287     if (sim_simHitIdx_branch != 0) {
6288       sim_simHitIdx_branch->GetEntry(index);
6289     } else {
6290       printf("branch sim_simHitIdx_branch does not exist!\n");
6291       exit(1);
6292     }
6293     sim_simHitIdx_isLoaded = true;
6294   }
6295   return *sim_simHitIdx_;
6296 }
6297 const std::vector<unsigned short> &Trktree::simhit_isUpper() {
6298   if (not simhit_isUpper_isLoaded) {
6299     if (simhit_isUpper_branch != 0) {
6300       simhit_isUpper_branch->GetEntry(index);
6301     } else {
6302       printf("branch simhit_isUpper_branch does not exist!\n");
6303       exit(1);
6304     }
6305     simhit_isUpper_isLoaded = true;
6306   }
6307   return *simhit_isUpper_;
6308 }
6309 const std::vector<float> &Trktree::see_stateCcov00() {
6310   if (not see_stateCcov00_isLoaded) {
6311     if (see_stateCcov00_branch != 0) {
6312       see_stateCcov00_branch->GetEntry(index);
6313     } else {
6314       printf("branch see_stateCcov00_branch does not exist!\n");
6315       exit(1);
6316     }
6317     see_stateCcov00_isLoaded = true;
6318   }
6319   return *see_stateCcov00_;
6320 }
6321 const std::vector<unsigned short> &Trktree::see_stopReason() {
6322   if (not see_stopReason_isLoaded) {
6323     if (see_stopReason_branch != 0) {
6324       see_stopReason_branch->GetEntry(index);
6325     } else {
6326       printf("branch see_stopReason_branch does not exist!\n");
6327       exit(1);
6328     }
6329     see_stopReason_isLoaded = true;
6330   }
6331   return *see_stopReason_;
6332 }
6333 const std::vector<short> &Trktree::vtx_valid() {
6334   if (not vtx_valid_isLoaded) {
6335     if (vtx_valid_branch != 0) {
6336       vtx_valid_branch->GetEntry(index);
6337     } else {
6338       printf("branch vtx_valid_branch does not exist!\n");
6339       exit(1);
6340     }
6341     vtx_valid_isLoaded = true;
6342   }
6343   return *vtx_valid_;
6344 }
6345 const unsigned int &Trktree::lumi() {
6346   if (not lumi_isLoaded) {
6347     if (lumi_branch != 0) {
6348       lumi_branch->GetEntry(index);
6349     } else {
6350       printf("branch lumi_branch does not exist!\n");
6351       exit(1);
6352     }
6353     lumi_isLoaded = true;
6354   }
6355   return lumi_;
6356 }
6357 const std::vector<float> &Trktree::trk_refpoint_x() {
6358   if (not trk_refpoint_x_isLoaded) {
6359     if (trk_refpoint_x_branch != 0) {
6360       trk_refpoint_x_branch->GetEntry(index);
6361     } else {
6362       printf("branch trk_refpoint_x_branch does not exist!\n");
6363       exit(1);
6364     }
6365     trk_refpoint_x_isLoaded = true;
6366   }
6367   return *trk_refpoint_x_;
6368 }
6369 const std::vector<float> &Trktree::trk_refpoint_y() {
6370   if (not trk_refpoint_y_isLoaded) {
6371     if (trk_refpoint_y_branch != 0) {
6372       trk_refpoint_y_branch->GetEntry(index);
6373     } else {
6374       printf("branch trk_refpoint_y_branch does not exist!\n");
6375       exit(1);
6376     }
6377     trk_refpoint_y_isLoaded = true;
6378   }
6379   return *trk_refpoint_y_;
6380 }
6381 const std::vector<float> &Trktree::trk_refpoint_z() {
6382   if (not trk_refpoint_z_isLoaded) {
6383     if (trk_refpoint_z_branch != 0) {
6384       trk_refpoint_z_branch->GetEntry(index);
6385     } else {
6386       printf("branch trk_refpoint_z_branch does not exist!\n");
6387       exit(1);
6388     }
6389     trk_refpoint_z_isLoaded = true;
6390   }
6391   return *trk_refpoint_z_;
6392 }
6393 const std::vector<unsigned int> &Trktree::sim_n3DLay() {
6394   if (not sim_n3DLay_isLoaded) {
6395     if (sim_n3DLay_branch != 0) {
6396       sim_n3DLay_branch->GetEntry(index);
6397     } else {
6398       printf("branch sim_n3DLay_branch does not exist!\n");
6399       exit(1);
6400     }
6401     sim_n3DLay_isLoaded = true;
6402   }
6403   return *sim_n3DLay_;
6404 }
6405 const std::vector<unsigned int> &Trktree::see_nPhase2OT() {
6406   if (not see_nPhase2OT_isLoaded) {
6407     if (see_nPhase2OT_branch != 0) {
6408       see_nPhase2OT_branch->GetEntry(index);
6409     } else {
6410       printf("branch see_nPhase2OT_branch does not exist!\n");
6411       exit(1);
6412     }
6413     see_nPhase2OT_isLoaded = true;
6414   }
6415   return *see_nPhase2OT_;
6416 }
6417 const std::vector<float> &Trktree::trk_bestFromFirstHitSimTrkShareFracSimDenom() {
6418   if (not trk_bestFromFirstHitSimTrkShareFracSimDenom_isLoaded) {
6419     if (trk_bestFromFirstHitSimTrkShareFracSimDenom_branch != 0) {
6420       trk_bestFromFirstHitSimTrkShareFracSimDenom_branch->GetEntry(index);
6421     } else {
6422       printf("branch trk_bestFromFirstHitSimTrkShareFracSimDenom_branch does not exist!\n");
6423       exit(1);
6424     }
6425     trk_bestFromFirstHitSimTrkShareFracSimDenom_isLoaded = true;
6426   }
6427   return *trk_bestFromFirstHitSimTrkShareFracSimDenom_;
6428 }
6429 const std::vector<float> &Trktree::ph2_yy() {
6430   if (not ph2_yy_isLoaded) {
6431     if (ph2_yy_branch != 0) {
6432       ph2_yy_branch->GetEntry(index);
6433     } else {
6434       printf("branch ph2_yy_branch does not exist!\n");
6435       exit(1);
6436     }
6437     ph2_yy_isLoaded = true;
6438   }
6439   return *ph2_yy_;
6440 }
6441 const std::vector<float> &Trktree::ph2_yz() {
6442   if (not ph2_yz_isLoaded) {
6443     if (ph2_yz_branch != 0) {
6444       ph2_yz_branch->GetEntry(index);
6445     } else {
6446       printf("branch ph2_yz_branch does not exist!\n");
6447       exit(1);
6448     }
6449     ph2_yz_isLoaded = true;
6450   }
6451   return *ph2_yz_;
6452 }
6453 const std::vector<unsigned short> &Trktree::inv_blade() {
6454   if (not inv_blade_isLoaded) {
6455     if (inv_blade_branch != 0) {
6456       inv_blade_branch->GetEntry(index);
6457     } else {
6458       printf("branch inv_blade_branch does not exist!\n");
6459       exit(1);
6460     }
6461     inv_blade_isLoaded = true;
6462   }
6463   return *inv_blade_;
6464 }
6465 const std::vector<float> &Trktree::trk_ptErr() {
6466   if (not trk_ptErr_isLoaded) {
6467     if (trk_ptErr_branch != 0) {
6468       trk_ptErr_branch->GetEntry(index);
6469     } else {
6470       printf("branch trk_ptErr_branch does not exist!\n");
6471       exit(1);
6472     }
6473     trk_ptErr_isLoaded = true;
6474   }
6475   return *trk_ptErr_;
6476 }
6477 const std::vector<float> &Trktree::pix_zx() {
6478   if (not pix_zx_isLoaded) {
6479     if (pix_zx_branch != 0) {
6480       pix_zx_branch->GetEntry(index);
6481     } else {
6482       printf("branch pix_zx_branch does not exist!\n");
6483       exit(1);
6484     }
6485     pix_zx_isLoaded = true;
6486   }
6487   return *pix_zx_;
6488 }
6489 const std::vector<float> &Trktree::simvtx_z() {
6490   if (not simvtx_z_isLoaded) {
6491     if (simvtx_z_branch != 0) {
6492       simvtx_z_branch->GetEntry(index);
6493     } else {
6494       printf("branch simvtx_z_branch does not exist!\n");
6495       exit(1);
6496     }
6497     simvtx_z_isLoaded = true;
6498   }
6499   return *simvtx_z_;
6500 }
6501 const std::vector<unsigned int> &Trktree::sim_nTrackerHits() {
6502   if (not sim_nTrackerHits_isLoaded) {
6503     if (sim_nTrackerHits_branch != 0) {
6504       sim_nTrackerHits_branch->GetEntry(index);
6505     } else {
6506       printf("branch sim_nTrackerHits_branch does not exist!\n");
6507       exit(1);
6508     }
6509     sim_nTrackerHits_isLoaded = true;
6510   }
6511   return *sim_nTrackerHits_;
6512 }
6513 const std::vector<unsigned short> &Trktree::ph2_subdet() {
6514   if (not ph2_subdet_isLoaded) {
6515     if (ph2_subdet_branch != 0) {
6516       ph2_subdet_branch->GetEntry(index);
6517     } else {
6518       printf("branch ph2_subdet_branch does not exist!\n");
6519       exit(1);
6520     }
6521     ph2_subdet_isLoaded = true;
6522   }
6523   return *ph2_subdet_;
6524 }
6525 const std::vector<float> &Trktree::see_stateTrajPx() {
6526   if (not see_stateTrajPx_isLoaded) {
6527     if (see_stateTrajPx_branch != 0) {
6528       see_stateTrajPx_branch->GetEntry(index);
6529     } else {
6530       printf("branch see_stateTrajPx_branch does not exist!\n");
6531       exit(1);
6532     }
6533     see_stateTrajPx_isLoaded = true;
6534   }
6535   return *see_stateTrajPx_;
6536 }
6537 const std::vector<std::vector<int> > &Trktree::simhit_hitIdx() {
6538   if (not simhit_hitIdx_isLoaded) {
6539     if (simhit_hitIdx_branch != 0) {
6540       simhit_hitIdx_branch->GetEntry(index);
6541     } else {
6542       printf("branch simhit_hitIdx_branch does not exist!\n");
6543       exit(1);
6544     }
6545     simhit_hitIdx_isLoaded = true;
6546   }
6547   return *simhit_hitIdx_;
6548 }
6549 const std::vector<unsigned short> &Trktree::simhit_ladder() {
6550   if (not simhit_ladder_isLoaded) {
6551     if (simhit_ladder_branch != 0) {
6552       simhit_ladder_branch->GetEntry(index);
6553     } else {
6554       printf("branch simhit_ladder_branch does not exist!\n");
6555       exit(1);
6556     }
6557     simhit_ladder_isLoaded = true;
6558   }
6559   return *simhit_ladder_;
6560 }
6561 const std::vector<unsigned short> &Trktree::ph2_layer() {
6562   if (not ph2_layer_isLoaded) {
6563     if (ph2_layer_branch != 0) {
6564       ph2_layer_branch->GetEntry(index);
6565     } else {
6566       printf("branch ph2_layer_branch does not exist!\n");
6567       exit(1);
6568     }
6569     ph2_layer_isLoaded = true;
6570   }
6571   return *ph2_layer_;
6572 }
6573 const std::vector<float> &Trktree::see_phi() {
6574   if (not see_phi_isLoaded) {
6575     if (see_phi_branch != 0) {
6576       see_phi_branch->GetEntry(index);
6577     } else {
6578       printf("branch see_phi_branch does not exist!\n");
6579       exit(1);
6580     }
6581     see_phi_isLoaded = true;
6582   }
6583   return *see_phi_;
6584 }
6585 const std::vector<float> &Trktree::trk_nChi2_1Dmod() {
6586   if (not trk_nChi2_1Dmod_isLoaded) {
6587     if (trk_nChi2_1Dmod_branch != 0) {
6588       trk_nChi2_1Dmod_branch->GetEntry(index);
6589     } else {
6590       printf("branch trk_nChi2_1Dmod_branch does not exist!\n");
6591       exit(1);
6592     }
6593     trk_nChi2_1Dmod_isLoaded = true;
6594   }
6595   return *trk_nChi2_1Dmod_;
6596 }
6597 const std::vector<float> &Trktree::trk_inner_py() {
6598   if (not trk_inner_py_isLoaded) {
6599     if (trk_inner_py_branch != 0) {
6600       trk_inner_py_branch->GetEntry(index);
6601     } else {
6602       printf("branch trk_inner_py_branch does not exist!\n");
6603       exit(1);
6604     }
6605     trk_inner_py_isLoaded = true;
6606   }
6607   return *trk_inner_py_;
6608 }
6609 const std::vector<float> &Trktree::trk_inner_px() {
6610   if (not trk_inner_px_isLoaded) {
6611     if (trk_inner_px_branch != 0) {
6612       trk_inner_px_branch->GetEntry(index);
6613     } else {
6614       printf("branch trk_inner_px_branch does not exist!\n");
6615       exit(1);
6616     }
6617     trk_inner_px_isLoaded = true;
6618   }
6619   return *trk_inner_px_;
6620 }
6621 const std::vector<float> &Trktree::trk_dxyErr() {
6622   if (not trk_dxyErr_isLoaded) {
6623     if (trk_dxyErr_branch != 0) {
6624       trk_dxyErr_branch->GetEntry(index);
6625     } else {
6626       printf("branch trk_dxyErr_branch does not exist!\n");
6627       exit(1);
6628     }
6629     trk_dxyErr_isLoaded = true;
6630   }
6631   return *trk_dxyErr_;
6632 }
6633 const std::vector<unsigned int> &Trktree::sim_nPixelLay() {
6634   if (not sim_nPixelLay_isLoaded) {
6635     if (sim_nPixelLay_branch != 0) {
6636       sim_nPixelLay_branch->GetEntry(index);
6637     } else {
6638       printf("branch sim_nPixelLay_branch does not exist!\n");
6639       exit(1);
6640     }
6641     sim_nPixelLay_isLoaded = true;
6642   }
6643   return *sim_nPixelLay_;
6644 }
6645 const std::vector<unsigned int> &Trktree::see_nValid() {
6646   if (not see_nValid_isLoaded) {
6647     if (see_nValid_branch != 0) {
6648       see_nValid_branch->GetEntry(index);
6649     } else {
6650       printf("branch see_nValid_branch does not exist!\n");
6651       exit(1);
6652     }
6653     see_nValid_isLoaded = true;
6654   }
6655   return *see_nValid_;
6656 }
6657 const std::vector<float> &Trktree::trk_inner_pt() {
6658   if (not trk_inner_pt_isLoaded) {
6659     if (trk_inner_pt_branch != 0) {
6660       trk_inner_pt_branch->GetEntry(index);
6661     } else {
6662       printf("branch trk_inner_pt_branch does not exist!\n");
6663       exit(1);
6664     }
6665     trk_inner_pt_isLoaded = true;
6666   }
6667   return *trk_inner_pt_;
6668 }
6669 const std::vector<float> &Trktree::see_stateTrajGlbPy() {
6670   if (not see_stateTrajGlbPy_isLoaded) {
6671     if (see_stateTrajGlbPy_branch != 0) {
6672       see_stateTrajGlbPy_branch->GetEntry(index);
6673     } else {
6674       printf("branch see_stateTrajGlbPy_branch does not exist!\n");
6675       exit(1);
6676     }
6677     see_stateTrajGlbPy_isLoaded = true;
6678   }
6679   return *see_stateTrajGlbPy_;
6680 }
6681 void Trktree::progress(int nEventsTotal, int nEventsChain) {
6682   int period = 1000;
6683   if (nEventsTotal % 1000 == 0) {
6684     if (isatty(1)) {
6685       if ((nEventsChain - nEventsTotal) > period) {
6686         float frac = (float)nEventsTotal / (nEventsChain * 0.01);
6687         printf(
6688             "\015\033[32m ---> \033[1m\033[31m%4.1f%%"
6689             "\033[0m\033[32m <---\033[0m\015",
6690             frac);
6691         fflush(stdout);
6692       } else {
6693         printf(
6694             "\015\033[32m ---> \033[1m\033[31m%4.1f%%"
6695             "\033[0m\033[32m <---\033[0m\015",
6696             100.);
6697         std::cout << std::endl;
6698       }
6699     }
6700   }
6701 }
6702 namespace tas {
6703   const std::vector<float> &see_stateCcov01() { return trk.see_stateCcov01(); }
6704   const std::vector<unsigned short> &simhit_rod() { return trk.simhit_rod(); }
6705   const std::vector<float> &trk_phi() { return trk.trk_phi(); }
6706   const float &bsp_x() { return trk.bsp_x(); }
6707   const std::vector<float> &see_stateCcov05() { return trk.see_stateCcov05(); }
6708   const std::vector<float> &see_stateCcov04() { return trk.see_stateCcov04(); }
6709   const std::vector<float> &trk_dxyPV() { return trk.trk_dxyPV(); }
6710   const std::vector<float> &simhit_tof() { return trk.simhit_tof(); }
6711   const std::vector<int> &sim_event() { return trk.sim_event(); }
6712   const std::vector<unsigned short> &simhit_isStack() { return trk.simhit_isStack(); }
6713   const std::vector<float> &trk_dz() { return trk.trk_dz(); }
6714   const std::vector<float> &see_stateCcov03() { return trk.see_stateCcov03(); }
6715   const std::vector<float> &sim_eta() { return trk.sim_eta(); }
6716   const std::vector<unsigned int> &simvtx_processType() { return trk.simvtx_processType(); }
6717   const std::vector<float> &pix_radL() { return trk.pix_radL(); }
6718   const std::vector<float> &see_stateCcov02() { return trk.see_stateCcov02(); }
6719   const std::vector<unsigned int> &see_nGlued() { return trk.see_nGlued(); }
6720   const std::vector<int> &trk_bestSimTrkIdx() { return trk.trk_bestSimTrkIdx(); }
6721   const std::vector<float> &see_stateTrajGlbPz() { return trk.see_stateTrajGlbPz(); }
6722   const std::vector<float> &pix_yz() { return trk.pix_yz(); }
6723   const std::vector<float> &pix_yy() { return trk.pix_yy(); }
6724   const std::vector<short> &simhit_process() { return trk.simhit_process(); }
6725   const std::vector<float> &see_stateCcov34() { return trk.see_stateCcov34(); }
6726   const std::vector<unsigned int> &trk_nInnerLost() { return trk.trk_nInnerLost(); }
6727   const std::vector<float> &see_py() { return trk.see_py(); }
6728   const std::vector<std::vector<int> > &sim_trkIdx() { return trk.sim_trkIdx(); }
6729   const std::vector<unsigned int> &trk_nLost() { return trk.trk_nLost(); }
6730   const std::vector<short> &pix_isBarrel() { return trk.pix_isBarrel(); }
6731   const std::vector<float> &see_dxyErr() { return trk.see_dxyErr(); }
6732   const std::vector<unsigned int> &simhit_detId() { return trk.simhit_detId(); }
6733   const std::vector<unsigned short> &simhit_subdet() { return trk.simhit_subdet(); }
6734   const std::vector<std::vector<int> > &see_hitIdx() { return trk.see_hitIdx(); }
6735   const std::vector<float> &see_pt() { return trk.see_pt(); }
6736   const std::vector<unsigned int> &ph2_detId() { return trk.ph2_detId(); }
6737   const std::vector<unsigned int> &trk_nStripLay() { return trk.trk_nStripLay(); }
6738   const std::vector<int> &see_bestFromFirstHitSimTrkIdx() { return trk.see_bestFromFirstHitSimTrkIdx(); }
6739   const std::vector<float> &sim_pca_pt() { return trk.sim_pca_pt(); }
6740   const std::vector<int> &see_trkIdx() { return trk.see_trkIdx(); }
6741   const std::vector<unsigned int> &trk_nCluster() { return trk.trk_nCluster(); }
6742   const std::vector<float> &trk_bestFromFirstHitSimTrkNChi2() { return trk.trk_bestFromFirstHitSimTrkNChi2(); }
6743   const std::vector<short> &trk_isHP() { return trk.trk_isHP(); }
6744   const std::vector<std::vector<int> > &simhit_hitType() { return trk.simhit_hitType(); }
6745   const std::vector<unsigned short> &ph2_isUpper() { return trk.ph2_isUpper(); }
6746   const std::vector<unsigned int> &see_nStrip() { return trk.see_nStrip(); }
6747   const std::vector<float> &trk_bestSimTrkShareFracSimClusterDenom() {
6748     return trk.trk_bestSimTrkShareFracSimClusterDenom();
6749   }
6750   const std::vector<unsigned short> &simhit_side() { return trk.simhit_side(); }
6751   const std::vector<float> &simhit_x() { return trk.simhit_x(); }
6752   const std::vector<int> &see_q() { return trk.see_q(); }
6753   const std::vector<float> &simhit_z() { return trk.simhit_z(); }
6754   const std::vector<float> &sim_pca_lambda() { return trk.sim_pca_lambda(); }
6755   const std::vector<int> &sim_q() { return trk.sim_q(); }
6756   const std::vector<float> &pix_bbxi() { return trk.pix_bbxi(); }
6757   const std::vector<unsigned short> &ph2_order() { return trk.ph2_order(); }
6758   const std::vector<unsigned short> &ph2_module() { return trk.ph2_module(); }
6759   const std::vector<unsigned short> &inv_order() { return trk.inv_order(); }
6760   const std::vector<float> &trk_dzErr() { return trk.trk_dzErr(); }
6761   const std::vector<unsigned int> &trk_nInnerInactive() { return trk.trk_nInnerInactive(); }
6762   const std::vector<short> &see_fitok() { return trk.see_fitok(); }
6763   const std::vector<unsigned short> &simhit_blade() { return trk.simhit_blade(); }
6764   const std::vector<unsigned short> &inv_subdet() { return trk.inv_subdet(); }
6765   const std::vector<unsigned short> &pix_blade() { return trk.pix_blade(); }
6766   const std::vector<float> &pix_xx() { return trk.pix_xx(); }
6767   const std::vector<float> &pix_xy() { return trk.pix_xy(); }
6768   const std::vector<unsigned short> &simhit_panel() { return trk.simhit_panel(); }
6769   const std::vector<float> &sim_pz() { return trk.sim_pz(); }
6770   const std::vector<float> &trk_dxy() { return trk.trk_dxy(); }
6771   const std::vector<float> &sim_px() { return trk.sim_px(); }
6772   const std::vector<float> &trk_lambda() { return trk.trk_lambda(); }
6773   const std::vector<float> &see_stateCcov12() { return trk.see_stateCcov12(); }
6774   const std::vector<float> &sim_pt() { return trk.sim_pt(); }
6775   const std::vector<float> &sim_py() { return trk.sim_py(); }
6776   const std::vector<std::vector<int> > &sim_decayVtxIdx() { return trk.sim_decayVtxIdx(); }
6777   const std::vector<unsigned int> &pix_detId() { return trk.pix_detId(); }
6778   const std::vector<float> &trk_eta() { return trk.trk_eta(); }
6779   const std::vector<float> &see_dxy() { return trk.see_dxy(); }
6780   const std::vector<int> &sim_isFromBHadron() { return trk.sim_isFromBHadron(); }
6781   const std::vector<float> &simhit_eloss() { return trk.simhit_eloss(); }
6782   const std::vector<float> &see_stateCcov11() { return trk.see_stateCcov11(); }
6783   const std::vector<float> &simhit_pz() { return trk.simhit_pz(); }
6784   const std::vector<int> &sim_pdgId() { return trk.sim_pdgId(); }
6785   const std::vector<unsigned short> &trk_stopReason() { return trk.trk_stopReason(); }
6786   const std::vector<float> &sim_pca_phi() { return trk.sim_pca_phi(); }
6787   const std::vector<unsigned short> &simhit_isLower() { return trk.simhit_isLower(); }
6788   const std::vector<unsigned short> &inv_ring() { return trk.inv_ring(); }
6789   const std::vector<std::vector<int> > &ph2_simHitIdx() { return trk.ph2_simHitIdx(); }
6790   const std::vector<unsigned short> &simhit_order() { return trk.simhit_order(); }
6791   const std::vector<float> &trk_dxyClosestPV() { return trk.trk_dxyClosestPV(); }
6792   const std::vector<float> &pix_z() { return trk.pix_z(); }
6793   const std::vector<float> &pix_y() { return trk.pix_y(); }
6794   const std::vector<float> &pix_x() { return trk.pix_x(); }
6795   const std::vector<std::vector<int> > &see_hitType() { return trk.see_hitType(); }
6796   const std::vector<float> &see_statePt() { return trk.see_statePt(); }
6797   const std::vector<std::vector<int> > &simvtx_sourceSimIdx() { return trk.simvtx_sourceSimIdx(); }
6798   const unsigned long long &event() { return trk.event(); }
6799   const std::vector<unsigned short> &pix_module() { return trk.pix_module(); }
6800   const std::vector<unsigned short> &ph2_side() { return trk.ph2_side(); }
6801   const std::vector<float> &trk_bestSimTrkNChi2() { return trk.trk_bestSimTrkNChi2(); }
6802   const std::vector<float> &see_stateTrajPy() { return trk.see_stateTrajPy(); }
6803   const std::vector<unsigned short> &inv_type() { return trk.inv_type(); }
6804   const float &bsp_z() { return trk.bsp_z(); }
6805   const float &bsp_y() { return trk.bsp_y(); }
6806   const std::vector<float> &simhit_py() { return trk.simhit_py(); }
6807   const std::vector<std::vector<int> > &see_simTrkIdx() { return trk.see_simTrkIdx(); }
6808   const std::vector<float> &see_stateTrajGlbZ() { return trk.see_stateTrajGlbZ(); }
6809   const std::vector<float> &see_stateTrajGlbX() { return trk.see_stateTrajGlbX(); }
6810   const std::vector<float> &see_stateTrajGlbY() { return trk.see_stateTrajGlbY(); }
6811   const std::vector<unsigned int> &trk_originalAlgo() { return trk.trk_originalAlgo(); }
6812   const std::vector<unsigned int> &trk_nPixel() { return trk.trk_nPixel(); }
6813   const std::vector<float> &see_stateCcov14() { return trk.see_stateCcov14(); }
6814   const std::vector<float> &see_stateCcov15() { return trk.see_stateCcov15(); }
6815   const std::vector<float> &trk_phiErr() { return trk.trk_phiErr(); }
6816   const std::vector<float> &see_stateCcov13() { return trk.see_stateCcov13(); }
6817   const std::vector<std::vector<float> > &pix_chargeFraction() { return trk.pix_chargeFraction(); }
6818   const std::vector<int> &trk_q() { return trk.trk_q(); }
6819   const std::vector<std::vector<int> > &sim_seedIdx() { return trk.sim_seedIdx(); }
6820   const std::vector<float> &see_dzErr() { return trk.see_dzErr(); }
6821   const std::vector<unsigned int> &sim_nRecoClusters() { return trk.sim_nRecoClusters(); }
6822   const unsigned int &run() { return trk.run(); }
6823   const std::vector<std::vector<float> > &ph2_xySignificance() { return trk.ph2_xySignificance(); }
6824   const std::vector<float> &trk_nChi2() { return trk.trk_nChi2(); }
6825   const std::vector<unsigned short> &pix_layer() { return trk.pix_layer(); }
6826   const std::vector<std::vector<float> > &pix_xySignificance() { return trk.pix_xySignificance(); }
6827   const std::vector<float> &sim_pca_eta() { return trk.sim_pca_eta(); }
6828   const std::vector<float> &see_bestSimTrkShareFrac() { return trk.see_bestSimTrkShareFrac(); }
6829   const std::vector<float> &see_etaErr() { return trk.see_etaErr(); }
6830   const std::vector<float> &trk_bestSimTrkShareFracSimDenom() { return trk.trk_bestSimTrkShareFracSimDenom(); }
6831   const float &bsp_sigmaz() { return trk.bsp_sigmaz(); }
6832   const float &bsp_sigmay() { return trk.bsp_sigmay(); }
6833   const float &bsp_sigmax() { return trk.bsp_sigmax(); }
6834   const std::vector<unsigned short> &pix_ladder() { return trk.pix_ladder(); }
6835   const std::vector<unsigned short> &trk_qualityMask() { return trk.trk_qualityMask(); }
6836   const std::vector<float> &trk_ndof() { return trk.trk_ndof(); }
6837   const std::vector<unsigned short> &pix_subdet() { return trk.pix_subdet(); }
6838   const std::vector<std::vector<int> > &ph2_seeIdx() { return trk.ph2_seeIdx(); }
6839   const std::vector<unsigned short> &inv_isUpper() { return trk.inv_isUpper(); }
6840   const std::vector<float> &ph2_zx() { return trk.ph2_zx(); }
6841   const std::vector<std::vector<int> > &pix_trkIdx() { return trk.pix_trkIdx(); }
6842   const std::vector<unsigned int> &trk_nOuterLost() { return trk.trk_nOuterLost(); }
6843   const std::vector<unsigned short> &inv_panel() { return trk.inv_panel(); }
6844   const std::vector<float> &vtx_z() { return trk.vtx_z(); }
6845   const std::vector<unsigned short> &simhit_layer() { return trk.simhit_layer(); }
6846   const std::vector<float> &vtx_y() { return trk.vtx_y(); }
6847   const std::vector<short> &ph2_isBarrel() { return trk.ph2_isBarrel(); }
6848   const std::vector<std::vector<int> > &pix_seeIdx() { return trk.pix_seeIdx(); }
6849   const std::vector<int> &trk_bestFromFirstHitSimTrkIdx() { return trk.trk_bestFromFirstHitSimTrkIdx(); }
6850   const std::vector<float> &simhit_px() { return trk.simhit_px(); }
6851   const std::vector<float> &see_stateTrajX() { return trk.see_stateTrajX(); }
6852   const std::vector<float> &see_stateTrajY() { return trk.see_stateTrajY(); }
6853   const std::vector<unsigned int> &trk_nOuterInactive() { return trk.trk_nOuterInactive(); }
6854   const std::vector<float> &sim_pca_dxy() { return trk.sim_pca_dxy(); }
6855   const std::vector<unsigned int> &trk_algo() { return trk.trk_algo(); }
6856   const std::vector<std::vector<int> > &trk_hitType() { return trk.trk_hitType(); }
6857   const std::vector<float> &trk_bestFromFirstHitSimTrkShareFrac() { return trk.trk_bestFromFirstHitSimTrkShareFrac(); }
6858   const std::vector<short> &inv_isBarrel() { return trk.inv_isBarrel(); }
6859   const std::vector<int> &simvtx_event() { return trk.simvtx_event(); }
6860   const std::vector<float> &ph2_z() { return trk.ph2_z(); }
6861   const std::vector<float> &ph2_x() { return trk.ph2_x(); }
6862   const std::vector<float> &ph2_y() { return trk.ph2_y(); }
6863   const std::vector<std::vector<int> > &sim_genPdgIds() { return trk.sim_genPdgIds(); }
6864   const std::vector<float> &trk_mva() { return trk.trk_mva(); }
6865   const std::vector<float> &see_stateCcov24() { return trk.see_stateCcov24(); }
6866   const std::vector<float> &trk_dzClosestPV() { return trk.trk_dzClosestPV(); }
6867   const std::vector<unsigned int> &see_nCluster() { return trk.see_nCluster(); }
6868   const std::vector<unsigned short> &inv_rod() { return trk.inv_rod(); }
6869   const std::vector<std::vector<int> > &trk_hitIdx() { return trk.trk_hitIdx(); }
6870   const std::vector<float> &see_stateCcov22() { return trk.see_stateCcov22(); }
6871   const std::vector<unsigned short> &pix_simType() { return trk.pix_simType(); }
6872   const std::vector<unsigned short> &simhit_ring() { return trk.simhit_ring(); }
6873   const std::vector<float> &trk_outer_px() { return trk.trk_outer_px(); }
6874   const std::vector<float> &trk_outer_py() { return trk.trk_outer_py(); }
6875   const std::vector<float> &trk_outer_pz() { return trk.trk_outer_pz(); }
6876   const std::vector<float> &ph2_zz() { return trk.ph2_zz(); }
6877   const std::vector<float> &trk_outer_pt() { return trk.trk_outer_pt(); }
6878   const std::vector<unsigned int> &trk_n3DLay() { return trk.trk_n3DLay(); }
6879   const std::vector<unsigned int> &trk_nValid() { return trk.trk_nValid(); }
6880   const std::vector<float> &see_ptErr() { return trk.see_ptErr(); }
6881   const std::vector<float> &see_stateTrajGlbPx() { return trk.see_stateTrajGlbPx(); }
6882   const std::vector<unsigned short> &ph2_simType() { return trk.ph2_simType(); }
6883   const std::vector<float> &trk_bestFromFirstHitSimTrkShareFracSimClusterDenom() {
6884     return trk.trk_bestFromFirstHitSimTrkShareFracSimClusterDenom();
6885   }
6886   const std::vector<float> &simvtx_x() { return trk.simvtx_x(); }
6887   const std::vector<float> &trk_pz() { return trk.trk_pz(); }
6888   const std::vector<float> &see_bestFromFirstHitSimTrkShareFrac() { return trk.see_bestFromFirstHitSimTrkShareFrac(); }
6889   const std::vector<float> &trk_px() { return trk.trk_px(); }
6890   const std::vector<float> &trk_py() { return trk.trk_py(); }
6891   const std::vector<int> &trk_vtxIdx() { return trk.trk_vtxIdx(); }
6892   const std::vector<unsigned int> &sim_nPixel() { return trk.sim_nPixel(); }
6893   const std::vector<float> &vtx_chi2() { return trk.vtx_chi2(); }
6894   const std::vector<unsigned short> &ph2_ring() { return trk.ph2_ring(); }
6895   const std::vector<float> &trk_pt() { return trk.trk_pt(); }
6896   const std::vector<float> &see_stateCcov44() { return trk.see_stateCcov44(); }
6897   const std::vector<float> &ph2_radL() { return trk.ph2_radL(); }
6898   const std::vector<float> &vtx_zErr() { return trk.vtx_zErr(); }
6899   const std::vector<float> &see_px() { return trk.see_px(); }
6900   const std::vector<float> &see_pz() { return trk.see_pz(); }
6901   const std::vector<float> &see_eta() { return trk.see_eta(); }
6902   const std::vector<int> &simvtx_bunchCrossing() { return trk.simvtx_bunchCrossing(); }
6903   const std::vector<float> &sim_pca_dz() { return trk.sim_pca_dz(); }
6904   const std::vector<float> &simvtx_y() { return trk.simvtx_y(); }
6905   const std::vector<unsigned short> &inv_isStack() { return trk.inv_isStack(); }
6906   const std::vector<unsigned int> &trk_nStrip() { return trk.trk_nStrip(); }
6907   const std::vector<float> &trk_etaErr() { return trk.trk_etaErr(); }
6908   const std::vector<std::vector<float> > &trk_simTrkNChi2() { return trk.trk_simTrkNChi2(); }
6909   const std::vector<float> &pix_zz() { return trk.pix_zz(); }
6910   const std::vector<int> &simhit_particle() { return trk.simhit_particle(); }
6911   const std::vector<float> &see_dz() { return trk.see_dz(); }
6912   const std::vector<float> &see_stateTrajPz() { return trk.see_stateTrajPz(); }
6913   const std::vector<float> &trk_bestSimTrkShareFrac() { return trk.trk_bestSimTrkShareFrac(); }
6914   const std::vector<float> &trk_lambdaErr() { return trk.trk_lambdaErr(); }
6915   const std::vector<std::vector<float> > &see_simTrkShareFrac() { return trk.see_simTrkShareFrac(); }
6916   const std::vector<std::vector<int> > &pix_simHitIdx() { return trk.pix_simHitIdx(); }
6917   const std::vector<std::vector<int> > &vtx_trkIdx() { return trk.vtx_trkIdx(); }
6918   const std::vector<unsigned short> &ph2_rod() { return trk.ph2_rod(); }
6919   const std::vector<float> &vtx_ndof() { return trk.vtx_ndof(); }
6920   const std::vector<unsigned int> &see_nPixel() { return trk.see_nPixel(); }
6921   const std::vector<unsigned int> &sim_nStrip() { return trk.sim_nStrip(); }
6922   const std::vector<int> &sim_bunchCrossing() { return trk.sim_bunchCrossing(); }
6923   const std::vector<float> &see_stateCcov45() { return trk.see_stateCcov45(); }
6924   const std::vector<unsigned short> &ph2_isStack() { return trk.ph2_isStack(); }
6925   const std::vector<std::vector<float> > &sim_trkShareFrac() { return trk.sim_trkShareFrac(); }
6926   const std::vector<std::vector<float> > &trk_simTrkShareFrac() { return trk.trk_simTrkShareFrac(); }
6927   const std::vector<float> &sim_phi() { return trk.sim_phi(); }
6928   const std::vector<unsigned short> &inv_side() { return trk.inv_side(); }
6929   const std::vector<short> &vtx_fake() { return trk.vtx_fake(); }
6930   const std::vector<unsigned int> &trk_nInactive() { return trk.trk_nInactive(); }
6931   const std::vector<unsigned int> &trk_nPixelLay() { return trk.trk_nPixelLay(); }
6932   const std::vector<float> &ph2_bbxi() { return trk.ph2_bbxi(); }
6933   const std::vector<float> &vtx_xErr() { return trk.vtx_xErr(); }
6934   const std::vector<float> &see_stateCcov25() { return trk.see_stateCcov25(); }
6935   const std::vector<int> &sim_parentVtxIdx() { return trk.sim_parentVtxIdx(); }
6936   const std::vector<float> &see_stateCcov23() { return trk.see_stateCcov23(); }
6937   const std::vector<ULong64_t> &trk_algoMask() { return trk.trk_algoMask(); }
6938   const std::vector<std::vector<int> > &trk_simTrkIdx() { return trk.trk_simTrkIdx(); }
6939   const std::vector<float> &see_phiErr() { return trk.see_phiErr(); }
6940   const std::vector<float> &trk_cotTheta() { return trk.trk_cotTheta(); }
6941   const std::vector<unsigned int> &see_algo() { return trk.see_algo(); }
6942   const std::vector<unsigned short> &simhit_module() { return trk.simhit_module(); }
6943   const std::vector<std::vector<int> > &simvtx_daughterSimIdx() { return trk.simvtx_daughterSimIdx(); }
6944   const std::vector<float> &vtx_x() { return trk.vtx_x(); }
6945   const std::vector<int> &trk_seedIdx() { return trk.trk_seedIdx(); }
6946   const std::vector<float> &simhit_y() { return trk.simhit_y(); }
6947   const std::vector<unsigned short> &inv_layer() { return trk.inv_layer(); }
6948   const std::vector<unsigned int> &trk_nLostLay() { return trk.trk_nLostLay(); }
6949   const std::vector<unsigned short> &ph2_isLower() { return trk.ph2_isLower(); }
6950   const std::vector<unsigned short> &pix_side() { return trk.pix_side(); }
6951   const std::vector<unsigned short> &inv_isLower() { return trk.inv_isLower(); }
6952   const std::vector<std::vector<int> > &ph2_trkIdx() { return trk.ph2_trkIdx(); }
6953   const std::vector<unsigned int> &sim_nValid() { return trk.sim_nValid(); }
6954   const std::vector<int> &simhit_simTrkIdx() { return trk.simhit_simTrkIdx(); }
6955   const std::vector<unsigned short> &see_nCands() { return trk.see_nCands(); }
6956   const std::vector<int> &see_bestSimTrkIdx() { return trk.see_bestSimTrkIdx(); }
6957   const std::vector<float> &vtx_yErr() { return trk.vtx_yErr(); }
6958   const std::vector<float> &trk_dzPV() { return trk.trk_dzPV(); }
6959   const std::vector<float> &ph2_xy() { return trk.ph2_xy(); }
6960   const std::vector<unsigned short> &inv_module() { return trk.inv_module(); }
6961   const std::vector<float> &see_stateCcov55() { return trk.see_stateCcov55(); }
6962   const std::vector<unsigned short> &pix_panel() { return trk.pix_panel(); }
6963   const std::vector<unsigned short> &inv_ladder() { return trk.inv_ladder(); }
6964   const std::vector<float> &ph2_xx() { return trk.ph2_xx(); }
6965   const std::vector<float> &sim_pca_cotTheta() { return trk.sim_pca_cotTheta(); }
6966   const std::vector<int> &simpv_idx() { return trk.simpv_idx(); }
6967   const std::vector<float> &trk_inner_pz() { return trk.trk_inner_pz(); }
6968   const std::vector<float> &see_chi2() { return trk.see_chi2(); }
6969   const std::vector<float> &see_stateCcov35() { return trk.see_stateCcov35(); }
6970   const std::vector<float> &see_stateCcov33() { return trk.see_stateCcov33(); }
6971   const std::vector<unsigned int> &inv_detId() { return trk.inv_detId(); }
6972   const std::vector<unsigned int> &see_offset() { return trk.see_offset(); }
6973   const std::vector<unsigned int> &sim_nLay() { return trk.sim_nLay(); }
6974   const std::vector<std::vector<int> > &sim_simHitIdx() { return trk.sim_simHitIdx(); }
6975   const std::vector<unsigned short> &simhit_isUpper() { return trk.simhit_isUpper(); }
6976   const std::vector<float> &see_stateCcov00() { return trk.see_stateCcov00(); }
6977   const std::vector<unsigned short> &see_stopReason() { return trk.see_stopReason(); }
6978   const std::vector<short> &vtx_valid() { return trk.vtx_valid(); }
6979   const unsigned int &lumi() { return trk.lumi(); }
6980   const std::vector<float> &trk_refpoint_x() { return trk.trk_refpoint_x(); }
6981   const std::vector<float> &trk_refpoint_y() { return trk.trk_refpoint_y(); }
6982   const std::vector<float> &trk_refpoint_z() { return trk.trk_refpoint_z(); }
6983   const std::vector<unsigned int> &sim_n3DLay() { return trk.sim_n3DLay(); }
6984   const std::vector<unsigned int> &see_nPhase2OT() { return trk.see_nPhase2OT(); }
6985   const std::vector<float> &trk_bestFromFirstHitSimTrkShareFracSimDenom() {
6986     return trk.trk_bestFromFirstHitSimTrkShareFracSimDenom();
6987   }
6988   const std::vector<float> &ph2_yy() { return trk.ph2_yy(); }
6989   const std::vector<float> &ph2_yz() { return trk.ph2_yz(); }
6990   const std::vector<unsigned short> &inv_blade() { return trk.inv_blade(); }
6991   const std::vector<float> &trk_ptErr() { return trk.trk_ptErr(); }
6992   const std::vector<float> &pix_zx() { return trk.pix_zx(); }
6993   const std::vector<float> &simvtx_z() { return trk.simvtx_z(); }
6994   const std::vector<unsigned int> &sim_nTrackerHits() { return trk.sim_nTrackerHits(); }
6995   const std::vector<unsigned short> &ph2_subdet() { return trk.ph2_subdet(); }
6996   const std::vector<float> &see_stateTrajPx() { return trk.see_stateTrajPx(); }
6997   const std::vector<std::vector<int> > &simhit_hitIdx() { return trk.simhit_hitIdx(); }
6998   const std::vector<unsigned short> &simhit_ladder() { return trk.simhit_ladder(); }
6999   const std::vector<unsigned short> &ph2_layer() { return trk.ph2_layer(); }
7000   const std::vector<float> &see_phi() { return trk.see_phi(); }
7001   const std::vector<float> &trk_nChi2_1Dmod() { return trk.trk_nChi2_1Dmod(); }
7002   const std::vector<float> &trk_inner_py() { return trk.trk_inner_py(); }
7003   const std::vector<float> &trk_inner_px() { return trk.trk_inner_px(); }
7004   const std::vector<float> &trk_dxyErr() { return trk.trk_dxyErr(); }
7005   const std::vector<unsigned int> &sim_nPixelLay() { return trk.sim_nPixelLay(); }
7006   const std::vector<unsigned int> &see_nValid() { return trk.see_nValid(); }
7007   const std::vector<float> &trk_inner_pt() { return trk.trk_inner_pt(); }
7008   const std::vector<float> &see_stateTrajGlbPy() { return trk.see_stateTrajGlbPy(); }
7009 }  // namespace tas