cfa_base.cpp

Go to the documentation of this file.

#include "cfa_base.hpp"

#include <string>
#include <vector>
#include <sstream>
#include <stdexcept>

#include "TChain.h"

cfa_base::cfa_base(const std::string &file):
  chainA_("chainA"),
  chainB_("chainB"),
  sample_name_(file),
  total_entries_(0),
  cfa_version_(-1),
  cached_total_entries_(false),
  NbeamSpot_(0),
  b_NbeamSpot_(NULL),
  c_NbeamSpot_(false),
  Nels_(0),
  b_Nels_(NULL),
  c_Nels_(false),
  Nmc_doc_(0),
  b_Nmc_doc_(NULL),
  c_Nmc_doc_(false),
  Nmus_(0),
  b_Nmus_(NULL),
  c_Nmus_(false),
  Nphotons_(0),
  b_Nphotons_(NULL),
  c_Nphotons_(false),
  Npv_(0),
  b_Npv_(NULL),
  c_Npv_(false),
  Ntaus_(0),
  b_Ntaus_(NULL),
  c_Ntaus_(false),
  PU_NumInteractions_(0),
  b_PU_NumInteractions_(NULL),
  c_PU_NumInteractions_(false),
  PU_TrueNumInteractions_(0),
  b_PU_TrueNumInteractions_(NULL),
  c_PU_TrueNumInteractions_(false),
  PU_bunchCrossing_(0),
  b_PU_bunchCrossing_(NULL),
  c_PU_bunchCrossing_(false),
  PU_ntrks_highpT_(0),
  b_PU_ntrks_highpT_(NULL),
  c_PU_ntrks_highpT_(false),
  PU_ntrks_lowpT_(0),
  b_PU_ntrks_lowpT_(NULL),
  c_PU_ntrks_lowpT_(false),
  PU_sumpT_highpT_(0),
  b_PU_sumpT_highpT_(NULL),
  c_PU_sumpT_highpT_(false),
  PU_sumpT_lowpT_(0),
  b_PU_sumpT_lowpT_(NULL),
  c_PU_sumpT_lowpT_(false),
  PU_zpositions_(0),
  b_PU_zpositions_(NULL),
  c_PU_zpositions_(false),
  beamSpot_beamWidthX_(0),
  b_beamSpot_beamWidthX_(NULL),
  c_beamSpot_beamWidthX_(false),
  beamSpot_beamWidthXError_(0),
  b_beamSpot_beamWidthXError_(NULL),
  c_beamSpot_beamWidthXError_(false),
  beamSpot_beamWidthY_(0),
  b_beamSpot_beamWidthY_(NULL),
  c_beamSpot_beamWidthY_(false),
  beamSpot_beamWidthYError_(0),
  b_beamSpot_beamWidthYError_(NULL),
  c_beamSpot_beamWidthYError_(false),
  beamSpot_dxdz_(0),
  b_beamSpot_dxdz_(NULL),
  c_beamSpot_dxdz_(false),
  beamSpot_dxdzError_(0),
  b_beamSpot_dxdzError_(NULL),
  c_beamSpot_dxdzError_(false),
  beamSpot_dydz_(0),
  b_beamSpot_dydz_(NULL),
  c_beamSpot_dydz_(false),
  beamSpot_dydzError_(0),
  b_beamSpot_dydzError_(NULL),
  c_beamSpot_dydzError_(false),
  beamSpot_sigmaZ_(0),
  b_beamSpot_sigmaZ_(NULL),
  c_beamSpot_sigmaZ_(false),
  beamSpot_sigmaZ0Error_(0),
  b_beamSpot_sigmaZ0Error_(NULL),
  c_beamSpot_sigmaZ0Error_(false),
  beamSpot_x_(0),
  b_beamSpot_x_(NULL),
  c_beamSpot_x_(false),
  beamSpot_x0Error_(0),
  b_beamSpot_x0Error_(NULL),
  c_beamSpot_x0Error_(false),
  beamSpot_y_(0),
  b_beamSpot_y_(NULL),
  c_beamSpot_y_(false),
  beamSpot_y0Error_(0),
  b_beamSpot_y0Error_(NULL),
  c_beamSpot_y0Error_(false),
  beamSpot_z_(0),
  b_beamSpot_z_(NULL),
  c_beamSpot_z_(false),
  beamSpot_z0Error_(0),
  b_beamSpot_z0Error_(NULL),
  c_beamSpot_z0Error_(false),
  bunchCrossing_(0),
  b_bunchCrossing_(NULL),
  c_bunchCrossing_(false),
  cschalofilter_decision_(0),
  b_cschalofilter_decision_(NULL),
  c_cschalofilter_decision_(false),
  ecallaserfilter_decision_(0),
  b_ecallaserfilter_decision_(NULL),
  c_ecallaserfilter_decision_(false),
  eebadscfilter_decision_(0),
  b_eebadscfilter_decision_(NULL),
  c_eebadscfilter_decision_(false),
  els_PATpassConversionVeto_(0),
  b_els_PATpassConversionVeto_(NULL),
  c_els_PATpassConversionVeto_(false),
  els_basicClustersSize_(0),
  b_els_basicClustersSize_(NULL),
  c_els_basicClustersSize_(false),
  els_cIso_(0),
  b_els_cIso_(NULL),
  c_els_cIso_(false),
  els_caloEnergy_(0),
  b_els_caloEnergy_(NULL),
  c_els_caloEnergy_(false),
  els_charge_(0),
  b_els_charge_(NULL),
  c_els_charge_(false),
  els_chi2_(0),
  b_els_chi2_(NULL),
  c_els_chi2_(false),
  els_core_ecalDrivenSeed_(0),
  b_els_core_ecalDrivenSeed_(NULL),
  c_els_core_ecalDrivenSeed_(false),
  els_cpx_(0),
  b_els_cpx_(NULL),
  c_els_cpx_(false),
  els_cpy_(0),
  b_els_cpy_(NULL),
  c_els_cpy_(false),
  els_cpz_(0),
  b_els_cpz_(NULL),
  c_els_cpz_(false),
  els_ctf_tk_charge_(0),
  b_els_ctf_tk_charge_(NULL),
  c_els_ctf_tk_charge_(false),
  els_ctf_tk_eta_(0),
  b_els_ctf_tk_eta_(NULL),
  c_els_ctf_tk_eta_(false),
  els_ctf_tk_id_(0),
  b_els_ctf_tk_id_(NULL),
  c_els_ctf_tk_id_(false),
  els_ctf_tk_phi_(0),
  b_els_ctf_tk_phi_(NULL),
  c_els_ctf_tk_phi_(false),
  els_cx_(0),
  b_els_cx_(NULL),
  c_els_cx_(false),
  els_cy_(0),
  b_els_cy_(NULL),
  c_els_cy_(false),
  els_cz_(0),
  b_els_cz_(NULL),
  c_els_cz_(false),
  els_d0dum_(0),
  b_els_d0dum_(NULL),
  c_els_d0dum_(false),
  els_d0dumError_(0),
  b_els_d0dumError_(NULL),
  c_els_d0dumError_(false),
  els_dEtaIn_(0),
  b_els_dEtaIn_(NULL),
  c_els_dEtaIn_(false),
  els_dEtaOut_(0),
  b_els_dEtaOut_(NULL),
  c_els_dEtaOut_(false),
  els_dPhiIn_(0),
  b_els_dPhiIn_(NULL),
  c_els_dPhiIn_(false),
  els_dPhiOut_(0),
  b_els_dPhiOut_(NULL),
  c_els_dPhiOut_(false),
  els_dr03EcalRecHitSumEt_(0),
  b_els_dr03EcalRecHitSumEt_(NULL),
  c_els_dr03EcalRecHitSumEt_(false),
  els_dr03HcalDepth1TowerSumEt_(0),
  b_els_dr03HcalDepth1TowerSumEt_(NULL),
  c_els_dr03HcalDepth1TowerSumEt_(false),
  els_dr03HcalDepth2TowerSumEt_(0),
  b_els_dr03HcalDepth2TowerSumEt_(NULL),
  c_els_dr03HcalDepth2TowerSumEt_(false),
  els_dr03HcalTowerSumEt_(0),
  b_els_dr03HcalTowerSumEt_(NULL),
  c_els_dr03HcalTowerSumEt_(false),
  els_dr03TkSumPt_(0),
  b_els_dr03TkSumPt_(NULL),
  c_els_dr03TkSumPt_(false),
  els_dr04EcalRecHitSumEt_(0),
  b_els_dr04EcalRecHitSumEt_(NULL),
  c_els_dr04EcalRecHitSumEt_(false),
  els_dr04HcalDepth1TowerSumEt_(0),
  b_els_dr04HcalDepth1TowerSumEt_(NULL),
  c_els_dr04HcalDepth1TowerSumEt_(false),
  els_dr04HcalDepth2TowerSumEt_(0),
  b_els_dr04HcalDepth2TowerSumEt_(NULL),
  c_els_dr04HcalDepth2TowerSumEt_(false),
  els_dr04HcalTowerSumEt_(0),
  b_els_dr04HcalTowerSumEt_(NULL),
  c_els_dr04HcalTowerSumEt_(false),
  els_dr04TkSumPt_(0),
  b_els_dr04TkSumPt_(NULL),
  c_els_dr04TkSumPt_(false),
  els_dz_(0),
  b_els_dz_(NULL),
  c_els_dz_(false),
  els_dzError_(0),
  b_els_dzError_(NULL),
  c_els_dzError_(false),
  els_eOverPIn_(0),
  b_els_eOverPIn_(NULL),
  c_els_eOverPIn_(false),
  els_eSeedOverPOut_(0),
  b_els_eSeedOverPOut_(NULL),
  c_els_eSeedOverPOut_(false),
  els_ecalIso_(0),
  b_els_ecalIso_(NULL),
  c_els_ecalIso_(false),
  els_energy_(0),
  b_els_energy_(NULL),
  c_els_energy_(false),
  els_et_(0),
  b_els_et_(NULL),
  c_els_et_(false),
  els_eta_(0),
  b_els_eta_(NULL),
  c_els_eta_(false),
  els_etaError_(0),
  b_els_etaError_(NULL),
  c_els_etaError_(false),
  els_fbrem_(0),
  b_els_fbrem_(NULL),
  c_els_fbrem_(false),
  els_hadOverEm_(0),
  b_els_hadOverEm_(NULL),
  c_els_hadOverEm_(false),
  els_hcalIso_(0),
  b_els_hcalIso_(NULL),
  c_els_hcalIso_(false),
  els_hcalOverEcalBc_(0),
  b_els_hcalOverEcalBc_(NULL),
  c_els_hcalOverEcalBc_(false),
  els_isEB_(0),
  b_els_isEB_(NULL),
  c_els_isEB_(false),
  els_isEE_(0),
  b_els_isEE_(NULL),
  c_els_isEE_(false),
  els_looseId_(0),
  b_els_looseId_(NULL),
  c_els_looseId_(false),
  els_ndof_(0),
  b_els_ndof_(NULL),
  c_els_ndof_(false),
  els_numlosthits_(0),
  b_els_numlosthits_(NULL),
  c_els_numlosthits_(false),
  els_numvalhits_(0),
  b_els_numvalhits_(NULL),
  c_els_numvalhits_(false),
  els_phi_(0),
  b_els_phi_(NULL),
  c_els_phi_(false),
  els_phiError_(0),
  b_els_phiError_(NULL),
  c_els_phiError_(false),
  els_pt_(0),
  b_els_pt_(NULL),
  c_els_pt_(false),
  els_ptError_(0),
  b_els_ptError_(NULL),
  c_els_ptError_(false),
  els_px_(0),
  b_els_px_(NULL),
  c_els_px_(false),
  els_py_(0),
  b_els_py_(NULL),
  c_els_py_(false),
  els_pz_(0),
  b_els_pz_(NULL),
  c_els_pz_(false),
  els_robustHighEnergyId_(0),
  b_els_robustHighEnergyId_(NULL),
  c_els_robustHighEnergyId_(false),
  els_robustLooseId_(0),
  b_els_robustLooseId_(NULL),
  c_els_robustLooseId_(false),
  els_robustTightId_(0),
  b_els_robustTightId_(NULL),
  c_els_robustTightId_(false),
  els_scE1x5_(0),
  b_els_scE1x5_(NULL),
  c_els_scE1x5_(false),
  els_scE2x5Max_(0),
  b_els_scE2x5Max_(NULL),
  c_els_scE2x5Max_(false),
  els_scE5x5_(0),
  b_els_scE5x5_(NULL),
  c_els_scE5x5_(false),
  els_scEnergy_(0),
  b_els_scEnergy_(NULL),
  c_els_scEnergy_(false),
  els_scEta_(0),
  b_els_scEta_(NULL),
  c_els_scEta_(false),
  els_scEtaWidth_(0),
  b_els_scEtaWidth_(NULL),
  c_els_scEtaWidth_(false),
  els_scPhi_(0),
  b_els_scPhi_(NULL),
  c_els_scPhi_(false),
  els_scPhiWidth_(0),
  b_els_scPhiWidth_(NULL),
  c_els_scPhiWidth_(false),
  els_scRawEnergy_(0),
  b_els_scRawEnergy_(NULL),
  c_els_scRawEnergy_(false),
  els_scSeedEnergy_(0),
  b_els_scSeedEnergy_(NULL),
  c_els_scSeedEnergy_(false),
  els_shFracInnerHits_(0),
  b_els_shFracInnerHits_(NULL),
  c_els_shFracInnerHits_(false),
  els_sigmaEtaEta_(0),
  b_els_sigmaEtaEta_(NULL),
  c_els_sigmaEtaEta_(false),
  els_sigmaIEtaIEta_(0),
  b_els_sigmaIEtaIEta_(NULL),
  c_els_sigmaIEtaIEta_(false),
  els_status_(0),
  b_els_status_(NULL),
  c_els_status_(false),
  els_tIso_(0),
  b_els_tIso_(NULL),
  c_els_tIso_(false),
  els_theta_(0),
  b_els_theta_(NULL),
  c_els_theta_(false),
  els_tightId_(0),
  b_els_tightId_(NULL),
  c_els_tightId_(false),
  els_tk_charge_(0),
  b_els_tk_charge_(NULL),
  c_els_tk_charge_(false),
  els_tk_eta_(0),
  b_els_tk_eta_(NULL),
  c_els_tk_eta_(false),
  els_tk_phi_(0),
  b_els_tk_phi_(NULL),
  c_els_tk_phi_(false),
  els_tk_pt_(0),
  b_els_tk_pt_(NULL),
  c_els_tk_pt_(false),
  els_tk_pz_(0),
  b_els_tk_pz_(NULL),
  c_els_tk_pz_(false),
  els_vpx_(0),
  b_els_vpx_(NULL),
  c_els_vpx_(false),
  els_vpy_(0),
  b_els_vpy_(NULL),
  c_els_vpy_(false),
  els_vpz_(0),
  b_els_vpz_(NULL),
  c_els_vpz_(false),
  els_vx_(0),
  b_els_vx_(NULL),
  c_els_vx_(false),
  els_vy_(0),
  b_els_vy_(NULL),
  c_els_vy_(false),
  els_vz_(0),
  b_els_vz_(NULL),
  c_els_vz_(false),
  event_(0),
  b_event_(NULL),
  c_event_(false),
  experimentType_(0),
  b_experimentType_(NULL),
  c_experimentType_(false),
  genHT_(0),
  b_genHT_(NULL),
  c_genHT_(false),
  hcallaserfilter_decision_(0),
  b_hcallaserfilter_decision_(NULL),
  c_hcallaserfilter_decision_(false),
  lumiblock_(0),
  b_lumiblock_(NULL),
  c_lumiblock_(false),
  mc_doc_charge_(0),
  b_mc_doc_charge_(NULL),
  c_mc_doc_charge_(false),
  mc_doc_energy_(0),
  b_mc_doc_energy_(NULL),
  c_mc_doc_energy_(false),
  mc_doc_eta_(0),
  b_mc_doc_eta_(NULL),
  c_mc_doc_eta_(false),
  mc_doc_ggrandmother_id_(0),
  b_mc_doc_ggrandmother_id_(NULL),
  c_mc_doc_ggrandmother_id_(false),
  mc_doc_grandmother_id_(0),
  b_mc_doc_grandmother_id_(NULL),
  c_mc_doc_grandmother_id_(false),
  mc_doc_id_(0),
  b_mc_doc_id_(NULL),
  c_mc_doc_id_(false),
  mc_doc_mass_(0),
  b_mc_doc_mass_(NULL),
  c_mc_doc_mass_(false),
  mc_doc_mother_id_(0),
  b_mc_doc_mother_id_(NULL),
  c_mc_doc_mother_id_(false),
  mc_doc_numOfDaughters_(0),
  b_mc_doc_numOfDaughters_(NULL),
  c_mc_doc_numOfDaughters_(false),
  mc_doc_numOfMothers_(0),
  b_mc_doc_numOfMothers_(NULL),
  c_mc_doc_numOfMothers_(false),
  mc_doc_phi_(0),
  b_mc_doc_phi_(NULL),
  c_mc_doc_phi_(false),
  mc_doc_pt_(0),
  b_mc_doc_pt_(NULL),
  c_mc_doc_pt_(false),
  mc_doc_px_(0),
  b_mc_doc_px_(NULL),
  c_mc_doc_px_(false),
  mc_doc_py_(0),
  b_mc_doc_py_(NULL),
  c_mc_doc_py_(false),
  mc_doc_pz_(0),
  b_mc_doc_pz_(NULL),
  c_mc_doc_pz_(false),
  mc_doc_status_(0),
  b_mc_doc_status_(NULL),
  c_mc_doc_status_(false),
  mc_doc_vertex_x_(0),
  b_mc_doc_vertex_x_(NULL),
  c_mc_doc_vertex_x_(false),
  mc_doc_vertex_y_(0),
  b_mc_doc_vertex_y_(NULL),
  c_mc_doc_vertex_y_(false),
  mc_doc_vertex_z_(0),
  b_mc_doc_vertex_z_(NULL),
  c_mc_doc_vertex_z_(false),
  model_params_(0),
  b_model_params_(NULL),
  c_model_params_(false),
  mus_cIso_(0),
  b_mus_cIso_(NULL),
  c_mus_cIso_(false),
  mus_calEnergyEm_(0),
  b_mus_calEnergyEm_(NULL),
  c_mus_calEnergyEm_(false),
  mus_calEnergyEmS9_(0),
  b_mus_calEnergyEmS9_(NULL),
  c_mus_calEnergyEmS9_(false),
  mus_calEnergyHad_(0),
  b_mus_calEnergyHad_(NULL),
  c_mus_calEnergyHad_(false),
  mus_calEnergyHadS9_(0),
  b_mus_calEnergyHadS9_(NULL),
  c_mus_calEnergyHadS9_(false),
  mus_calEnergyHo_(0),
  b_mus_calEnergyHo_(NULL),
  c_mus_calEnergyHo_(false),
  mus_calEnergyHoS9_(0),
  b_mus_calEnergyHoS9_(NULL),
  c_mus_calEnergyHoS9_(false),
  mus_charge_(0),
  b_mus_charge_(NULL),
  c_mus_charge_(false),
  mus_cm_LayersWithMeasurement_(0),
  b_mus_cm_LayersWithMeasurement_(NULL),
  c_mus_cm_LayersWithMeasurement_(false),
  mus_cm_LayersWithoutMeasurement_(0),
  b_mus_cm_LayersWithoutMeasurement_(NULL),
  c_mus_cm_LayersWithoutMeasurement_(false),
  mus_cm_PixelLayersWithMeasurement_(0),
  b_mus_cm_PixelLayersWithMeasurement_(NULL),
  c_mus_cm_PixelLayersWithMeasurement_(false),
  mus_cm_ValidStripLayersWithMonoAndStereoHit_(0),
  b_mus_cm_ValidStripLayersWithMonoAndStereoHit_(NULL),
  c_mus_cm_ValidStripLayersWithMonoAndStereoHit_(false),
  mus_cm_chg_(0),
  b_mus_cm_chg_(NULL),
  c_mus_cm_chg_(false),
  mus_cm_chi2_(0),
  b_mus_cm_chi2_(NULL),
  c_mus_cm_chi2_(false),
  mus_cm_d0dum_(0),
  b_mus_cm_d0dum_(NULL),
  c_mus_cm_d0dum_(false),
  mus_cm_d0dumErr_(0),
  b_mus_cm_d0dumErr_(NULL),
  c_mus_cm_d0dumErr_(false),
  mus_cm_dz_(0),
  b_mus_cm_dz_(NULL),
  c_mus_cm_dz_(false),
  mus_cm_dzErr_(0),
  b_mus_cm_dzErr_(NULL),
  c_mus_cm_dzErr_(false),
  mus_cm_eta_(0),
  b_mus_cm_eta_(NULL),
  c_mus_cm_eta_(false),
  mus_cm_etaErr_(0),
  b_mus_cm_etaErr_(NULL),
  c_mus_cm_etaErr_(false),
  mus_cm_ndof_(0),
  b_mus_cm_ndof_(NULL),
  c_mus_cm_ndof_(false),
  mus_cm_numlosthits_(0),
  b_mus_cm_numlosthits_(NULL),
  c_mus_cm_numlosthits_(false),
  mus_cm_numvalMuonhits_(0),
  b_mus_cm_numvalMuonhits_(NULL),
  c_mus_cm_numvalMuonhits_(false),
  mus_cm_numvalhits_(0),
  b_mus_cm_numvalhits_(NULL),
  c_mus_cm_numvalhits_(false),
  mus_cm_phi_(0),
  b_mus_cm_phi_(NULL),
  c_mus_cm_phi_(false),
  mus_cm_phiErr_(0),
  b_mus_cm_phiErr_(NULL),
  c_mus_cm_phiErr_(false),
  mus_cm_pt_(0),
  b_mus_cm_pt_(NULL),
  c_mus_cm_pt_(false),
  mus_cm_ptErr_(0),
  b_mus_cm_ptErr_(NULL),
  c_mus_cm_ptErr_(false),
  mus_cm_px_(0),
  b_mus_cm_px_(NULL),
  c_mus_cm_px_(false),
  mus_cm_py_(0),
  b_mus_cm_py_(NULL),
  c_mus_cm_py_(false),
  mus_cm_pz_(0),
  b_mus_cm_pz_(NULL),
  c_mus_cm_pz_(false),
  mus_cm_theta_(0),
  b_mus_cm_theta_(NULL),
  c_mus_cm_theta_(false),
  mus_cm_vx_(0),
  b_mus_cm_vx_(NULL),
  c_mus_cm_vx_(false),
  mus_cm_vy_(0),
  b_mus_cm_vy_(NULL),
  c_mus_cm_vy_(false),
  mus_cm_vz_(0),
  b_mus_cm_vz_(NULL),
  c_mus_cm_vz_(false),
  mus_dB_(0),
  b_mus_dB_(NULL),
  c_mus_dB_(false),
  mus_ecalIso_(0),
  b_mus_ecalIso_(NULL),
  c_mus_ecalIso_(false),
  mus_ecalvetoDep_(0),
  b_mus_ecalvetoDep_(NULL),
  c_mus_ecalvetoDep_(false),
  mus_energy_(0),
  b_mus_energy_(NULL),
  c_mus_energy_(false),
  mus_et_(0),
  b_mus_et_(NULL),
  c_mus_et_(false),
  mus_eta_(0),
  b_mus_eta_(NULL),
  c_mus_eta_(false),
  mus_hcalIso_(0),
  b_mus_hcalIso_(NULL),
  c_mus_hcalIso_(false),
  mus_hcalvetoDep_(0),
  b_mus_hcalvetoDep_(NULL),
  c_mus_hcalvetoDep_(false),
  mus_id_All_(0),
  b_mus_id_All_(NULL),
  c_mus_id_All_(false),
  mus_id_AllArbitrated_(0),
  b_mus_id_AllArbitrated_(NULL),
  c_mus_id_AllArbitrated_(false),
  mus_id_AllGlobalMuons_(0),
  b_mus_id_AllGlobalMuons_(NULL),
  c_mus_id_AllGlobalMuons_(false),
  mus_id_AllStandAloneMuons_(0),
  b_mus_id_AllStandAloneMuons_(NULL),
  c_mus_id_AllStandAloneMuons_(false),
  mus_id_AllTrackerMuons_(0),
  b_mus_id_AllTrackerMuons_(NULL),
  c_mus_id_AllTrackerMuons_(false),
  mus_id_GlobalMuonPromptTight_(0),
  b_mus_id_GlobalMuonPromptTight_(NULL),
  c_mus_id_GlobalMuonPromptTight_(false),
  mus_id_TM2DCompatibilityLoose_(0),
  b_mus_id_TM2DCompatibilityLoose_(NULL),
  c_mus_id_TM2DCompatibilityLoose_(false),
  mus_id_TM2DCompatibilityTight_(0),
  b_mus_id_TM2DCompatibilityTight_(NULL),
  c_mus_id_TM2DCompatibilityTight_(false),
  mus_id_TMLastStationLoose_(0),
  b_mus_id_TMLastStationLoose_(NULL),
  c_mus_id_TMLastStationLoose_(false),
  mus_id_TMLastStationOptimizedLowPtLoose_(0),
  b_mus_id_TMLastStationOptimizedLowPtLoose_(NULL),
  c_mus_id_TMLastStationOptimizedLowPtLoose_(false),
  mus_id_TMLastStationOptimizedLowPtTight_(0),
  b_mus_id_TMLastStationOptimizedLowPtTight_(NULL),
  c_mus_id_TMLastStationOptimizedLowPtTight_(false),
  mus_id_TMLastStationTight_(0),
  b_mus_id_TMLastStationTight_(NULL),
  c_mus_id_TMLastStationTight_(false),
  mus_id_TMOneStationLoose_(0),
  b_mus_id_TMOneStationLoose_(NULL),
  c_mus_id_TMOneStationLoose_(false),
  mus_id_TMOneStationTight_(0),
  b_mus_id_TMOneStationTight_(NULL),
  c_mus_id_TMOneStationTight_(false),
  mus_id_TrackerMuonArbitrated_(0),
  b_mus_id_TrackerMuonArbitrated_(NULL),
  c_mus_id_TrackerMuonArbitrated_(false),
  mus_isGlobalMuon_(0),
  b_mus_isGlobalMuon_(NULL),
  c_mus_isGlobalMuon_(false),
  mus_isPFMuon_(0),
  b_mus_isPFMuon_(NULL),
  c_mus_isPFMuon_(false),
  mus_isStandAloneMuon_(0),
  b_mus_isStandAloneMuon_(NULL),
  c_mus_isStandAloneMuon_(false),
  mus_isTrackerMuon_(0),
  b_mus_isTrackerMuon_(NULL),
  c_mus_isTrackerMuon_(false),
  mus_iso03_emEt_(0),
  b_mus_iso03_emEt_(NULL),
  c_mus_iso03_emEt_(false),
  mus_iso03_emVetoEt_(0),
  b_mus_iso03_emVetoEt_(NULL),
  c_mus_iso03_emVetoEt_(false),
  mus_iso03_hadEt_(0),
  b_mus_iso03_hadEt_(NULL),
  c_mus_iso03_hadEt_(false),
  mus_iso03_hadVetoEt_(0),
  b_mus_iso03_hadVetoEt_(NULL),
  c_mus_iso03_hadVetoEt_(false),
  mus_iso03_hoEt_(0),
  b_mus_iso03_hoEt_(NULL),
  c_mus_iso03_hoEt_(false),
  mus_iso03_nTracks_(0),
  b_mus_iso03_nTracks_(NULL),
  c_mus_iso03_nTracks_(false),
  mus_iso03_sumPt_(0),
  b_mus_iso03_sumPt_(NULL),
  c_mus_iso03_sumPt_(false),
  mus_iso05_emEt_(0),
  b_mus_iso05_emEt_(NULL),
  c_mus_iso05_emEt_(false),
  mus_iso05_hadEt_(0),
  b_mus_iso05_hadEt_(NULL),
  c_mus_iso05_hadEt_(false),
  mus_iso05_hoEt_(0),
  b_mus_iso05_hoEt_(NULL),
  c_mus_iso05_hoEt_(false),
  mus_iso05_nTracks_(0),
  b_mus_iso05_nTracks_(NULL),
  c_mus_iso05_nTracks_(false),
  mus_iso05_sumPt_(0),
  b_mus_iso05_sumPt_(NULL),
  c_mus_iso05_sumPt_(false),
  mus_num_matches_(0),
  b_mus_num_matches_(NULL),
  c_mus_num_matches_(false),
  mus_numberOfMatchedStations_(0),
  b_mus_numberOfMatchedStations_(NULL),
  c_mus_numberOfMatchedStations_(false),
  mus_pfIsolationR03_sumChargedHadronPt_(0),
  b_mus_pfIsolationR03_sumChargedHadronPt_(NULL),
  c_mus_pfIsolationR03_sumChargedHadronPt_(false),
  mus_pfIsolationR03_sumChargedParticlePt_(0),
  b_mus_pfIsolationR03_sumChargedParticlePt_(NULL),
  c_mus_pfIsolationR03_sumChargedParticlePt_(false),
  mus_pfIsolationR03_sumNeutralHadronEt_(0),
  b_mus_pfIsolationR03_sumNeutralHadronEt_(NULL),
  c_mus_pfIsolationR03_sumNeutralHadronEt_(false),
  mus_pfIsolationR03_sumNeutralHadronEtHighThreshold_(0),
  b_mus_pfIsolationR03_sumNeutralHadronEtHighThreshold_(NULL),
  c_mus_pfIsolationR03_sumNeutralHadronEtHighThreshold_(false),
  mus_pfIsolationR03_sumPUPt_(0),
  b_mus_pfIsolationR03_sumPUPt_(NULL),
  c_mus_pfIsolationR03_sumPUPt_(false),
  mus_pfIsolationR03_sumPhotonEt_(0),
  b_mus_pfIsolationR03_sumPhotonEt_(NULL),
  c_mus_pfIsolationR03_sumPhotonEt_(false),
  mus_pfIsolationR03_sumPhotonEtHighThreshold_(0),
  b_mus_pfIsolationR03_sumPhotonEtHighThreshold_(NULL),
  c_mus_pfIsolationR03_sumPhotonEtHighThreshold_(false),
  mus_pfIsolationR04_sumChargedHadronPt_(0),
  b_mus_pfIsolationR04_sumChargedHadronPt_(NULL),
  c_mus_pfIsolationR04_sumChargedHadronPt_(false),
  mus_pfIsolationR04_sumChargedParticlePt_(0),
  b_mus_pfIsolationR04_sumChargedParticlePt_(NULL),
  c_mus_pfIsolationR04_sumChargedParticlePt_(false),
  mus_pfIsolationR04_sumNeutralHadronEt_(0),
  b_mus_pfIsolationR04_sumNeutralHadronEt_(NULL),
  c_mus_pfIsolationR04_sumNeutralHadronEt_(false),
  mus_pfIsolationR04_sumNeutralHadronEtHighThreshold_(0),
  b_mus_pfIsolationR04_sumNeutralHadronEtHighThreshold_(NULL),
  c_mus_pfIsolationR04_sumNeutralHadronEtHighThreshold_(false),
  mus_pfIsolationR04_sumPUPt_(0),
  b_mus_pfIsolationR04_sumPUPt_(NULL),
  c_mus_pfIsolationR04_sumPUPt_(false),
  mus_pfIsolationR04_sumPhotonEt_(0),
  b_mus_pfIsolationR04_sumPhotonEt_(NULL),
  c_mus_pfIsolationR04_sumPhotonEt_(false),
  mus_pfIsolationR04_sumPhotonEtHighThreshold_(0),
  b_mus_pfIsolationR04_sumPhotonEtHighThreshold_(NULL),
  c_mus_pfIsolationR04_sumPhotonEtHighThreshold_(false),
  mus_phi_(0),
  b_mus_phi_(NULL),
  c_mus_phi_(false),
  mus_pt_(0),
  b_mus_pt_(NULL),
  c_mus_pt_(false),
  mus_px_(0),
  b_mus_px_(NULL),
  c_mus_px_(false),
  mus_py_(0),
  b_mus_py_(NULL),
  c_mus_py_(false),
  mus_pz_(0),
  b_mus_pz_(NULL),
  c_mus_pz_(false),
  mus_stamu_chg_(0),
  b_mus_stamu_chg_(NULL),
  c_mus_stamu_chg_(false),
  mus_stamu_chi2_(0),
  b_mus_stamu_chi2_(NULL),
  c_mus_stamu_chi2_(false),
  mus_stamu_d0dum_(0),
  b_mus_stamu_d0dum_(NULL),
  c_mus_stamu_d0dum_(false),
  mus_stamu_d0dumErr_(0),
  b_mus_stamu_d0dumErr_(NULL),
  c_mus_stamu_d0dumErr_(false),
  mus_stamu_dz_(0),
  b_mus_stamu_dz_(NULL),
  c_mus_stamu_dz_(false),
  mus_stamu_dzErr_(0),
  b_mus_stamu_dzErr_(NULL),
  c_mus_stamu_dzErr_(false),
  mus_stamu_eta_(0),
  b_mus_stamu_eta_(NULL),
  c_mus_stamu_eta_(false),
  mus_stamu_etaErr_(0),
  b_mus_stamu_etaErr_(NULL),
  c_mus_stamu_etaErr_(false),
  mus_stamu_ndof_(0),
  b_mus_stamu_ndof_(NULL),
  c_mus_stamu_ndof_(false),
  mus_stamu_numlosthits_(0),
  b_mus_stamu_numlosthits_(NULL),
  c_mus_stamu_numlosthits_(false),
  mus_stamu_numvalhits_(0),
  b_mus_stamu_numvalhits_(NULL),
  c_mus_stamu_numvalhits_(false),
  mus_stamu_phi_(0),
  b_mus_stamu_phi_(NULL),
  c_mus_stamu_phi_(false),
  mus_stamu_phiErr_(0),
  b_mus_stamu_phiErr_(NULL),
  c_mus_stamu_phiErr_(false),
  mus_stamu_pt_(0),
  b_mus_stamu_pt_(NULL),
  c_mus_stamu_pt_(false),
  mus_stamu_ptErr_(0),
  b_mus_stamu_ptErr_(NULL),
  c_mus_stamu_ptErr_(false),
  mus_stamu_px_(0),
  b_mus_stamu_px_(NULL),
  c_mus_stamu_px_(false),
  mus_stamu_py_(0),
  b_mus_stamu_py_(NULL),
  c_mus_stamu_py_(false),
  mus_stamu_pz_(0),
  b_mus_stamu_pz_(NULL),
  c_mus_stamu_pz_(false),
  mus_stamu_theta_(0),
  b_mus_stamu_theta_(NULL),
  c_mus_stamu_theta_(false),
  mus_stamu_vx_(0),
  b_mus_stamu_vx_(NULL),
  c_mus_stamu_vx_(false),
  mus_stamu_vy_(0),
  b_mus_stamu_vy_(NULL),
  c_mus_stamu_vy_(false),
  mus_stamu_vz_(0),
  b_mus_stamu_vz_(NULL),
  c_mus_stamu_vz_(false),
  mus_status_(0),
  b_mus_status_(NULL),
  c_mus_status_(false),
  mus_tIso_(0),
  b_mus_tIso_(NULL),
  c_mus_tIso_(false),
  mus_theta_(0),
  b_mus_theta_(NULL),
  c_mus_theta_(false),
  mus_tkHits_(0),
  b_mus_tkHits_(NULL),
  c_mus_tkHits_(false),
  mus_tk_LayersWithMeasurement_(0),
  b_mus_tk_LayersWithMeasurement_(NULL),
  c_mus_tk_LayersWithMeasurement_(false),
  mus_tk_LayersWithoutMeasurement_(0),
  b_mus_tk_LayersWithoutMeasurement_(NULL),
  c_mus_tk_LayersWithoutMeasurement_(false),
  mus_tk_PixelLayersWithMeasurement_(0),
  b_mus_tk_PixelLayersWithMeasurement_(NULL),
  c_mus_tk_PixelLayersWithMeasurement_(false),
  mus_tk_ValidStripLayersWithMonoAndStereoHit_(0),
  b_mus_tk_ValidStripLayersWithMonoAndStereoHit_(NULL),
  c_mus_tk_ValidStripLayersWithMonoAndStereoHit_(false),
  mus_tk_chg_(0),
  b_mus_tk_chg_(NULL),
  c_mus_tk_chg_(false),
  mus_tk_chi2_(0),
  b_mus_tk_chi2_(NULL),
  c_mus_tk_chi2_(false),
  mus_tk_d0dum_(0),
  b_mus_tk_d0dum_(NULL),
  c_mus_tk_d0dum_(false),
  mus_tk_d0dumErr_(0),
  b_mus_tk_d0dumErr_(NULL),
  c_mus_tk_d0dumErr_(false),
  mus_tk_dz_(0),
  b_mus_tk_dz_(NULL),
  c_mus_tk_dz_(false),
  mus_tk_dzErr_(0),
  b_mus_tk_dzErr_(NULL),
  c_mus_tk_dzErr_(false),
  mus_tk_eta_(0),
  b_mus_tk_eta_(NULL),
  c_mus_tk_eta_(false),
  mus_tk_etaErr_(0),
  b_mus_tk_etaErr_(NULL),
  c_mus_tk_etaErr_(false),
  mus_tk_id_(0),
  b_mus_tk_id_(NULL),
  c_mus_tk_id_(false),
  mus_tk_ndof_(0),
  b_mus_tk_ndof_(NULL),
  c_mus_tk_ndof_(false),
  mus_tk_numlosthits_(0),
  b_mus_tk_numlosthits_(NULL),
  c_mus_tk_numlosthits_(false),
  mus_tk_numpixelWthMeasr_(0),
  b_mus_tk_numpixelWthMeasr_(NULL),
  c_mus_tk_numpixelWthMeasr_(false),
  mus_tk_numvalPixelhits_(0),
  b_mus_tk_numvalPixelhits_(NULL),
  c_mus_tk_numvalPixelhits_(false),
  mus_tk_numvalhits_(0),
  b_mus_tk_numvalhits_(NULL),
  c_mus_tk_numvalhits_(false),
  mus_tk_phi_(0),
  b_mus_tk_phi_(NULL),
  c_mus_tk_phi_(false),
  mus_tk_phiErr_(0),
  b_mus_tk_phiErr_(NULL),
  c_mus_tk_phiErr_(false),
  mus_tk_pt_(0),
  b_mus_tk_pt_(NULL),
  c_mus_tk_pt_(false),
  mus_tk_ptErr_(0),
  b_mus_tk_ptErr_(NULL),
  c_mus_tk_ptErr_(false),
  mus_tk_px_(0),
  b_mus_tk_px_(NULL),
  c_mus_tk_px_(false),
  mus_tk_py_(0),
  b_mus_tk_py_(NULL),
  c_mus_tk_py_(false),
  mus_tk_pz_(0),
  b_mus_tk_pz_(NULL),
  c_mus_tk_pz_(false),
  mus_tk_theta_(0),
  b_mus_tk_theta_(NULL),
  c_mus_tk_theta_(false),
  mus_tk_vx_(0),
  b_mus_tk_vx_(NULL),
  c_mus_tk_vx_(false),
  mus_tk_vy_(0),
  b_mus_tk_vy_(NULL),
  c_mus_tk_vy_(false),
  mus_tk_vz_(0),
  b_mus_tk_vz_(NULL),
  c_mus_tk_vz_(false),
  orbitNumber_(0),
  b_orbitNumber_(NULL),
  c_orbitNumber_(false),
  photons_e1x5_(0),
  b_photons_e1x5_(NULL),
  c_photons_e1x5_(false),
  photons_e2x5_(0),
  b_photons_e2x5_(NULL),
  c_photons_e2x5_(false),
  photons_e3x3_(0),
  b_photons_e3x3_(NULL),
  c_photons_e3x3_(false),
  photons_e5x5_(0),
  b_photons_e5x5_(NULL),
  c_photons_e5x5_(false),
  photons_ecalIso_(0),
  b_photons_ecalIso_(NULL),
  c_photons_ecalIso_(false),
  photons_energy_(0),
  b_photons_energy_(NULL),
  c_photons_energy_(false),
  photons_et_(0),
  b_photons_et_(NULL),
  c_photons_et_(false),
  photons_eta_(0),
  b_photons_eta_(NULL),
  c_photons_eta_(false),
  photons_hadOverEM_(0),
  b_photons_hadOverEM_(NULL),
  c_photons_hadOverEM_(false),
  photons_hadTowOverEM_(0),
  b_photons_hadTowOverEM_(NULL),
  c_photons_hadTowOverEM_(false),
  photons_hasPixelSeed_(0),
  b_photons_hasPixelSeed_(NULL),
  c_photons_hasPixelSeed_(false),
  photons_hcalIso_(0),
  b_photons_hcalIso_(NULL),
  c_photons_hcalIso_(false),
  photons_isEBEEGap_(0),
  b_photons_isEBEEGap_(NULL),
  c_photons_isEBEEGap_(false),
  photons_isEBGap_(0),
  b_photons_isEBGap_(NULL),
  c_photons_isEBGap_(false),
  photons_isEBPho_(0),
  b_photons_isEBPho_(NULL),
  c_photons_isEBPho_(false),
  photons_isEEGap_(0),
  b_photons_isEEGap_(NULL),
  c_photons_isEEGap_(false),
  photons_isEEPho_(0),
  b_photons_isEEPho_(NULL),
  c_photons_isEEPho_(false),
  photons_isLoosePhoton_(0),
  b_photons_isLoosePhoton_(NULL),
  c_photons_isLoosePhoton_(false),
  photons_isTightPhoton_(0),
  b_photons_isTightPhoton_(NULL),
  c_photons_isTightPhoton_(false),
  photons_isoEcalRecHitDR03_(0),
  b_photons_isoEcalRecHitDR03_(NULL),
  c_photons_isoEcalRecHitDR03_(false),
  photons_isoEcalRecHitDR04_(0),
  b_photons_isoEcalRecHitDR04_(NULL),
  c_photons_isoEcalRecHitDR04_(false),
  photons_isoHcalRecHitDR03_(0),
  b_photons_isoHcalRecHitDR03_(NULL),
  c_photons_isoHcalRecHitDR03_(false),
  photons_isoHcalRecHitDR04_(0),
  b_photons_isoHcalRecHitDR04_(NULL),
  c_photons_isoHcalRecHitDR04_(false),
  photons_isoHollowTrkConeDR03_(0),
  b_photons_isoHollowTrkConeDR03_(NULL),
  c_photons_isoHollowTrkConeDR03_(false),
  photons_isoHollowTrkConeDR04_(0),
  b_photons_isoHollowTrkConeDR04_(NULL),
  c_photons_isoHollowTrkConeDR04_(false),
  photons_isoSolidTrkConeDR03_(0),
  b_photons_isoSolidTrkConeDR03_(NULL),
  c_photons_isoSolidTrkConeDR03_(false),
  photons_isoSolidTrkConeDR04_(0),
  b_photons_isoSolidTrkConeDR04_(NULL),
  c_photons_isoSolidTrkConeDR04_(false),
  photons_maxEnergyXtal_(0),
  b_photons_maxEnergyXtal_(NULL),
  c_photons_maxEnergyXtal_(false),
  photons_nTrkHollowConeDR03_(0),
  b_photons_nTrkHollowConeDR03_(NULL),
  c_photons_nTrkHollowConeDR03_(false),
  photons_nTrkHollowConeDR04_(0),
  b_photons_nTrkHollowConeDR04_(NULL),
  c_photons_nTrkHollowConeDR04_(false),
  photons_nTrkSolidConeDR03_(0),
  b_photons_nTrkSolidConeDR03_(NULL),
  c_photons_nTrkSolidConeDR03_(false),
  photons_nTrkSolidConeDR04_(0),
  b_photons_nTrkSolidConeDR04_(NULL),
  c_photons_nTrkSolidConeDR04_(false),
  photons_phi_(0),
  b_photons_phi_(NULL),
  c_photons_phi_(false),
  photons_pt_(0),
  b_photons_pt_(NULL),
  c_photons_pt_(false),
  photons_px_(0),
  b_photons_px_(NULL),
  c_photons_px_(false),
  photons_py_(0),
  b_photons_py_(NULL),
  c_photons_py_(false),
  photons_pz_(0),
  b_photons_pz_(NULL),
  c_photons_pz_(false),
  photons_r9_(0),
  b_photons_r9_(NULL),
  c_photons_r9_(false),
  photons_scEnergy_(0),
  b_photons_scEnergy_(NULL),
  c_photons_scEnergy_(false),
  photons_scEta_(0),
  b_photons_scEta_(NULL),
  c_photons_scEta_(false),
  photons_scEtaWidth_(0),
  b_photons_scEtaWidth_(NULL),
  c_photons_scEtaWidth_(false),
  photons_scPhi_(0),
  b_photons_scPhi_(NULL),
  c_photons_scPhi_(false),
  photons_scPhiWidth_(0),
  b_photons_scPhiWidth_(NULL),
  c_photons_scPhiWidth_(false),
  photons_scRawEnergy_(0),
  b_photons_scRawEnergy_(NULL),
  c_photons_scRawEnergy_(false),
  photons_sigmaEtaEta_(0),
  b_photons_sigmaEtaEta_(NULL),
  c_photons_sigmaEtaEta_(false),
  photons_sigmaIetaIeta_(0),
  b_photons_sigmaIetaIeta_(NULL),
  c_photons_sigmaIetaIeta_(false),
  photons_status_(0),
  b_photons_status_(NULL),
  c_photons_status_(false),
  photons_tIso_(0),
  b_photons_tIso_(NULL),
  c_photons_tIso_(false),
  photons_theta_(0),
  b_photons_theta_(NULL),
  c_photons_theta_(false),
  pv_chi2_(0),
  b_pv_chi2_(NULL),
  c_pv_chi2_(false),
  pv_isFake_(0),
  b_pv_isFake_(NULL),
  c_pv_isFake_(false),
  pv_isValid_(0),
  b_pv_isValid_(NULL),
  c_pv_isValid_(false),
  pv_ndof_(0),
  b_pv_ndof_(NULL),
  c_pv_ndof_(false),
  pv_x_(0),
  b_pv_x_(NULL),
  c_pv_x_(false),
  pv_xErr_(0),
  b_pv_xErr_(NULL),
  c_pv_xErr_(false),
  pv_y_(0),
  b_pv_y_(NULL),
  c_pv_y_(false),
  pv_yErr_(0),
  b_pv_yErr_(NULL),
  c_pv_yErr_(false),
  pv_z_(0),
  b_pv_z_(NULL),
  c_pv_z_(false),
  pv_zErr_(0),
  b_pv_zErr_(NULL),
  c_pv_zErr_(false),
  run_(0),
  b_run_(NULL),
  c_run_(false),
  standalone_triggerobject_collectionname_(0),
  b_standalone_triggerobject_collectionname_(NULL),
  c_standalone_triggerobject_collectionname_(false),
  standalone_triggerobject_energy_(0),
  b_standalone_triggerobject_energy_(NULL),
  c_standalone_triggerobject_energy_(false),
  standalone_triggerobject_et_(0),
  b_standalone_triggerobject_et_(NULL),
  c_standalone_triggerobject_et_(false),
  standalone_triggerobject_eta_(0),
  b_standalone_triggerobject_eta_(NULL),
  c_standalone_triggerobject_eta_(false),
  standalone_triggerobject_phi_(0),
  b_standalone_triggerobject_phi_(NULL),
  c_standalone_triggerobject_phi_(false),
  standalone_triggerobject_pt_(0),
  b_standalone_triggerobject_pt_(NULL),
  c_standalone_triggerobject_pt_(false),
  standalone_triggerobject_px_(0),
  b_standalone_triggerobject_px_(NULL),
  c_standalone_triggerobject_px_(false),
  standalone_triggerobject_py_(0),
  b_standalone_triggerobject_py_(NULL),
  c_standalone_triggerobject_py_(false),
  standalone_triggerobject_pz_(0),
  b_standalone_triggerobject_pz_(NULL),
  c_standalone_triggerobject_pz_(false),
  taus_charge_(0),
  b_taus_charge_(NULL),
  c_taus_charge_(false),
  taus_energy_(0),
  b_taus_energy_(NULL),
  c_taus_energy_(false),
  taus_et_(0),
  b_taus_et_(NULL),
  c_taus_et_(false),
  taus_eta_(0),
  b_taus_eta_(NULL),
  c_taus_eta_(false),
  taus_phi_(0),
  b_taus_phi_(NULL),
  c_taus_phi_(false),
  taus_pt_(0),
  b_taus_pt_(NULL),
  c_taus_pt_(false),
  taus_px_(0),
  b_taus_px_(NULL),
  c_taus_px_(false),
  taus_py_(0),
  b_taus_py_(NULL),
  c_taus_py_(false),
  taus_pz_(0),
  b_taus_pz_(NULL),
  c_taus_pz_(false),
  taus_status_(0),
  b_taus_status_(NULL),
  c_taus_status_(false),
  taus_theta_(0),
  b_taus_theta_(NULL),
  c_taus_theta_(false),
  trackingfailurefilter_decision_(0),
  b_trackingfailurefilter_decision_(NULL),
  c_trackingfailurefilter_decision_(false),
  trigger_name_(0),
  b_trigger_name_(NULL),
  c_trigger_name_(false),
  trigger_prescalevalue_(0),
  b_trigger_prescalevalue_(NULL),
  c_trigger_prescalevalue_(false),
  weight_(0),
  b_weight_(NULL),
  c_weight_(false){
  CalcVersion();
  AddFiles(file);
  PrepareNewChains();
}

long cfa_base::TotalEntries() const{
  if(!cached_total_entries_){
    const long nEntriesA(chainA_.GetEntries()), nEntriesB(chainB_.GetEntries());
    if (nEntriesA!=nEntriesB){
      total_entries_=-1;
    }else{
      total_entries_=nEntriesA;
    }
    cached_total_entries_=true;
  }
  return total_entries_;
}

void cfa_base::GetEntry(const long entry){
  c_NbeamSpot_ = false;
  c_Nels_ = false;
  c_Nmc_doc_ = false;
  c_Nmus_ = false;
  c_Nphotons_ = false;
  c_Npv_ = false;
  c_Ntaus_ = false;
  c_PU_NumInteractions_ = false;
  c_PU_TrueNumInteractions_ = false;
  c_PU_bunchCrossing_ = false;
  c_PU_ntrks_highpT_ = false;
  c_PU_ntrks_lowpT_ = false;
  c_PU_sumpT_highpT_ = false;
  c_PU_sumpT_lowpT_ = false;
  c_PU_zpositions_ = false;
  c_beamSpot_beamWidthX_ = false;
  c_beamSpot_beamWidthXError_ = false;
  c_beamSpot_beamWidthY_ = false;
  c_beamSpot_beamWidthYError_ = false;
  c_beamSpot_dxdz_ = false;
  c_beamSpot_dxdzError_ = false;
  c_beamSpot_dydz_ = false;
  c_beamSpot_dydzError_ = false;
  c_beamSpot_sigmaZ_ = false;
  c_beamSpot_sigmaZ0Error_ = false;
  c_beamSpot_x_ = false;
  c_beamSpot_x0Error_ = false;
  c_beamSpot_y_ = false;
  c_beamSpot_y0Error_ = false;
  c_beamSpot_z_ = false;
  c_beamSpot_z0Error_ = false;
  c_bunchCrossing_ = false;
  c_cschalofilter_decision_ = false;
  c_ecallaserfilter_decision_ = false;
  c_eebadscfilter_decision_ = false;
  c_els_PATpassConversionVeto_ = false;
  c_els_basicClustersSize_ = false;
  c_els_cIso_ = false;
  c_els_caloEnergy_ = false;
  c_els_charge_ = false;
  c_els_chi2_ = false;
  c_els_core_ecalDrivenSeed_ = false;
  c_els_cpx_ = false;
  c_els_cpy_ = false;
  c_els_cpz_ = false;
  c_els_ctf_tk_charge_ = false;
  c_els_ctf_tk_eta_ = false;
  c_els_ctf_tk_id_ = false;
  c_els_ctf_tk_phi_ = false;
  c_els_cx_ = false;
  c_els_cy_ = false;
  c_els_cz_ = false;
  c_els_d0dum_ = false;
  c_els_d0dumError_ = false;
  c_els_dEtaIn_ = false;
  c_els_dEtaOut_ = false;
  c_els_dPhiIn_ = false;
  c_els_dPhiOut_ = false;
  c_els_dr03EcalRecHitSumEt_ = false;
  c_els_dr03HcalDepth1TowerSumEt_ = false;
  c_els_dr03HcalDepth2TowerSumEt_ = false;
  c_els_dr03HcalTowerSumEt_ = false;
  c_els_dr03TkSumPt_ = false;
  c_els_dr04EcalRecHitSumEt_ = false;
  c_els_dr04HcalDepth1TowerSumEt_ = false;
  c_els_dr04HcalDepth2TowerSumEt_ = false;
  c_els_dr04HcalTowerSumEt_ = false;
  c_els_dr04TkSumPt_ = false;
  c_els_dz_ = false;
  c_els_dzError_ = false;
  c_els_eOverPIn_ = false;
  c_els_eSeedOverPOut_ = false;
  c_els_ecalIso_ = false;
  c_els_energy_ = false;
  c_els_et_ = false;
  c_els_eta_ = false;
  c_els_etaError_ = false;
  c_els_fbrem_ = false;
  c_els_hadOverEm_ = false;
  c_els_hcalIso_ = false;
  c_els_hcalOverEcalBc_ = false;
  c_els_isEB_ = false;
  c_els_isEE_ = false;
  c_els_looseId_ = false;
  c_els_ndof_ = false;
  c_els_numlosthits_ = false;
  c_els_numvalhits_ = false;
  c_els_phi_ = false;
  c_els_phiError_ = false;
  c_els_pt_ = false;
  c_els_ptError_ = false;
  c_els_px_ = false;
  c_els_py_ = false;
  c_els_pz_ = false;
  c_els_robustHighEnergyId_ = false;
  c_els_robustLooseId_ = false;
  c_els_robustTightId_ = false;
  c_els_scE1x5_ = false;
  c_els_scE2x5Max_ = false;
  c_els_scE5x5_ = false;
  c_els_scEnergy_ = false;
  c_els_scEta_ = false;
  c_els_scEtaWidth_ = false;
  c_els_scPhi_ = false;
  c_els_scPhiWidth_ = false;
  c_els_scRawEnergy_ = false;
  c_els_scSeedEnergy_ = false;
  c_els_shFracInnerHits_ = false;
  c_els_sigmaEtaEta_ = false;
  c_els_sigmaIEtaIEta_ = false;
  c_els_status_ = false;
  c_els_tIso_ = false;
  c_els_theta_ = false;
  c_els_tightId_ = false;
  c_els_tk_charge_ = false;
  c_els_tk_eta_ = false;
  c_els_tk_phi_ = false;
  c_els_tk_pt_ = false;
  c_els_tk_pz_ = false;
  c_els_vpx_ = false;
  c_els_vpy_ = false;
  c_els_vpz_ = false;
  c_els_vx_ = false;
  c_els_vy_ = false;
  c_els_vz_ = false;
  c_event_ = false;
  c_experimentType_ = false;
  c_genHT_ = false;
  c_hcallaserfilter_decision_ = false;
  c_lumiblock_ = false;
  c_mc_doc_charge_ = false;
  c_mc_doc_energy_ = false;
  c_mc_doc_eta_ = false;
  c_mc_doc_ggrandmother_id_ = false;
  c_mc_doc_grandmother_id_ = false;
  c_mc_doc_id_ = false;
  c_mc_doc_mass_ = false;
  c_mc_doc_mother_id_ = false;
  c_mc_doc_numOfDaughters_ = false;
  c_mc_doc_numOfMothers_ = false;
  c_mc_doc_phi_ = false;
  c_mc_doc_pt_ = false;
  c_mc_doc_px_ = false;
  c_mc_doc_py_ = false;
  c_mc_doc_pz_ = false;
  c_mc_doc_status_ = false;
  c_mc_doc_vertex_x_ = false;
  c_mc_doc_vertex_y_ = false;
  c_mc_doc_vertex_z_ = false;
  c_model_params_ = false;
  c_mus_cIso_ = false;
  c_mus_calEnergyEm_ = false;
  c_mus_calEnergyEmS9_ = false;
  c_mus_calEnergyHad_ = false;
  c_mus_calEnergyHadS9_ = false;
  c_mus_calEnergyHo_ = false;
  c_mus_calEnergyHoS9_ = false;
  c_mus_charge_ = false;
  c_mus_cm_LayersWithMeasurement_ = false;
  c_mus_cm_LayersWithoutMeasurement_ = false;
  c_mus_cm_PixelLayersWithMeasurement_ = false;
  c_mus_cm_ValidStripLayersWithMonoAndStereoHit_ = false;
  c_mus_cm_chg_ = false;
  c_mus_cm_chi2_ = false;
  c_mus_cm_d0dum_ = false;
  c_mus_cm_d0dumErr_ = false;
  c_mus_cm_dz_ = false;
  c_mus_cm_dzErr_ = false;
  c_mus_cm_eta_ = false;
  c_mus_cm_etaErr_ = false;
  c_mus_cm_ndof_ = false;
  c_mus_cm_numlosthits_ = false;
  c_mus_cm_numvalMuonhits_ = false;
  c_mus_cm_numvalhits_ = false;
  c_mus_cm_phi_ = false;
  c_mus_cm_phiErr_ = false;
  c_mus_cm_pt_ = false;
  c_mus_cm_ptErr_ = false;
  c_mus_cm_px_ = false;
  c_mus_cm_py_ = false;
  c_mus_cm_pz_ = false;
  c_mus_cm_theta_ = false;
  c_mus_cm_vx_ = false;
  c_mus_cm_vy_ = false;
  c_mus_cm_vz_ = false;
  c_mus_dB_ = false;
  c_mus_ecalIso_ = false;
  c_mus_ecalvetoDep_ = false;
  c_mus_energy_ = false;
  c_mus_et_ = false;
  c_mus_eta_ = false;
  c_mus_hcalIso_ = false;
  c_mus_hcalvetoDep_ = false;
  c_mus_id_All_ = false;
  c_mus_id_AllArbitrated_ = false;
  c_mus_id_AllGlobalMuons_ = false;
  c_mus_id_AllStandAloneMuons_ = false;
  c_mus_id_AllTrackerMuons_ = false;
  c_mus_id_GlobalMuonPromptTight_ = false;
  c_mus_id_TM2DCompatibilityLoose_ = false;
  c_mus_id_TM2DCompatibilityTight_ = false;
  c_mus_id_TMLastStationLoose_ = false;
  c_mus_id_TMLastStationOptimizedLowPtLoose_ = false;
  c_mus_id_TMLastStationOptimizedLowPtTight_ = false;
  c_mus_id_TMLastStationTight_ = false;
  c_mus_id_TMOneStationLoose_ = false;
  c_mus_id_TMOneStationTight_ = false;
  c_mus_id_TrackerMuonArbitrated_ = false;
  c_mus_isGlobalMuon_ = false;
  c_mus_isPFMuon_ = false;
  c_mus_isStandAloneMuon_ = false;
  c_mus_isTrackerMuon_ = false;
  c_mus_iso03_emEt_ = false;
  c_mus_iso03_emVetoEt_ = false;
  c_mus_iso03_hadEt_ = false;
  c_mus_iso03_hadVetoEt_ = false;
  c_mus_iso03_hoEt_ = false;
  c_mus_iso03_nTracks_ = false;
  c_mus_iso03_sumPt_ = false;
  c_mus_iso05_emEt_ = false;
  c_mus_iso05_hadEt_ = false;
  c_mus_iso05_hoEt_ = false;
  c_mus_iso05_nTracks_ = false;
  c_mus_iso05_sumPt_ = false;
  c_mus_num_matches_ = false;
  c_mus_numberOfMatchedStations_ = false;
  c_mus_pfIsolationR03_sumChargedHadronPt_ = false;
  c_mus_pfIsolationR03_sumChargedParticlePt_ = false;
  c_mus_pfIsolationR03_sumNeutralHadronEt_ = false;
  c_mus_pfIsolationR03_sumNeutralHadronEtHighThreshold_ = false;
  c_mus_pfIsolationR03_sumPUPt_ = false;
  c_mus_pfIsolationR03_sumPhotonEt_ = false;
  c_mus_pfIsolationR03_sumPhotonEtHighThreshold_ = false;
  c_mus_pfIsolationR04_sumChargedHadronPt_ = false;
  c_mus_pfIsolationR04_sumChargedParticlePt_ = false;
  c_mus_pfIsolationR04_sumNeutralHadronEt_ = false;
  c_mus_pfIsolationR04_sumNeutralHadronEtHighThreshold_ = false;
  c_mus_pfIsolationR04_sumPUPt_ = false;
  c_mus_pfIsolationR04_sumPhotonEt_ = false;
  c_mus_pfIsolationR04_sumPhotonEtHighThreshold_ = false;
  c_mus_phi_ = false;
  c_mus_pt_ = false;
  c_mus_px_ = false;
  c_mus_py_ = false;
  c_mus_pz_ = false;
  c_mus_stamu_chg_ = false;
  c_mus_stamu_chi2_ = false;
  c_mus_stamu_d0dum_ = false;
  c_mus_stamu_d0dumErr_ = false;
  c_mus_stamu_dz_ = false;
  c_mus_stamu_dzErr_ = false;
  c_mus_stamu_eta_ = false;
  c_mus_stamu_etaErr_ = false;
  c_mus_stamu_ndof_ = false;
  c_mus_stamu_numlosthits_ = false;
  c_mus_stamu_numvalhits_ = false;
  c_mus_stamu_phi_ = false;
  c_mus_stamu_phiErr_ = false;
  c_mus_stamu_pt_ = false;
  c_mus_stamu_ptErr_ = false;
  c_mus_stamu_px_ = false;
  c_mus_stamu_py_ = false;
  c_mus_stamu_pz_ = false;
  c_mus_stamu_theta_ = false;
  c_mus_stamu_vx_ = false;
  c_mus_stamu_vy_ = false;
  c_mus_stamu_vz_ = false;
  c_mus_status_ = false;
  c_mus_tIso_ = false;
  c_mus_theta_ = false;
  c_mus_tkHits_ = false;
  c_mus_tk_LayersWithMeasurement_ = false;
  c_mus_tk_LayersWithoutMeasurement_ = false;
  c_mus_tk_PixelLayersWithMeasurement_ = false;
  c_mus_tk_ValidStripLayersWithMonoAndStereoHit_ = false;
  c_mus_tk_chg_ = false;
  c_mus_tk_chi2_ = false;
  c_mus_tk_d0dum_ = false;
  c_mus_tk_d0dumErr_ = false;
  c_mus_tk_dz_ = false;
  c_mus_tk_dzErr_ = false;
  c_mus_tk_eta_ = false;
  c_mus_tk_etaErr_ = false;
  c_mus_tk_id_ = false;
  c_mus_tk_ndof_ = false;
  c_mus_tk_numlosthits_ = false;
  c_mus_tk_numpixelWthMeasr_ = false;
  c_mus_tk_numvalPixelhits_ = false;
  c_mus_tk_numvalhits_ = false;
  c_mus_tk_phi_ = false;
  c_mus_tk_phiErr_ = false;
  c_mus_tk_pt_ = false;
  c_mus_tk_ptErr_ = false;
  c_mus_tk_px_ = false;
  c_mus_tk_py_ = false;
  c_mus_tk_pz_ = false;
  c_mus_tk_theta_ = false;
  c_mus_tk_vx_ = false;
  c_mus_tk_vy_ = false;
  c_mus_tk_vz_ = false;
  c_orbitNumber_ = false;
  c_photons_e1x5_ = false;
  c_photons_e2x5_ = false;
  c_photons_e3x3_ = false;
  c_photons_e5x5_ = false;
  c_photons_ecalIso_ = false;
  c_photons_energy_ = false;
  c_photons_et_ = false;
  c_photons_eta_ = false;
  c_photons_hadOverEM_ = false;
  c_photons_hadTowOverEM_ = false;
  c_photons_hasPixelSeed_ = false;
  c_photons_hcalIso_ = false;
  c_photons_isEBEEGap_ = false;
  c_photons_isEBGap_ = false;
  c_photons_isEBPho_ = false;
  c_photons_isEEGap_ = false;
  c_photons_isEEPho_ = false;
  c_photons_isLoosePhoton_ = false;
  c_photons_isTightPhoton_ = false;
  c_photons_isoEcalRecHitDR03_ = false;
  c_photons_isoEcalRecHitDR04_ = false;
  c_photons_isoHcalRecHitDR03_ = false;
  c_photons_isoHcalRecHitDR04_ = false;
  c_photons_isoHollowTrkConeDR03_ = false;
  c_photons_isoHollowTrkConeDR04_ = false;
  c_photons_isoSolidTrkConeDR03_ = false;
  c_photons_isoSolidTrkConeDR04_ = false;
  c_photons_maxEnergyXtal_ = false;
  c_photons_nTrkHollowConeDR03_ = false;
  c_photons_nTrkHollowConeDR04_ = false;
  c_photons_nTrkSolidConeDR03_ = false;
  c_photons_nTrkSolidConeDR04_ = false;
  c_photons_phi_ = false;
  c_photons_pt_ = false;
  c_photons_px_ = false;
  c_photons_py_ = false;
  c_photons_pz_ = false;
  c_photons_r9_ = false;
  c_photons_scEnergy_ = false;
  c_photons_scEta_ = false;
  c_photons_scEtaWidth_ = false;
  c_photons_scPhi_ = false;
  c_photons_scPhiWidth_ = false;
  c_photons_scRawEnergy_ = false;
  c_photons_sigmaEtaEta_ = false;
  c_photons_sigmaIetaIeta_ = false;
  c_photons_status_ = false;
  c_photons_tIso_ = false;
  c_photons_theta_ = false;
  c_pv_chi2_ = false;
  c_pv_isFake_ = false;
  c_pv_isValid_ = false;
  c_pv_ndof_ = false;
  c_pv_x_ = false;
  c_pv_xErr_ = false;
  c_pv_y_ = false;
  c_pv_yErr_ = false;
  c_pv_z_ = false;
  c_pv_zErr_ = false;
  c_run_ = false;
  c_standalone_triggerobject_collectionname_ = false;
  c_standalone_triggerobject_energy_ = false;
  c_standalone_triggerobject_et_ = false;
  c_standalone_triggerobject_eta_ = false;
  c_standalone_triggerobject_phi_ = false;
  c_standalone_triggerobject_pt_ = false;
  c_standalone_triggerobject_px_ = false;
  c_standalone_triggerobject_py_ = false;
  c_standalone_triggerobject_pz_ = false;
  c_taus_charge_ = false;
  c_taus_energy_ = false;
  c_taus_et_ = false;
  c_taus_eta_ = false;
  c_taus_phi_ = false;
  c_taus_pt_ = false;
  c_taus_px_ = false;
  c_taus_py_ = false;
  c_taus_pz_ = false;
  c_taus_status_ = false;
  c_taus_theta_ = false;
  c_trackingfailurefilter_decision_ = false;
  c_trigger_name_ = false;
  c_trigger_prescalevalue_ = false;
  c_weight_ = false;
  const long entry_a = chainA_.LoadTree(entry);
  const long entry_b = chainB_.LoadTree(entry);
  if(entry_a!=entry_b) throw std::runtime_error("Entry is in different trees for chains A and B");
  entry_ = entry_a;
}

short cfa_base::GetVersion() const{
  return cfa_version_;
}

const std::string& cfa_base::SampleName() const{
  return sample_name_;
}

const std::string& cfa_base::SampleName(const std::string &sample_name){
  sample_name_=sample_name;
  return sample_name_;
}

void cfa_base::SetFile(const std::string &file_name){
  cached_total_entries_=false;
  chainA_.Reset(); chainB_.Reset();
  AddFiles(file_name);
}

cfa_base::~cfa_base(){
}

void cfa_base::CalcVersion(){
  size_t pos = sample_name_.rfind("_v");
  if(pos != std::string::npos && pos < sample_name_.size()-2){
    std::istringstream iss(sample_name_.substr(pos+2));
    iss >> cfa_version_;
    if(iss.fail() || iss.bad()){
      cfa_version_ = -1;
    }
  }
}

void cfa_base::AddFiles(const std::string &file_name){
  cached_total_entries_=false;
  std::string dir_name = "/cfA";
  if(file_name.find("cfa_file_8")!=std::string::npos) dir_name = "/configurableAnalysis";
  chainA_.Add((file_name+dir_name+"/eventA").c_str());
  chainB_.Add((file_name+dir_name+"/eventB").c_str());
}

void cfa_base::PrepareNewChains(){
  InitializeA();
  InitializeB();
}

void cfa_base::InitializeA(){
  chainA_.SetMakeClass(1);
  chainA_.SetBranchAddress("PU_NumInteractions", &PU_NumInteractions_, &b_PU_NumInteractions_);
  chainA_.SetBranchAddress("PU_TrueNumInteractions", &PU_TrueNumInteractions_, &b_PU_TrueNumInteractions_);
  chainA_.SetBranchAddress("PU_bunchCrossing", &PU_bunchCrossing_, &b_PU_bunchCrossing_);
  chainA_.SetBranchAddress("PU_ntrks_highpT", &PU_ntrks_highpT_, &b_PU_ntrks_highpT_);
  chainA_.SetBranchAddress("PU_ntrks_lowpT", &PU_ntrks_lowpT_, &b_PU_ntrks_lowpT_);
  chainA_.SetBranchAddress("PU_sumpT_highpT", &PU_sumpT_highpT_, &b_PU_sumpT_highpT_);
  chainA_.SetBranchAddress("PU_sumpT_lowpT", &PU_sumpT_lowpT_, &b_PU_sumpT_lowpT_);
  chainA_.SetBranchAddress("PU_zpositions", &PU_zpositions_, &b_PU_zpositions_);
  chainA_.SetBranchAddress("cschalofilter_decision", &cschalofilter_decision_, &b_cschalofilter_decision_);
  chainA_.SetBranchAddress("ecallaserfilter_decision", &ecallaserfilter_decision_, &b_ecallaserfilter_decision_);
  chainA_.SetBranchAddress("eebadscfilter_decision", &eebadscfilter_decision_, &b_eebadscfilter_decision_);
  chainA_.SetBranchAddress("genHT", &genHT_, &b_genHT_);
  chainA_.SetBranchAddress("hcallaserfilter_decision", &hcallaserfilter_decision_, &b_hcallaserfilter_decision_);
  chainA_.SetBranchAddress("standalone_triggerobject_collectionname", &standalone_triggerobject_collectionname_, &b_standalone_triggerobject_collectionname_);
  chainA_.SetBranchAddress("standalone_triggerobject_energy", &standalone_triggerobject_energy_, &b_standalone_triggerobject_energy_);
  chainA_.SetBranchAddress("standalone_triggerobject_et", &standalone_triggerobject_et_, &b_standalone_triggerobject_et_);
  chainA_.SetBranchAddress("standalone_triggerobject_eta", &standalone_triggerobject_eta_, &b_standalone_triggerobject_eta_);
  chainA_.SetBranchAddress("standalone_triggerobject_phi", &standalone_triggerobject_phi_, &b_standalone_triggerobject_phi_);
  chainA_.SetBranchAddress("standalone_triggerobject_pt", &standalone_triggerobject_pt_, &b_standalone_triggerobject_pt_);
  chainA_.SetBranchAddress("standalone_triggerobject_px", &standalone_triggerobject_px_, &b_standalone_triggerobject_px_);
  chainA_.SetBranchAddress("standalone_triggerobject_py", &standalone_triggerobject_py_, &b_standalone_triggerobject_py_);
  chainA_.SetBranchAddress("standalone_triggerobject_pz", &standalone_triggerobject_pz_, &b_standalone_triggerobject_pz_);
  chainA_.SetBranchAddress("trackingfailurefilter_decision", &trackingfailurefilter_decision_, &b_trackingfailurefilter_decision_);
  chainA_.SetBranchAddress("trigger_name", &trigger_name_, &b_trigger_name_);
  chainA_.SetBranchAddress("trigger_prescalevalue", &trigger_prescalevalue_, &b_trigger_prescalevalue_);
}

void cfa_base::InitializeB(){
  chainB_.SetMakeClass(1);
  chainB_.SetBranchAddress("NbeamSpot", &NbeamSpot_, &b_NbeamSpot_);
  chainB_.SetBranchAddress("Nels", &Nels_, &b_Nels_);
  chainB_.SetBranchAddress("Nmc_doc", &Nmc_doc_, &b_Nmc_doc_);
  chainB_.SetBranchAddress("Nmus", &Nmus_, &b_Nmus_);
  chainB_.SetBranchAddress("Nphotons", &Nphotons_, &b_Nphotons_);
  chainB_.SetBranchAddress("Npv", &Npv_, &b_Npv_);
  chainB_.SetBranchAddress("Ntaus", &Ntaus_, &b_Ntaus_);
  chainB_.SetBranchAddress("beamSpot_beamWidthX", &beamSpot_beamWidthX_, &b_beamSpot_beamWidthX_);
  chainB_.SetBranchAddress("beamSpot_beamWidthXError", &beamSpot_beamWidthXError_, &b_beamSpot_beamWidthXError_);
  chainB_.SetBranchAddress("beamSpot_beamWidthY", &beamSpot_beamWidthY_, &b_beamSpot_beamWidthY_);
  chainB_.SetBranchAddress("beamSpot_beamWidthYError", &beamSpot_beamWidthYError_, &b_beamSpot_beamWidthYError_);
  chainB_.SetBranchAddress("beamSpot_dxdz", &beamSpot_dxdz_, &b_beamSpot_dxdz_);
  chainB_.SetBranchAddress("beamSpot_dxdzError", &beamSpot_dxdzError_, &b_beamSpot_dxdzError_);
  chainB_.SetBranchAddress("beamSpot_dydz", &beamSpot_dydz_, &b_beamSpot_dydz_);
  chainB_.SetBranchAddress("beamSpot_dydzError", &beamSpot_dydzError_, &b_beamSpot_dydzError_);
  chainB_.SetBranchAddress("beamSpot_sigmaZ", &beamSpot_sigmaZ_, &b_beamSpot_sigmaZ_);
  chainB_.SetBranchAddress("beamSpot_sigmaZ0Error", &beamSpot_sigmaZ0Error_, &b_beamSpot_sigmaZ0Error_);
  chainB_.SetBranchAddress("beamSpot_x", &beamSpot_x_, &b_beamSpot_x_);
  chainB_.SetBranchAddress("beamSpot_x0Error", &beamSpot_x0Error_, &b_beamSpot_x0Error_);
  chainB_.SetBranchAddress("beamSpot_y", &beamSpot_y_, &b_beamSpot_y_);
  chainB_.SetBranchAddress("beamSpot_y0Error", &beamSpot_y0Error_, &b_beamSpot_y0Error_);
  chainB_.SetBranchAddress("beamSpot_z", &beamSpot_z_, &b_beamSpot_z_);
  chainB_.SetBranchAddress("beamSpot_z0Error", &beamSpot_z0Error_, &b_beamSpot_z0Error_);
  chainB_.SetBranchAddress("bunchCrossing", &bunchCrossing_, &b_bunchCrossing_);
  chainB_.SetBranchAddress("els_PATpassConversionVeto", &els_PATpassConversionVeto_, &b_els_PATpassConversionVeto_);
  chainB_.SetBranchAddress("els_basicClustersSize", &els_basicClustersSize_, &b_els_basicClustersSize_);
  chainB_.SetBranchAddress("els_cIso", &els_cIso_, &b_els_cIso_);
  chainB_.SetBranchAddress("els_caloEnergy", &els_caloEnergy_, &b_els_caloEnergy_);
  chainB_.SetBranchAddress("els_charge", &els_charge_, &b_els_charge_);
  chainB_.SetBranchAddress("els_chi2", &els_chi2_, &b_els_chi2_);
  chainB_.SetBranchAddress("els_core_ecalDrivenSeed", &els_core_ecalDrivenSeed_, &b_els_core_ecalDrivenSeed_);
  chainB_.SetBranchAddress("els_cpx", &els_cpx_, &b_els_cpx_);
  chainB_.SetBranchAddress("els_cpy", &els_cpy_, &b_els_cpy_);
  chainB_.SetBranchAddress("els_cpz", &els_cpz_, &b_els_cpz_);
  chainB_.SetBranchAddress("els_ctf_tk_charge", &els_ctf_tk_charge_, &b_els_ctf_tk_charge_);
  chainB_.SetBranchAddress("els_ctf_tk_eta", &els_ctf_tk_eta_, &b_els_ctf_tk_eta_);
  chainB_.SetBranchAddress("els_ctf_tk_id", &els_ctf_tk_id_, &b_els_ctf_tk_id_);
  chainB_.SetBranchAddress("els_ctf_tk_phi", &els_ctf_tk_phi_, &b_els_ctf_tk_phi_);
  chainB_.SetBranchAddress("els_cx", &els_cx_, &b_els_cx_);
  chainB_.SetBranchAddress("els_cy", &els_cy_, &b_els_cy_);
  chainB_.SetBranchAddress("els_cz", &els_cz_, &b_els_cz_);
  chainB_.SetBranchAddress("els_d0dum", &els_d0dum_, &b_els_d0dum_);
  chainB_.SetBranchAddress("els_d0dumError", &els_d0dumError_, &b_els_d0dumError_);
  chainB_.SetBranchAddress("els_dEtaIn", &els_dEtaIn_, &b_els_dEtaIn_);
  chainB_.SetBranchAddress("els_dEtaOut", &els_dEtaOut_, &b_els_dEtaOut_);
  chainB_.SetBranchAddress("els_dPhiIn", &els_dPhiIn_, &b_els_dPhiIn_);
  chainB_.SetBranchAddress("els_dPhiOut", &els_dPhiOut_, &b_els_dPhiOut_);
  chainB_.SetBranchAddress("els_dr03EcalRecHitSumEt", &els_dr03EcalRecHitSumEt_, &b_els_dr03EcalRecHitSumEt_);
  chainB_.SetBranchAddress("els_dr03HcalDepth1TowerSumEt", &els_dr03HcalDepth1TowerSumEt_, &b_els_dr03HcalDepth1TowerSumEt_);
  chainB_.SetBranchAddress("els_dr03HcalDepth2TowerSumEt", &els_dr03HcalDepth2TowerSumEt_, &b_els_dr03HcalDepth2TowerSumEt_);
  chainB_.SetBranchAddress("els_dr03HcalTowerSumEt", &els_dr03HcalTowerSumEt_, &b_els_dr03HcalTowerSumEt_);
  chainB_.SetBranchAddress("els_dr03TkSumPt", &els_dr03TkSumPt_, &b_els_dr03TkSumPt_);
  chainB_.SetBranchAddress("els_dr04EcalRecHitSumEt", &els_dr04EcalRecHitSumEt_, &b_els_dr04EcalRecHitSumEt_);
  chainB_.SetBranchAddress("els_dr04HcalDepth1TowerSumEt", &els_dr04HcalDepth1TowerSumEt_, &b_els_dr04HcalDepth1TowerSumEt_);
  chainB_.SetBranchAddress("els_dr04HcalDepth2TowerSumEt", &els_dr04HcalDepth2TowerSumEt_, &b_els_dr04HcalDepth2TowerSumEt_);
  chainB_.SetBranchAddress("els_dr04HcalTowerSumEt", &els_dr04HcalTowerSumEt_, &b_els_dr04HcalTowerSumEt_);
  chainB_.SetBranchAddress("els_dr04TkSumPt", &els_dr04TkSumPt_, &b_els_dr04TkSumPt_);
  chainB_.SetBranchAddress("els_dz", &els_dz_, &b_els_dz_);
  chainB_.SetBranchAddress("els_dzError", &els_dzError_, &b_els_dzError_);
  chainB_.SetBranchAddress("els_eOverPIn", &els_eOverPIn_, &b_els_eOverPIn_);
  chainB_.SetBranchAddress("els_eSeedOverPOut", &els_eSeedOverPOut_, &b_els_eSeedOverPOut_);
  chainB_.SetBranchAddress("els_ecalIso", &els_ecalIso_, &b_els_ecalIso_);
  chainB_.SetBranchAddress("els_energy", &els_energy_, &b_els_energy_);
  chainB_.SetBranchAddress("els_et", &els_et_, &b_els_et_);
  chainB_.SetBranchAddress("els_eta", &els_eta_, &b_els_eta_);
  chainB_.SetBranchAddress("els_etaError", &els_etaError_, &b_els_etaError_);
  chainB_.SetBranchAddress("els_fbrem", &els_fbrem_, &b_els_fbrem_);
  chainB_.SetBranchAddress("els_hadOverEm", &els_hadOverEm_, &b_els_hadOverEm_);
  chainB_.SetBranchAddress("els_hcalIso", &els_hcalIso_, &b_els_hcalIso_);
  chainB_.SetBranchAddress("els_hcalOverEcalBc", &els_hcalOverEcalBc_, &b_els_hcalOverEcalBc_);
  chainB_.SetBranchAddress("els_isEB", &els_isEB_, &b_els_isEB_);
  chainB_.SetBranchAddress("els_isEE", &els_isEE_, &b_els_isEE_);
  chainB_.SetBranchAddress("els_looseId", &els_looseId_, &b_els_looseId_);
  chainB_.SetBranchAddress("els_ndof", &els_ndof_, &b_els_ndof_);
  chainB_.SetBranchAddress("els_numlosthits", &els_numlosthits_, &b_els_numlosthits_);
  chainB_.SetBranchAddress("els_numvalhits", &els_numvalhits_, &b_els_numvalhits_);
  chainB_.SetBranchAddress("els_phi", &els_phi_, &b_els_phi_);
  chainB_.SetBranchAddress("els_phiError", &els_phiError_, &b_els_phiError_);
  chainB_.SetBranchAddress("els_pt", &els_pt_, &b_els_pt_);
  chainB_.SetBranchAddress("els_ptError", &els_ptError_, &b_els_ptError_);
  chainB_.SetBranchAddress("els_px", &els_px_, &b_els_px_);
  chainB_.SetBranchAddress("els_py", &els_py_, &b_els_py_);
  chainB_.SetBranchAddress("els_pz", &els_pz_, &b_els_pz_);
  chainB_.SetBranchAddress("els_robustHighEnergyId", &els_robustHighEnergyId_, &b_els_robustHighEnergyId_);
  chainB_.SetBranchAddress("els_robustLooseId", &els_robustLooseId_, &b_els_robustLooseId_);
  chainB_.SetBranchAddress("els_robustTightId", &els_robustTightId_, &b_els_robustTightId_);
  chainB_.SetBranchAddress("els_scE1x5", &els_scE1x5_, &b_els_scE1x5_);
  chainB_.SetBranchAddress("els_scE2x5Max", &els_scE2x5Max_, &b_els_scE2x5Max_);
  chainB_.SetBranchAddress("els_scE5x5", &els_scE5x5_, &b_els_scE5x5_);
  chainB_.SetBranchAddress("els_scEnergy", &els_scEnergy_, &b_els_scEnergy_);
  chainB_.SetBranchAddress("els_scEta", &els_scEta_, &b_els_scEta_);
  chainB_.SetBranchAddress("els_scEtaWidth", &els_scEtaWidth_, &b_els_scEtaWidth_);
  chainB_.SetBranchAddress("els_scPhi", &els_scPhi_, &b_els_scPhi_);
  chainB_.SetBranchAddress("els_scPhiWidth", &els_scPhiWidth_, &b_els_scPhiWidth_);
  chainB_.SetBranchAddress("els_scRawEnergy", &els_scRawEnergy_, &b_els_scRawEnergy_);
  chainB_.SetBranchAddress("els_scSeedEnergy", &els_scSeedEnergy_, &b_els_scSeedEnergy_);
  chainB_.SetBranchAddress("els_shFracInnerHits", &els_shFracInnerHits_, &b_els_shFracInnerHits_);
  chainB_.SetBranchAddress("els_sigmaEtaEta", &els_sigmaEtaEta_, &b_els_sigmaEtaEta_);
  chainB_.SetBranchAddress("els_sigmaIEtaIEta", &els_sigmaIEtaIEta_, &b_els_sigmaIEtaIEta_);
  chainB_.SetBranchAddress("els_status", &els_status_, &b_els_status_);
  chainB_.SetBranchAddress("els_tIso", &els_tIso_, &b_els_tIso_);
  chainB_.SetBranchAddress("els_theta", &els_theta_, &b_els_theta_);
  chainB_.SetBranchAddress("els_tightId", &els_tightId_, &b_els_tightId_);
  chainB_.SetBranchAddress("els_tk_charge", &els_tk_charge_, &b_els_tk_charge_);
  chainB_.SetBranchAddress("els_tk_eta", &els_tk_eta_, &b_els_tk_eta_);
  chainB_.SetBranchAddress("els_tk_phi", &els_tk_phi_, &b_els_tk_phi_);
  chainB_.SetBranchAddress("els_tk_pt", &els_tk_pt_, &b_els_tk_pt_);
  chainB_.SetBranchAddress("els_tk_pz", &els_tk_pz_, &b_els_tk_pz_);
  chainB_.SetBranchAddress("els_vpx", &els_vpx_, &b_els_vpx_);
  chainB_.SetBranchAddress("els_vpy", &els_vpy_, &b_els_vpy_);
  chainB_.SetBranchAddress("els_vpz", &els_vpz_, &b_els_vpz_);
  chainB_.SetBranchAddress("els_vx", &els_vx_, &b_els_vx_);
  chainB_.SetBranchAddress("els_vy", &els_vy_, &b_els_vy_);
  chainB_.SetBranchAddress("els_vz", &els_vz_, &b_els_vz_);
  chainB_.SetBranchAddress("event", &event_, &b_event_);
  chainB_.SetBranchAddress("experimentType", &experimentType_, &b_experimentType_);
  chainB_.SetBranchAddress("lumiblock", &lumiblock_, &b_lumiblock_);
  chainB_.SetBranchAddress("mc_doc_charge", &mc_doc_charge_, &b_mc_doc_charge_);
  chainB_.SetBranchAddress("mc_doc_energy", &mc_doc_energy_, &b_mc_doc_energy_);
  chainB_.SetBranchAddress("mc_doc_eta", &mc_doc_eta_, &b_mc_doc_eta_);
  chainB_.SetBranchAddress("mc_doc_ggrandmother_id", &mc_doc_ggrandmother_id_, &b_mc_doc_ggrandmother_id_);
  chainB_.SetBranchAddress("mc_doc_grandmother_id", &mc_doc_grandmother_id_, &b_mc_doc_grandmother_id_);
  chainB_.SetBranchAddress("mc_doc_id", &mc_doc_id_, &b_mc_doc_id_);
  chainB_.SetBranchAddress("mc_doc_mass", &mc_doc_mass_, &b_mc_doc_mass_);
  chainB_.SetBranchAddress("mc_doc_mother_id", &mc_doc_mother_id_, &b_mc_doc_mother_id_);
  chainB_.SetBranchAddress("mc_doc_numOfDaughters", &mc_doc_numOfDaughters_, &b_mc_doc_numOfDaughters_);
  chainB_.SetBranchAddress("mc_doc_numOfMothers", &mc_doc_numOfMothers_, &b_mc_doc_numOfMothers_);
  chainB_.SetBranchAddress("mc_doc_phi", &mc_doc_phi_, &b_mc_doc_phi_);
  chainB_.SetBranchAddress("mc_doc_pt", &mc_doc_pt_, &b_mc_doc_pt_);
  chainB_.SetBranchAddress("mc_doc_px", &mc_doc_px_, &b_mc_doc_px_);
  chainB_.SetBranchAddress("mc_doc_py", &mc_doc_py_, &b_mc_doc_py_);
  chainB_.SetBranchAddress("mc_doc_pz", &mc_doc_pz_, &b_mc_doc_pz_);
  chainB_.SetBranchAddress("mc_doc_status", &mc_doc_status_, &b_mc_doc_status_);
  chainB_.SetBranchAddress("mc_doc_vertex_x", &mc_doc_vertex_x_, &b_mc_doc_vertex_x_);
  chainB_.SetBranchAddress("mc_doc_vertex_y", &mc_doc_vertex_y_, &b_mc_doc_vertex_y_);
  chainB_.SetBranchAddress("mc_doc_vertex_z", &mc_doc_vertex_z_, &b_mc_doc_vertex_z_);
  chainB_.SetBranchAddress("model_params", &model_params_, &b_model_params_);
  chainB_.SetBranchAddress("mus_cIso", &mus_cIso_, &b_mus_cIso_);
  chainB_.SetBranchAddress("mus_calEnergyEm", &mus_calEnergyEm_, &b_mus_calEnergyEm_);
  chainB_.SetBranchAddress("mus_calEnergyEmS9", &mus_calEnergyEmS9_, &b_mus_calEnergyEmS9_);
  chainB_.SetBranchAddress("mus_calEnergyHad", &mus_calEnergyHad_, &b_mus_calEnergyHad_);
  chainB_.SetBranchAddress("mus_calEnergyHadS9", &mus_calEnergyHadS9_, &b_mus_calEnergyHadS9_);
  chainB_.SetBranchAddress("mus_calEnergyHo", &mus_calEnergyHo_, &b_mus_calEnergyHo_);
  chainB_.SetBranchAddress("mus_calEnergyHoS9", &mus_calEnergyHoS9_, &b_mus_calEnergyHoS9_);
  chainB_.SetBranchAddress("mus_charge", &mus_charge_, &b_mus_charge_);
  chainB_.SetBranchAddress("mus_cm_LayersWithMeasurement", &mus_cm_LayersWithMeasurement_, &b_mus_cm_LayersWithMeasurement_);
  chainB_.SetBranchAddress("mus_cm_LayersWithoutMeasurement", &mus_cm_LayersWithoutMeasurement_, &b_mus_cm_LayersWithoutMeasurement_);
  chainB_.SetBranchAddress("mus_cm_PixelLayersWithMeasurement", &mus_cm_PixelLayersWithMeasurement_, &b_mus_cm_PixelLayersWithMeasurement_);
  chainB_.SetBranchAddress("mus_cm_ValidStripLayersWithMonoAndStereoHit", &mus_cm_ValidStripLayersWithMonoAndStereoHit_, &b_mus_cm_ValidStripLayersWithMonoAndStereoHit_);
  chainB_.SetBranchAddress("mus_cm_chg", &mus_cm_chg_, &b_mus_cm_chg_);
  chainB_.SetBranchAddress("mus_cm_chi2", &mus_cm_chi2_, &b_mus_cm_chi2_);
  chainB_.SetBranchAddress("mus_cm_d0dum", &mus_cm_d0dum_, &b_mus_cm_d0dum_);
  chainB_.SetBranchAddress("mus_cm_d0dumErr", &mus_cm_d0dumErr_, &b_mus_cm_d0dumErr_);
  chainB_.SetBranchAddress("mus_cm_dz", &mus_cm_dz_, &b_mus_cm_dz_);
  chainB_.SetBranchAddress("mus_cm_dzErr", &mus_cm_dzErr_, &b_mus_cm_dzErr_);
  chainB_.SetBranchAddress("mus_cm_eta", &mus_cm_eta_, &b_mus_cm_eta_);
  chainB_.SetBranchAddress("mus_cm_etaErr", &mus_cm_etaErr_, &b_mus_cm_etaErr_);
  chainB_.SetBranchAddress("mus_cm_ndof", &mus_cm_ndof_, &b_mus_cm_ndof_);
  chainB_.SetBranchAddress("mus_cm_numlosthits", &mus_cm_numlosthits_, &b_mus_cm_numlosthits_);
  chainB_.SetBranchAddress("mus_cm_numvalMuonhits", &mus_cm_numvalMuonhits_, &b_mus_cm_numvalMuonhits_);
  chainB_.SetBranchAddress("mus_cm_numvalhits", &mus_cm_numvalhits_, &b_mus_cm_numvalhits_);
  chainB_.SetBranchAddress("mus_cm_phi", &mus_cm_phi_, &b_mus_cm_phi_);
  chainB_.SetBranchAddress("mus_cm_phiErr", &mus_cm_phiErr_, &b_mus_cm_phiErr_);
  chainB_.SetBranchAddress("mus_cm_pt", &mus_cm_pt_, &b_mus_cm_pt_);
  chainB_.SetBranchAddress("mus_cm_ptErr", &mus_cm_ptErr_, &b_mus_cm_ptErr_);
  chainB_.SetBranchAddress("mus_cm_px", &mus_cm_px_, &b_mus_cm_px_);
  chainB_.SetBranchAddress("mus_cm_py", &mus_cm_py_, &b_mus_cm_py_);
  chainB_.SetBranchAddress("mus_cm_pz", &mus_cm_pz_, &b_mus_cm_pz_);
  chainB_.SetBranchAddress("mus_cm_theta", &mus_cm_theta_, &b_mus_cm_theta_);
  chainB_.SetBranchAddress("mus_cm_vx", &mus_cm_vx_, &b_mus_cm_vx_);
  chainB_.SetBranchAddress("mus_cm_vy", &mus_cm_vy_, &b_mus_cm_vy_);
  chainB_.SetBranchAddress("mus_cm_vz", &mus_cm_vz_, &b_mus_cm_vz_);
  chainB_.SetBranchAddress("mus_dB", &mus_dB_, &b_mus_dB_);
  chainB_.SetBranchAddress("mus_ecalIso", &mus_ecalIso_, &b_mus_ecalIso_);
  chainB_.SetBranchAddress("mus_ecalvetoDep", &mus_ecalvetoDep_, &b_mus_ecalvetoDep_);
  chainB_.SetBranchAddress("mus_energy", &mus_energy_, &b_mus_energy_);
  chainB_.SetBranchAddress("mus_et", &mus_et_, &b_mus_et_);
  chainB_.SetBranchAddress("mus_eta", &mus_eta_, &b_mus_eta_);
  chainB_.SetBranchAddress("mus_hcalIso", &mus_hcalIso_, &b_mus_hcalIso_);
  chainB_.SetBranchAddress("mus_hcalvetoDep", &mus_hcalvetoDep_, &b_mus_hcalvetoDep_);
  chainB_.SetBranchAddress("mus_id_All", &mus_id_All_, &b_mus_id_All_);
  chainB_.SetBranchAddress("mus_id_AllArbitrated", &mus_id_AllArbitrated_, &b_mus_id_AllArbitrated_);
  chainB_.SetBranchAddress("mus_id_AllGlobalMuons", &mus_id_AllGlobalMuons_, &b_mus_id_AllGlobalMuons_);
  chainB_.SetBranchAddress("mus_id_AllStandAloneMuons", &mus_id_AllStandAloneMuons_, &b_mus_id_AllStandAloneMuons_);
  chainB_.SetBranchAddress("mus_id_AllTrackerMuons", &mus_id_AllTrackerMuons_, &b_mus_id_AllTrackerMuons_);
  chainB_.SetBranchAddress("mus_id_GlobalMuonPromptTight", &mus_id_GlobalMuonPromptTight_, &b_mus_id_GlobalMuonPromptTight_);
  chainB_.SetBranchAddress("mus_id_TM2DCompatibilityLoose", &mus_id_TM2DCompatibilityLoose_, &b_mus_id_TM2DCompatibilityLoose_);
  chainB_.SetBranchAddress("mus_id_TM2DCompatibilityTight", &mus_id_TM2DCompatibilityTight_, &b_mus_id_TM2DCompatibilityTight_);
  chainB_.SetBranchAddress("mus_id_TMLastStationLoose", &mus_id_TMLastStationLoose_, &b_mus_id_TMLastStationLoose_);
  chainB_.SetBranchAddress("mus_id_TMLastStationOptimizedLowPtLoose", &mus_id_TMLastStationOptimizedLowPtLoose_, &b_mus_id_TMLastStationOptimizedLowPtLoose_);
  chainB_.SetBranchAddress("mus_id_TMLastStationOptimizedLowPtTight", &mus_id_TMLastStationOptimizedLowPtTight_, &b_mus_id_TMLastStationOptimizedLowPtTight_);
  chainB_.SetBranchAddress("mus_id_TMLastStationTight", &mus_id_TMLastStationTight_, &b_mus_id_TMLastStationTight_);
  chainB_.SetBranchAddress("mus_id_TMOneStationLoose", &mus_id_TMOneStationLoose_, &b_mus_id_TMOneStationLoose_);
  chainB_.SetBranchAddress("mus_id_TMOneStationTight", &mus_id_TMOneStationTight_, &b_mus_id_TMOneStationTight_);
  chainB_.SetBranchAddress("mus_id_TrackerMuonArbitrated", &mus_id_TrackerMuonArbitrated_, &b_mus_id_TrackerMuonArbitrated_);
  chainB_.SetBranchAddress("mus_isGlobalMuon", &mus_isGlobalMuon_, &b_mus_isGlobalMuon_);
  chainB_.SetBranchAddress("mus_isPFMuon", &mus_isPFMuon_, &b_mus_isPFMuon_);
  chainB_.SetBranchAddress("mus_isStandAloneMuon", &mus_isStandAloneMuon_, &b_mus_isStandAloneMuon_);
  chainB_.SetBranchAddress("mus_isTrackerMuon", &mus_isTrackerMuon_, &b_mus_isTrackerMuon_);
  chainB_.SetBranchAddress("mus_iso03_emEt", &mus_iso03_emEt_, &b_mus_iso03_emEt_);
  chainB_.SetBranchAddress("mus_iso03_emVetoEt", &mus_iso03_emVetoEt_, &b_mus_iso03_emVetoEt_);
  chainB_.SetBranchAddress("mus_iso03_hadEt", &mus_iso03_hadEt_, &b_mus_iso03_hadEt_);
  chainB_.SetBranchAddress("mus_iso03_hadVetoEt", &mus_iso03_hadVetoEt_, &b_mus_iso03_hadVetoEt_);
  chainB_.SetBranchAddress("mus_iso03_hoEt", &mus_iso03_hoEt_, &b_mus_iso03_hoEt_);
  chainB_.SetBranchAddress("mus_iso03_nTracks", &mus_iso03_nTracks_, &b_mus_iso03_nTracks_);
  chainB_.SetBranchAddress("mus_iso03_sumPt", &mus_iso03_sumPt_, &b_mus_iso03_sumPt_);
  chainB_.SetBranchAddress("mus_iso05_emEt", &mus_iso05_emEt_, &b_mus_iso05_emEt_);
  chainB_.SetBranchAddress("mus_iso05_hadEt", &mus_iso05_hadEt_, &b_mus_iso05_hadEt_);
  chainB_.SetBranchAddress("mus_iso05_hoEt", &mus_iso05_hoEt_, &b_mus_iso05_hoEt_);
  chainB_.SetBranchAddress("mus_iso05_nTracks", &mus_iso05_nTracks_, &b_mus_iso05_nTracks_);
  chainB_.SetBranchAddress("mus_iso05_sumPt", &mus_iso05_sumPt_, &b_mus_iso05_sumPt_);
  chainB_.SetBranchAddress("mus_num_matches", &mus_num_matches_, &b_mus_num_matches_);
  chainB_.SetBranchAddress("mus_numberOfMatchedStations", &mus_numberOfMatchedStations_, &b_mus_numberOfMatchedStations_);
  chainB_.SetBranchAddress("mus_pfIsolationR03_sumChargedHadronPt", &mus_pfIsolationR03_sumChargedHadronPt_, &b_mus_pfIsolationR03_sumChargedHadronPt_);
  chainB_.SetBranchAddress("mus_pfIsolationR03_sumChargedParticlePt", &mus_pfIsolationR03_sumChargedParticlePt_, &b_mus_pfIsolationR03_sumChargedParticlePt_);
  chainB_.SetBranchAddress("mus_pfIsolationR03_sumNeutralHadronEt", &mus_pfIsolationR03_sumNeutralHadronEt_, &b_mus_pfIsolationR03_sumNeutralHadronEt_);
  chainB_.SetBranchAddress("mus_pfIsolationR03_sumNeutralHadronEtHighThreshold", &mus_pfIsolationR03_sumNeutralHadronEtHighThreshold_, &b_mus_pfIsolationR03_sumNeutralHadronEtHighThreshold_);
  chainB_.SetBranchAddress("mus_pfIsolationR03_sumPUPt", &mus_pfIsolationR03_sumPUPt_, &b_mus_pfIsolationR03_sumPUPt_);
  chainB_.SetBranchAddress("mus_pfIsolationR03_sumPhotonEt", &mus_pfIsolationR03_sumPhotonEt_, &b_mus_pfIsolationR03_sumPhotonEt_);
  chainB_.SetBranchAddress("mus_pfIsolationR03_sumPhotonEtHighThreshold", &mus_pfIsolationR03_sumPhotonEtHighThreshold_, &b_mus_pfIsolationR03_sumPhotonEtHighThreshold_);
  chainB_.SetBranchAddress("mus_pfIsolationR04_sumChargedHadronPt", &mus_pfIsolationR04_sumChargedHadronPt_, &b_mus_pfIsolationR04_sumChargedHadronPt_);
  chainB_.SetBranchAddress("mus_pfIsolationR04_sumChargedParticlePt", &mus_pfIsolationR04_sumChargedParticlePt_, &b_mus_pfIsolationR04_sumChargedParticlePt_);
  chainB_.SetBranchAddress("mus_pfIsolationR04_sumNeutralHadronEt", &mus_pfIsolationR04_sumNeutralHadronEt_, &b_mus_pfIsolationR04_sumNeutralHadronEt_);
  chainB_.SetBranchAddress("mus_pfIsolationR04_sumNeutralHadronEtHighThreshold", &mus_pfIsolationR04_sumNeutralHadronEtHighThreshold_, &b_mus_pfIsolationR04_sumNeutralHadronEtHighThreshold_);
  chainB_.SetBranchAddress("mus_pfIsolationR04_sumPUPt", &mus_pfIsolationR04_sumPUPt_, &b_mus_pfIsolationR04_sumPUPt_);
  chainB_.SetBranchAddress("mus_pfIsolationR04_sumPhotonEt", &mus_pfIsolationR04_sumPhotonEt_, &b_mus_pfIsolationR04_sumPhotonEt_);
  chainB_.SetBranchAddress("mus_pfIsolationR04_sumPhotonEtHighThreshold", &mus_pfIsolationR04_sumPhotonEtHighThreshold_, &b_mus_pfIsolationR04_sumPhotonEtHighThreshold_);
  chainB_.SetBranchAddress("mus_phi", &mus_phi_, &b_mus_phi_);
  chainB_.SetBranchAddress("mus_pt", &mus_pt_, &b_mus_pt_);
  chainB_.SetBranchAddress("mus_px", &mus_px_, &b_mus_px_);
  chainB_.SetBranchAddress("mus_py", &mus_py_, &b_mus_py_);
  chainB_.SetBranchAddress("mus_pz", &mus_pz_, &b_mus_pz_);
  chainB_.SetBranchAddress("mus_stamu_chg", &mus_stamu_chg_, &b_mus_stamu_chg_);
  chainB_.SetBranchAddress("mus_stamu_chi2", &mus_stamu_chi2_, &b_mus_stamu_chi2_);
  chainB_.SetBranchAddress("mus_stamu_d0dum", &mus_stamu_d0dum_, &b_mus_stamu_d0dum_);
  chainB_.SetBranchAddress("mus_stamu_d0dumErr", &mus_stamu_d0dumErr_, &b_mus_stamu_d0dumErr_);
  chainB_.SetBranchAddress("mus_stamu_dz", &mus_stamu_dz_, &b_mus_stamu_dz_);
  chainB_.SetBranchAddress("mus_stamu_dzErr", &mus_stamu_dzErr_, &b_mus_stamu_dzErr_);
  chainB_.SetBranchAddress("mus_stamu_eta", &mus_stamu_eta_, &b_mus_stamu_eta_);
  chainB_.SetBranchAddress("mus_stamu_etaErr", &mus_stamu_etaErr_, &b_mus_stamu_etaErr_);
  chainB_.SetBranchAddress("mus_stamu_ndof", &mus_stamu_ndof_, &b_mus_stamu_ndof_);
  chainB_.SetBranchAddress("mus_stamu_numlosthits", &mus_stamu_numlosthits_, &b_mus_stamu_numlosthits_);
  chainB_.SetBranchAddress("mus_stamu_numvalhits", &mus_stamu_numvalhits_, &b_mus_stamu_numvalhits_);
  chainB_.SetBranchAddress("mus_stamu_phi", &mus_stamu_phi_, &b_mus_stamu_phi_);
  chainB_.SetBranchAddress("mus_stamu_phiErr", &mus_stamu_phiErr_, &b_mus_stamu_phiErr_);
  chainB_.SetBranchAddress("mus_stamu_pt", &mus_stamu_pt_, &b_mus_stamu_pt_);
  chainB_.SetBranchAddress("mus_stamu_ptErr", &mus_stamu_ptErr_, &b_mus_stamu_ptErr_);
  chainB_.SetBranchAddress("mus_stamu_px", &mus_stamu_px_, &b_mus_stamu_px_);
  chainB_.SetBranchAddress("mus_stamu_py", &mus_stamu_py_, &b_mus_stamu_py_);
  chainB_.SetBranchAddress("mus_stamu_pz", &mus_stamu_pz_, &b_mus_stamu_pz_);
  chainB_.SetBranchAddress("mus_stamu_theta", &mus_stamu_theta_, &b_mus_stamu_theta_);
  chainB_.SetBranchAddress("mus_stamu_vx", &mus_stamu_vx_, &b_mus_stamu_vx_);
  chainB_.SetBranchAddress("mus_stamu_vy", &mus_stamu_vy_, &b_mus_stamu_vy_);
  chainB_.SetBranchAddress("mus_stamu_vz", &mus_stamu_vz_, &b_mus_stamu_vz_);
  chainB_.SetBranchAddress("mus_status", &mus_status_, &b_mus_status_);
  chainB_.SetBranchAddress("mus_tIso", &mus_tIso_, &b_mus_tIso_);
  chainB_.SetBranchAddress("mus_theta", &mus_theta_, &b_mus_theta_);
  chainB_.SetBranchAddress("mus_tkHits", &mus_tkHits_, &b_mus_tkHits_);
  chainB_.SetBranchAddress("mus_tk_LayersWithMeasurement", &mus_tk_LayersWithMeasurement_, &b_mus_tk_LayersWithMeasurement_);
  chainB_.SetBranchAddress("mus_tk_LayersWithoutMeasurement", &mus_tk_LayersWithoutMeasurement_, &b_mus_tk_LayersWithoutMeasurement_);
  chainB_.SetBranchAddress("mus_tk_PixelLayersWithMeasurement", &mus_tk_PixelLayersWithMeasurement_, &b_mus_tk_PixelLayersWithMeasurement_);
  chainB_.SetBranchAddress("mus_tk_ValidStripLayersWithMonoAndStereoHit", &mus_tk_ValidStripLayersWithMonoAndStereoHit_, &b_mus_tk_ValidStripLayersWithMonoAndStereoHit_);
  chainB_.SetBranchAddress("mus_tk_chg", &mus_tk_chg_, &b_mus_tk_chg_);
  chainB_.SetBranchAddress("mus_tk_chi2", &mus_tk_chi2_, &b_mus_tk_chi2_);
  chainB_.SetBranchAddress("mus_tk_d0dum", &mus_tk_d0dum_, &b_mus_tk_d0dum_);
  chainB_.SetBranchAddress("mus_tk_d0dumErr", &mus_tk_d0dumErr_, &b_mus_tk_d0dumErr_);
  chainB_.SetBranchAddress("mus_tk_dz", &mus_tk_dz_, &b_mus_tk_dz_);
  chainB_.SetBranchAddress("mus_tk_dzErr", &mus_tk_dzErr_, &b_mus_tk_dzErr_);
  chainB_.SetBranchAddress("mus_tk_eta", &mus_tk_eta_, &b_mus_tk_eta_);
  chainB_.SetBranchAddress("mus_tk_etaErr", &mus_tk_etaErr_, &b_mus_tk_etaErr_);
  chainB_.SetBranchAddress("mus_tk_id", &mus_tk_id_, &b_mus_tk_id_);
  chainB_.SetBranchAddress("mus_tk_ndof", &mus_tk_ndof_, &b_mus_tk_ndof_);
  chainB_.SetBranchAddress("mus_tk_numlosthits", &mus_tk_numlosthits_, &b_mus_tk_numlosthits_);
  chainB_.SetBranchAddress("mus_tk_numpixelWthMeasr", &mus_tk_numpixelWthMeasr_, &b_mus_tk_numpixelWthMeasr_);
  chainB_.SetBranchAddress("mus_tk_numvalPixelhits", &mus_tk_numvalPixelhits_, &b_mus_tk_numvalPixelhits_);
  chainB_.SetBranchAddress("mus_tk_numvalhits", &mus_tk_numvalhits_, &b_mus_tk_numvalhits_);
  chainB_.SetBranchAddress("mus_tk_phi", &mus_tk_phi_, &b_mus_tk_phi_);
  chainB_.SetBranchAddress("mus_tk_phiErr", &mus_tk_phiErr_, &b_mus_tk_phiErr_);
  chainB_.SetBranchAddress("mus_tk_pt", &mus_tk_pt_, &b_mus_tk_pt_);
  chainB_.SetBranchAddress("mus_tk_ptErr", &mus_tk_ptErr_, &b_mus_tk_ptErr_);
  chainB_.SetBranchAddress("mus_tk_px", &mus_tk_px_, &b_mus_tk_px_);
  chainB_.SetBranchAddress("mus_tk_py", &mus_tk_py_, &b_mus_tk_py_);
  chainB_.SetBranchAddress("mus_tk_pz", &mus_tk_pz_, &b_mus_tk_pz_);
  chainB_.SetBranchAddress("mus_tk_theta", &mus_tk_theta_, &b_mus_tk_theta_);
  chainB_.SetBranchAddress("mus_tk_vx", &mus_tk_vx_, &b_mus_tk_vx_);
  chainB_.SetBranchAddress("mus_tk_vy", &mus_tk_vy_, &b_mus_tk_vy_);
  chainB_.SetBranchAddress("mus_tk_vz", &mus_tk_vz_, &b_mus_tk_vz_);
  chainB_.SetBranchAddress("orbitNumber", &orbitNumber_, &b_orbitNumber_);
  chainB_.SetBranchAddress("photons_e1x5", &photons_e1x5_, &b_photons_e1x5_);
  chainB_.SetBranchAddress("photons_e2x5", &photons_e2x5_, &b_photons_e2x5_);
  chainB_.SetBranchAddress("photons_e3x3", &photons_e3x3_, &b_photons_e3x3_);
  chainB_.SetBranchAddress("photons_e5x5", &photons_e5x5_, &b_photons_e5x5_);
  chainB_.SetBranchAddress("photons_ecalIso", &photons_ecalIso_, &b_photons_ecalIso_);
  chainB_.SetBranchAddress("photons_energy", &photons_energy_, &b_photons_energy_);
  chainB_.SetBranchAddress("photons_et", &photons_et_, &b_photons_et_);
  chainB_.SetBranchAddress("photons_eta", &photons_eta_, &b_photons_eta_);
  chainB_.SetBranchAddress("photons_hadOverEM", &photons_hadOverEM_, &b_photons_hadOverEM_);
  chainB_.SetBranchAddress("photons_hadTowOverEM", &photons_hadTowOverEM_, &b_photons_hadTowOverEM_);
  chainB_.SetBranchAddress("photons_hasPixelSeed", &photons_hasPixelSeed_, &b_photons_hasPixelSeed_);
  chainB_.SetBranchAddress("photons_hcalIso", &photons_hcalIso_, &b_photons_hcalIso_);
  chainB_.SetBranchAddress("photons_isEBEEGap", &photons_isEBEEGap_, &b_photons_isEBEEGap_);
  chainB_.SetBranchAddress("photons_isEBGap", &photons_isEBGap_, &b_photons_isEBGap_);
  chainB_.SetBranchAddress("photons_isEBPho", &photons_isEBPho_, &b_photons_isEBPho_);
  chainB_.SetBranchAddress("photons_isEEGap", &photons_isEEGap_, &b_photons_isEEGap_);
  chainB_.SetBranchAddress("photons_isEEPho", &photons_isEEPho_, &b_photons_isEEPho_);
  chainB_.SetBranchAddress("photons_isLoosePhoton", &photons_isLoosePhoton_, &b_photons_isLoosePhoton_);
  chainB_.SetBranchAddress("photons_isTightPhoton", &photons_isTightPhoton_, &b_photons_isTightPhoton_);
  chainB_.SetBranchAddress("photons_isoEcalRecHitDR03", &photons_isoEcalRecHitDR03_, &b_photons_isoEcalRecHitDR03_);
  chainB_.SetBranchAddress("photons_isoEcalRecHitDR04", &photons_isoEcalRecHitDR04_, &b_photons_isoEcalRecHitDR04_);
  chainB_.SetBranchAddress("photons_isoHcalRecHitDR03", &photons_isoHcalRecHitDR03_, &b_photons_isoHcalRecHitDR03_);
  chainB_.SetBranchAddress("photons_isoHcalRecHitDR04", &photons_isoHcalRecHitDR04_, &b_photons_isoHcalRecHitDR04_);
  chainB_.SetBranchAddress("photons_isoHollowTrkConeDR03", &photons_isoHollowTrkConeDR03_, &b_photons_isoHollowTrkConeDR03_);
  chainB_.SetBranchAddress("photons_isoHollowTrkConeDR04", &photons_isoHollowTrkConeDR04_, &b_photons_isoHollowTrkConeDR04_);
  chainB_.SetBranchAddress("photons_isoSolidTrkConeDR03", &photons_isoSolidTrkConeDR03_, &b_photons_isoSolidTrkConeDR03_);
  chainB_.SetBranchAddress("photons_isoSolidTrkConeDR04", &photons_isoSolidTrkConeDR04_, &b_photons_isoSolidTrkConeDR04_);
  chainB_.SetBranchAddress("photons_maxEnergyXtal", &photons_maxEnergyXtal_, &b_photons_maxEnergyXtal_);
  chainB_.SetBranchAddress("photons_nTrkHollowConeDR03", &photons_nTrkHollowConeDR03_, &b_photons_nTrkHollowConeDR03_);
  chainB_.SetBranchAddress("photons_nTrkHollowConeDR04", &photons_nTrkHollowConeDR04_, &b_photons_nTrkHollowConeDR04_);
  chainB_.SetBranchAddress("photons_nTrkSolidConeDR03", &photons_nTrkSolidConeDR03_, &b_photons_nTrkSolidConeDR03_);
  chainB_.SetBranchAddress("photons_nTrkSolidConeDR04", &photons_nTrkSolidConeDR04_, &b_photons_nTrkSolidConeDR04_);
  chainB_.SetBranchAddress("photons_phi", &photons_phi_, &b_photons_phi_);
  chainB_.SetBranchAddress("photons_pt", &photons_pt_, &b_photons_pt_);
  chainB_.SetBranchAddress("photons_px", &photons_px_, &b_photons_px_);
  chainB_.SetBranchAddress("photons_py", &photons_py_, &b_photons_py_);
  chainB_.SetBranchAddress("photons_pz", &photons_pz_, &b_photons_pz_);
  chainB_.SetBranchAddress("photons_r9", &photons_r9_, &b_photons_r9_);
  chainB_.SetBranchAddress("photons_scEnergy", &photons_scEnergy_, &b_photons_scEnergy_);
  chainB_.SetBranchAddress("photons_scEta", &photons_scEta_, &b_photons_scEta_);
  chainB_.SetBranchAddress("photons_scEtaWidth", &photons_scEtaWidth_, &b_photons_scEtaWidth_);
  chainB_.SetBranchAddress("photons_scPhi", &photons_scPhi_, &b_photons_scPhi_);
  chainB_.SetBranchAddress("photons_scPhiWidth", &photons_scPhiWidth_, &b_photons_scPhiWidth_);
  chainB_.SetBranchAddress("photons_scRawEnergy", &photons_scRawEnergy_, &b_photons_scRawEnergy_);
  chainB_.SetBranchAddress("photons_sigmaEtaEta", &photons_sigmaEtaEta_, &b_photons_sigmaEtaEta_);
  chainB_.SetBranchAddress("photons_sigmaIetaIeta", &photons_sigmaIetaIeta_, &b_photons_sigmaIetaIeta_);
  chainB_.SetBranchAddress("photons_status", &photons_status_, &b_photons_status_);
  chainB_.SetBranchAddress("photons_tIso", &photons_tIso_, &b_photons_tIso_);
  chainB_.SetBranchAddress("photons_theta", &photons_theta_, &b_photons_theta_);
  chainB_.SetBranchAddress("pv_chi2", &pv_chi2_, &b_pv_chi2_);
  chainB_.SetBranchAddress("pv_isFake", &pv_isFake_, &b_pv_isFake_);
  chainB_.SetBranchAddress("pv_isValid", &pv_isValid_, &b_pv_isValid_);
  chainB_.SetBranchAddress("pv_ndof", &pv_ndof_, &b_pv_ndof_);
  chainB_.SetBranchAddress("pv_x", &pv_x_, &b_pv_x_);
  chainB_.SetBranchAddress("pv_xErr", &pv_xErr_, &b_pv_xErr_);
  chainB_.SetBranchAddress("pv_y", &pv_y_, &b_pv_y_);
  chainB_.SetBranchAddress("pv_yErr", &pv_yErr_, &b_pv_yErr_);
  chainB_.SetBranchAddress("pv_z", &pv_z_, &b_pv_z_);
  chainB_.SetBranchAddress("pv_zErr", &pv_zErr_, &b_pv_zErr_);
  chainB_.SetBranchAddress("run", &run_, &b_run_);
  chainB_.SetBranchAddress("taus_charge", &taus_charge_, &b_taus_charge_);
  chainB_.SetBranchAddress("taus_energy", &taus_energy_, &b_taus_energy_);
  chainB_.SetBranchAddress("taus_et", &taus_et_, &b_taus_et_);
  chainB_.SetBranchAddress("taus_eta", &taus_eta_, &b_taus_eta_);
  chainB_.SetBranchAddress("taus_phi", &taus_phi_, &b_taus_phi_);
  chainB_.SetBranchAddress("taus_pt", &taus_pt_, &b_taus_pt_);
  chainB_.SetBranchAddress("taus_px", &taus_px_, &b_taus_px_);
  chainB_.SetBranchAddress("taus_py", &taus_py_, &b_taus_py_);
  chainB_.SetBranchAddress("taus_pz", &taus_pz_, &b_taus_pz_);
  chainB_.SetBranchAddress("taus_status", &taus_status_, &b_taus_status_);
  chainB_.SetBranchAddress("taus_theta", &taus_theta_, &b_taus_theta_);
  chainB_.SetBranchAddress("weight", &weight_, &b_weight_);
}

UInt_t const & cfa_base::NbeamSpot() const{
  if(!c_NbeamSpot_ && b_NbeamSpot_){
    b_NbeamSpot_->GetEntry(entry_);
    c_NbeamSpot_ = true;
  }
  return NbeamSpot_;
}

UInt_t const & cfa_base::Nels() const{
  if(!c_Nels_ && b_Nels_){
    b_Nels_->GetEntry(entry_);
    c_Nels_ = true;
  }
  return Nels_;
}

UInt_t const & cfa_base::Nmc_doc() const{
  if(!c_Nmc_doc_ && b_Nmc_doc_){
    b_Nmc_doc_->GetEntry(entry_);
    c_Nmc_doc_ = true;
  }
  return Nmc_doc_;
}

UInt_t const & cfa_base::Nmus() const{
  if(!c_Nmus_ && b_Nmus_){
    b_Nmus_->GetEntry(entry_);
    c_Nmus_ = true;
  }
  return Nmus_;
}

UInt_t const & cfa_base::Nphotons() const{
  if(!c_Nphotons_ && b_Nphotons_){
    b_Nphotons_->GetEntry(entry_);
    c_Nphotons_ = true;
  }
  return Nphotons_;
}

UInt_t const & cfa_base::Npv() const{
  if(!c_Npv_ && b_Npv_){
    b_Npv_->GetEntry(entry_);
    c_Npv_ = true;
  }
  return Npv_;
}

UInt_t const & cfa_base::Ntaus() const{
  if(!c_Ntaus_ && b_Ntaus_){
    b_Ntaus_->GetEntry(entry_);
    c_Ntaus_ = true;
  }
  return Ntaus_;
}

std::vector<int>* const & cfa_base::PU_NumInteractions() const{
  if(!c_PU_NumInteractions_ && b_PU_NumInteractions_){
    b_PU_NumInteractions_->GetEntry(entry_);
    c_PU_NumInteractions_ = true;
  }
  return PU_NumInteractions_;
}

std::vector<float>* const & cfa_base::PU_TrueNumInteractions() const{
  if(!c_PU_TrueNumInteractions_ && b_PU_TrueNumInteractions_){
    b_PU_TrueNumInteractions_->GetEntry(entry_);
    c_PU_TrueNumInteractions_ = true;
  }
  return PU_TrueNumInteractions_;
}

std::vector<int>* const & cfa_base::PU_bunchCrossing() const{
  if(!c_PU_bunchCrossing_ && b_PU_bunchCrossing_){
    b_PU_bunchCrossing_->GetEntry(entry_);
    c_PU_bunchCrossing_ = true;
  }
  return PU_bunchCrossing_;
}

std::vector<std::vector<int> >* const & cfa_base::PU_ntrks_highpT() const{
  if(!c_PU_ntrks_highpT_ && b_PU_ntrks_highpT_){
    b_PU_ntrks_highpT_->GetEntry(entry_);
    c_PU_ntrks_highpT_ = true;
  }
  return PU_ntrks_highpT_;
}

std::vector<std::vector<int> >* const & cfa_base::PU_ntrks_lowpT() const{
  if(!c_PU_ntrks_lowpT_ && b_PU_ntrks_lowpT_){
    b_PU_ntrks_lowpT_->GetEntry(entry_);
    c_PU_ntrks_lowpT_ = true;
  }
  return PU_ntrks_lowpT_;
}

std::vector<std::vector<float> >* const & cfa_base::PU_sumpT_highpT() const{
  if(!c_PU_sumpT_highpT_ && b_PU_sumpT_highpT_){
    b_PU_sumpT_highpT_->GetEntry(entry_);
    c_PU_sumpT_highpT_ = true;
  }
  return PU_sumpT_highpT_;
}

std::vector<std::vector<float> >* const & cfa_base::PU_sumpT_lowpT() const{
  if(!c_PU_sumpT_lowpT_ && b_PU_sumpT_lowpT_){
    b_PU_sumpT_lowpT_->GetEntry(entry_);
    c_PU_sumpT_lowpT_ = true;
  }
  return PU_sumpT_lowpT_;
}

std::vector<std::vector<float> >* const & cfa_base::PU_zpositions() const{
  if(!c_PU_zpositions_ && b_PU_zpositions_){
    b_PU_zpositions_->GetEntry(entry_);
    c_PU_zpositions_ = true;
  }
  return PU_zpositions_;
}

std::vector<float>* const & cfa_base::beamSpot_beamWidthX() const{
  if(!c_beamSpot_beamWidthX_ && b_beamSpot_beamWidthX_){
    b_beamSpot_beamWidthX_->GetEntry(entry_);
    c_beamSpot_beamWidthX_ = true;
  }
  return beamSpot_beamWidthX_;
}

std::vector<float>* const & cfa_base::beamSpot_beamWidthXError() const{
  if(!c_beamSpot_beamWidthXError_ && b_beamSpot_beamWidthXError_){
    b_beamSpot_beamWidthXError_->GetEntry(entry_);
    c_beamSpot_beamWidthXError_ = true;
  }
  return beamSpot_beamWidthXError_;
}

std::vector<float>* const & cfa_base::beamSpot_beamWidthY() const{
  if(!c_beamSpot_beamWidthY_ && b_beamSpot_beamWidthY_){
    b_beamSpot_beamWidthY_->GetEntry(entry_);
    c_beamSpot_beamWidthY_ = true;
  }
  return beamSpot_beamWidthY_;
}

std::vector<float>* const & cfa_base::beamSpot_beamWidthYError() const{
  if(!c_beamSpot_beamWidthYError_ && b_beamSpot_beamWidthYError_){
    b_beamSpot_beamWidthYError_->GetEntry(entry_);
    c_beamSpot_beamWidthYError_ = true;
  }
  return beamSpot_beamWidthYError_;
}

std::vector<float>* const & cfa_base::beamSpot_dxdz() const{
  if(!c_beamSpot_dxdz_ && b_beamSpot_dxdz_){
    b_beamSpot_dxdz_->GetEntry(entry_);
    c_beamSpot_dxdz_ = true;
  }
  return beamSpot_dxdz_;
}

std::vector<float>* const & cfa_base::beamSpot_dxdzError() const{
  if(!c_beamSpot_dxdzError_ && b_beamSpot_dxdzError_){
    b_beamSpot_dxdzError_->GetEntry(entry_);
    c_beamSpot_dxdzError_ = true;
  }
  return beamSpot_dxdzError_;
}

std::vector<float>* const & cfa_base::beamSpot_dydz() const{
  if(!c_beamSpot_dydz_ && b_beamSpot_dydz_){
    b_beamSpot_dydz_->GetEntry(entry_);
    c_beamSpot_dydz_ = true;
  }
  return beamSpot_dydz_;
}

std::vector<float>* const & cfa_base::beamSpot_dydzError() const{
  if(!c_beamSpot_dydzError_ && b_beamSpot_dydzError_){
    b_beamSpot_dydzError_->GetEntry(entry_);
    c_beamSpot_dydzError_ = true;
  }
  return beamSpot_dydzError_;
}

std::vector<float>* const & cfa_base::beamSpot_sigmaZ() const{
  if(!c_beamSpot_sigmaZ_ && b_beamSpot_sigmaZ_){
    b_beamSpot_sigmaZ_->GetEntry(entry_);
    c_beamSpot_sigmaZ_ = true;
  }
  return beamSpot_sigmaZ_;
}

std::vector<float>* const & cfa_base::beamSpot_sigmaZ0Error() const{
  if(!c_beamSpot_sigmaZ0Error_ && b_beamSpot_sigmaZ0Error_){
    b_beamSpot_sigmaZ0Error_->GetEntry(entry_);
    c_beamSpot_sigmaZ0Error_ = true;
  }
  return beamSpot_sigmaZ0Error_;
}

std::vector<float>* const & cfa_base::beamSpot_x() const{
  if(!c_beamSpot_x_ && b_beamSpot_x_){
    b_beamSpot_x_->GetEntry(entry_);
    c_beamSpot_x_ = true;
  }
  return beamSpot_x_;
}

std::vector<float>* const & cfa_base::beamSpot_x0Error() const{
  if(!c_beamSpot_x0Error_ && b_beamSpot_x0Error_){
    b_beamSpot_x0Error_->GetEntry(entry_);
    c_beamSpot_x0Error_ = true;
  }
  return beamSpot_x0Error_;
}

std::vector<float>* const & cfa_base::beamSpot_y() const{
  if(!c_beamSpot_y_ && b_beamSpot_y_){
    b_beamSpot_y_->GetEntry(entry_);
    c_beamSpot_y_ = true;
  }
  return beamSpot_y_;
}

std::vector<float>* const & cfa_base::beamSpot_y0Error() const{
  if(!c_beamSpot_y0Error_ && b_beamSpot_y0Error_){
    b_beamSpot_y0Error_->GetEntry(entry_);
    c_beamSpot_y0Error_ = true;
  }
  return beamSpot_y0Error_;
}

std::vector<float>* const & cfa_base::beamSpot_z() const{
  if(!c_beamSpot_z_ && b_beamSpot_z_){
    b_beamSpot_z_->GetEntry(entry_);
    c_beamSpot_z_ = true;
  }
  return beamSpot_z_;
}

std::vector<float>* const & cfa_base::beamSpot_z0Error() const{
  if(!c_beamSpot_z0Error_ && b_beamSpot_z0Error_){
    b_beamSpot_z0Error_->GetEntry(entry_);
    c_beamSpot_z0Error_ = true;
  }
  return beamSpot_z0Error_;
}

UInt_t const & cfa_base::bunchCrossing() const{
  if(!c_bunchCrossing_ && b_bunchCrossing_){
    b_bunchCrossing_->GetEntry(entry_);
    c_bunchCrossing_ = true;
  }
  return bunchCrossing_;
}

Int_t const & cfa_base::cschalofilter_decision() const{
  if(!c_cschalofilter_decision_ && b_cschalofilter_decision_){
    b_cschalofilter_decision_->GetEntry(entry_);
    c_cschalofilter_decision_ = true;
  }
  return cschalofilter_decision_;
}

Int_t const & cfa_base::ecallaserfilter_decision() const{
  if(!c_ecallaserfilter_decision_ && b_ecallaserfilter_decision_){
    b_ecallaserfilter_decision_->GetEntry(entry_);
    c_ecallaserfilter_decision_ = true;
  }
  return ecallaserfilter_decision_;
}

Int_t const & cfa_base::eebadscfilter_decision() const{
  if(!c_eebadscfilter_decision_ && b_eebadscfilter_decision_){
    b_eebadscfilter_decision_->GetEntry(entry_);
    c_eebadscfilter_decision_ = true;
  }
  return eebadscfilter_decision_;
}

std::vector<float>* const & cfa_base::els_PATpassConversionVeto() const{
  if(!c_els_PATpassConversionVeto_ && b_els_PATpassConversionVeto_){
    b_els_PATpassConversionVeto_->GetEntry(entry_);
    c_els_PATpassConversionVeto_ = true;
  }
  return els_PATpassConversionVeto_;
}

std::vector<float>* const & cfa_base::els_basicClustersSize() const{
  if(!c_els_basicClustersSize_ && b_els_basicClustersSize_){
    b_els_basicClustersSize_->GetEntry(entry_);
    c_els_basicClustersSize_ = true;
  }
  return els_basicClustersSize_;
}

std::vector<float>* const & cfa_base::els_cIso() const{
  if(!c_els_cIso_ && b_els_cIso_){
    b_els_cIso_->GetEntry(entry_);
    c_els_cIso_ = true;
  }
  return els_cIso_;
}

std::vector<float>* const & cfa_base::els_caloEnergy() const{
  if(!c_els_caloEnergy_ && b_els_caloEnergy_){
    b_els_caloEnergy_->GetEntry(entry_);
    c_els_caloEnergy_ = true;
  }
  return els_caloEnergy_;
}

std::vector<float>* const & cfa_base::els_charge() const{
  if(!c_els_charge_ && b_els_charge_){
    b_els_charge_->GetEntry(entry_);
    c_els_charge_ = true;
  }
  return els_charge_;
}

std::vector<float>* const & cfa_base::els_chi2() const{
  if(!c_els_chi2_ && b_els_chi2_){
    b_els_chi2_->GetEntry(entry_);
    c_els_chi2_ = true;
  }
  return els_chi2_;
}

std::vector<float>* const & cfa_base::els_core_ecalDrivenSeed() const{
  if(!c_els_core_ecalDrivenSeed_ && b_els_core_ecalDrivenSeed_){
    b_els_core_ecalDrivenSeed_->GetEntry(entry_);
    c_els_core_ecalDrivenSeed_ = true;
  }
  return els_core_ecalDrivenSeed_;
}

std::vector<float>* const & cfa_base::els_cpx() const{
  if(!c_els_cpx_ && b_els_cpx_){
    b_els_cpx_->GetEntry(entry_);
    c_els_cpx_ = true;
  }
  return els_cpx_;
}

std::vector<float>* const & cfa_base::els_cpy() const{
  if(!c_els_cpy_ && b_els_cpy_){
    b_els_cpy_->GetEntry(entry_);
    c_els_cpy_ = true;
  }
  return els_cpy_;
}

std::vector<float>* const & cfa_base::els_cpz() const{
  if(!c_els_cpz_ && b_els_cpz_){
    b_els_cpz_->GetEntry(entry_);
    c_els_cpz_ = true;
  }
  return els_cpz_;
}

std::vector<float>* const & cfa_base::els_ctf_tk_charge() const{
  if(!c_els_ctf_tk_charge_ && b_els_ctf_tk_charge_){
    b_els_ctf_tk_charge_->GetEntry(entry_);
    c_els_ctf_tk_charge_ = true;
  }
  return els_ctf_tk_charge_;
}

std::vector<float>* const & cfa_base::els_ctf_tk_eta() const{
  if(!c_els_ctf_tk_eta_ && b_els_ctf_tk_eta_){
    b_els_ctf_tk_eta_->GetEntry(entry_);
    c_els_ctf_tk_eta_ = true;
  }
  return els_ctf_tk_eta_;
}

std::vector<float>* const & cfa_base::els_ctf_tk_id() const{
  if(!c_els_ctf_tk_id_ && b_els_ctf_tk_id_){
    b_els_ctf_tk_id_->GetEntry(entry_);
    c_els_ctf_tk_id_ = true;
  }
  return els_ctf_tk_id_;
}

std::vector<float>* const & cfa_base::els_ctf_tk_phi() const{
  if(!c_els_ctf_tk_phi_ && b_els_ctf_tk_phi_){
    b_els_ctf_tk_phi_->GetEntry(entry_);
    c_els_ctf_tk_phi_ = true;
  }
  return els_ctf_tk_phi_;
}

std::vector<float>* const & cfa_base::els_cx() const{
  if(!c_els_cx_ && b_els_cx_){
    b_els_cx_->GetEntry(entry_);
    c_els_cx_ = true;
  }
  return els_cx_;
}

std::vector<float>* const & cfa_base::els_cy() const{
  if(!c_els_cy_ && b_els_cy_){
    b_els_cy_->GetEntry(entry_);
    c_els_cy_ = true;
  }
  return els_cy_;
}

std::vector<float>* const & cfa_base::els_cz() const{
  if(!c_els_cz_ && b_els_cz_){
    b_els_cz_->GetEntry(entry_);
    c_els_cz_ = true;
  }
  return els_cz_;
}

std::vector<float>* const & cfa_base::els_d0dum() const{
  if(!c_els_d0dum_ && b_els_d0dum_){
    b_els_d0dum_->GetEntry(entry_);
    c_els_d0dum_ = true;
  }
  return els_d0dum_;
}

std::vector<float>* const & cfa_base::els_d0dumError() const{
  if(!c_els_d0dumError_ && b_els_d0dumError_){
    b_els_d0dumError_->GetEntry(entry_);
    c_els_d0dumError_ = true;
  }
  return els_d0dumError_;
}

std::vector<float>* const & cfa_base::els_dEtaIn() const{
  if(!c_els_dEtaIn_ && b_els_dEtaIn_){
    b_els_dEtaIn_->GetEntry(entry_);
    c_els_dEtaIn_ = true;
  }
  return els_dEtaIn_;
}

std::vector<float>* const & cfa_base::els_dEtaOut() const{
  if(!c_els_dEtaOut_ && b_els_dEtaOut_){
    b_els_dEtaOut_->GetEntry(entry_);
    c_els_dEtaOut_ = true;
  }
  return els_dEtaOut_;
}

std::vector<float>* const & cfa_base::els_dPhiIn() const{
  if(!c_els_dPhiIn_ && b_els_dPhiIn_){
    b_els_dPhiIn_->GetEntry(entry_);
    c_els_dPhiIn_ = true;
  }
  return els_dPhiIn_;
}

std::vector<float>* const & cfa_base::els_dPhiOut() const{
  if(!c_els_dPhiOut_ && b_els_dPhiOut_){
    b_els_dPhiOut_->GetEntry(entry_);
    c_els_dPhiOut_ = true;
  }
  return els_dPhiOut_;
}

std::vector<float>* const & cfa_base::els_dr03EcalRecHitSumEt() const{
  if(!c_els_dr03EcalRecHitSumEt_ && b_els_dr03EcalRecHitSumEt_){
    b_els_dr03EcalRecHitSumEt_->GetEntry(entry_);
    c_els_dr03EcalRecHitSumEt_ = true;
  }
  return els_dr03EcalRecHitSumEt_;
}

std::vector<float>* const & cfa_base::els_dr03HcalDepth1TowerSumEt() const{
  if(!c_els_dr03HcalDepth1TowerSumEt_ && b_els_dr03HcalDepth1TowerSumEt_){
    b_els_dr03HcalDepth1TowerSumEt_->GetEntry(entry_);
    c_els_dr03HcalDepth1TowerSumEt_ = true;
  }
  return els_dr03HcalDepth1TowerSumEt_;
}

std::vector<float>* const & cfa_base::els_dr03HcalDepth2TowerSumEt() const{
  if(!c_els_dr03HcalDepth2TowerSumEt_ && b_els_dr03HcalDepth2TowerSumEt_){
    b_els_dr03HcalDepth2TowerSumEt_->GetEntry(entry_);
    c_els_dr03HcalDepth2TowerSumEt_ = true;
  }
  return els_dr03HcalDepth2TowerSumEt_;
}

std::vector<float>* const & cfa_base::els_dr03HcalTowerSumEt() const{
  if(!c_els_dr03HcalTowerSumEt_ && b_els_dr03HcalTowerSumEt_){
    b_els_dr03HcalTowerSumEt_->GetEntry(entry_);
    c_els_dr03HcalTowerSumEt_ = true;
  }
  return els_dr03HcalTowerSumEt_;
}

std::vector<float>* const & cfa_base::els_dr03TkSumPt() const{
  if(!c_els_dr03TkSumPt_ && b_els_dr03TkSumPt_){
    b_els_dr03TkSumPt_->GetEntry(entry_);
    c_els_dr03TkSumPt_ = true;
  }
  return els_dr03TkSumPt_;
}

std::vector<float>* const & cfa_base::els_dr04EcalRecHitSumEt() const{
  if(!c_els_dr04EcalRecHitSumEt_ && b_els_dr04EcalRecHitSumEt_){
    b_els_dr04EcalRecHitSumEt_->GetEntry(entry_);
    c_els_dr04EcalRecHitSumEt_ = true;
  }
  return els_dr04EcalRecHitSumEt_;
}

std::vector<float>* const & cfa_base::els_dr04HcalDepth1TowerSumEt() const{
  if(!c_els_dr04HcalDepth1TowerSumEt_ && b_els_dr04HcalDepth1TowerSumEt_){
    b_els_dr04HcalDepth1TowerSumEt_->GetEntry(entry_);
    c_els_dr04HcalDepth1TowerSumEt_ = true;
  }
  return els_dr04HcalDepth1TowerSumEt_;
}

std::vector<float>* const & cfa_base::els_dr04HcalDepth2TowerSumEt() const{
  if(!c_els_dr04HcalDepth2TowerSumEt_ && b_els_dr04HcalDepth2TowerSumEt_){
    b_els_dr04HcalDepth2TowerSumEt_->GetEntry(entry_);
    c_els_dr04HcalDepth2TowerSumEt_ = true;
  }
  return els_dr04HcalDepth2TowerSumEt_;
}

std::vector<float>* const & cfa_base::els_dr04HcalTowerSumEt() const{
  if(!c_els_dr04HcalTowerSumEt_ && b_els_dr04HcalTowerSumEt_){
    b_els_dr04HcalTowerSumEt_->GetEntry(entry_);
    c_els_dr04HcalTowerSumEt_ = true;
  }
  return els_dr04HcalTowerSumEt_;
}

std::vector<float>* const & cfa_base::els_dr04TkSumPt() const{
  if(!c_els_dr04TkSumPt_ && b_els_dr04TkSumPt_){
    b_els_dr04TkSumPt_->GetEntry(entry_);
    c_els_dr04TkSumPt_ = true;
  }
  return els_dr04TkSumPt_;
}

std::vector<float>* const & cfa_base::els_dz() const{
  if(!c_els_dz_ && b_els_dz_){
    b_els_dz_->GetEntry(entry_);
    c_els_dz_ = true;
  }
  return els_dz_;
}

std::vector<float>* const & cfa_base::els_dzError() const{
  if(!c_els_dzError_ && b_els_dzError_){
    b_els_dzError_->GetEntry(entry_);
    c_els_dzError_ = true;
  }
  return els_dzError_;
}

std::vector<float>* const & cfa_base::els_eOverPIn() const{
  if(!c_els_eOverPIn_ && b_els_eOverPIn_){
    b_els_eOverPIn_->GetEntry(entry_);
    c_els_eOverPIn_ = true;
  }
  return els_eOverPIn_;
}

std::vector<float>* const & cfa_base::els_eSeedOverPOut() const{
  if(!c_els_eSeedOverPOut_ && b_els_eSeedOverPOut_){
    b_els_eSeedOverPOut_->GetEntry(entry_);
    c_els_eSeedOverPOut_ = true;
  }
  return els_eSeedOverPOut_;
}

std::vector<float>* const & cfa_base::els_ecalIso() const{
  if(!c_els_ecalIso_ && b_els_ecalIso_){
    b_els_ecalIso_->GetEntry(entry_);
    c_els_ecalIso_ = true;
  }
  return els_ecalIso_;
}

std::vector<float>* const & cfa_base::els_energy() const{
  if(!c_els_energy_ && b_els_energy_){
    b_els_energy_->GetEntry(entry_);
    c_els_energy_ = true;
  }
  return els_energy_;
}

std::vector<float>* const & cfa_base::els_et() const{
  if(!c_els_et_ && b_els_et_){
    b_els_et_->GetEntry(entry_);
    c_els_et_ = true;
  }
  return els_et_;
}

std::vector<float>* const & cfa_base::els_eta() const{
  if(!c_els_eta_ && b_els_eta_){
    b_els_eta_->GetEntry(entry_);
    c_els_eta_ = true;
  }
  return els_eta_;
}

std::vector<float>* const & cfa_base::els_etaError() const{
  if(!c_els_etaError_ && b_els_etaError_){
    b_els_etaError_->GetEntry(entry_);
    c_els_etaError_ = true;
  }
  return els_etaError_;
}

std::vector<float>* const & cfa_base::els_fbrem() const{
  if(!c_els_fbrem_ && b_els_fbrem_){
    b_els_fbrem_->GetEntry(entry_);
    c_els_fbrem_ = true;
  }
  return els_fbrem_;
}

std::vector<float>* const & cfa_base::els_hadOverEm() const{
  if(!c_els_hadOverEm_ && b_els_hadOverEm_){
    b_els_hadOverEm_->GetEntry(entry_);
    c_els_hadOverEm_ = true;
  }
  return els_hadOverEm_;
}

std::vector<float>* const & cfa_base::els_hcalIso() const{
  if(!c_els_hcalIso_ && b_els_hcalIso_){
    b_els_hcalIso_->GetEntry(entry_);
    c_els_hcalIso_ = true;
  }
  return els_hcalIso_;
}

std::vector<float>* const & cfa_base::els_hcalOverEcalBc() const{
  if(!c_els_hcalOverEcalBc_ && b_els_hcalOverEcalBc_){
    b_els_hcalOverEcalBc_->GetEntry(entry_);
    c_els_hcalOverEcalBc_ = true;
  }
  return els_hcalOverEcalBc_;
}

std::vector<float>* const & cfa_base::els_isEB() const{
  if(!c_els_isEB_ && b_els_isEB_){
    b_els_isEB_->GetEntry(entry_);
    c_els_isEB_ = true;
  }
  return els_isEB_;
}

std::vector<float>* const & cfa_base::els_isEE() const{
  if(!c_els_isEE_ && b_els_isEE_){
    b_els_isEE_->GetEntry(entry_);
    c_els_isEE_ = true;
  }
  return els_isEE_;
}

std::vector<float>* const & cfa_base::els_looseId() const{
  if(!c_els_looseId_ && b_els_looseId_){
    b_els_looseId_->GetEntry(entry_);
    c_els_looseId_ = true;
  }
  return els_looseId_;
}

std::vector<float>* const & cfa_base::els_ndof() const{
  if(!c_els_ndof_ && b_els_ndof_){
    b_els_ndof_->GetEntry(entry_);
    c_els_ndof_ = true;
  }
  return els_ndof_;
}

std::vector<float>* const & cfa_base::els_numlosthits() const{
  if(!c_els_numlosthits_ && b_els_numlosthits_){
    b_els_numlosthits_->GetEntry(entry_);
    c_els_numlosthits_ = true;
  }
  return els_numlosthits_;
}

std::vector<float>* const & cfa_base::els_numvalhits() const{
  if(!c_els_numvalhits_ && b_els_numvalhits_){
    b_els_numvalhits_->GetEntry(entry_);
    c_els_numvalhits_ = true;
  }
  return els_numvalhits_;
}

std::vector<float>* const & cfa_base::els_phi() const{
  if(!c_els_phi_ && b_els_phi_){
    b_els_phi_->GetEntry(entry_);
    c_els_phi_ = true;
  }
  return els_phi_;
}

std::vector<float>* const & cfa_base::els_phiError() const{
  if(!c_els_phiError_ && b_els_phiError_){
    b_els_phiError_->GetEntry(entry_);
    c_els_phiError_ = true;
  }
  return els_phiError_;
}

std::vector<float>* const & cfa_base::els_pt() const{
  if(!c_els_pt_ && b_els_pt_){
    b_els_pt_->GetEntry(entry_);
    c_els_pt_ = true;
  }
  return els_pt_;
}

std::vector<float>* const & cfa_base::els_ptError() const{
  if(!c_els_ptError_ && b_els_ptError_){
    b_els_ptError_->GetEntry(entry_);
    c_els_ptError_ = true;
  }
  return els_ptError_;
}

std::vector<float>* const & cfa_base::els_px() const{
  if(!c_els_px_ && b_els_px_){
    b_els_px_->GetEntry(entry_);
    c_els_px_ = true;
  }
  return els_px_;
}

std::vector<float>* const & cfa_base::els_py() const{
  if(!c_els_py_ && b_els_py_){
    b_els_py_->GetEntry(entry_);
    c_els_py_ = true;
  }
  return els_py_;
}

std::vector<float>* const & cfa_base::els_pz() const{
  if(!c_els_pz_ && b_els_pz_){
    b_els_pz_->GetEntry(entry_);
    c_els_pz_ = true;
  }
  return els_pz_;
}

std::vector<float>* const & cfa_base::els_robustHighEnergyId() const{
  if(!c_els_robustHighEnergyId_ && b_els_robustHighEnergyId_){
    b_els_robustHighEnergyId_->GetEntry(entry_);
    c_els_robustHighEnergyId_ = true;
  }
  return els_robustHighEnergyId_;
}

std::vector<float>* const & cfa_base::els_robustLooseId() const{
  if(!c_els_robustLooseId_ && b_els_robustLooseId_){
    b_els_robustLooseId_->GetEntry(entry_);
    c_els_robustLooseId_ = true;
  }
  return els_robustLooseId_;
}

std::vector<float>* const & cfa_base::els_robustTightId() const{
  if(!c_els_robustTightId_ && b_els_robustTightId_){
    b_els_robustTightId_->GetEntry(entry_);
    c_els_robustTightId_ = true;
  }
  return els_robustTightId_;
}

std::vector<float>* const & cfa_base::els_scE1x5() const{
  if(!c_els_scE1x5_ && b_els_scE1x5_){
    b_els_scE1x5_->GetEntry(entry_);
    c_els_scE1x5_ = true;
  }
  return els_scE1x5_;
}

std::vector<float>* const & cfa_base::els_scE2x5Max() const{
  if(!c_els_scE2x5Max_ && b_els_scE2x5Max_){
    b_els_scE2x5Max_->GetEntry(entry_);
    c_els_scE2x5Max_ = true;
  }
  return els_scE2x5Max_;
}

std::vector<float>* const & cfa_base::els_scE5x5() const{
  if(!c_els_scE5x5_ && b_els_scE5x5_){
    b_els_scE5x5_->GetEntry(entry_);
    c_els_scE5x5_ = true;
  }
  return els_scE5x5_;
}

std::vector<float>* const & cfa_base::els_scEnergy() const{
  if(!c_els_scEnergy_ && b_els_scEnergy_){
    b_els_scEnergy_->GetEntry(entry_);
    c_els_scEnergy_ = true;
  }
  return els_scEnergy_;
}

std::vector<float>* const & cfa_base::els_scEta() const{
  if(!c_els_scEta_ && b_els_scEta_){
    b_els_scEta_->GetEntry(entry_);
    c_els_scEta_ = true;
  }
  return els_scEta_;
}

std::vector<float>* const & cfa_base::els_scEtaWidth() const{
  if(!c_els_scEtaWidth_ && b_els_scEtaWidth_){
    b_els_scEtaWidth_->GetEntry(entry_);
    c_els_scEtaWidth_ = true;
  }
  return els_scEtaWidth_;
}

std::vector<float>* const & cfa_base::els_scPhi() const{
  if(!c_els_scPhi_ && b_els_scPhi_){
    b_els_scPhi_->GetEntry(entry_);
    c_els_scPhi_ = true;
  }
  return els_scPhi_;
}

std::vector<float>* const & cfa_base::els_scPhiWidth() const{
  if(!c_els_scPhiWidth_ && b_els_scPhiWidth_){
    b_els_scPhiWidth_->GetEntry(entry_);
    c_els_scPhiWidth_ = true;
  }
  return els_scPhiWidth_;
}

std::vector<float>* const & cfa_base::els_scRawEnergy() const{
  if(!c_els_scRawEnergy_ && b_els_scRawEnergy_){
    b_els_scRawEnergy_->GetEntry(entry_);
    c_els_scRawEnergy_ = true;
  }
  return els_scRawEnergy_;
}

std::vector<float>* const & cfa_base::els_scSeedEnergy() const{
  if(!c_els_scSeedEnergy_ && b_els_scSeedEnergy_){
    b_els_scSeedEnergy_->GetEntry(entry_);
    c_els_scSeedEnergy_ = true;
  }
  return els_scSeedEnergy_;
}

std::vector<float>* const & cfa_base::els_shFracInnerHits() const{
  if(!c_els_shFracInnerHits_ && b_els_shFracInnerHits_){
    b_els_shFracInnerHits_->GetEntry(entry_);
    c_els_shFracInnerHits_ = true;
  }
  return els_shFracInnerHits_;
}

std::vector<float>* const & cfa_base::els_sigmaEtaEta() const{
  if(!c_els_sigmaEtaEta_ && b_els_sigmaEtaEta_){
    b_els_sigmaEtaEta_->GetEntry(entry_);
    c_els_sigmaEtaEta_ = true;
  }
  return els_sigmaEtaEta_;
}

std::vector<float>* const & cfa_base::els_sigmaIEtaIEta() const{
  if(!c_els_sigmaIEtaIEta_ && b_els_sigmaIEtaIEta_){
    b_els_sigmaIEtaIEta_->GetEntry(entry_);
    c_els_sigmaIEtaIEta_ = true;
  }
  return els_sigmaIEtaIEta_;
}

std::vector<float>* const & cfa_base::els_status() const{
  if(!c_els_status_ && b_els_status_){
    b_els_status_->GetEntry(entry_);
    c_els_status_ = true;
  }
  return els_status_;
}

std::vector<float>* const & cfa_base::els_tIso() const{
  if(!c_els_tIso_ && b_els_tIso_){
    b_els_tIso_->GetEntry(entry_);
    c_els_tIso_ = true;
  }
  return els_tIso_;
}

std::vector<float>* const & cfa_base::els_theta() const{
  if(!c_els_theta_ && b_els_theta_){
    b_els_theta_->GetEntry(entry_);
    c_els_theta_ = true;
  }
  return els_theta_;
}

std::vector<float>* const & cfa_base::els_tightId() const{
  if(!c_els_tightId_ && b_els_tightId_){
    b_els_tightId_->GetEntry(entry_);
    c_els_tightId_ = true;
  }
  return els_tightId_;
}

std::vector<float>* const & cfa_base::els_tk_charge() const{
  if(!c_els_tk_charge_ && b_els_tk_charge_){
    b_els_tk_charge_->GetEntry(entry_);
    c_els_tk_charge_ = true;
  }
  return els_tk_charge_;
}

std::vector<float>* const & cfa_base::els_tk_eta() const{
  if(!c_els_tk_eta_ && b_els_tk_eta_){
    b_els_tk_eta_->GetEntry(entry_);
    c_els_tk_eta_ = true;
  }
  return els_tk_eta_;
}

std::vector<float>* const & cfa_base::els_tk_phi() const{
  if(!c_els_tk_phi_ && b_els_tk_phi_){
    b_els_tk_phi_->GetEntry(entry_);
    c_els_tk_phi_ = true;
  }
  return els_tk_phi_;
}

std::vector<float>* const & cfa_base::els_tk_pt() const{
  if(!c_els_tk_pt_ && b_els_tk_pt_){
    b_els_tk_pt_->GetEntry(entry_);
    c_els_tk_pt_ = true;
  }
  return els_tk_pt_;
}

std::vector<float>* const & cfa_base::els_tk_pz() const{
  if(!c_els_tk_pz_ && b_els_tk_pz_){
    b_els_tk_pz_->GetEntry(entry_);
    c_els_tk_pz_ = true;
  }
  return els_tk_pz_;
}

std::vector<float>* const & cfa_base::els_vpx() const{
  if(!c_els_vpx_ && b_els_vpx_){
    b_els_vpx_->GetEntry(entry_);
    c_els_vpx_ = true;
  }
  return els_vpx_;
}

std::vector<float>* const & cfa_base::els_vpy() const{
  if(!c_els_vpy_ && b_els_vpy_){
    b_els_vpy_->GetEntry(entry_);
    c_els_vpy_ = true;
  }
  return els_vpy_;
}

std::vector<float>* const & cfa_base::els_vpz() const{
  if(!c_els_vpz_ && b_els_vpz_){
    b_els_vpz_->GetEntry(entry_);
    c_els_vpz_ = true;
  }
  return els_vpz_;
}

std::vector<float>* const & cfa_base::els_vx() const{
  if(!c_els_vx_ && b_els_vx_){
    b_els_vx_->GetEntry(entry_);
    c_els_vx_ = true;
  }
  return els_vx_;
}

std::vector<float>* const & cfa_base::els_vy() const{
  if(!c_els_vy_ && b_els_vy_){
    b_els_vy_->GetEntry(entry_);
    c_els_vy_ = true;
  }
  return els_vy_;
}

std::vector<float>* const & cfa_base::els_vz() const{
  if(!c_els_vz_ && b_els_vz_){
    b_els_vz_->GetEntry(entry_);
    c_els_vz_ = true;
  }
  return els_vz_;
}

UInt_t const & cfa_base::event() const{
  if(!c_event_ && b_event_){
    b_event_->GetEntry(entry_);
    c_event_ = true;
  }
  return event_;
}

UInt_t const & cfa_base::experimentType() const{
  if(!c_experimentType_ && b_experimentType_){
    b_experimentType_->GetEntry(entry_);
    c_experimentType_ = true;
  }
  return experimentType_;
}

Float_t const & cfa_base::genHT() const{
  if(!c_genHT_ && b_genHT_){
    b_genHT_->GetEntry(entry_);
    c_genHT_ = true;
  }
  return genHT_;
}

Int_t const & cfa_base::hcallaserfilter_decision() const{
  if(!c_hcallaserfilter_decision_ && b_hcallaserfilter_decision_){
    b_hcallaserfilter_decision_->GetEntry(entry_);
    c_hcallaserfilter_decision_ = true;
  }
  return hcallaserfilter_decision_;
}

UInt_t const & cfa_base::lumiblock() const{
  if(!c_lumiblock_ && b_lumiblock_){
    b_lumiblock_->GetEntry(entry_);
    c_lumiblock_ = true;
  }
  return lumiblock_;
}

std::vector<float>* const & cfa_base::mc_doc_charge() const{
  if(!c_mc_doc_charge_ && b_mc_doc_charge_){
    b_mc_doc_charge_->GetEntry(entry_);
    c_mc_doc_charge_ = true;
  }
  return mc_doc_charge_;
}

std::vector<float>* const & cfa_base::mc_doc_energy() const{
  if(!c_mc_doc_energy_ && b_mc_doc_energy_){
    b_mc_doc_energy_->GetEntry(entry_);
    c_mc_doc_energy_ = true;
  }
  return mc_doc_energy_;
}

std::vector<float>* const & cfa_base::mc_doc_eta() const{
  if(!c_mc_doc_eta_ && b_mc_doc_eta_){
    b_mc_doc_eta_->GetEntry(entry_);
    c_mc_doc_eta_ = true;
  }
  return mc_doc_eta_;
}

std::vector<float>* const & cfa_base::mc_doc_ggrandmother_id() const{
  if(!c_mc_doc_ggrandmother_id_ && b_mc_doc_ggrandmother_id_){
    b_mc_doc_ggrandmother_id_->GetEntry(entry_);
    c_mc_doc_ggrandmother_id_ = true;
  }
  return mc_doc_ggrandmother_id_;
}

std::vector<float>* const & cfa_base::mc_doc_grandmother_id() const{
  if(!c_mc_doc_grandmother_id_ && b_mc_doc_grandmother_id_){
    b_mc_doc_grandmother_id_->GetEntry(entry_);
    c_mc_doc_grandmother_id_ = true;
  }
  return mc_doc_grandmother_id_;
}

std::vector<float>* const & cfa_base::mc_doc_id() const{
  if(!c_mc_doc_id_ && b_mc_doc_id_){
    b_mc_doc_id_->GetEntry(entry_);
    c_mc_doc_id_ = true;
  }
  return mc_doc_id_;
}

std::vector<float>* const & cfa_base::mc_doc_mass() const{
  if(!c_mc_doc_mass_ && b_mc_doc_mass_){
    b_mc_doc_mass_->GetEntry(entry_);
    c_mc_doc_mass_ = true;
  }
  return mc_doc_mass_;
}

std::vector<float>* const & cfa_base::mc_doc_mother_id() const{
  if(!c_mc_doc_mother_id_ && b_mc_doc_mother_id_){
    b_mc_doc_mother_id_->GetEntry(entry_);
    c_mc_doc_mother_id_ = true;
  }
  return mc_doc_mother_id_;
}

std::vector<float>* const & cfa_base::mc_doc_numOfDaughters() const{
  if(!c_mc_doc_numOfDaughters_ && b_mc_doc_numOfDaughters_){
    b_mc_doc_numOfDaughters_->GetEntry(entry_);
    c_mc_doc_numOfDaughters_ = true;
  }
  return mc_doc_numOfDaughters_;
}

std::vector<float>* const & cfa_base::mc_doc_numOfMothers() const{
  if(!c_mc_doc_numOfMothers_ && b_mc_doc_numOfMothers_){
    b_mc_doc_numOfMothers_->GetEntry(entry_);
    c_mc_doc_numOfMothers_ = true;
  }
  return mc_doc_numOfMothers_;
}

std::vector<float>* const & cfa_base::mc_doc_phi() const{
  if(!c_mc_doc_phi_ && b_mc_doc_phi_){
    b_mc_doc_phi_->GetEntry(entry_);
    c_mc_doc_phi_ = true;
  }
  return mc_doc_phi_;
}

std::vector<float>* const & cfa_base::mc_doc_pt() const{
  if(!c_mc_doc_pt_ && b_mc_doc_pt_){
    b_mc_doc_pt_->GetEntry(entry_);
    c_mc_doc_pt_ = true;
  }
  return mc_doc_pt_;
}

std::vector<float>* const & cfa_base::mc_doc_px() const{
  if(!c_mc_doc_px_ && b_mc_doc_px_){
    b_mc_doc_px_->GetEntry(entry_);
    c_mc_doc_px_ = true;
  }
  return mc_doc_px_;
}

std::vector<float>* const & cfa_base::mc_doc_py() const{
  if(!c_mc_doc_py_ && b_mc_doc_py_){
    b_mc_doc_py_->GetEntry(entry_);
    c_mc_doc_py_ = true;
  }
  return mc_doc_py_;
}

std::vector<float>* const & cfa_base::mc_doc_pz() const{
  if(!c_mc_doc_pz_ && b_mc_doc_pz_){
    b_mc_doc_pz_->GetEntry(entry_);
    c_mc_doc_pz_ = true;
  }
  return mc_doc_pz_;
}

std::vector<float>* const & cfa_base::mc_doc_status() const{
  if(!c_mc_doc_status_ && b_mc_doc_status_){
    b_mc_doc_status_->GetEntry(entry_);
    c_mc_doc_status_ = true;
  }
  return mc_doc_status_;
}

std::vector<float>* const & cfa_base::mc_doc_vertex_x() const{
  if(!c_mc_doc_vertex_x_ && b_mc_doc_vertex_x_){
    b_mc_doc_vertex_x_->GetEntry(entry_);
    c_mc_doc_vertex_x_ = true;
  }
  return mc_doc_vertex_x_;
}

std::vector<float>* const & cfa_base::mc_doc_vertex_y() const{
  if(!c_mc_doc_vertex_y_ && b_mc_doc_vertex_y_){
    b_mc_doc_vertex_y_->GetEntry(entry_);
    c_mc_doc_vertex_y_ = true;
  }
  return mc_doc_vertex_y_;
}

std::vector<float>* const & cfa_base::mc_doc_vertex_z() const{
  if(!c_mc_doc_vertex_z_ && b_mc_doc_vertex_z_){
    b_mc_doc_vertex_z_->GetEntry(entry_);
    c_mc_doc_vertex_z_ = true;
  }
  return mc_doc_vertex_z_;
}

std::string* const & cfa_base::model_params() const{
  if(!c_model_params_ && b_model_params_){
    b_model_params_->GetEntry(entry_);
    c_model_params_ = true;
  }
  return model_params_;
}

std::vector<float>* const & cfa_base::mus_cIso() const{
  if(!c_mus_cIso_ && b_mus_cIso_){
    b_mus_cIso_->GetEntry(entry_);
    c_mus_cIso_ = true;
  }
  return mus_cIso_;
}

std::vector<float>* const & cfa_base::mus_calEnergyEm() const{
  if(!c_mus_calEnergyEm_ && b_mus_calEnergyEm_){
    b_mus_calEnergyEm_->GetEntry(entry_);
    c_mus_calEnergyEm_ = true;
  }
  return mus_calEnergyEm_;
}

std::vector<float>* const & cfa_base::mus_calEnergyEmS9() const{
  if(!c_mus_calEnergyEmS9_ && b_mus_calEnergyEmS9_){
    b_mus_calEnergyEmS9_->GetEntry(entry_);
    c_mus_calEnergyEmS9_ = true;
  }
  return mus_calEnergyEmS9_;
}

std::vector<float>* const & cfa_base::mus_calEnergyHad() const{
  if(!c_mus_calEnergyHad_ && b_mus_calEnergyHad_){
    b_mus_calEnergyHad_->GetEntry(entry_);
    c_mus_calEnergyHad_ = true;
  }
  return mus_calEnergyHad_;
}

std::vector<float>* const & cfa_base::mus_calEnergyHadS9() const{
  if(!c_mus_calEnergyHadS9_ && b_mus_calEnergyHadS9_){
    b_mus_calEnergyHadS9_->GetEntry(entry_);
    c_mus_calEnergyHadS9_ = true;
  }
  return mus_calEnergyHadS9_;
}

std::vector<float>* const & cfa_base::mus_calEnergyHo() const{
  if(!c_mus_calEnergyHo_ && b_mus_calEnergyHo_){
    b_mus_calEnergyHo_->GetEntry(entry_);
    c_mus_calEnergyHo_ = true;
  }
  return mus_calEnergyHo_;
}

std::vector<float>* const & cfa_base::mus_calEnergyHoS9() const{
  if(!c_mus_calEnergyHoS9_ && b_mus_calEnergyHoS9_){
    b_mus_calEnergyHoS9_->GetEntry(entry_);
    c_mus_calEnergyHoS9_ = true;
  }
  return mus_calEnergyHoS9_;
}

std::vector<float>* const & cfa_base::mus_charge() const{
  if(!c_mus_charge_ && b_mus_charge_){
    b_mus_charge_->GetEntry(entry_);
    c_mus_charge_ = true;
  }
  return mus_charge_;
}

std::vector<float>* const & cfa_base::mus_cm_LayersWithMeasurement() const{
  if(!c_mus_cm_LayersWithMeasurement_ && b_mus_cm_LayersWithMeasurement_){
    b_mus_cm_LayersWithMeasurement_->GetEntry(entry_);
    c_mus_cm_LayersWithMeasurement_ = true;
  }
  return mus_cm_LayersWithMeasurement_;
}

std::vector<float>* const & cfa_base::mus_cm_LayersWithoutMeasurement() const{
  if(!c_mus_cm_LayersWithoutMeasurement_ && b_mus_cm_LayersWithoutMeasurement_){
    b_mus_cm_LayersWithoutMeasurement_->GetEntry(entry_);
    c_mus_cm_LayersWithoutMeasurement_ = true;
  }
  return mus_cm_LayersWithoutMeasurement_;
}

std::vector<float>* const & cfa_base::mus_cm_PixelLayersWithMeasurement() const{
  if(!c_mus_cm_PixelLayersWithMeasurement_ && b_mus_cm_PixelLayersWithMeasurement_){
    b_mus_cm_PixelLayersWithMeasurement_->GetEntry(entry_);
    c_mus_cm_PixelLayersWithMeasurement_ = true;
  }
  return mus_cm_PixelLayersWithMeasurement_;
}

std::vector<float>* const & cfa_base::mus_cm_ValidStripLayersWithMonoAndStereoHit() const{
  if(!c_mus_cm_ValidStripLayersWithMonoAndStereoHit_ && b_mus_cm_ValidStripLayersWithMonoAndStereoHit_){
    b_mus_cm_ValidStripLayersWithMonoAndStereoHit_->GetEntry(entry_);
    c_mus_cm_ValidStripLayersWithMonoAndStereoHit_ = true;
  }
  return mus_cm_ValidStripLayersWithMonoAndStereoHit_;
}

std::vector<float>* const & cfa_base::mus_cm_chg() const{
  if(!c_mus_cm_chg_ && b_mus_cm_chg_){
    b_mus_cm_chg_->GetEntry(entry_);
    c_mus_cm_chg_ = true;
  }
  return mus_cm_chg_;
}

std::vector<float>* const & cfa_base::mus_cm_chi2() const{
  if(!c_mus_cm_chi2_ && b_mus_cm_chi2_){
    b_mus_cm_chi2_->GetEntry(entry_);
    c_mus_cm_chi2_ = true;
  }
  return mus_cm_chi2_;
}

std::vector<float>* const & cfa_base::mus_cm_d0dum() const{
  if(!c_mus_cm_d0dum_ && b_mus_cm_d0dum_){
    b_mus_cm_d0dum_->GetEntry(entry_);
    c_mus_cm_d0dum_ = true;
  }
  return mus_cm_d0dum_;
}

std::vector<float>* const & cfa_base::mus_cm_d0dumErr() const{
  if(!c_mus_cm_d0dumErr_ && b_mus_cm_d0dumErr_){
    b_mus_cm_d0dumErr_->GetEntry(entry_);
    c_mus_cm_d0dumErr_ = true;
  }
  return mus_cm_d0dumErr_;
}

std::vector<float>* const & cfa_base::mus_cm_dz() const{
  if(!c_mus_cm_dz_ && b_mus_cm_dz_){
    b_mus_cm_dz_->GetEntry(entry_);
    c_mus_cm_dz_ = true;
  }
  return mus_cm_dz_;
}

std::vector<float>* const & cfa_base::mus_cm_dzErr() const{
  if(!c_mus_cm_dzErr_ && b_mus_cm_dzErr_){
    b_mus_cm_dzErr_->GetEntry(entry_);
    c_mus_cm_dzErr_ = true;
  }
  return mus_cm_dzErr_;
}

std::vector<float>* const & cfa_base::mus_cm_eta() const{
  if(!c_mus_cm_eta_ && b_mus_cm_eta_){
    b_mus_cm_eta_->GetEntry(entry_);
    c_mus_cm_eta_ = true;
  }
  return mus_cm_eta_;
}

std::vector<float>* const & cfa_base::mus_cm_etaErr() const{
  if(!c_mus_cm_etaErr_ && b_mus_cm_etaErr_){
    b_mus_cm_etaErr_->GetEntry(entry_);
    c_mus_cm_etaErr_ = true;
  }
  return mus_cm_etaErr_;
}

std::vector<float>* const & cfa_base::mus_cm_ndof() const{
  if(!c_mus_cm_ndof_ && b_mus_cm_ndof_){
    b_mus_cm_ndof_->GetEntry(entry_);
    c_mus_cm_ndof_ = true;
  }
  return mus_cm_ndof_;
}

std::vector<float>* const & cfa_base::mus_cm_numlosthits() const{
  if(!c_mus_cm_numlosthits_ && b_mus_cm_numlosthits_){
    b_mus_cm_numlosthits_->GetEntry(entry_);
    c_mus_cm_numlosthits_ = true;
  }
  return mus_cm_numlosthits_;
}

std::vector<float>* const & cfa_base::mus_cm_numvalMuonhits() const{
  if(!c_mus_cm_numvalMuonhits_ && b_mus_cm_numvalMuonhits_){
    b_mus_cm_numvalMuonhits_->GetEntry(entry_);
    c_mus_cm_numvalMuonhits_ = true;
  }
  return mus_cm_numvalMuonhits_;
}

std::vector<float>* const & cfa_base::mus_cm_numvalhits() const{
  if(!c_mus_cm_numvalhits_ && b_mus_cm_numvalhits_){
    b_mus_cm_numvalhits_->GetEntry(entry_);
    c_mus_cm_numvalhits_ = true;
  }
  return mus_cm_numvalhits_;
}

std::vector<float>* const & cfa_base::mus_cm_phi() const{
  if(!c_mus_cm_phi_ && b_mus_cm_phi_){
    b_mus_cm_phi_->GetEntry(entry_);
    c_mus_cm_phi_ = true;
  }
  return mus_cm_phi_;
}

std::vector<float>* const & cfa_base::mus_cm_phiErr() const{
  if(!c_mus_cm_phiErr_ && b_mus_cm_phiErr_){
    b_mus_cm_phiErr_->GetEntry(entry_);
    c_mus_cm_phiErr_ = true;
  }
  return mus_cm_phiErr_;
}

std::vector<float>* const & cfa_base::mus_cm_pt() const{
  if(!c_mus_cm_pt_ && b_mus_cm_pt_){
    b_mus_cm_pt_->GetEntry(entry_);
    c_mus_cm_pt_ = true;
  }
  return mus_cm_pt_;
}

std::vector<float>* const & cfa_base::mus_cm_ptErr() const{
  if(!c_mus_cm_ptErr_ && b_mus_cm_ptErr_){
    b_mus_cm_ptErr_->GetEntry(entry_);
    c_mus_cm_ptErr_ = true;
  }
  return mus_cm_ptErr_;
}

std::vector<float>* const & cfa_base::mus_cm_px() const{
  if(!c_mus_cm_px_ && b_mus_cm_px_){
    b_mus_cm_px_->GetEntry(entry_);
    c_mus_cm_px_ = true;
  }
  return mus_cm_px_;
}

std::vector<float>* const & cfa_base::mus_cm_py() const{
  if(!c_mus_cm_py_ && b_mus_cm_py_){
    b_mus_cm_py_->GetEntry(entry_);
    c_mus_cm_py_ = true;
  }
  return mus_cm_py_;
}

std::vector<float>* const & cfa_base::mus_cm_pz() const{
  if(!c_mus_cm_pz_ && b_mus_cm_pz_){
    b_mus_cm_pz_->GetEntry(entry_);
    c_mus_cm_pz_ = true;
  }
  return mus_cm_pz_;
}

std::vector<float>* const & cfa_base::mus_cm_theta() const{
  if(!c_mus_cm_theta_ && b_mus_cm_theta_){
    b_mus_cm_theta_->GetEntry(entry_);
    c_mus_cm_theta_ = true;
  }
  return mus_cm_theta_;
}

std::vector<float>* const & cfa_base::mus_cm_vx() const{
  if(!c_mus_cm_vx_ && b_mus_cm_vx_){
    b_mus_cm_vx_->GetEntry(entry_);
    c_mus_cm_vx_ = true;
  }
  return mus_cm_vx_;
}

std::vector<float>* const & cfa_base::mus_cm_vy() const{
  if(!c_mus_cm_vy_ && b_mus_cm_vy_){
    b_mus_cm_vy_->GetEntry(entry_);
    c_mus_cm_vy_ = true;
  }
  return mus_cm_vy_;
}

std::vector<float>* const & cfa_base::mus_cm_vz() const{
  if(!c_mus_cm_vz_ && b_mus_cm_vz_){
    b_mus_cm_vz_->GetEntry(entry_);
    c_mus_cm_vz_ = true;
  }
  return mus_cm_vz_;
}

std::vector<float>* const & cfa_base::mus_dB() const{
  if(!c_mus_dB_ && b_mus_dB_){
    b_mus_dB_->GetEntry(entry_);
    c_mus_dB_ = true;
  }
  return mus_dB_;
}

std::vector<float>* const & cfa_base::mus_ecalIso() const{
  if(!c_mus_ecalIso_ && b_mus_ecalIso_){
    b_mus_ecalIso_->GetEntry(entry_);
    c_mus_ecalIso_ = true;
  }
  return mus_ecalIso_;
}

std::vector<float>* const & cfa_base::mus_ecalvetoDep() const{
  if(!c_mus_ecalvetoDep_ && b_mus_ecalvetoDep_){
    b_mus_ecalvetoDep_->GetEntry(entry_);
    c_mus_ecalvetoDep_ = true;
  }
  return mus_ecalvetoDep_;
}

std::vector<float>* const & cfa_base::mus_energy() const{
  if(!c_mus_energy_ && b_mus_energy_){
    b_mus_energy_->GetEntry(entry_);
    c_mus_energy_ = true;
  }
  return mus_energy_;
}

std::vector<float>* const & cfa_base::mus_et() const{
  if(!c_mus_et_ && b_mus_et_){
    b_mus_et_->GetEntry(entry_);
    c_mus_et_ = true;
  }
  return mus_et_;
}

std::vector<float>* const & cfa_base::mus_eta() const{
  if(!c_mus_eta_ && b_mus_eta_){
    b_mus_eta_->GetEntry(entry_);
    c_mus_eta_ = true;
  }
  return mus_eta_;
}

std::vector<float>* const & cfa_base::mus_hcalIso() const{
  if(!c_mus_hcalIso_ && b_mus_hcalIso_){
    b_mus_hcalIso_->GetEntry(entry_);
    c_mus_hcalIso_ = true;
  }
  return mus_hcalIso_;
}

std::vector<float>* const & cfa_base::mus_hcalvetoDep() const{
  if(!c_mus_hcalvetoDep_ && b_mus_hcalvetoDep_){
    b_mus_hcalvetoDep_->GetEntry(entry_);
    c_mus_hcalvetoDep_ = true;
  }
  return mus_hcalvetoDep_;
}

std::vector<float>* const & cfa_base::mus_id_All() const{
  if(!c_mus_id_All_ && b_mus_id_All_){
    b_mus_id_All_->GetEntry(entry_);
    c_mus_id_All_ = true;
  }
  return mus_id_All_;
}

std::vector<float>* const & cfa_base::mus_id_AllArbitrated() const{
  if(!c_mus_id_AllArbitrated_ && b_mus_id_AllArbitrated_){
    b_mus_id_AllArbitrated_->GetEntry(entry_);
    c_mus_id_AllArbitrated_ = true;
  }
  return mus_id_AllArbitrated_;
}

std::vector<float>* const & cfa_base::mus_id_AllGlobalMuons() const{
  if(!c_mus_id_AllGlobalMuons_ && b_mus_id_AllGlobalMuons_){
    b_mus_id_AllGlobalMuons_->GetEntry(entry_);
    c_mus_id_AllGlobalMuons_ = true;
  }
  return mus_id_AllGlobalMuons_;
}

std::vector<float>* const & cfa_base::mus_id_AllStandAloneMuons() const{
  if(!c_mus_id_AllStandAloneMuons_ && b_mus_id_AllStandAloneMuons_){
    b_mus_id_AllStandAloneMuons_->GetEntry(entry_);
    c_mus_id_AllStandAloneMuons_ = true;
  }
  return mus_id_AllStandAloneMuons_;
}

std::vector<float>* const & cfa_base::mus_id_AllTrackerMuons() const{
  if(!c_mus_id_AllTrackerMuons_ && b_mus_id_AllTrackerMuons_){
    b_mus_id_AllTrackerMuons_->GetEntry(entry_);
    c_mus_id_AllTrackerMuons_ = true;
  }
  return mus_id_AllTrackerMuons_;
}

std::vector<float>* const & cfa_base::mus_id_GlobalMuonPromptTight() const{
  if(!c_mus_id_GlobalMuonPromptTight_ && b_mus_id_GlobalMuonPromptTight_){
    b_mus_id_GlobalMuonPromptTight_->GetEntry(entry_);
    c_mus_id_GlobalMuonPromptTight_ = true;
  }
  return mus_id_GlobalMuonPromptTight_;
}

std::vector<float>* const & cfa_base::mus_id_TM2DCompatibilityLoose() const{
  if(!c_mus_id_TM2DCompatibilityLoose_ && b_mus_id_TM2DCompatibilityLoose_){
    b_mus_id_TM2DCompatibilityLoose_->GetEntry(entry_);
    c_mus_id_TM2DCompatibilityLoose_ = true;
  }
  return mus_id_TM2DCompatibilityLoose_;
}

std::vector<float>* const & cfa_base::mus_id_TM2DCompatibilityTight() const{
  if(!c_mus_id_TM2DCompatibilityTight_ && b_mus_id_TM2DCompatibilityTight_){
    b_mus_id_TM2DCompatibilityTight_->GetEntry(entry_);
    c_mus_id_TM2DCompatibilityTight_ = true;
  }
  return mus_id_TM2DCompatibilityTight_;
}

std::vector<float>* const & cfa_base::mus_id_TMLastStationLoose() const{
  if(!c_mus_id_TMLastStationLoose_ && b_mus_id_TMLastStationLoose_){
    b_mus_id_TMLastStationLoose_->GetEntry(entry_);
    c_mus_id_TMLastStationLoose_ = true;
  }
  return mus_id_TMLastStationLoose_;
}

std::vector<float>* const & cfa_base::mus_id_TMLastStationOptimizedLowPtLoose() const{
  if(!c_mus_id_TMLastStationOptimizedLowPtLoose_ && b_mus_id_TMLastStationOptimizedLowPtLoose_){
    b_mus_id_TMLastStationOptimizedLowPtLoose_->GetEntry(entry_);
    c_mus_id_TMLastStationOptimizedLowPtLoose_ = true;
  }
  return mus_id_TMLastStationOptimizedLowPtLoose_;
}

std::vector<float>* const & cfa_base::mus_id_TMLastStationOptimizedLowPtTight() const{
  if(!c_mus_id_TMLastStationOptimizedLowPtTight_ && b_mus_id_TMLastStationOptimizedLowPtTight_){
    b_mus_id_TMLastStationOptimizedLowPtTight_->GetEntry(entry_);
    c_mus_id_TMLastStationOptimizedLowPtTight_ = true;
  }
  return mus_id_TMLastStationOptimizedLowPtTight_;
}

std::vector<float>* const & cfa_base::mus_id_TMLastStationTight() const{
  if(!c_mus_id_TMLastStationTight_ && b_mus_id_TMLastStationTight_){
    b_mus_id_TMLastStationTight_->GetEntry(entry_);
    c_mus_id_TMLastStationTight_ = true;
  }
  return mus_id_TMLastStationTight_;
}

std::vector<float>* const & cfa_base::mus_id_TMOneStationLoose() const{
  if(!c_mus_id_TMOneStationLoose_ && b_mus_id_TMOneStationLoose_){
    b_mus_id_TMOneStationLoose_->GetEntry(entry_);
    c_mus_id_TMOneStationLoose_ = true;
  }
  return mus_id_TMOneStationLoose_;
}

std::vector<float>* const & cfa_base::mus_id_TMOneStationTight() const{
  if(!c_mus_id_TMOneStationTight_ && b_mus_id_TMOneStationTight_){
    b_mus_id_TMOneStationTight_->GetEntry(entry_);
    c_mus_id_TMOneStationTight_ = true;
  }
  return mus_id_TMOneStationTight_;
}

std::vector<float>* const & cfa_base::mus_id_TrackerMuonArbitrated() const{
  if(!c_mus_id_TrackerMuonArbitrated_ && b_mus_id_TrackerMuonArbitrated_){
    b_mus_id_TrackerMuonArbitrated_->GetEntry(entry_);
    c_mus_id_TrackerMuonArbitrated_ = true;
  }
  return mus_id_TrackerMuonArbitrated_;
}

std::vector<float>* const & cfa_base::mus_isGlobalMuon() const{
  if(!c_mus_isGlobalMuon_ && b_mus_isGlobalMuon_){
    b_mus_isGlobalMuon_->GetEntry(entry_);
    c_mus_isGlobalMuon_ = true;
  }
  return mus_isGlobalMuon_;
}

std::vector<float>* const & cfa_base::mus_isPFMuon() const{
  if(!c_mus_isPFMuon_ && b_mus_isPFMuon_){
    b_mus_isPFMuon_->GetEntry(entry_);
    c_mus_isPFMuon_ = true;
  }
  return mus_isPFMuon_;
}

std::vector<float>* const & cfa_base::mus_isStandAloneMuon() const{
  if(!c_mus_isStandAloneMuon_ && b_mus_isStandAloneMuon_){
    b_mus_isStandAloneMuon_->GetEntry(entry_);
    c_mus_isStandAloneMuon_ = true;
  }
  return mus_isStandAloneMuon_;
}

std::vector<float>* const & cfa_base::mus_isTrackerMuon() const{
  if(!c_mus_isTrackerMuon_ && b_mus_isTrackerMuon_){
    b_mus_isTrackerMuon_->GetEntry(entry_);
    c_mus_isTrackerMuon_ = true;
  }
  return mus_isTrackerMuon_;
}

std::vector<float>* const & cfa_base::mus_iso03_emEt() const{
  if(!c_mus_iso03_emEt_ && b_mus_iso03_emEt_){
    b_mus_iso03_emEt_->GetEntry(entry_);
    c_mus_iso03_emEt_ = true;
  }
  return mus_iso03_emEt_;
}

std::vector<float>* const & cfa_base::mus_iso03_emVetoEt() const{
  if(!c_mus_iso03_emVetoEt_ && b_mus_iso03_emVetoEt_){
    b_mus_iso03_emVetoEt_->GetEntry(entry_);
    c_mus_iso03_emVetoEt_ = true;
  }
  return mus_iso03_emVetoEt_;
}

std::vector<float>* const & cfa_base::mus_iso03_hadEt() const{
  if(!c_mus_iso03_hadEt_ && b_mus_iso03_hadEt_){
    b_mus_iso03_hadEt_->GetEntry(entry_);
    c_mus_iso03_hadEt_ = true;
  }
  return mus_iso03_hadEt_;
}

std::vector<float>* const & cfa_base::mus_iso03_hadVetoEt() const{
  if(!c_mus_iso03_hadVetoEt_ && b_mus_iso03_hadVetoEt_){
    b_mus_iso03_hadVetoEt_->GetEntry(entry_);
    c_mus_iso03_hadVetoEt_ = true;
  }
  return mus_iso03_hadVetoEt_;
}

std::vector<float>* const & cfa_base::mus_iso03_hoEt() const{
  if(!c_mus_iso03_hoEt_ && b_mus_iso03_hoEt_){
    b_mus_iso03_hoEt_->GetEntry(entry_);
    c_mus_iso03_hoEt_ = true;
  }
  return mus_iso03_hoEt_;
}

std::vector<float>* const & cfa_base::mus_iso03_nTracks() const{
  if(!c_mus_iso03_nTracks_ && b_mus_iso03_nTracks_){
    b_mus_iso03_nTracks_->GetEntry(entry_);
    c_mus_iso03_nTracks_ = true;
  }
  return mus_iso03_nTracks_;
}

std::vector<float>* const & cfa_base::mus_iso03_sumPt() const{
  if(!c_mus_iso03_sumPt_ && b_mus_iso03_sumPt_){
    b_mus_iso03_sumPt_->GetEntry(entry_);
    c_mus_iso03_sumPt_ = true;
  }
  return mus_iso03_sumPt_;
}

std::vector<float>* const & cfa_base::mus_iso05_emEt() const{
  if(!c_mus_iso05_emEt_ && b_mus_iso05_emEt_){
    b_mus_iso05_emEt_->GetEntry(entry_);
    c_mus_iso05_emEt_ = true;
  }
  return mus_iso05_emEt_;
}

std::vector<float>* const & cfa_base::mus_iso05_hadEt() const{
  if(!c_mus_iso05_hadEt_ && b_mus_iso05_hadEt_){
    b_mus_iso05_hadEt_->GetEntry(entry_);
    c_mus_iso05_hadEt_ = true;
  }
  return mus_iso05_hadEt_;
}

std::vector<float>* const & cfa_base::mus_iso05_hoEt() const{
  if(!c_mus_iso05_hoEt_ && b_mus_iso05_hoEt_){
    b_mus_iso05_hoEt_->GetEntry(entry_);
    c_mus_iso05_hoEt_ = true;
  }
  return mus_iso05_hoEt_;
}

std::vector<float>* const & cfa_base::mus_iso05_nTracks() const{
  if(!c_mus_iso05_nTracks_ && b_mus_iso05_nTracks_){
    b_mus_iso05_nTracks_->GetEntry(entry_);
    c_mus_iso05_nTracks_ = true;
  }
  return mus_iso05_nTracks_;
}

std::vector<float>* const & cfa_base::mus_iso05_sumPt() const{
  if(!c_mus_iso05_sumPt_ && b_mus_iso05_sumPt_){
    b_mus_iso05_sumPt_->GetEntry(entry_);
    c_mus_iso05_sumPt_ = true;
  }
  return mus_iso05_sumPt_;
}

std::vector<float>* const & cfa_base::mus_num_matches() const{
  if(!c_mus_num_matches_ && b_mus_num_matches_){
    b_mus_num_matches_->GetEntry(entry_);
    c_mus_num_matches_ = true;
  }
  return mus_num_matches_;
}

std::vector<float>* const & cfa_base::mus_numberOfMatchedStations() const{
  if(!c_mus_numberOfMatchedStations_ && b_mus_numberOfMatchedStations_){
    b_mus_numberOfMatchedStations_->GetEntry(entry_);
    c_mus_numberOfMatchedStations_ = true;
  }
  return mus_numberOfMatchedStations_;
}

std::vector<float>* const & cfa_base::mus_pfIsolationR03_sumChargedHadronPt() const{
  if(!c_mus_pfIsolationR03_sumChargedHadronPt_ && b_mus_pfIsolationR03_sumChargedHadronPt_){
    b_mus_pfIsolationR03_sumChargedHadronPt_->GetEntry(entry_);
    c_mus_pfIsolationR03_sumChargedHadronPt_ = true;
  }
  return mus_pfIsolationR03_sumChargedHadronPt_;
}

std::vector<float>* const & cfa_base::mus_pfIsolationR03_sumChargedParticlePt() const{
  if(!c_mus_pfIsolationR03_sumChargedParticlePt_ && b_mus_pfIsolationR03_sumChargedParticlePt_){
    b_mus_pfIsolationR03_sumChargedParticlePt_->GetEntry(entry_);
    c_mus_pfIsolationR03_sumChargedParticlePt_ = true;
  }
  return mus_pfIsolationR03_sumChargedParticlePt_;
}

std::vector<float>* const & cfa_base::mus_pfIsolationR03_sumNeutralHadronEt() const{
  if(!c_mus_pfIsolationR03_sumNeutralHadronEt_ && b_mus_pfIsolationR03_sumNeutralHadronEt_){
    b_mus_pfIsolationR03_sumNeutralHadronEt_->GetEntry(entry_);
    c_mus_pfIsolationR03_sumNeutralHadronEt_ = true;
  }
  return mus_pfIsolationR03_sumNeutralHadronEt_;
}

std::vector<float>* const & cfa_base::mus_pfIsolationR03_sumNeutralHadronEtHighThreshold() const{
  if(!c_mus_pfIsolationR03_sumNeutralHadronEtHighThreshold_ && b_mus_pfIsolationR03_sumNeutralHadronEtHighThreshold_){
    b_mus_pfIsolationR03_sumNeutralHadronEtHighThreshold_->GetEntry(entry_);
    c_mus_pfIsolationR03_sumNeutralHadronEtHighThreshold_ = true;
  }
  return mus_pfIsolationR03_sumNeutralHadronEtHighThreshold_;
}

std::vector<float>* const & cfa_base::mus_pfIsolationR03_sumPUPt() const{
  if(!c_mus_pfIsolationR03_sumPUPt_ && b_mus_pfIsolationR03_sumPUPt_){
    b_mus_pfIsolationR03_sumPUPt_->GetEntry(entry_);
    c_mus_pfIsolationR03_sumPUPt_ = true;
  }
  return mus_pfIsolationR03_sumPUPt_;
}

std::vector<float>* const & cfa_base::mus_pfIsolationR03_sumPhotonEt() const{
  if(!c_mus_pfIsolationR03_sumPhotonEt_ && b_mus_pfIsolationR03_sumPhotonEt_){
    b_mus_pfIsolationR03_sumPhotonEt_->GetEntry(entry_);
    c_mus_pfIsolationR03_sumPhotonEt_ = true;
  }
  return mus_pfIsolationR03_sumPhotonEt_;
}

std::vector<float>* const & cfa_base::mus_pfIsolationR03_sumPhotonEtHighThreshold() const{
  if(!c_mus_pfIsolationR03_sumPhotonEtHighThreshold_ && b_mus_pfIsolationR03_sumPhotonEtHighThreshold_){
    b_mus_pfIsolationR03_sumPhotonEtHighThreshold_->GetEntry(entry_);
    c_mus_pfIsolationR03_sumPhotonEtHighThreshold_ = true;
  }
  return mus_pfIsolationR03_sumPhotonEtHighThreshold_;
}

std::vector<float>* const & cfa_base::mus_pfIsolationR04_sumChargedHadronPt() const{
  if(!c_mus_pfIsolationR04_sumChargedHadronPt_ && b_mus_pfIsolationR04_sumChargedHadronPt_){
    b_mus_pfIsolationR04_sumChargedHadronPt_->GetEntry(entry_);
    c_mus_pfIsolationR04_sumChargedHadronPt_ = true;
  }
  return mus_pfIsolationR04_sumChargedHadronPt_;
}

std::vector<float>* const & cfa_base::mus_pfIsolationR04_sumChargedParticlePt() const{
  if(!c_mus_pfIsolationR04_sumChargedParticlePt_ && b_mus_pfIsolationR04_sumChargedParticlePt_){
    b_mus_pfIsolationR04_sumChargedParticlePt_->GetEntry(entry_);
    c_mus_pfIsolationR04_sumChargedParticlePt_ = true;
  }
  return mus_pfIsolationR04_sumChargedParticlePt_;
}

std::vector<float>* const & cfa_base::mus_pfIsolationR04_sumNeutralHadronEt() const{
  if(!c_mus_pfIsolationR04_sumNeutralHadronEt_ && b_mus_pfIsolationR04_sumNeutralHadronEt_){
    b_mus_pfIsolationR04_sumNeutralHadronEt_->GetEntry(entry_);
    c_mus_pfIsolationR04_sumNeutralHadronEt_ = true;
  }
  return mus_pfIsolationR04_sumNeutralHadronEt_;
}

std::vector<float>* const & cfa_base::mus_pfIsolationR04_sumNeutralHadronEtHighThreshold() const{
  if(!c_mus_pfIsolationR04_sumNeutralHadronEtHighThreshold_ && b_mus_pfIsolationR04_sumNeutralHadronEtHighThreshold_){
    b_mus_pfIsolationR04_sumNeutralHadronEtHighThreshold_->GetEntry(entry_);
    c_mus_pfIsolationR04_sumNeutralHadronEtHighThreshold_ = true;
  }
  return mus_pfIsolationR04_sumNeutralHadronEtHighThreshold_;
}

std::vector<float>* const & cfa_base::mus_pfIsolationR04_sumPUPt() const{
  if(!c_mus_pfIsolationR04_sumPUPt_ && b_mus_pfIsolationR04_sumPUPt_){
    b_mus_pfIsolationR04_sumPUPt_->GetEntry(entry_);
    c_mus_pfIsolationR04_sumPUPt_ = true;
  }
  return mus_pfIsolationR04_sumPUPt_;
}

std::vector<float>* const & cfa_base::mus_pfIsolationR04_sumPhotonEt() const{
  if(!c_mus_pfIsolationR04_sumPhotonEt_ && b_mus_pfIsolationR04_sumPhotonEt_){
    b_mus_pfIsolationR04_sumPhotonEt_->GetEntry(entry_);
    c_mus_pfIsolationR04_sumPhotonEt_ = true;
  }
  return mus_pfIsolationR04_sumPhotonEt_;
}

std::vector<float>* const & cfa_base::mus_pfIsolationR04_sumPhotonEtHighThreshold() const{
  if(!c_mus_pfIsolationR04_sumPhotonEtHighThreshold_ && b_mus_pfIsolationR04_sumPhotonEtHighThreshold_){
    b_mus_pfIsolationR04_sumPhotonEtHighThreshold_->GetEntry(entry_);
    c_mus_pfIsolationR04_sumPhotonEtHighThreshold_ = true;
  }
  return mus_pfIsolationR04_sumPhotonEtHighThreshold_;
}

std::vector<float>* const & cfa_base::mus_phi() const{
  if(!c_mus_phi_ && b_mus_phi_){
    b_mus_phi_->GetEntry(entry_);
    c_mus_phi_ = true;
  }
  return mus_phi_;
}

std::vector<float>* const & cfa_base::mus_pt() const{
  if(!c_mus_pt_ && b_mus_pt_){
    b_mus_pt_->GetEntry(entry_);
    c_mus_pt_ = true;
  }
  return mus_pt_;
}

std::vector<float>* const & cfa_base::mus_px() const{
  if(!c_mus_px_ && b_mus_px_){
    b_mus_px_->GetEntry(entry_);
    c_mus_px_ = true;
  }
  return mus_px_;
}

std::vector<float>* const & cfa_base::mus_py() const{
  if(!c_mus_py_ && b_mus_py_){
    b_mus_py_->GetEntry(entry_);
    c_mus_py_ = true;
  }
  return mus_py_;
}

std::vector<float>* const & cfa_base::mus_pz() const{
  if(!c_mus_pz_ && b_mus_pz_){
    b_mus_pz_->GetEntry(entry_);
    c_mus_pz_ = true;
  }
  return mus_pz_;
}

std::vector<float>* const & cfa_base::mus_stamu_chg() const{
  if(!c_mus_stamu_chg_ && b_mus_stamu_chg_){
    b_mus_stamu_chg_->GetEntry(entry_);
    c_mus_stamu_chg_ = true;
  }
  return mus_stamu_chg_;
}

std::vector<float>* const & cfa_base::mus_stamu_chi2() const{
  if(!c_mus_stamu_chi2_ && b_mus_stamu_chi2_){
    b_mus_stamu_chi2_->GetEntry(entry_);
    c_mus_stamu_chi2_ = true;
  }
  return mus_stamu_chi2_;
}

std::vector<float>* const & cfa_base::mus_stamu_d0dum() const{
  if(!c_mus_stamu_d0dum_ && b_mus_stamu_d0dum_){
    b_mus_stamu_d0dum_->GetEntry(entry_);
    c_mus_stamu_d0dum_ = true;
  }
  return mus_stamu_d0dum_;
}

std::vector<float>* const & cfa_base::mus_stamu_d0dumErr() const{
  if(!c_mus_stamu_d0dumErr_ && b_mus_stamu_d0dumErr_){
    b_mus_stamu_d0dumErr_->GetEntry(entry_);
    c_mus_stamu_d0dumErr_ = true;
  }
  return mus_stamu_d0dumErr_;
}

std::vector<float>* const & cfa_base::mus_stamu_dz() const{
  if(!c_mus_stamu_dz_ && b_mus_stamu_dz_){
    b_mus_stamu_dz_->GetEntry(entry_);
    c_mus_stamu_dz_ = true;
  }
  return mus_stamu_dz_;
}

std::vector<float>* const & cfa_base::mus_stamu_dzErr() const{
  if(!c_mus_stamu_dzErr_ && b_mus_stamu_dzErr_){
    b_mus_stamu_dzErr_->GetEntry(entry_);
    c_mus_stamu_dzErr_ = true;
  }
  return mus_stamu_dzErr_;
}

std::vector<float>* const & cfa_base::mus_stamu_eta() const{
  if(!c_mus_stamu_eta_ && b_mus_stamu_eta_){
    b_mus_stamu_eta_->GetEntry(entry_);
    c_mus_stamu_eta_ = true;
  }
  return mus_stamu_eta_;
}

std::vector<float>* const & cfa_base::mus_stamu_etaErr() const{
  if(!c_mus_stamu_etaErr_ && b_mus_stamu_etaErr_){
    b_mus_stamu_etaErr_->GetEntry(entry_);
    c_mus_stamu_etaErr_ = true;
  }
  return mus_stamu_etaErr_;
}

std::vector<float>* const & cfa_base::mus_stamu_ndof() const{
  if(!c_mus_stamu_ndof_ && b_mus_stamu_ndof_){
    b_mus_stamu_ndof_->GetEntry(entry_);
    c_mus_stamu_ndof_ = true;
  }
  return mus_stamu_ndof_;
}

std::vector<float>* const & cfa_base::mus_stamu_numlosthits() const{
  if(!c_mus_stamu_numlosthits_ && b_mus_stamu_numlosthits_){
    b_mus_stamu_numlosthits_->GetEntry(entry_);
    c_mus_stamu_numlosthits_ = true;
  }
  return mus_stamu_numlosthits_;
}

std::vector<float>* const & cfa_base::mus_stamu_numvalhits() const{
  if(!c_mus_stamu_numvalhits_ && b_mus_stamu_numvalhits_){
    b_mus_stamu_numvalhits_->GetEntry(entry_);
    c_mus_stamu_numvalhits_ = true;
  }
  return mus_stamu_numvalhits_;
}

std::vector<float>* const & cfa_base::mus_stamu_phi() const{
  if(!c_mus_stamu_phi_ && b_mus_stamu_phi_){
    b_mus_stamu_phi_->GetEntry(entry_);
    c_mus_stamu_phi_ = true;
  }
  return mus_stamu_phi_;
}

std::vector<float>* const & cfa_base::mus_stamu_phiErr() const{
  if(!c_mus_stamu_phiErr_ && b_mus_stamu_phiErr_){
    b_mus_stamu_phiErr_->GetEntry(entry_);
    c_mus_stamu_phiErr_ = true;
  }
  return mus_stamu_phiErr_;
}

std::vector<float>* const & cfa_base::mus_stamu_pt() const{
  if(!c_mus_stamu_pt_ && b_mus_stamu_pt_){
    b_mus_stamu_pt_->GetEntry(entry_);
    c_mus_stamu_pt_ = true;
  }
  return mus_stamu_pt_;
}

std::vector<float>* const & cfa_base::mus_stamu_ptErr() const{
  if(!c_mus_stamu_ptErr_ && b_mus_stamu_ptErr_){
    b_mus_stamu_ptErr_->GetEntry(entry_);
    c_mus_stamu_ptErr_ = true;
  }
  return mus_stamu_ptErr_;
}

std::vector<float>* const & cfa_base::mus_stamu_px() const{
  if(!c_mus_stamu_px_ && b_mus_stamu_px_){
    b_mus_stamu_px_->GetEntry(entry_);
    c_mus_stamu_px_ = true;
  }
  return mus_stamu_px_;
}

std::vector<float>* const & cfa_base::mus_stamu_py() const{
  if(!c_mus_stamu_py_ && b_mus_stamu_py_){
    b_mus_stamu_py_->GetEntry(entry_);
    c_mus_stamu_py_ = true;
  }
  return mus_stamu_py_;
}

std::vector<float>* const & cfa_base::mus_stamu_pz() const{
  if(!c_mus_stamu_pz_ && b_mus_stamu_pz_){
    b_mus_stamu_pz_->GetEntry(entry_);
    c_mus_stamu_pz_ = true;
  }
  return mus_stamu_pz_;
}

std::vector<float>* const & cfa_base::mus_stamu_theta() const{
  if(!c_mus_stamu_theta_ && b_mus_stamu_theta_){
    b_mus_stamu_theta_->GetEntry(entry_);
    c_mus_stamu_theta_ = true;
  }
  return mus_stamu_theta_;
}

std::vector<float>* const & cfa_base::mus_stamu_vx() const{
  if(!c_mus_stamu_vx_ && b_mus_stamu_vx_){
    b_mus_stamu_vx_->GetEntry(entry_);
    c_mus_stamu_vx_ = true;
  }
  return mus_stamu_vx_;
}

std::vector<float>* const & cfa_base::mus_stamu_vy() const{
  if(!c_mus_stamu_vy_ && b_mus_stamu_vy_){
    b_mus_stamu_vy_->GetEntry(entry_);
    c_mus_stamu_vy_ = true;
  }
  return mus_stamu_vy_;
}

std::vector<float>* const & cfa_base::mus_stamu_vz() const{
  if(!c_mus_stamu_vz_ && b_mus_stamu_vz_){
    b_mus_stamu_vz_->GetEntry(entry_);
    c_mus_stamu_vz_ = true;
  }
  return mus_stamu_vz_;
}

std::vector<float>* const & cfa_base::mus_status() const{
  if(!c_mus_status_ && b_mus_status_){
    b_mus_status_->GetEntry(entry_);
    c_mus_status_ = true;
  }
  return mus_status_;
}

std::vector<float>* const & cfa_base::mus_tIso() const{
  if(!c_mus_tIso_ && b_mus_tIso_){
    b_mus_tIso_->GetEntry(entry_);
    c_mus_tIso_ = true;
  }
  return mus_tIso_;
}

std::vector<float>* const & cfa_base::mus_theta() const{
  if(!c_mus_theta_ && b_mus_theta_){
    b_mus_theta_->GetEntry(entry_);
    c_mus_theta_ = true;
  }
  return mus_theta_;
}

std::vector<float>* const & cfa_base::mus_tkHits() const{
  if(!c_mus_tkHits_ && b_mus_tkHits_){
    b_mus_tkHits_->GetEntry(entry_);
    c_mus_tkHits_ = true;
  }
  return mus_tkHits_;
}

std::vector<float>* const & cfa_base::mus_tk_LayersWithMeasurement() const{
  if(!c_mus_tk_LayersWithMeasurement_ && b_mus_tk_LayersWithMeasurement_){
    b_mus_tk_LayersWithMeasurement_->GetEntry(entry_);
    c_mus_tk_LayersWithMeasurement_ = true;
  }
  return mus_tk_LayersWithMeasurement_;
}

std::vector<float>* const & cfa_base::mus_tk_LayersWithoutMeasurement() const{
  if(!c_mus_tk_LayersWithoutMeasurement_ && b_mus_tk_LayersWithoutMeasurement_){
    b_mus_tk_LayersWithoutMeasurement_->GetEntry(entry_);
    c_mus_tk_LayersWithoutMeasurement_ = true;
  }
  return mus_tk_LayersWithoutMeasurement_;
}

std::vector<float>* const & cfa_base::mus_tk_PixelLayersWithMeasurement() const{
  if(!c_mus_tk_PixelLayersWithMeasurement_ && b_mus_tk_PixelLayersWithMeasurement_){
    b_mus_tk_PixelLayersWithMeasurement_->GetEntry(entry_);
    c_mus_tk_PixelLayersWithMeasurement_ = true;
  }
  return mus_tk_PixelLayersWithMeasurement_;
}

std::vector<float>* const & cfa_base::mus_tk_ValidStripLayersWithMonoAndStereoHit() const{
  if(!c_mus_tk_ValidStripLayersWithMonoAndStereoHit_ && b_mus_tk_ValidStripLayersWithMonoAndStereoHit_){
    b_mus_tk_ValidStripLayersWithMonoAndStereoHit_->GetEntry(entry_);
    c_mus_tk_ValidStripLayersWithMonoAndStereoHit_ = true;
  }
  return mus_tk_ValidStripLayersWithMonoAndStereoHit_;
}

std::vector<float>* const & cfa_base::mus_tk_chg() const{
  if(!c_mus_tk_chg_ && b_mus_tk_chg_){
    b_mus_tk_chg_->GetEntry(entry_);
    c_mus_tk_chg_ = true;
  }
  return mus_tk_chg_;
}

std::vector<float>* const & cfa_base::mus_tk_chi2() const{
  if(!c_mus_tk_chi2_ && b_mus_tk_chi2_){
    b_mus_tk_chi2_->GetEntry(entry_);
    c_mus_tk_chi2_ = true;
  }
  return mus_tk_chi2_;
}

std::vector<float>* const & cfa_base::mus_tk_d0dum() const{
  if(!c_mus_tk_d0dum_ && b_mus_tk_d0dum_){
    b_mus_tk_d0dum_->GetEntry(entry_);
    c_mus_tk_d0dum_ = true;
  }
  return mus_tk_d0dum_;
}

std::vector<float>* const & cfa_base::mus_tk_d0dumErr() const{
  if(!c_mus_tk_d0dumErr_ && b_mus_tk_d0dumErr_){
    b_mus_tk_d0dumErr_->GetEntry(entry_);
    c_mus_tk_d0dumErr_ = true;
  }
  return mus_tk_d0dumErr_;
}

std::vector<float>* const & cfa_base::mus_tk_dz() const{
  if(!c_mus_tk_dz_ && b_mus_tk_dz_){
    b_mus_tk_dz_->GetEntry(entry_);
    c_mus_tk_dz_ = true;
  }
  return mus_tk_dz_;
}

std::vector<float>* const & cfa_base::mus_tk_dzErr() const{
  if(!c_mus_tk_dzErr_ && b_mus_tk_dzErr_){
    b_mus_tk_dzErr_->GetEntry(entry_);
    c_mus_tk_dzErr_ = true;
  }
  return mus_tk_dzErr_;
}

std::vector<float>* const & cfa_base::mus_tk_eta() const{
  if(!c_mus_tk_eta_ && b_mus_tk_eta_){
    b_mus_tk_eta_->GetEntry(entry_);
    c_mus_tk_eta_ = true;
  }
  return mus_tk_eta_;
}

std::vector<float>* const & cfa_base::mus_tk_etaErr() const{
  if(!c_mus_tk_etaErr_ && b_mus_tk_etaErr_){
    b_mus_tk_etaErr_->GetEntry(entry_);
    c_mus_tk_etaErr_ = true;
  }
  return mus_tk_etaErr_;
}

std::vector<float>* const & cfa_base::mus_tk_id() const{
  if(!c_mus_tk_id_ && b_mus_tk_id_){
    b_mus_tk_id_->GetEntry(entry_);
    c_mus_tk_id_ = true;
  }
  return mus_tk_id_;
}

std::vector<float>* const & cfa_base::mus_tk_ndof() const{
  if(!c_mus_tk_ndof_ && b_mus_tk_ndof_){
    b_mus_tk_ndof_->GetEntry(entry_);
    c_mus_tk_ndof_ = true;
  }
  return mus_tk_ndof_;
}

std::vector<float>* const & cfa_base::mus_tk_numlosthits() const{
  if(!c_mus_tk_numlosthits_ && b_mus_tk_numlosthits_){
    b_mus_tk_numlosthits_->GetEntry(entry_);
    c_mus_tk_numlosthits_ = true;
  }
  return mus_tk_numlosthits_;
}

std::vector<float>* const & cfa_base::mus_tk_numpixelWthMeasr() const{
  if(!c_mus_tk_numpixelWthMeasr_ && b_mus_tk_numpixelWthMeasr_){
    b_mus_tk_numpixelWthMeasr_->GetEntry(entry_);
    c_mus_tk_numpixelWthMeasr_ = true;
  }
  return mus_tk_numpixelWthMeasr_;
}

std::vector<float>* const & cfa_base::mus_tk_numvalPixelhits() const{
  if(!c_mus_tk_numvalPixelhits_ && b_mus_tk_numvalPixelhits_){
    b_mus_tk_numvalPixelhits_->GetEntry(entry_);
    c_mus_tk_numvalPixelhits_ = true;
  }
  return mus_tk_numvalPixelhits_;
}

std::vector<float>* const & cfa_base::mus_tk_numvalhits() const{
  if(!c_mus_tk_numvalhits_ && b_mus_tk_numvalhits_){
    b_mus_tk_numvalhits_->GetEntry(entry_);
    c_mus_tk_numvalhits_ = true;
  }
  return mus_tk_numvalhits_;
}

std::vector<float>* const & cfa_base::mus_tk_phi() const{
  if(!c_mus_tk_phi_ && b_mus_tk_phi_){
    b_mus_tk_phi_->GetEntry(entry_);
    c_mus_tk_phi_ = true;
  }
  return mus_tk_phi_;
}

std::vector<float>* const & cfa_base::mus_tk_phiErr() const{
  if(!c_mus_tk_phiErr_ && b_mus_tk_phiErr_){
    b_mus_tk_phiErr_->GetEntry(entry_);
    c_mus_tk_phiErr_ = true;
  }
  return mus_tk_phiErr_;
}

std::vector<float>* const & cfa_base::mus_tk_pt() const{
  if(!c_mus_tk_pt_ && b_mus_tk_pt_){
    b_mus_tk_pt_->GetEntry(entry_);
    c_mus_tk_pt_ = true;
  }
  return mus_tk_pt_;
}

std::vector<float>* const & cfa_base::mus_tk_ptErr() const{
  if(!c_mus_tk_ptErr_ && b_mus_tk_ptErr_){
    b_mus_tk_ptErr_->GetEntry(entry_);
    c_mus_tk_ptErr_ = true;
  }
  return mus_tk_ptErr_;
}

std::vector<float>* const & cfa_base::mus_tk_px() const{
  if(!c_mus_tk_px_ && b_mus_tk_px_){
    b_mus_tk_px_->GetEntry(entry_);
    c_mus_tk_px_ = true;
  }
  return mus_tk_px_;
}

std::vector<float>* const & cfa_base::mus_tk_py() const{
  if(!c_mus_tk_py_ && b_mus_tk_py_){
    b_mus_tk_py_->GetEntry(entry_);
    c_mus_tk_py_ = true;
  }
  return mus_tk_py_;
}

std::vector<float>* const & cfa_base::mus_tk_pz() const{
  if(!c_mus_tk_pz_ && b_mus_tk_pz_){
    b_mus_tk_pz_->GetEntry(entry_);
    c_mus_tk_pz_ = true;
  }
  return mus_tk_pz_;
}

std::vector<float>* const & cfa_base::mus_tk_theta() const{
  if(!c_mus_tk_theta_ && b_mus_tk_theta_){
    b_mus_tk_theta_->GetEntry(entry_);
    c_mus_tk_theta_ = true;
  }
  return mus_tk_theta_;
}

std::vector<float>* const & cfa_base::mus_tk_vx() const{
  if(!c_mus_tk_vx_ && b_mus_tk_vx_){
    b_mus_tk_vx_->GetEntry(entry_);
    c_mus_tk_vx_ = true;
  }
  return mus_tk_vx_;
}

std::vector<float>* const & cfa_base::mus_tk_vy() const{
  if(!c_mus_tk_vy_ && b_mus_tk_vy_){
    b_mus_tk_vy_->GetEntry(entry_);
    c_mus_tk_vy_ = true;
  }
  return mus_tk_vy_;
}

std::vector<float>* const & cfa_base::mus_tk_vz() const{
  if(!c_mus_tk_vz_ && b_mus_tk_vz_){
    b_mus_tk_vz_->GetEntry(entry_);
    c_mus_tk_vz_ = true;
  }
  return mus_tk_vz_;
}

UInt_t const & cfa_base::orbitNumber() const{
  if(!c_orbitNumber_ && b_orbitNumber_){
    b_orbitNumber_->GetEntry(entry_);
    c_orbitNumber_ = true;
  }
  return orbitNumber_;
}

std::vector<float>* const & cfa_base::photons_e1x5() const{
  if(!c_photons_e1x5_ && b_photons_e1x5_){
    b_photons_e1x5_->GetEntry(entry_);
    c_photons_e1x5_ = true;
  }
  return photons_e1x5_;
}

std::vector<float>* const & cfa_base::photons_e2x5() const{
  if(!c_photons_e2x5_ && b_photons_e2x5_){
    b_photons_e2x5_->GetEntry(entry_);
    c_photons_e2x5_ = true;
  }
  return photons_e2x5_;
}

std::vector<float>* const & cfa_base::photons_e3x3() const{
  if(!c_photons_e3x3_ && b_photons_e3x3_){
    b_photons_e3x3_->GetEntry(entry_);
    c_photons_e3x3_ = true;
  }
  return photons_e3x3_;
}

std::vector<float>* const & cfa_base::photons_e5x5() const{
  if(!c_photons_e5x5_ && b_photons_e5x5_){
    b_photons_e5x5_->GetEntry(entry_);
    c_photons_e5x5_ = true;
  }
  return photons_e5x5_;
}

std::vector<float>* const & cfa_base::photons_ecalIso() const{
  if(!c_photons_ecalIso_ && b_photons_ecalIso_){
    b_photons_ecalIso_->GetEntry(entry_);
    c_photons_ecalIso_ = true;
  }
  return photons_ecalIso_;
}

std::vector<float>* const & cfa_base::photons_energy() const{
  if(!c_photons_energy_ && b_photons_energy_){
    b_photons_energy_->GetEntry(entry_);
    c_photons_energy_ = true;
  }
  return photons_energy_;
}

std::vector<float>* const & cfa_base::photons_et() const{
  if(!c_photons_et_ && b_photons_et_){
    b_photons_et_->GetEntry(entry_);
    c_photons_et_ = true;
  }
  return photons_et_;
}

std::vector<float>* const & cfa_base::photons_eta() const{
  if(!c_photons_eta_ && b_photons_eta_){
    b_photons_eta_->GetEntry(entry_);
    c_photons_eta_ = true;
  }
  return photons_eta_;
}

std::vector<float>* const & cfa_base::photons_hadOverEM() const{
  if(!c_photons_hadOverEM_ && b_photons_hadOverEM_){
    b_photons_hadOverEM_->GetEntry(entry_);
    c_photons_hadOverEM_ = true;
  }
  return photons_hadOverEM_;
}

std::vector<float>* const & cfa_base::photons_hadTowOverEM() const{
  if(!c_photons_hadTowOverEM_ && b_photons_hadTowOverEM_){
    b_photons_hadTowOverEM_->GetEntry(entry_);
    c_photons_hadTowOverEM_ = true;
  }
  return photons_hadTowOverEM_;
}

std::vector<float>* const & cfa_base::photons_hasPixelSeed() const{
  if(!c_photons_hasPixelSeed_ && b_photons_hasPixelSeed_){
    b_photons_hasPixelSeed_->GetEntry(entry_);
    c_photons_hasPixelSeed_ = true;
  }
  return photons_hasPixelSeed_;
}

std::vector<float>* const & cfa_base::photons_hcalIso() const{
  if(!c_photons_hcalIso_ && b_photons_hcalIso_){
    b_photons_hcalIso_->GetEntry(entry_);
    c_photons_hcalIso_ = true;
  }
  return photons_hcalIso_;
}

std::vector<float>* const & cfa_base::photons_isEBEEGap() const{
  if(!c_photons_isEBEEGap_ && b_photons_isEBEEGap_){
    b_photons_isEBEEGap_->GetEntry(entry_);
    c_photons_isEBEEGap_ = true;
  }
  return photons_isEBEEGap_;
}

std::vector<float>* const & cfa_base::photons_isEBGap() const{
  if(!c_photons_isEBGap_ && b_photons_isEBGap_){
    b_photons_isEBGap_->GetEntry(entry_);
    c_photons_isEBGap_ = true;
  }
  return photons_isEBGap_;
}

std::vector<float>* const & cfa_base::photons_isEBPho() const{
  if(!c_photons_isEBPho_ && b_photons_isEBPho_){
    b_photons_isEBPho_->GetEntry(entry_);
    c_photons_isEBPho_ = true;
  }
  return photons_isEBPho_;
}

std::vector<float>* const & cfa_base::photons_isEEGap() const{
  if(!c_photons_isEEGap_ && b_photons_isEEGap_){
    b_photons_isEEGap_->GetEntry(entry_);
    c_photons_isEEGap_ = true;
  }
  return photons_isEEGap_;
}

std::vector<float>* const & cfa_base::photons_isEEPho() const{
  if(!c_photons_isEEPho_ && b_photons_isEEPho_){
    b_photons_isEEPho_->GetEntry(entry_);
    c_photons_isEEPho_ = true;
  }
  return photons_isEEPho_;
}

std::vector<float>* const & cfa_base::photons_isLoosePhoton() const{
  if(!c_photons_isLoosePhoton_ && b_photons_isLoosePhoton_){
    b_photons_isLoosePhoton_->GetEntry(entry_);
    c_photons_isLoosePhoton_ = true;
  }
  return photons_isLoosePhoton_;
}

std::vector<float>* const & cfa_base::photons_isTightPhoton() const{
  if(!c_photons_isTightPhoton_ && b_photons_isTightPhoton_){
    b_photons_isTightPhoton_->GetEntry(entry_);
    c_photons_isTightPhoton_ = true;
  }
  return photons_isTightPhoton_;
}

std::vector<float>* const & cfa_base::photons_isoEcalRecHitDR03() const{
  if(!c_photons_isoEcalRecHitDR03_ && b_photons_isoEcalRecHitDR03_){
    b_photons_isoEcalRecHitDR03_->GetEntry(entry_);
    c_photons_isoEcalRecHitDR03_ = true;
  }
  return photons_isoEcalRecHitDR03_;
}

std::vector<float>* const & cfa_base::photons_isoEcalRecHitDR04() const{
  if(!c_photons_isoEcalRecHitDR04_ && b_photons_isoEcalRecHitDR04_){
    b_photons_isoEcalRecHitDR04_->GetEntry(entry_);
    c_photons_isoEcalRecHitDR04_ = true;
  }
  return photons_isoEcalRecHitDR04_;
}

std::vector<float>* const & cfa_base::photons_isoHcalRecHitDR03() const{
  if(!c_photons_isoHcalRecHitDR03_ && b_photons_isoHcalRecHitDR03_){
    b_photons_isoHcalRecHitDR03_->GetEntry(entry_);
    c_photons_isoHcalRecHitDR03_ = true;
  }
  return photons_isoHcalRecHitDR03_;
}

std::vector<float>* const & cfa_base::photons_isoHcalRecHitDR04() const{
  if(!c_photons_isoHcalRecHitDR04_ && b_photons_isoHcalRecHitDR04_){
    b_photons_isoHcalRecHitDR04_->GetEntry(entry_);
    c_photons_isoHcalRecHitDR04_ = true;
  }
  return photons_isoHcalRecHitDR04_;
}

std::vector<float>* const & cfa_base::photons_isoHollowTrkConeDR03() const{
  if(!c_photons_isoHollowTrkConeDR03_ && b_photons_isoHollowTrkConeDR03_){
    b_photons_isoHollowTrkConeDR03_->GetEntry(entry_);
    c_photons_isoHollowTrkConeDR03_ = true;
  }
  return photons_isoHollowTrkConeDR03_;
}

std::vector<float>* const & cfa_base::photons_isoHollowTrkConeDR04() const{
  if(!c_photons_isoHollowTrkConeDR04_ && b_photons_isoHollowTrkConeDR04_){
    b_photons_isoHollowTrkConeDR04_->GetEntry(entry_);
    c_photons_isoHollowTrkConeDR04_ = true;
  }
  return photons_isoHollowTrkConeDR04_;
}

std::vector<float>* const & cfa_base::photons_isoSolidTrkConeDR03() const{
  if(!c_photons_isoSolidTrkConeDR03_ && b_photons_isoSolidTrkConeDR03_){
    b_photons_isoSolidTrkConeDR03_->GetEntry(entry_);
    c_photons_isoSolidTrkConeDR03_ = true;
  }
  return photons_isoSolidTrkConeDR03_;
}

std::vector<float>* const & cfa_base::photons_isoSolidTrkConeDR04() const{
  if(!c_photons_isoSolidTrkConeDR04_ && b_photons_isoSolidTrkConeDR04_){
    b_photons_isoSolidTrkConeDR04_->GetEntry(entry_);
    c_photons_isoSolidTrkConeDR04_ = true;
  }
  return photons_isoSolidTrkConeDR04_;
}

std::vector<float>* const & cfa_base::photons_maxEnergyXtal() const{
  if(!c_photons_maxEnergyXtal_ && b_photons_maxEnergyXtal_){
    b_photons_maxEnergyXtal_->GetEntry(entry_);
    c_photons_maxEnergyXtal_ = true;
  }
  return photons_maxEnergyXtal_;
}

std::vector<float>* const & cfa_base::photons_nTrkHollowConeDR03() const{
  if(!c_photons_nTrkHollowConeDR03_ && b_photons_nTrkHollowConeDR03_){
    b_photons_nTrkHollowConeDR03_->GetEntry(entry_);
    c_photons_nTrkHollowConeDR03_ = true;
  }
  return photons_nTrkHollowConeDR03_;
}

std::vector<float>* const & cfa_base::photons_nTrkHollowConeDR04() const{
  if(!c_photons_nTrkHollowConeDR04_ && b_photons_nTrkHollowConeDR04_){
    b_photons_nTrkHollowConeDR04_->GetEntry(entry_);
    c_photons_nTrkHollowConeDR04_ = true;
  }
  return photons_nTrkHollowConeDR04_;
}

std::vector<float>* const & cfa_base::photons_nTrkSolidConeDR03() const{
  if(!c_photons_nTrkSolidConeDR03_ && b_photons_nTrkSolidConeDR03_){
    b_photons_nTrkSolidConeDR03_->GetEntry(entry_);
    c_photons_nTrkSolidConeDR03_ = true;
  }
  return photons_nTrkSolidConeDR03_;
}

std::vector<float>* const & cfa_base::photons_nTrkSolidConeDR04() const{
  if(!c_photons_nTrkSolidConeDR04_ && b_photons_nTrkSolidConeDR04_){
    b_photons_nTrkSolidConeDR04_->GetEntry(entry_);
    c_photons_nTrkSolidConeDR04_ = true;
  }
  return photons_nTrkSolidConeDR04_;
}

std::vector<float>* const & cfa_base::photons_phi() const{
  if(!c_photons_phi_ && b_photons_phi_){
    b_photons_phi_->GetEntry(entry_);
    c_photons_phi_ = true;
  }
  return photons_phi_;
}

std::vector<float>* const & cfa_base::photons_pt() const{
  if(!c_photons_pt_ && b_photons_pt_){
    b_photons_pt_->GetEntry(entry_);
    c_photons_pt_ = true;
  }
  return photons_pt_;
}

std::vector<float>* const & cfa_base::photons_px() const{
  if(!c_photons_px_ && b_photons_px_){
    b_photons_px_->GetEntry(entry_);
    c_photons_px_ = true;
  }
  return photons_px_;
}

std::vector<float>* const & cfa_base::photons_py() const{
  if(!c_photons_py_ && b_photons_py_){
    b_photons_py_->GetEntry(entry_);
    c_photons_py_ = true;
  }
  return photons_py_;
}

std::vector<float>* const & cfa_base::photons_pz() const{
  if(!c_photons_pz_ && b_photons_pz_){
    b_photons_pz_->GetEntry(entry_);
    c_photons_pz_ = true;
  }
  return photons_pz_;
}

std::vector<float>* const & cfa_base::photons_r9() const{
  if(!c_photons_r9_ && b_photons_r9_){
    b_photons_r9_->GetEntry(entry_);
    c_photons_r9_ = true;
  }
  return photons_r9_;
}

std::vector<float>* const & cfa_base::photons_scEnergy() const{
  if(!c_photons_scEnergy_ && b_photons_scEnergy_){
    b_photons_scEnergy_->GetEntry(entry_);
    c_photons_scEnergy_ = true;
  }
  return photons_scEnergy_;
}

std::vector<float>* const & cfa_base::photons_scEta() const{
  if(!c_photons_scEta_ && b_photons_scEta_){
    b_photons_scEta_->GetEntry(entry_);
    c_photons_scEta_ = true;
  }
  return photons_scEta_;
}

std::vector<float>* const & cfa_base::photons_scEtaWidth() const{
  if(!c_photons_scEtaWidth_ && b_photons_scEtaWidth_){
    b_photons_scEtaWidth_->GetEntry(entry_);
    c_photons_scEtaWidth_ = true;
  }
  return photons_scEtaWidth_;
}

std::vector<float>* const & cfa_base::photons_scPhi() const{
  if(!c_photons_scPhi_ && b_photons_scPhi_){
    b_photons_scPhi_->GetEntry(entry_);
    c_photons_scPhi_ = true;
  }
  return photons_scPhi_;
}

std::vector<float>* const & cfa_base::photons_scPhiWidth() const{
  if(!c_photons_scPhiWidth_ && b_photons_scPhiWidth_){
    b_photons_scPhiWidth_->GetEntry(entry_);
    c_photons_scPhiWidth_ = true;
  }
  return photons_scPhiWidth_;
}

std::vector<float>* const & cfa_base::photons_scRawEnergy() const{
  if(!c_photons_scRawEnergy_ && b_photons_scRawEnergy_){
    b_photons_scRawEnergy_->GetEntry(entry_);
    c_photons_scRawEnergy_ = true;
  }
  return photons_scRawEnergy_;
}

std::vector<float>* const & cfa_base::photons_sigmaEtaEta() const{
  if(!c_photons_sigmaEtaEta_ && b_photons_sigmaEtaEta_){
    b_photons_sigmaEtaEta_->GetEntry(entry_);
    c_photons_sigmaEtaEta_ = true;
  }
  return photons_sigmaEtaEta_;
}

std::vector<float>* const & cfa_base::photons_sigmaIetaIeta() const{
  if(!c_photons_sigmaIetaIeta_ && b_photons_sigmaIetaIeta_){
    b_photons_sigmaIetaIeta_->GetEntry(entry_);
    c_photons_sigmaIetaIeta_ = true;
  }
  return photons_sigmaIetaIeta_;
}

std::vector<float>* const & cfa_base::photons_status() const{
  if(!c_photons_status_ && b_photons_status_){
    b_photons_status_->GetEntry(entry_);
    c_photons_status_ = true;
  }
  return photons_status_;
}

std::vector<float>* const & cfa_base::photons_tIso() const{
  if(!c_photons_tIso_ && b_photons_tIso_){
    b_photons_tIso_->GetEntry(entry_);
    c_photons_tIso_ = true;
  }
  return photons_tIso_;
}

std::vector<float>* const & cfa_base::photons_theta() const{
  if(!c_photons_theta_ && b_photons_theta_){
    b_photons_theta_->GetEntry(entry_);
    c_photons_theta_ = true;
  }
  return photons_theta_;
}

std::vector<float>* const & cfa_base::pv_chi2() const{
  if(!c_pv_chi2_ && b_pv_chi2_){
    b_pv_chi2_->GetEntry(entry_);
    c_pv_chi2_ = true;
  }
  return pv_chi2_;
}

std::vector<float>* const & cfa_base::pv_isFake() const{
  if(!c_pv_isFake_ && b_pv_isFake_){
    b_pv_isFake_->GetEntry(entry_);
    c_pv_isFake_ = true;
  }
  return pv_isFake_;
}

std::vector<float>* const & cfa_base::pv_isValid() const{
  if(!c_pv_isValid_ && b_pv_isValid_){
    b_pv_isValid_->GetEntry(entry_);
    c_pv_isValid_ = true;
  }
  return pv_isValid_;
}

std::vector<float>* const & cfa_base::pv_ndof() const{
  if(!c_pv_ndof_ && b_pv_ndof_){
    b_pv_ndof_->GetEntry(entry_);
    c_pv_ndof_ = true;
  }
  return pv_ndof_;
}

std::vector<float>* const & cfa_base::pv_x() const{
  if(!c_pv_x_ && b_pv_x_){
    b_pv_x_->GetEntry(entry_);
    c_pv_x_ = true;
  }
  return pv_x_;
}

std::vector<float>* const & cfa_base::pv_xErr() const{
  if(!c_pv_xErr_ && b_pv_xErr_){
    b_pv_xErr_->GetEntry(entry_);
    c_pv_xErr_ = true;
  }
  return pv_xErr_;
}

std::vector<float>* const & cfa_base::pv_y() const{
  if(!c_pv_y_ && b_pv_y_){
    b_pv_y_->GetEntry(entry_);
    c_pv_y_ = true;
  }
  return pv_y_;
}

std::vector<float>* const & cfa_base::pv_yErr() const{
  if(!c_pv_yErr_ && b_pv_yErr_){
    b_pv_yErr_->GetEntry(entry_);
    c_pv_yErr_ = true;
  }
  return pv_yErr_;
}

std::vector<float>* const & cfa_base::pv_z() const{
  if(!c_pv_z_ && b_pv_z_){
    b_pv_z_->GetEntry(entry_);
    c_pv_z_ = true;
  }
  return pv_z_;
}

std::vector<float>* const & cfa_base::pv_zErr() const{
  if(!c_pv_zErr_ && b_pv_zErr_){
    b_pv_zErr_->GetEntry(entry_);
    c_pv_zErr_ = true;
  }
  return pv_zErr_;
}

UInt_t const & cfa_base::run() const{
  if(!c_run_ && b_run_){
    b_run_->GetEntry(entry_);
    c_run_ = true;
  }
  return run_;
}

std::vector<std::string>* const & cfa_base::standalone_triggerobject_collectionname() const{
  if(!c_standalone_triggerobject_collectionname_ && b_standalone_triggerobject_collectionname_){
    b_standalone_triggerobject_collectionname_->GetEntry(entry_);
    c_standalone_triggerobject_collectionname_ = true;
  }
  return standalone_triggerobject_collectionname_;
}

std::vector<float>* const & cfa_base::standalone_triggerobject_energy() const{
  if(!c_standalone_triggerobject_energy_ && b_standalone_triggerobject_energy_){
    b_standalone_triggerobject_energy_->GetEntry(entry_);
    c_standalone_triggerobject_energy_ = true;
  }
  return standalone_triggerobject_energy_;
}

std::vector<float>* const & cfa_base::standalone_triggerobject_et() const{
  if(!c_standalone_triggerobject_et_ && b_standalone_triggerobject_et_){
    b_standalone_triggerobject_et_->GetEntry(entry_);
    c_standalone_triggerobject_et_ = true;
  }
  return standalone_triggerobject_et_;
}

std::vector<float>* const & cfa_base::standalone_triggerobject_eta() const{
  if(!c_standalone_triggerobject_eta_ && b_standalone_triggerobject_eta_){
    b_standalone_triggerobject_eta_->GetEntry(entry_);
    c_standalone_triggerobject_eta_ = true;
  }
  return standalone_triggerobject_eta_;
}

std::vector<float>* const & cfa_base::standalone_triggerobject_phi() const{
  if(!c_standalone_triggerobject_phi_ && b_standalone_triggerobject_phi_){
    b_standalone_triggerobject_phi_->GetEntry(entry_);
    c_standalone_triggerobject_phi_ = true;
  }
  return standalone_triggerobject_phi_;
}

std::vector<float>* const & cfa_base::standalone_triggerobject_pt() const{
  if(!c_standalone_triggerobject_pt_ && b_standalone_triggerobject_pt_){
    b_standalone_triggerobject_pt_->GetEntry(entry_);
    c_standalone_triggerobject_pt_ = true;
  }
  return standalone_triggerobject_pt_;
}

std::vector<float>* const & cfa_base::standalone_triggerobject_px() const{
  if(!c_standalone_triggerobject_px_ && b_standalone_triggerobject_px_){
    b_standalone_triggerobject_px_->GetEntry(entry_);
    c_standalone_triggerobject_px_ = true;
  }
  return standalone_triggerobject_px_;
}

std::vector<float>* const & cfa_base::standalone_triggerobject_py() const{
  if(!c_standalone_triggerobject_py_ && b_standalone_triggerobject_py_){
    b_standalone_triggerobject_py_->GetEntry(entry_);
    c_standalone_triggerobject_py_ = true;
  }
  return standalone_triggerobject_py_;
}

std::vector<float>* const & cfa_base::standalone_triggerobject_pz() const{
  if(!c_standalone_triggerobject_pz_ && b_standalone_triggerobject_pz_){
    b_standalone_triggerobject_pz_->GetEntry(entry_);
    c_standalone_triggerobject_pz_ = true;
  }
  return standalone_triggerobject_pz_;
}

std::vector<float>* const & cfa_base::taus_charge() const{
  if(!c_taus_charge_ && b_taus_charge_){
    b_taus_charge_->GetEntry(entry_);
    c_taus_charge_ = true;
  }
  return taus_charge_;
}

std::vector<float>* const & cfa_base::taus_energy() const{
  if(!c_taus_energy_ && b_taus_energy_){
    b_taus_energy_->GetEntry(entry_);
    c_taus_energy_ = true;
  }
  return taus_energy_;
}

std::vector<float>* const & cfa_base::taus_et() const{
  if(!c_taus_et_ && b_taus_et_){
    b_taus_et_->GetEntry(entry_);
    c_taus_et_ = true;
  }
  return taus_et_;
}

std::vector<float>* const & cfa_base::taus_eta() const{
  if(!c_taus_eta_ && b_taus_eta_){
    b_taus_eta_->GetEntry(entry_);
    c_taus_eta_ = true;
  }
  return taus_eta_;
}

std::vector<float>* const & cfa_base::taus_phi() const{
  if(!c_taus_phi_ && b_taus_phi_){
    b_taus_phi_->GetEntry(entry_);
    c_taus_phi_ = true;
  }
  return taus_phi_;
}

std::vector<float>* const & cfa_base::taus_pt() const{
  if(!c_taus_pt_ && b_taus_pt_){
    b_taus_pt_->GetEntry(entry_);
    c_taus_pt_ = true;
  }
  return taus_pt_;
}

std::vector<float>* const & cfa_base::taus_px() const{
  if(!c_taus_px_ && b_taus_px_){
    b_taus_px_->GetEntry(entry_);
    c_taus_px_ = true;
  }
  return taus_px_;
}

std::vector<float>* const & cfa_base::taus_py() const{
  if(!c_taus_py_ && b_taus_py_){
    b_taus_py_->GetEntry(entry_);
    c_taus_py_ = true;
  }
  return taus_py_;
}

std::vector<float>* const & cfa_base::taus_pz() const{
  if(!c_taus_pz_ && b_taus_pz_){
    b_taus_pz_->GetEntry(entry_);
    c_taus_pz_ = true;
  }
  return taus_pz_;
}

std::vector<float>* const & cfa_base::taus_status() const{
  if(!c_taus_status_ && b_taus_status_){
    b_taus_status_->GetEntry(entry_);
    c_taus_status_ = true;
  }
  return taus_status_;
}

std::vector<float>* const & cfa_base::taus_theta() const{
  if(!c_taus_theta_ && b_taus_theta_){
    b_taus_theta_->GetEntry(entry_);
    c_taus_theta_ = true;
  }
  return taus_theta_;
}

Int_t const & cfa_base::trackingfailurefilter_decision() const{
  if(!c_trackingfailurefilter_decision_ && b_trackingfailurefilter_decision_){
    b_trackingfailurefilter_decision_->GetEntry(entry_);
    c_trackingfailurefilter_decision_ = true;
  }
  return trackingfailurefilter_decision_;
}

std::vector<std::string>* const & cfa_base::trigger_name() const{
  if(!c_trigger_name_ && b_trigger_name_){
    b_trigger_name_->GetEntry(entry_);
    c_trigger_name_ = true;
  }
  return trigger_name_;
}

std::vector<float>* const & cfa_base::trigger_prescalevalue() const{
  if(!c_trigger_prescalevalue_ && b_trigger_prescalevalue_){
    b_trigger_prescalevalue_->GetEntry(entry_);
    c_trigger_prescalevalue_ = true;
  }
  return trigger_prescalevalue_;
}

Float_t const & cfa_base::weight() const{
  if(!c_weight_ && b_weight_){
    b_weight_->GetEntry(entry_);
    c_weight_ = true;
  }
  return weight_;
}

Int_t const & cfa_base::EcalDeadCellTriggerPrimitivefilter_decision() const{
  throw std::runtime_error("EcalDeadCellTriggerPrimitivefilter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::HBHENoisefilter_decision() const{
  throw std::runtime_error("HBHENoisefilter_decision does not exist in this cfA version.");
}

std::vector<std::string>* const & cfa_base::L1trigger_alias() const{
  throw std::runtime_error("L1trigger_alias does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::L1trigger_bit() const{
  throw std::runtime_error("L1trigger_bit does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::L1trigger_decision() const{
  throw std::runtime_error("L1trigger_decision does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::L1trigger_decision_nomask() const{
  throw std::runtime_error("L1trigger_decision_nomask does not exist in this cfA version.");
}

std::vector<std::string>* const & cfa_base::L1trigger_name() const{
  throw std::runtime_error("L1trigger_name does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::L1trigger_prescalevalue() const{
  throw std::runtime_error("L1trigger_prescalevalue does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::L1trigger_techTrigger() const{
  throw std::runtime_error("L1trigger_techTrigger does not exist in this cfA version.");
}

Int_t const & cfa_base::METFiltersfilter_decision() const{
  throw std::runtime_error("METFiltersfilter_decision does not exist in this cfA version.");
}

Float_t const & cfa_base::MPT() const{
  throw std::runtime_error("MPT does not exist in this cfA version.");
}

UInt_t const & cfa_base::Njets_AK4() const{
  throw std::runtime_error("Njets_AK4 does not exist in this cfA version.");
}

UInt_t const & cfa_base::Njets_AK5PF() const{
  throw std::runtime_error("Njets_AK5PF does not exist in this cfA version.");
}

UInt_t const & cfa_base::Njets_AK5PFclean() const{
  throw std::runtime_error("Njets_AK5PFclean does not exist in this cfA version.");
}

UInt_t const & cfa_base::Nmc_electrons() const{
  throw std::runtime_error("Nmc_electrons does not exist in this cfA version.");
}

UInt_t const & cfa_base::Nmc_final() const{
  throw std::runtime_error("Nmc_final does not exist in this cfA version.");
}

UInt_t const & cfa_base::Nmc_jets() const{
  throw std::runtime_error("Nmc_jets does not exist in this cfA version.");
}

UInt_t const & cfa_base::Nmc_mus() const{
  throw std::runtime_error("Nmc_mus does not exist in this cfA version.");
}

UInt_t const & cfa_base::Nmc_nues() const{
  throw std::runtime_error("Nmc_nues does not exist in this cfA version.");
}

UInt_t const & cfa_base::Nmc_numus() const{
  throw std::runtime_error("Nmc_numus does not exist in this cfA version.");
}

UInt_t const & cfa_base::Nmc_nutaus() const{
  throw std::runtime_error("Nmc_nutaus does not exist in this cfA version.");
}

UInt_t const & cfa_base::Nmc_pdf() const{
  throw std::runtime_error("Nmc_pdf does not exist in this cfA version.");
}

UInt_t const & cfa_base::Nmc_photons() const{
  throw std::runtime_error("Nmc_photons does not exist in this cfA version.");
}

UInt_t const & cfa_base::Nmc_taus() const{
  throw std::runtime_error("Nmc_taus does not exist in this cfA version.");
}

UInt_t const & cfa_base::NmetsHO() const{
  throw std::runtime_error("NmetsHO does not exist in this cfA version.");
}

UInt_t const & cfa_base::Nmets_AK5() const{
  throw std::runtime_error("Nmets_AK5 does not exist in this cfA version.");
}

UInt_t const & cfa_base::NpfType1mets_default() const{
  throw std::runtime_error("NpfType1mets_default does not exist in this cfA version.");
}

UInt_t const & cfa_base::NpfTypeINoXYCorrmets() const{
  throw std::runtime_error("NpfTypeINoXYCorrmets does not exist in this cfA version.");
}

UInt_t const & cfa_base::NpfTypeIType0mets() const{
  throw std::runtime_error("NpfTypeIType0mets does not exist in this cfA version.");
}

UInt_t const & cfa_base::NpfTypeImets() const{
  throw std::runtime_error("NpfTypeImets does not exist in this cfA version.");
}

UInt_t const & cfa_base::Npf_els() const{
  throw std::runtime_error("Npf_els does not exist in this cfA version.");
}

UInt_t const & cfa_base::Npf_mus() const{
  throw std::runtime_error("Npf_mus does not exist in this cfA version.");
}

UInt_t const & cfa_base::Npf_photons() const{
  throw std::runtime_error("Npf_photons does not exist in this cfA version.");
}

UInt_t const & cfa_base::Npfcand() const{
  throw std::runtime_error("Npfcand does not exist in this cfA version.");
}

UInt_t const & cfa_base::Npfmets() const{
  throw std::runtime_error("Npfmets does not exist in this cfA version.");
}

UInt_t const & cfa_base::Ntcmets() const{
  throw std::runtime_error("Ntcmets does not exist in this cfA version.");
}

UInt_t const & cfa_base::Ntracks() const{
  throw std::runtime_error("Ntracks does not exist in this cfA version.");
}

Int_t const & cfa_base::ecalBEfilter_decision() const{
  throw std::runtime_error("ecalBEfilter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::ecalTPfilter_decision() const{
  throw std::runtime_error("ecalTPfilter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::eenoisefilter_decision() const{
  throw std::runtime_error("eenoisefilter_decision does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::el_tracks_E() const{
  throw std::runtime_error("el_tracks_E does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::el_tracks_R03_trkiso() const{
  throw std::runtime_error("el_tracks_R03_trkiso does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::el_tracks_chg() const{
  throw std::runtime_error("el_tracks_chg does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::el_tracks_dzpv() const{
  throw std::runtime_error("el_tracks_dzpv does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::el_tracks_eta() const{
  throw std::runtime_error("el_tracks_eta does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::el_tracks_fromPV() const{
  throw std::runtime_error("el_tracks_fromPV does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::el_tracks_miniso() const{
  throw std::runtime_error("el_tracks_miniso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::el_tracks_miniso_chg_only() const{
  throw std::runtime_error("el_tracks_miniso_chg_only does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::el_tracks_phi() const{
  throw std::runtime_error("el_tracks_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::el_tracks_pt() const{
  throw std::runtime_error("el_tracks_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_PFchargedHadronIsoR03() const{
  throw std::runtime_error("els_PFchargedHadronIsoR03 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_PFneutralHadronIsoR03() const{
  throw std::runtime_error("els_PFneutralHadronIsoR03 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_PFphotonIsoR03() const{
  throw std::runtime_error("els_PFphotonIsoR03 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_conversion_dcot() const{
  throw std::runtime_error("els_conversion_dcot does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_conversion_dist() const{
  throw std::runtime_error("els_conversion_dist does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_expectedMissingInnerHits() const{
  throw std::runtime_error("els_expectedMissingInnerHits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_full5x5_sigmaIetaIeta() const{
  throw std::runtime_error("els_full5x5_sigmaIetaIeta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_et() const{
  throw std::runtime_error("els_gen_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_eta() const{
  throw std::runtime_error("els_gen_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_id() const{
  throw std::runtime_error("els_gen_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_mother_et() const{
  throw std::runtime_error("els_gen_mother_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_mother_eta() const{
  throw std::runtime_error("els_gen_mother_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_mother_id() const{
  throw std::runtime_error("els_gen_mother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_mother_phi() const{
  throw std::runtime_error("els_gen_mother_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_mother_pt() const{
  throw std::runtime_error("els_gen_mother_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_mother_px() const{
  throw std::runtime_error("els_gen_mother_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_mother_py() const{
  throw std::runtime_error("els_gen_mother_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_mother_pz() const{
  throw std::runtime_error("els_gen_mother_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_mother_theta() const{
  throw std::runtime_error("els_gen_mother_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_phi() const{
  throw std::runtime_error("els_gen_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_pt() const{
  throw std::runtime_error("els_gen_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_px() const{
  throw std::runtime_error("els_gen_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_py() const{
  throw std::runtime_error("els_gen_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_pz() const{
  throw std::runtime_error("els_gen_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_gen_theta() const{
  throw std::runtime_error("els_gen_theta does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::els_hasMatchedConversion() const{
  throw std::runtime_error("els_hasMatchedConversion does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::els_isPF() const{
  throw std::runtime_error("els_isPF does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::els_jet_ind() const{
  throw std::runtime_error("els_jet_ind does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_miniso() const{
  throw std::runtime_error("els_miniso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_n_inner_layer() const{
  throw std::runtime_error("els_n_inner_layer does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_n_outer_layer() const{
  throw std::runtime_error("els_n_outer_layer does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_pfIsolationR03_sumChargedHadronPt() const{
  throw std::runtime_error("els_pfIsolationR03_sumChargedHadronPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_pfIsolationR03_sumNeutralHadronEt() const{
  throw std::runtime_error("els_pfIsolationR03_sumNeutralHadronEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_pfIsolationR03_sumPUPt() const{
  throw std::runtime_error("els_pfIsolationR03_sumPUPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_pfIsolationR03_sumPhotonEt() const{
  throw std::runtime_error("els_pfIsolationR03_sumPhotonEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_simpleEleId60cIso() const{
  throw std::runtime_error("els_simpleEleId60cIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_simpleEleId60relIso() const{
  throw std::runtime_error("els_simpleEleId60relIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_simpleEleId70cIso() const{
  throw std::runtime_error("els_simpleEleId70cIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_simpleEleId70relIso() const{
  throw std::runtime_error("els_simpleEleId70relIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_simpleEleId80cIso() const{
  throw std::runtime_error("els_simpleEleId80cIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_simpleEleId80relIso() const{
  throw std::runtime_error("els_simpleEleId80relIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_simpleEleId85cIso() const{
  throw std::runtime_error("els_simpleEleId85cIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_simpleEleId85relIso() const{
  throw std::runtime_error("els_simpleEleId85relIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_simpleEleId90cIso() const{
  throw std::runtime_error("els_simpleEleId90cIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_simpleEleId90relIso() const{
  throw std::runtime_error("els_simpleEleId90relIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_simpleEleId95cIso() const{
  throw std::runtime_error("els_simpleEleId95cIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::els_simpleEleId95relIso() const{
  throw std::runtime_error("els_simpleEleId95relIso does not exist in this cfA version.");
}

Float_t const & cfa_base::fixedGridRhoFastjetAll() const{
  throw std::runtime_error("fixedGridRhoFastjetAll does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::fjets30_energy() const{
  throw std::runtime_error("fjets30_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::fjets30_eta() const{
  throw std::runtime_error("fjets30_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::fjets30_m() const{
  throw std::runtime_error("fjets30_m does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::fjets30_phi() const{
  throw std::runtime_error("fjets30_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::fjets30_pt() const{
  throw std::runtime_error("fjets30_pt does not exist in this cfA version.");
}

Int_t const & cfa_base::goodVerticesfilter_decision() const{
  throw std::runtime_error("goodVerticesfilter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::greedymuonfilter_decision() const{
  throw std::runtime_error("greedymuonfilter_decision does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::had_tracks_E() const{
  throw std::runtime_error("had_tracks_E does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::had_tracks_R03_trkiso() const{
  throw std::runtime_error("had_tracks_R03_trkiso does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::had_tracks_chg() const{
  throw std::runtime_error("had_tracks_chg does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::had_tracks_dzpv() const{
  throw std::runtime_error("had_tracks_dzpv does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::had_tracks_eta() const{
  throw std::runtime_error("had_tracks_eta does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::had_tracks_fromPV() const{
  throw std::runtime_error("had_tracks_fromPV does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::had_tracks_miniso() const{
  throw std::runtime_error("had_tracks_miniso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::had_tracks_miniso_chg_only() const{
  throw std::runtime_error("had_tracks_miniso_chg_only does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::had_tracks_phi() const{
  throw std::runtime_error("had_tracks_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::had_tracks_pt() const{
  throw std::runtime_error("had_tracks_pt does not exist in this cfA version.");
}

Int_t const & cfa_base::hbhefilter_decision() const{
  throw std::runtime_error("hbhefilter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::inconsistentPFmuonfilter_decision() const{
  throw std::runtime_error("inconsistentPFmuonfilter_decision does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::isotk_charge() const{
  throw std::runtime_error("isotk_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::isotk_dzpv() const{
  throw std::runtime_error("isotk_dzpv does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::isotk_eta() const{
  throw std::runtime_error("isotk_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::isotk_iso() const{
  throw std::runtime_error("isotk_iso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::isotk_phi() const{
  throw std::runtime_error("isotk_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::isotk_pt() const{
  throw std::runtime_error("isotk_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_area() const{
  throw std::runtime_error("jets_AK4_area does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_btag_MVA() const{
  throw std::runtime_error("jets_AK4_btag_MVA does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_btag_TC_highEff() const{
  throw std::runtime_error("jets_AK4_btag_TC_highEff does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_btag_TC_highPur() const{
  throw std::runtime_error("jets_AK4_btag_TC_highPur does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_btag_csv_soft_lepton() const{
  throw std::runtime_error("jets_AK4_btag_csv_soft_lepton does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_btag_inc_secVertexCombined() const{
  throw std::runtime_error("jets_AK4_btag_inc_secVertexCombined does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_btag_jetBProb() const{
  throw std::runtime_error("jets_AK4_btag_jetBProb does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_btag_jetProb() const{
  throw std::runtime_error("jets_AK4_btag_jetProb does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_btag_pf_secVertexCombined() const{
  throw std::runtime_error("jets_AK4_btag_pf_secVertexCombined does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_btag_secVertexHighEff() const{
  throw std::runtime_error("jets_AK4_btag_secVertexHighEff does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_btag_secVertexHighPur() const{
  throw std::runtime_error("jets_AK4_btag_secVertexHighPur does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_caloJetMap_emEnergyFraction() const{
  throw std::runtime_error("jets_AK4_caloJetMap_emEnergyFraction does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_caloJetMap_pt() const{
  throw std::runtime_error("jets_AK4_caloJetMap_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_chgEmE() const{
  throw std::runtime_error("jets_AK4_chgEmE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_chgHadE() const{
  throw std::runtime_error("jets_AK4_chgHadE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_chgMuE() const{
  throw std::runtime_error("jets_AK4_chgMuE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_chg_Mult() const{
  throw std::runtime_error("jets_AK4_chg_Mult does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_corL1Fast() const{
  throw std::runtime_error("jets_AK4_corL1Fast does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_corL1FastL2L3() const{
  throw std::runtime_error("jets_AK4_corL1FastL2L3 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_corL2L3() const{
  throw std::runtime_error("jets_AK4_corL2L3 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_corrFactorRaw() const{
  throw std::runtime_error("jets_AK4_corrFactorRaw does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::jets_AK4_el_ind() const{
  throw std::runtime_error("jets_AK4_el_ind does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_energy() const{
  throw std::runtime_error("jets_AK4_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_et() const{
  throw std::runtime_error("jets_AK4_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_eta() const{
  throw std::runtime_error("jets_AK4_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_gen_pt() const{
  throw std::runtime_error("jets_AK4_gen_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_jetCharge() const{
  throw std::runtime_error("jets_AK4_jetCharge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_mass() const{
  throw std::runtime_error("jets_AK4_mass does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::jets_AK4_maxpt_id() const{
  throw std::runtime_error("jets_AK4_maxpt_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_mu_Mult() const{
  throw std::runtime_error("jets_AK4_mu_Mult does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::jets_AK4_mu_ind() const{
  throw std::runtime_error("jets_AK4_mu_ind does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_n60() const{
  throw std::runtime_error("jets_AK4_n60 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_n90() const{
  throw std::runtime_error("jets_AK4_n90 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_neutralEmE() const{
  throw std::runtime_error("jets_AK4_neutralEmE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_neutralHadE() const{
  throw std::runtime_error("jets_AK4_neutralHadE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_neutral_Mult() const{
  throw std::runtime_error("jets_AK4_neutral_Mult does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_partonFlavour() const{
  throw std::runtime_error("jets_AK4_partonFlavour does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_parton_Energy() const{
  throw std::runtime_error("jets_AK4_parton_Energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_parton_Id() const{
  throw std::runtime_error("jets_AK4_parton_Id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_parton_eta() const{
  throw std::runtime_error("jets_AK4_parton_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_parton_grandmotherID() const{
  throw std::runtime_error("jets_AK4_parton_grandmotherID does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_parton_mass() const{
  throw std::runtime_error("jets_AK4_parton_mass does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_parton_motherId() const{
  throw std::runtime_error("jets_AK4_parton_motherId does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_parton_phi() const{
  throw std::runtime_error("jets_AK4_parton_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_parton_pt() const{
  throw std::runtime_error("jets_AK4_parton_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_phi() const{
  throw std::runtime_error("jets_AK4_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_photonEnergy() const{
  throw std::runtime_error("jets_AK4_photonEnergy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_pileupID_MVA() const{
  throw std::runtime_error("jets_AK4_pileupID_MVA does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_pt() const{
  throw std::runtime_error("jets_AK4_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_px() const{
  throw std::runtime_error("jets_AK4_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_py() const{
  throw std::runtime_error("jets_AK4_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_pz() const{
  throw std::runtime_error("jets_AK4_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_rawPt() const{
  throw std::runtime_error("jets_AK4_rawPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_status() const{
  throw std::runtime_error("jets_AK4_status does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK4_theta() const{
  throw std::runtime_error("jets_AK4_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_area() const{
  throw std::runtime_error("jets_AK5PF_area does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_btag_TC_highEff() const{
  throw std::runtime_error("jets_AK5PF_btag_TC_highEff does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_btag_TC_highPur() const{
  throw std::runtime_error("jets_AK5PF_btag_TC_highPur does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_btag_jetBProb() const{
  throw std::runtime_error("jets_AK5PF_btag_jetBProb does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_btag_jetProb() const{
  throw std::runtime_error("jets_AK5PF_btag_jetProb does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_btag_secVertexCombined() const{
  throw std::runtime_error("jets_AK5PF_btag_secVertexCombined does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_btag_secVertexHighEff() const{
  throw std::runtime_error("jets_AK5PF_btag_secVertexHighEff does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_btag_secVertexHighPur() const{
  throw std::runtime_error("jets_AK5PF_btag_secVertexHighPur does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_btag_softEle() const{
  throw std::runtime_error("jets_AK5PF_btag_softEle does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_btag_softMuon() const{
  throw std::runtime_error("jets_AK5PF_btag_softMuon does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_chgEmE() const{
  throw std::runtime_error("jets_AK5PF_chgEmE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_chgHadE() const{
  throw std::runtime_error("jets_AK5PF_chgHadE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_chgMuE() const{
  throw std::runtime_error("jets_AK5PF_chgMuE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_chg_Mult() const{
  throw std::runtime_error("jets_AK5PF_chg_Mult does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_corrFactorRaw() const{
  throw std::runtime_error("jets_AK5PF_corrFactorRaw does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_ehf() const{
  throw std::runtime_error("jets_AK5PF_ehf does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_emf() const{
  throw std::runtime_error("jets_AK5PF_emf does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_energy() const{
  throw std::runtime_error("jets_AK5PF_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_et() const{
  throw std::runtime_error("jets_AK5PF_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_eta() const{
  throw std::runtime_error("jets_AK5PF_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_etaetaMoment() const{
  throw std::runtime_error("jets_AK5PF_etaetaMoment does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_etaphiMoment() const{
  throw std::runtime_error("jets_AK5PF_etaphiMoment does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_fHPD() const{
  throw std::runtime_error("jets_AK5PF_fHPD does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_fRBX() const{
  throw std::runtime_error("jets_AK5PF_fRBX does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_fSubDetector1() const{
  throw std::runtime_error("jets_AK5PF_fSubDetector1 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_fSubDetector2() const{
  throw std::runtime_error("jets_AK5PF_fSubDetector2 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_fSubDetector3() const{
  throw std::runtime_error("jets_AK5PF_fSubDetector3 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_fSubDetector4() const{
  throw std::runtime_error("jets_AK5PF_fSubDetector4 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_gen_Energy() const{
  throw std::runtime_error("jets_AK5PF_gen_Energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_gen_Id() const{
  throw std::runtime_error("jets_AK5PF_gen_Id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_gen_et() const{
  throw std::runtime_error("jets_AK5PF_gen_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_gen_eta() const{
  throw std::runtime_error("jets_AK5PF_gen_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_gen_mass() const{
  throw std::runtime_error("jets_AK5PF_gen_mass does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_gen_motherID() const{
  throw std::runtime_error("jets_AK5PF_gen_motherID does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_gen_phi() const{
  throw std::runtime_error("jets_AK5PF_gen_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_gen_pt() const{
  throw std::runtime_error("jets_AK5PF_gen_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_gen_threeCharge() const{
  throw std::runtime_error("jets_AK5PF_gen_threeCharge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_hitsInN90() const{
  throw std::runtime_error("jets_AK5PF_hitsInN90 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_jetCharge() const{
  throw std::runtime_error("jets_AK5PF_jetCharge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_mass() const{
  throw std::runtime_error("jets_AK5PF_mass does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_mu_Mult() const{
  throw std::runtime_error("jets_AK5PF_mu_Mult does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_n60() const{
  throw std::runtime_error("jets_AK5PF_n60 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_n90() const{
  throw std::runtime_error("jets_AK5PF_n90 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_n90Hits() const{
  throw std::runtime_error("jets_AK5PF_n90Hits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_nECALTowers() const{
  throw std::runtime_error("jets_AK5PF_nECALTowers does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_nHCALTowers() const{
  throw std::runtime_error("jets_AK5PF_nHCALTowers does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_neutralEmE() const{
  throw std::runtime_error("jets_AK5PF_neutralEmE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_neutralHadE() const{
  throw std::runtime_error("jets_AK5PF_neutralHadE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_neutral_Mult() const{
  throw std::runtime_error("jets_AK5PF_neutral_Mult does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_partonFlavour() const{
  throw std::runtime_error("jets_AK5PF_partonFlavour does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_parton_Energy() const{
  throw std::runtime_error("jets_AK5PF_parton_Energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_parton_Id() const{
  throw std::runtime_error("jets_AK5PF_parton_Id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_parton_eta() const{
  throw std::runtime_error("jets_AK5PF_parton_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_parton_mass() const{
  throw std::runtime_error("jets_AK5PF_parton_mass does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_parton_motherId() const{
  throw std::runtime_error("jets_AK5PF_parton_motherId does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_parton_phi() const{
  throw std::runtime_error("jets_AK5PF_parton_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_parton_pt() const{
  throw std::runtime_error("jets_AK5PF_parton_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_phi() const{
  throw std::runtime_error("jets_AK5PF_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_phiphiMoment() const{
  throw std::runtime_error("jets_AK5PF_phiphiMoment does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_photonEnergy() const{
  throw std::runtime_error("jets_AK5PF_photonEnergy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_pt() const{
  throw std::runtime_error("jets_AK5PF_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_px() const{
  throw std::runtime_error("jets_AK5PF_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_py() const{
  throw std::runtime_error("jets_AK5PF_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_pz() const{
  throw std::runtime_error("jets_AK5PF_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_rawPt() const{
  throw std::runtime_error("jets_AK5PF_rawPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_status() const{
  throw std::runtime_error("jets_AK5PF_status does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PF_theta() const{
  throw std::runtime_error("jets_AK5PF_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_Uncert() const{
  throw std::runtime_error("jets_AK5PFclean_Uncert does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_area() const{
  throw std::runtime_error("jets_AK5PFclean_area does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_btag_TC_highEff() const{
  throw std::runtime_error("jets_AK5PFclean_btag_TC_highEff does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_btag_TC_highPur() const{
  throw std::runtime_error("jets_AK5PFclean_btag_TC_highPur does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_btag_jetBProb() const{
  throw std::runtime_error("jets_AK5PFclean_btag_jetBProb does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_btag_jetProb() const{
  throw std::runtime_error("jets_AK5PFclean_btag_jetProb does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_btag_secVertexCombined() const{
  throw std::runtime_error("jets_AK5PFclean_btag_secVertexCombined does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_btag_secVertexHighEff() const{
  throw std::runtime_error("jets_AK5PFclean_btag_secVertexHighEff does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_btag_secVertexHighPur() const{
  throw std::runtime_error("jets_AK5PFclean_btag_secVertexHighPur does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_btag_softEle() const{
  throw std::runtime_error("jets_AK5PFclean_btag_softEle does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_btag_softMuon() const{
  throw std::runtime_error("jets_AK5PFclean_btag_softMuon does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_chgEmE() const{
  throw std::runtime_error("jets_AK5PFclean_chgEmE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_chgHadE() const{
  throw std::runtime_error("jets_AK5PFclean_chgHadE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_chgMuE() const{
  throw std::runtime_error("jets_AK5PFclean_chgMuE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_chg_Mult() const{
  throw std::runtime_error("jets_AK5PFclean_chg_Mult does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_corrFactorRaw() const{
  throw std::runtime_error("jets_AK5PFclean_corrFactorRaw does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_corrL1FastL2L3() const{
  throw std::runtime_error("jets_AK5PFclean_corrL1FastL2L3 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_corrL1FastL2L3Residual() const{
  throw std::runtime_error("jets_AK5PFclean_corrL1FastL2L3Residual does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_corrL1L2L3() const{
  throw std::runtime_error("jets_AK5PFclean_corrL1L2L3 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_corrL1L2L3Residual() const{
  throw std::runtime_error("jets_AK5PFclean_corrL1L2L3Residual does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_corrL2L3() const{
  throw std::runtime_error("jets_AK5PFclean_corrL2L3 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_corrL2L3Residual() const{
  throw std::runtime_error("jets_AK5PFclean_corrL2L3Residual does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_ehf() const{
  throw std::runtime_error("jets_AK5PFclean_ehf does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_emf() const{
  throw std::runtime_error("jets_AK5PFclean_emf does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_energy() const{
  throw std::runtime_error("jets_AK5PFclean_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_et() const{
  throw std::runtime_error("jets_AK5PFclean_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_eta() const{
  throw std::runtime_error("jets_AK5PFclean_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_etaetaMoment() const{
  throw std::runtime_error("jets_AK5PFclean_etaetaMoment does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_etaphiMoment() const{
  throw std::runtime_error("jets_AK5PFclean_etaphiMoment does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_fHPD() const{
  throw std::runtime_error("jets_AK5PFclean_fHPD does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_fRBX() const{
  throw std::runtime_error("jets_AK5PFclean_fRBX does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_fSubDetector1() const{
  throw std::runtime_error("jets_AK5PFclean_fSubDetector1 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_fSubDetector2() const{
  throw std::runtime_error("jets_AK5PFclean_fSubDetector2 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_fSubDetector3() const{
  throw std::runtime_error("jets_AK5PFclean_fSubDetector3 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_fSubDetector4() const{
  throw std::runtime_error("jets_AK5PFclean_fSubDetector4 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_gen_Energy() const{
  throw std::runtime_error("jets_AK5PFclean_gen_Energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_gen_Id() const{
  throw std::runtime_error("jets_AK5PFclean_gen_Id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_gen_et() const{
  throw std::runtime_error("jets_AK5PFclean_gen_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_gen_eta() const{
  throw std::runtime_error("jets_AK5PFclean_gen_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_gen_mass() const{
  throw std::runtime_error("jets_AK5PFclean_gen_mass does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_gen_phi() const{
  throw std::runtime_error("jets_AK5PFclean_gen_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_gen_pt() const{
  throw std::runtime_error("jets_AK5PFclean_gen_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_hitsInN90() const{
  throw std::runtime_error("jets_AK5PFclean_hitsInN90 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_jetCharge() const{
  throw std::runtime_error("jets_AK5PFclean_jetCharge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_mass() const{
  throw std::runtime_error("jets_AK5PFclean_mass does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_mu_Mult() const{
  throw std::runtime_error("jets_AK5PFclean_mu_Mult does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_n60() const{
  throw std::runtime_error("jets_AK5PFclean_n60 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_n90() const{
  throw std::runtime_error("jets_AK5PFclean_n90 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_n90Hits() const{
  throw std::runtime_error("jets_AK5PFclean_n90Hits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_nECALTowers() const{
  throw std::runtime_error("jets_AK5PFclean_nECALTowers does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_nHCALTowers() const{
  throw std::runtime_error("jets_AK5PFclean_nHCALTowers does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_neutralEmE() const{
  throw std::runtime_error("jets_AK5PFclean_neutralEmE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_neutralHadE() const{
  throw std::runtime_error("jets_AK5PFclean_neutralHadE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_neutral_Mult() const{
  throw std::runtime_error("jets_AK5PFclean_neutral_Mult does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_partonFlavour() const{
  throw std::runtime_error("jets_AK5PFclean_partonFlavour does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_parton_Energy() const{
  throw std::runtime_error("jets_AK5PFclean_parton_Energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_parton_Id() const{
  throw std::runtime_error("jets_AK5PFclean_parton_Id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_parton_eta() const{
  throw std::runtime_error("jets_AK5PFclean_parton_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_parton_mass() const{
  throw std::runtime_error("jets_AK5PFclean_parton_mass does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_parton_motherId() const{
  throw std::runtime_error("jets_AK5PFclean_parton_motherId does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_parton_phi() const{
  throw std::runtime_error("jets_AK5PFclean_parton_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_parton_pt() const{
  throw std::runtime_error("jets_AK5PFclean_parton_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_phi() const{
  throw std::runtime_error("jets_AK5PFclean_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_phiphiMoment() const{
  throw std::runtime_error("jets_AK5PFclean_phiphiMoment does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_photonEnergy() const{
  throw std::runtime_error("jets_AK5PFclean_photonEnergy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_pt() const{
  throw std::runtime_error("jets_AK5PFclean_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_px() const{
  throw std::runtime_error("jets_AK5PFclean_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_py() const{
  throw std::runtime_error("jets_AK5PFclean_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_pz() const{
  throw std::runtime_error("jets_AK5PFclean_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_rawPt() const{
  throw std::runtime_error("jets_AK5PFclean_rawPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_status() const{
  throw std::runtime_error("jets_AK5PFclean_status does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::jets_AK5PFclean_theta() const{
  throw std::runtime_error("jets_AK5PFclean_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_doc_isDirectPromptTauDecayProductFinalState() const{
  throw std::runtime_error("mc_doc_isDirectPromptTauDecayProductFinalState does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_doc_isPromptFinalState() const{
  throw std::runtime_error("mc_doc_isPromptFinalState does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::mc_doc_mother_ind() const{
  throw std::runtime_error("mc_doc_mother_ind does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_doc_mother_pt() const{
  throw std::runtime_error("mc_doc_mother_pt does not exist in this cfA version.");
}

std::vector<short>* const & cfa_base::mc_doc_statusFlags() const{
  throw std::runtime_error("mc_doc_statusFlags does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_doc_theta() const{
  throw std::runtime_error("mc_doc_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_charge() const{
  throw std::runtime_error("mc_electrons_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_energy() const{
  throw std::runtime_error("mc_electrons_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_eta() const{
  throw std::runtime_error("mc_electrons_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_ggrandmother_id() const{
  throw std::runtime_error("mc_electrons_ggrandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_grandmother_id() const{
  throw std::runtime_error("mc_electrons_grandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_id() const{
  throw std::runtime_error("mc_electrons_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_mass() const{
  throw std::runtime_error("mc_electrons_mass does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_mother_id() const{
  throw std::runtime_error("mc_electrons_mother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_mother_pt() const{
  throw std::runtime_error("mc_electrons_mother_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_numOfDaughters() const{
  throw std::runtime_error("mc_electrons_numOfDaughters does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_phi() const{
  throw std::runtime_error("mc_electrons_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_pt() const{
  throw std::runtime_error("mc_electrons_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_px() const{
  throw std::runtime_error("mc_electrons_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_py() const{
  throw std::runtime_error("mc_electrons_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_pz() const{
  throw std::runtime_error("mc_electrons_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_status() const{
  throw std::runtime_error("mc_electrons_status does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_theta() const{
  throw std::runtime_error("mc_electrons_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_vertex_x() const{
  throw std::runtime_error("mc_electrons_vertex_x does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_vertex_y() const{
  throw std::runtime_error("mc_electrons_vertex_y does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_electrons_vertex_z() const{
  throw std::runtime_error("mc_electrons_vertex_z does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_final_charge() const{
  throw std::runtime_error("mc_final_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_final_energy() const{
  throw std::runtime_error("mc_final_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_final_eta() const{
  throw std::runtime_error("mc_final_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_final_ggrandmother_id() const{
  throw std::runtime_error("mc_final_ggrandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_final_grandmother_id() const{
  throw std::runtime_error("mc_final_grandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_final_id() const{
  throw std::runtime_error("mc_final_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_final_isDirectPromptTauDecayProductFinalState() const{
  throw std::runtime_error("mc_final_isDirectPromptTauDecayProductFinalState does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_final_isPromptFinalState() const{
  throw std::runtime_error("mc_final_isPromptFinalState does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_final_mother_id() const{
  throw std::runtime_error("mc_final_mother_id does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::mc_final_mother_ind() const{
  throw std::runtime_error("mc_final_mother_ind does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_final_numOfMothers() const{
  throw std::runtime_error("mc_final_numOfMothers does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_final_phi() const{
  throw std::runtime_error("mc_final_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_final_pt() const{
  throw std::runtime_error("mc_final_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_jets_auxiliaryEnergy() const{
  throw std::runtime_error("mc_jets_auxiliaryEnergy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_jets_emEnergy() const{
  throw std::runtime_error("mc_jets_emEnergy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_jets_energy() const{
  throw std::runtime_error("mc_jets_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_jets_et() const{
  throw std::runtime_error("mc_jets_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_jets_eta() const{
  throw std::runtime_error("mc_jets_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_jets_hadEnergy() const{
  throw std::runtime_error("mc_jets_hadEnergy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_jets_invisibleEnergy() const{
  throw std::runtime_error("mc_jets_invisibleEnergy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_jets_mass() const{
  throw std::runtime_error("mc_jets_mass does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_jets_phi() const{
  throw std::runtime_error("mc_jets_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_jets_pt() const{
  throw std::runtime_error("mc_jets_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_charge() const{
  throw std::runtime_error("mc_mus_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_energy() const{
  throw std::runtime_error("mc_mus_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_eta() const{
  throw std::runtime_error("mc_mus_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_ggrandmother_id() const{
  throw std::runtime_error("mc_mus_ggrandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_grandmother_id() const{
  throw std::runtime_error("mc_mus_grandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_id() const{
  throw std::runtime_error("mc_mus_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_mass() const{
  throw std::runtime_error("mc_mus_mass does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_mother_id() const{
  throw std::runtime_error("mc_mus_mother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_mother_pt() const{
  throw std::runtime_error("mc_mus_mother_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_numOfDaughters() const{
  throw std::runtime_error("mc_mus_numOfDaughters does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_phi() const{
  throw std::runtime_error("mc_mus_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_pt() const{
  throw std::runtime_error("mc_mus_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_px() const{
  throw std::runtime_error("mc_mus_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_py() const{
  throw std::runtime_error("mc_mus_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_pz() const{
  throw std::runtime_error("mc_mus_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_status() const{
  throw std::runtime_error("mc_mus_status does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_theta() const{
  throw std::runtime_error("mc_mus_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_vertex_x() const{
  throw std::runtime_error("mc_mus_vertex_x does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_vertex_y() const{
  throw std::runtime_error("mc_mus_vertex_y does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_mus_vertex_z() const{
  throw std::runtime_error("mc_mus_vertex_z does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_charge() const{
  throw std::runtime_error("mc_nues_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_energy() const{
  throw std::runtime_error("mc_nues_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_eta() const{
  throw std::runtime_error("mc_nues_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_ggrandmother_id() const{
  throw std::runtime_error("mc_nues_ggrandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_grandmother_id() const{
  throw std::runtime_error("mc_nues_grandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_id() const{
  throw std::runtime_error("mc_nues_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_mass() const{
  throw std::runtime_error("mc_nues_mass does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_mother_id() const{
  throw std::runtime_error("mc_nues_mother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_mother_pt() const{
  throw std::runtime_error("mc_nues_mother_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_numOfDaughters() const{
  throw std::runtime_error("mc_nues_numOfDaughters does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_phi() const{
  throw std::runtime_error("mc_nues_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_pt() const{
  throw std::runtime_error("mc_nues_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_px() const{
  throw std::runtime_error("mc_nues_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_py() const{
  throw std::runtime_error("mc_nues_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_pz() const{
  throw std::runtime_error("mc_nues_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_status() const{
  throw std::runtime_error("mc_nues_status does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_theta() const{
  throw std::runtime_error("mc_nues_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_vertex_x() const{
  throw std::runtime_error("mc_nues_vertex_x does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_vertex_y() const{
  throw std::runtime_error("mc_nues_vertex_y does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nues_vertex_z() const{
  throw std::runtime_error("mc_nues_vertex_z does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_charge() const{
  throw std::runtime_error("mc_numus_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_energy() const{
  throw std::runtime_error("mc_numus_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_eta() const{
  throw std::runtime_error("mc_numus_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_ggrandmother_id() const{
  throw std::runtime_error("mc_numus_ggrandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_grandmother_id() const{
  throw std::runtime_error("mc_numus_grandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_id() const{
  throw std::runtime_error("mc_numus_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_mass() const{
  throw std::runtime_error("mc_numus_mass does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_mother_id() const{
  throw std::runtime_error("mc_numus_mother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_mother_pt() const{
  throw std::runtime_error("mc_numus_mother_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_numOfDaughters() const{
  throw std::runtime_error("mc_numus_numOfDaughters does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_phi() const{
  throw std::runtime_error("mc_numus_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_pt() const{
  throw std::runtime_error("mc_numus_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_px() const{
  throw std::runtime_error("mc_numus_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_py() const{
  throw std::runtime_error("mc_numus_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_pz() const{
  throw std::runtime_error("mc_numus_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_status() const{
  throw std::runtime_error("mc_numus_status does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_theta() const{
  throw std::runtime_error("mc_numus_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_vertex_x() const{
  throw std::runtime_error("mc_numus_vertex_x does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_vertex_y() const{
  throw std::runtime_error("mc_numus_vertex_y does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_numus_vertex_z() const{
  throw std::runtime_error("mc_numus_vertex_z does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_charge() const{
  throw std::runtime_error("mc_nutaus_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_energy() const{
  throw std::runtime_error("mc_nutaus_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_eta() const{
  throw std::runtime_error("mc_nutaus_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_ggrandmother_id() const{
  throw std::runtime_error("mc_nutaus_ggrandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_grandmother_id() const{
  throw std::runtime_error("mc_nutaus_grandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_id() const{
  throw std::runtime_error("mc_nutaus_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_mass() const{
  throw std::runtime_error("mc_nutaus_mass does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_mother_id() const{
  throw std::runtime_error("mc_nutaus_mother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_mother_pt() const{
  throw std::runtime_error("mc_nutaus_mother_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_numOfDaughters() const{
  throw std::runtime_error("mc_nutaus_numOfDaughters does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_phi() const{
  throw std::runtime_error("mc_nutaus_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_pt() const{
  throw std::runtime_error("mc_nutaus_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_px() const{
  throw std::runtime_error("mc_nutaus_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_py() const{
  throw std::runtime_error("mc_nutaus_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_pz() const{
  throw std::runtime_error("mc_nutaus_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_status() const{
  throw std::runtime_error("mc_nutaus_status does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_theta() const{
  throw std::runtime_error("mc_nutaus_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_vertex_x() const{
  throw std::runtime_error("mc_nutaus_vertex_x does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_vertex_y() const{
  throw std::runtime_error("mc_nutaus_vertex_y does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_nutaus_vertex_z() const{
  throw std::runtime_error("mc_nutaus_vertex_z does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_pdf_id1() const{
  throw std::runtime_error("mc_pdf_id1 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_pdf_id2() const{
  throw std::runtime_error("mc_pdf_id2 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_pdf_q() const{
  throw std::runtime_error("mc_pdf_q does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_pdf_x1() const{
  throw std::runtime_error("mc_pdf_x1 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_pdf_x2() const{
  throw std::runtime_error("mc_pdf_x2 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_charge() const{
  throw std::runtime_error("mc_photons_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_energy() const{
  throw std::runtime_error("mc_photons_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_eta() const{
  throw std::runtime_error("mc_photons_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_ggrandmother_id() const{
  throw std::runtime_error("mc_photons_ggrandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_grandmother_id() const{
  throw std::runtime_error("mc_photons_grandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_id() const{
  throw std::runtime_error("mc_photons_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_mass() const{
  throw std::runtime_error("mc_photons_mass does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_mother_id() const{
  throw std::runtime_error("mc_photons_mother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_mother_pt() const{
  throw std::runtime_error("mc_photons_mother_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_numOfDaughters() const{
  throw std::runtime_error("mc_photons_numOfDaughters does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_phi() const{
  throw std::runtime_error("mc_photons_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_pt() const{
  throw std::runtime_error("mc_photons_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_px() const{
  throw std::runtime_error("mc_photons_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_py() const{
  throw std::runtime_error("mc_photons_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_pz() const{
  throw std::runtime_error("mc_photons_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_status() const{
  throw std::runtime_error("mc_photons_status does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_theta() const{
  throw std::runtime_error("mc_photons_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_vertex_x() const{
  throw std::runtime_error("mc_photons_vertex_x does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_vertex_y() const{
  throw std::runtime_error("mc_photons_vertex_y does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_photons_vertex_z() const{
  throw std::runtime_error("mc_photons_vertex_z does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_charge() const{
  throw std::runtime_error("mc_taus_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_energy() const{
  throw std::runtime_error("mc_taus_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_eta() const{
  throw std::runtime_error("mc_taus_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_ggrandmother_id() const{
  throw std::runtime_error("mc_taus_ggrandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_grandmother_id() const{
  throw std::runtime_error("mc_taus_grandmother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_id() const{
  throw std::runtime_error("mc_taus_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_mass() const{
  throw std::runtime_error("mc_taus_mass does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_mother_id() const{
  throw std::runtime_error("mc_taus_mother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_mother_pt() const{
  throw std::runtime_error("mc_taus_mother_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_numOfDaughters() const{
  throw std::runtime_error("mc_taus_numOfDaughters does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_phi() const{
  throw std::runtime_error("mc_taus_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_pt() const{
  throw std::runtime_error("mc_taus_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_px() const{
  throw std::runtime_error("mc_taus_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_py() const{
  throw std::runtime_error("mc_taus_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_pz() const{
  throw std::runtime_error("mc_taus_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_status() const{
  throw std::runtime_error("mc_taus_status does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_theta() const{
  throw std::runtime_error("mc_taus_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_vertex_x() const{
  throw std::runtime_error("mc_taus_vertex_x does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_vertex_y() const{
  throw std::runtime_error("mc_taus_vertex_y does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mc_taus_vertex_z() const{
  throw std::runtime_error("mc_taus_vertex_z does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::metsHO_et() const{
  throw std::runtime_error("metsHO_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::metsHO_ex() const{
  throw std::runtime_error("metsHO_ex does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::metsHO_ey() const{
  throw std::runtime_error("metsHO_ey does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::metsHO_phi() const{
  throw std::runtime_error("metsHO_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::metsHO_sumEt() const{
  throw std::runtime_error("metsHO_sumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mets_AK5_et() const{
  throw std::runtime_error("mets_AK5_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mets_AK5_ex() const{
  throw std::runtime_error("mets_AK5_ex does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mets_AK5_ey() const{
  throw std::runtime_error("mets_AK5_ey does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mets_AK5_gen_et() const{
  throw std::runtime_error("mets_AK5_gen_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mets_AK5_gen_phi() const{
  throw std::runtime_error("mets_AK5_gen_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mets_AK5_phi() const{
  throw std::runtime_error("mets_AK5_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mets_AK5_sign() const{
  throw std::runtime_error("mets_AK5_sign does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mets_AK5_sumEt() const{
  throw std::runtime_error("mets_AK5_sumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mets_AK5_unCPhi() const{
  throw std::runtime_error("mets_AK5_unCPhi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mets_AK5_unCPt() const{
  throw std::runtime_error("mets_AK5_unCPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mu_tracks_E() const{
  throw std::runtime_error("mu_tracks_E does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mu_tracks_R03_trkiso() const{
  throw std::runtime_error("mu_tracks_R03_trkiso does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::mu_tracks_chg() const{
  throw std::runtime_error("mu_tracks_chg does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mu_tracks_dzpv() const{
  throw std::runtime_error("mu_tracks_dzpv does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mu_tracks_eta() const{
  throw std::runtime_error("mu_tracks_eta does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::mu_tracks_fromPV() const{
  throw std::runtime_error("mu_tracks_fromPV does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mu_tracks_miniso() const{
  throw std::runtime_error("mu_tracks_miniso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mu_tracks_miniso_chg_only() const{
  throw std::runtime_error("mu_tracks_miniso_chg_only does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mu_tracks_phi() const{
  throw std::runtime_error("mu_tracks_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mu_tracks_pt() const{
  throw std::runtime_error("mu_tracks_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_caloCompatibility() const{
  throw std::runtime_error("mus_caloCompatibility does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_cm_ExpectedHitsInner() const{
  throw std::runtime_error("mus_cm_ExpectedHitsInner does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_cm_ExpectedHitsOuter() const{
  throw std::runtime_error("mus_cm_ExpectedHitsOuter does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_et() const{
  throw std::runtime_error("mus_gen_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_eta() const{
  throw std::runtime_error("mus_gen_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_id() const{
  throw std::runtime_error("mus_gen_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_mother_et() const{
  throw std::runtime_error("mus_gen_mother_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_mother_eta() const{
  throw std::runtime_error("mus_gen_mother_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_mother_id() const{
  throw std::runtime_error("mus_gen_mother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_mother_phi() const{
  throw std::runtime_error("mus_gen_mother_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_mother_pt() const{
  throw std::runtime_error("mus_gen_mother_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_mother_px() const{
  throw std::runtime_error("mus_gen_mother_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_mother_py() const{
  throw std::runtime_error("mus_gen_mother_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_mother_pz() const{
  throw std::runtime_error("mus_gen_mother_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_mother_theta() const{
  throw std::runtime_error("mus_gen_mother_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_phi() const{
  throw std::runtime_error("mus_gen_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_pt() const{
  throw std::runtime_error("mus_gen_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_px() const{
  throw std::runtime_error("mus_gen_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_py() const{
  throw std::runtime_error("mus_gen_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_pz() const{
  throw std::runtime_error("mus_gen_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_gen_theta() const{
  throw std::runtime_error("mus_gen_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_globalTrack_normalizedChi2() const{
  throw std::runtime_error("mus_globalTrack_normalizedChi2 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_isCaloMuon() const{
  throw std::runtime_error("mus_isCaloMuon does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_isConvertedPhoton() const{
  throw std::runtime_error("mus_isConvertedPhoton does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_isElectron() const{
  throw std::runtime_error("mus_isElectron does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::mus_isLooseMuon() const{
  throw std::runtime_error("mus_isLooseMuon does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::mus_isMediumMuon() const{
  throw std::runtime_error("mus_isMediumMuon does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::mus_isPF() const{
  throw std::runtime_error("mus_isPF does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_isPhoton() const{
  throw std::runtime_error("mus_isPhoton does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::mus_isTightMuon() const{
  throw std::runtime_error("mus_isTightMuon does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::mus_jet_ind() const{
  throw std::runtime_error("mus_jet_ind does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_miniso() const{
  throw std::runtime_error("mus_miniso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_ExpectedHitsInner() const{
  throw std::runtime_error("mus_picky_ExpectedHitsInner does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_ExpectedHitsOuter() const{
  throw std::runtime_error("mus_picky_ExpectedHitsOuter does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_LayersWithMeasurement() const{
  throw std::runtime_error("mus_picky_LayersWithMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_LayersWithoutMeasurement() const{
  throw std::runtime_error("mus_picky_LayersWithoutMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_PixelLayersWithMeasurement() const{
  throw std::runtime_error("mus_picky_PixelLayersWithMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_ValidStripLayersWithMonoAndStereoHit() const{
  throw std::runtime_error("mus_picky_ValidStripLayersWithMonoAndStereoHit does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_chg() const{
  throw std::runtime_error("mus_picky_chg does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_chi2() const{
  throw std::runtime_error("mus_picky_chi2 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_d0dum() const{
  throw std::runtime_error("mus_picky_d0dum does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_d0dumErr() const{
  throw std::runtime_error("mus_picky_d0dumErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_dz() const{
  throw std::runtime_error("mus_picky_dz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_dzErr() const{
  throw std::runtime_error("mus_picky_dzErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_eta() const{
  throw std::runtime_error("mus_picky_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_etaErr() const{
  throw std::runtime_error("mus_picky_etaErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_id() const{
  throw std::runtime_error("mus_picky_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_ndof() const{
  throw std::runtime_error("mus_picky_ndof does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_numlosthits() const{
  throw std::runtime_error("mus_picky_numlosthits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_numvalPixelhits() const{
  throw std::runtime_error("mus_picky_numvalPixelhits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_numvalhits() const{
  throw std::runtime_error("mus_picky_numvalhits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_phi() const{
  throw std::runtime_error("mus_picky_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_phiErr() const{
  throw std::runtime_error("mus_picky_phiErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_pt() const{
  throw std::runtime_error("mus_picky_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_ptErr() const{
  throw std::runtime_error("mus_picky_ptErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_px() const{
  throw std::runtime_error("mus_picky_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_py() const{
  throw std::runtime_error("mus_picky_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_pz() const{
  throw std::runtime_error("mus_picky_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_theta() const{
  throw std::runtime_error("mus_picky_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_vx() const{
  throw std::runtime_error("mus_picky_vx does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_vy() const{
  throw std::runtime_error("mus_picky_vy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_picky_vz() const{
  throw std::runtime_error("mus_picky_vz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_segmentCompatibility() const{
  throw std::runtime_error("mus_segmentCompatibility does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tkHitsFrac() const{
  throw std::runtime_error("mus_tkHitsFrac does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tk_ExpectedHitsInner() const{
  throw std::runtime_error("mus_tk_ExpectedHitsInner does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tk_ExpectedHitsOuter() const{
  throw std::runtime_error("mus_tk_ExpectedHitsOuter does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_ExpectedHitsInner() const{
  throw std::runtime_error("mus_tpfms_ExpectedHitsInner does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_ExpectedHitsOuter() const{
  throw std::runtime_error("mus_tpfms_ExpectedHitsOuter does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_LayersWithMeasurement() const{
  throw std::runtime_error("mus_tpfms_LayersWithMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_LayersWithoutMeasurement() const{
  throw std::runtime_error("mus_tpfms_LayersWithoutMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_PixelLayersWithMeasurement() const{
  throw std::runtime_error("mus_tpfms_PixelLayersWithMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_ValidStripLayersWithMonoAndStereoHit() const{
  throw std::runtime_error("mus_tpfms_ValidStripLayersWithMonoAndStereoHit does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_chg() const{
  throw std::runtime_error("mus_tpfms_chg does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_chi2() const{
  throw std::runtime_error("mus_tpfms_chi2 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_d0dum() const{
  throw std::runtime_error("mus_tpfms_d0dum does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_d0dumErr() const{
  throw std::runtime_error("mus_tpfms_d0dumErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_dz() const{
  throw std::runtime_error("mus_tpfms_dz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_dzErr() const{
  throw std::runtime_error("mus_tpfms_dzErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_eta() const{
  throw std::runtime_error("mus_tpfms_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_etaErr() const{
  throw std::runtime_error("mus_tpfms_etaErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_id() const{
  throw std::runtime_error("mus_tpfms_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_ndof() const{
  throw std::runtime_error("mus_tpfms_ndof does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_numlosthits() const{
  throw std::runtime_error("mus_tpfms_numlosthits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_numvalPixelhits() const{
  throw std::runtime_error("mus_tpfms_numvalPixelhits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_numvalhits() const{
  throw std::runtime_error("mus_tpfms_numvalhits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_phi() const{
  throw std::runtime_error("mus_tpfms_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_phiErr() const{
  throw std::runtime_error("mus_tpfms_phiErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_pt() const{
  throw std::runtime_error("mus_tpfms_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_ptErr() const{
  throw std::runtime_error("mus_tpfms_ptErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_px() const{
  throw std::runtime_error("mus_tpfms_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_py() const{
  throw std::runtime_error("mus_tpfms_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_pz() const{
  throw std::runtime_error("mus_tpfms_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_theta() const{
  throw std::runtime_error("mus_tpfms_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_vx() const{
  throw std::runtime_error("mus_tpfms_vx does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_vy() const{
  throw std::runtime_error("mus_tpfms_vy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_tpfms_vz() const{
  throw std::runtime_error("mus_tpfms_vz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_trkKink() const{
  throw std::runtime_error("mus_trkKink does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::mus_trkPositionMatch() const{
  throw std::runtime_error("mus_trkPositionMatch does not exist in this cfA version.");
}

Int_t const & cfa_base::passprescaleHT250filter_decision() const{
  throw std::runtime_error("passprescaleHT250filter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::passprescaleHT300filter_decision() const{
  throw std::runtime_error("passprescaleHT300filter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::passprescaleHT350filter_decision() const{
  throw std::runtime_error("passprescaleHT350filter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::passprescaleHT400filter_decision() const{
  throw std::runtime_error("passprescaleHT400filter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::passprescaleHT450filter_decision() const{
  throw std::runtime_error("passprescaleHT450filter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::passprescaleJet30MET80filter_decision() const{
  throw std::runtime_error("passprescaleJet30MET80filter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::passprescalePFHT350filter_decision() const{
  throw std::runtime_error("passprescalePFHT350filter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::pdf_info_id1() const{
  throw std::runtime_error("pdf_info_id1 does not exist in this cfA version.");
}

Int_t const & cfa_base::pdf_info_id2() const{
  throw std::runtime_error("pdf_info_id2 does not exist in this cfA version.");
}

Float_t const & cfa_base::pdf_info_pdf1() const{
  throw std::runtime_error("pdf_info_pdf1 does not exist in this cfA version.");
}

Float_t const & cfa_base::pdf_info_pdf2() const{
  throw std::runtime_error("pdf_info_pdf2 does not exist in this cfA version.");
}

Float_t const & cfa_base::pdf_info_scale() const{
  throw std::runtime_error("pdf_info_scale does not exist in this cfA version.");
}

Float_t const & cfa_base::pdf_info_x1() const{
  throw std::runtime_error("pdf_info_x1 does not exist in this cfA version.");
}

Float_t const & cfa_base::pdf_info_x2() const{
  throw std::runtime_error("pdf_info_x2 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pdfweights_cteq() const{
  throw std::runtime_error("pdfweights_cteq does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pdfweights_mstw() const{
  throw std::runtime_error("pdfweights_mstw does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pdfweights_nnpdf() const{
  throw std::runtime_error("pdfweights_nnpdf does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1metsSummer15V2_NoHF_et() const{
  throw std::runtime_error("pfType1metsSummer15V2_NoHF_et does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1metsSummer15V2_NoHF_phi() const{
  throw std::runtime_error("pfType1metsSummer15V2_NoHF_phi does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1metsSummer15V2_NoHF_sumEt() const{
  throw std::runtime_error("pfType1metsSummer15V2_NoHF_sumEt does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1metsSummer15V2_et() const{
  throw std::runtime_error("pfType1metsSummer15V2_et does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1metsSummer15V2_phi() const{
  throw std::runtime_error("pfType1metsSummer15V2_phi does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1metsSummer15V2_sumEt() const{
  throw std::runtime_error("pfType1metsSummer15V2_sumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfType1mets_default_ChargedEMEtFraction() const{
  throw std::runtime_error("pfType1mets_default_ChargedEMEtFraction does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfType1mets_default_ChargedHadEtFraction() const{
  throw std::runtime_error("pfType1mets_default_ChargedHadEtFraction does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfType1mets_default_MuonEtFraction() const{
  throw std::runtime_error("pfType1mets_default_MuonEtFraction does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfType1mets_default_NeutralEMFraction() const{
  throw std::runtime_error("pfType1mets_default_NeutralEMFraction does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfType1mets_default_NeutralHadEtFraction() const{
  throw std::runtime_error("pfType1mets_default_NeutralHadEtFraction does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfType1mets_default_Sig() const{
  throw std::runtime_error("pfType1mets_default_Sig does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfType1mets_default_Type6EtFraction() const{
  throw std::runtime_error("pfType1mets_default_Type6EtFraction does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfType1mets_default_Type7EtFraction() const{
  throw std::runtime_error("pfType1mets_default_Type7EtFraction does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfType1mets_default_et() const{
  throw std::runtime_error("pfType1mets_default_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfType1mets_default_ex() const{
  throw std::runtime_error("pfType1mets_default_ex does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfType1mets_default_ey() const{
  throw std::runtime_error("pfType1mets_default_ey does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfType1mets_default_gen_et() const{
  throw std::runtime_error("pfType1mets_default_gen_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfType1mets_default_gen_phi() const{
  throw std::runtime_error("pfType1mets_default_gen_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfType1mets_default_phi() const{
  throw std::runtime_error("pfType1mets_default_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfType1mets_default_sumEt() const{
  throw std::runtime_error("pfType1mets_default_sumEt does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1mets_uncert_JetEnDown_dpx() const{
  throw std::runtime_error("pfType1mets_uncert_JetEnDown_dpx does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1mets_uncert_JetEnDown_dpy() const{
  throw std::runtime_error("pfType1mets_uncert_JetEnDown_dpy does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1mets_uncert_JetEnDown_sumEt() const{
  throw std::runtime_error("pfType1mets_uncert_JetEnDown_sumEt does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1mets_uncert_JetEnUp_dpx() const{
  throw std::runtime_error("pfType1mets_uncert_JetEnUp_dpx does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1mets_uncert_JetEnUp_dpy() const{
  throw std::runtime_error("pfType1mets_uncert_JetEnUp_dpy does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1mets_uncert_JetEnUp_sumEt() const{
  throw std::runtime_error("pfType1mets_uncert_JetEnUp_sumEt does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1mets_uncert_JetResDown_dpx() const{
  throw std::runtime_error("pfType1mets_uncert_JetResDown_dpx does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1mets_uncert_JetResDown_dpy() const{
  throw std::runtime_error("pfType1mets_uncert_JetResDown_dpy does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1mets_uncert_JetResDown_sumEt() const{
  throw std::runtime_error("pfType1mets_uncert_JetResDown_sumEt does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1mets_uncert_JetResUp_dpx() const{
  throw std::runtime_error("pfType1mets_uncert_JetResUp_dpx does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1mets_uncert_JetResUp_dpy() const{
  throw std::runtime_error("pfType1mets_uncert_JetResUp_dpy does not exist in this cfA version.");
}

Float_t const & cfa_base::pfType1mets_uncert_JetResUp_sumEt() const{
  throw std::runtime_error("pfType1mets_uncert_JetResUp_sumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeINoXYCorrmets_et() const{
  throw std::runtime_error("pfTypeINoXYCorrmets_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeINoXYCorrmets_ex() const{
  throw std::runtime_error("pfTypeINoXYCorrmets_ex does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeINoXYCorrmets_ey() const{
  throw std::runtime_error("pfTypeINoXYCorrmets_ey does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeINoXYCorrmets_gen_et() const{
  throw std::runtime_error("pfTypeINoXYCorrmets_gen_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeINoXYCorrmets_gen_phi() const{
  throw std::runtime_error("pfTypeINoXYCorrmets_gen_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeINoXYCorrmets_phi() const{
  throw std::runtime_error("pfTypeINoXYCorrmets_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeINoXYCorrmets_sign() const{
  throw std::runtime_error("pfTypeINoXYCorrmets_sign does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeINoXYCorrmets_sumEt() const{
  throw std::runtime_error("pfTypeINoXYCorrmets_sumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeINoXYCorrmets_unCPhi() const{
  throw std::runtime_error("pfTypeINoXYCorrmets_unCPhi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeINoXYCorrmets_unCPt() const{
  throw std::runtime_error("pfTypeINoXYCorrmets_unCPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeIType0mets_et() const{
  throw std::runtime_error("pfTypeIType0mets_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeIType0mets_ex() const{
  throw std::runtime_error("pfTypeIType0mets_ex does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeIType0mets_ey() const{
  throw std::runtime_error("pfTypeIType0mets_ey does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeIType0mets_gen_et() const{
  throw std::runtime_error("pfTypeIType0mets_gen_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeIType0mets_gen_phi() const{
  throw std::runtime_error("pfTypeIType0mets_gen_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeIType0mets_phi() const{
  throw std::runtime_error("pfTypeIType0mets_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeIType0mets_sign() const{
  throw std::runtime_error("pfTypeIType0mets_sign does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeIType0mets_sumEt() const{
  throw std::runtime_error("pfTypeIType0mets_sumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeIType0mets_unCPhi() const{
  throw std::runtime_error("pfTypeIType0mets_unCPhi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeIType0mets_unCPt() const{
  throw std::runtime_error("pfTypeIType0mets_unCPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeImets_et() const{
  throw std::runtime_error("pfTypeImets_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeImets_ex() const{
  throw std::runtime_error("pfTypeImets_ex does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeImets_ey() const{
  throw std::runtime_error("pfTypeImets_ey does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeImets_gen_et() const{
  throw std::runtime_error("pfTypeImets_gen_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeImets_gen_phi() const{
  throw std::runtime_error("pfTypeImets_gen_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeImets_phi() const{
  throw std::runtime_error("pfTypeImets_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeImets_sign() const{
  throw std::runtime_error("pfTypeImets_sign does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeImets_sumEt() const{
  throw std::runtime_error("pfTypeImets_sumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeImets_unCPhi() const{
  throw std::runtime_error("pfTypeImets_unCPhi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfTypeImets_unCPt() const{
  throw std::runtime_error("pfTypeImets_unCPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_PATpassConversionVeto() const{
  throw std::runtime_error("pf_els_PATpassConversionVeto does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_PFchargedHadronIsoR03() const{
  throw std::runtime_error("pf_els_PFchargedHadronIsoR03 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_PFneutralHadronIsoR03() const{
  throw std::runtime_error("pf_els_PFneutralHadronIsoR03 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_PFphotonIsoR03() const{
  throw std::runtime_error("pf_els_PFphotonIsoR03 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_basicClustersSize() const{
  throw std::runtime_error("pf_els_basicClustersSize does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_cIso() const{
  throw std::runtime_error("pf_els_cIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_caloEnergy() const{
  throw std::runtime_error("pf_els_caloEnergy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_charge() const{
  throw std::runtime_error("pf_els_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_chargedHadronIso() const{
  throw std::runtime_error("pf_els_chargedHadronIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_chi2() const{
  throw std::runtime_error("pf_els_chi2 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_core_ecalDrivenSeed() const{
  throw std::runtime_error("pf_els_core_ecalDrivenSeed does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_cpx() const{
  throw std::runtime_error("pf_els_cpx does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_cpy() const{
  throw std::runtime_error("pf_els_cpy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_cpz() const{
  throw std::runtime_error("pf_els_cpz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_ctf_tk_charge() const{
  throw std::runtime_error("pf_els_ctf_tk_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_ctf_tk_eta() const{
  throw std::runtime_error("pf_els_ctf_tk_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_ctf_tk_id() const{
  throw std::runtime_error("pf_els_ctf_tk_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_ctf_tk_phi() const{
  throw std::runtime_error("pf_els_ctf_tk_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_cx() const{
  throw std::runtime_error("pf_els_cx does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_cy() const{
  throw std::runtime_error("pf_els_cy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_cz() const{
  throw std::runtime_error("pf_els_cz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_d0dum() const{
  throw std::runtime_error("pf_els_d0dum does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_d0dumError() const{
  throw std::runtime_error("pf_els_d0dumError does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dEtaIn() const{
  throw std::runtime_error("pf_els_dEtaIn does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dEtaOut() const{
  throw std::runtime_error("pf_els_dEtaOut does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dPhiIn() const{
  throw std::runtime_error("pf_els_dPhiIn does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dPhiOut() const{
  throw std::runtime_error("pf_els_dPhiOut does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dr03EcalRecHitSumEt() const{
  throw std::runtime_error("pf_els_dr03EcalRecHitSumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dr03HcalDepth1TowerSumEt() const{
  throw std::runtime_error("pf_els_dr03HcalDepth1TowerSumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dr03HcalDepth2TowerSumEt() const{
  throw std::runtime_error("pf_els_dr03HcalDepth2TowerSumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dr03HcalTowerSumEt() const{
  throw std::runtime_error("pf_els_dr03HcalTowerSumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dr03TkSumPt() const{
  throw std::runtime_error("pf_els_dr03TkSumPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dr04EcalRecHitSumEt() const{
  throw std::runtime_error("pf_els_dr04EcalRecHitSumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dr04HcalDepth1TowerSumEt() const{
  throw std::runtime_error("pf_els_dr04HcalDepth1TowerSumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dr04HcalDepth2TowerSumEt() const{
  throw std::runtime_error("pf_els_dr04HcalDepth2TowerSumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dr04HcalTowerSumEt() const{
  throw std::runtime_error("pf_els_dr04HcalTowerSumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dr04TkSumPt() const{
  throw std::runtime_error("pf_els_dr04TkSumPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dz() const{
  throw std::runtime_error("pf_els_dz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_dzError() const{
  throw std::runtime_error("pf_els_dzError does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_eOverPIn() const{
  throw std::runtime_error("pf_els_eOverPIn does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_eSeedOverPOut() const{
  throw std::runtime_error("pf_els_eSeedOverPOut does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_ecalIso() const{
  throw std::runtime_error("pf_els_ecalIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_energy() const{
  throw std::runtime_error("pf_els_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_et() const{
  throw std::runtime_error("pf_els_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_eta() const{
  throw std::runtime_error("pf_els_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_etaError() const{
  throw std::runtime_error("pf_els_etaError does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_fbrem() const{
  throw std::runtime_error("pf_els_fbrem does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_et() const{
  throw std::runtime_error("pf_els_gen_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_eta() const{
  throw std::runtime_error("pf_els_gen_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_id() const{
  throw std::runtime_error("pf_els_gen_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_mother_et() const{
  throw std::runtime_error("pf_els_gen_mother_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_mother_eta() const{
  throw std::runtime_error("pf_els_gen_mother_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_mother_id() const{
  throw std::runtime_error("pf_els_gen_mother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_mother_phi() const{
  throw std::runtime_error("pf_els_gen_mother_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_mother_pt() const{
  throw std::runtime_error("pf_els_gen_mother_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_mother_px() const{
  throw std::runtime_error("pf_els_gen_mother_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_mother_py() const{
  throw std::runtime_error("pf_els_gen_mother_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_mother_pz() const{
  throw std::runtime_error("pf_els_gen_mother_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_mother_theta() const{
  throw std::runtime_error("pf_els_gen_mother_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_phi() const{
  throw std::runtime_error("pf_els_gen_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_pt() const{
  throw std::runtime_error("pf_els_gen_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_px() const{
  throw std::runtime_error("pf_els_gen_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_py() const{
  throw std::runtime_error("pf_els_gen_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_pz() const{
  throw std::runtime_error("pf_els_gen_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_gen_theta() const{
  throw std::runtime_error("pf_els_gen_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_hadOverEm() const{
  throw std::runtime_error("pf_els_hadOverEm does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::pf_els_hasMatchedConversion() const{
  throw std::runtime_error("pf_els_hasMatchedConversion does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_hcalIso() const{
  throw std::runtime_error("pf_els_hcalIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_hcalOverEcalBc() const{
  throw std::runtime_error("pf_els_hcalOverEcalBc does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_isEB() const{
  throw std::runtime_error("pf_els_isEB does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_isEE() const{
  throw std::runtime_error("pf_els_isEE does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_looseId() const{
  throw std::runtime_error("pf_els_looseId does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_n_inner_layer() const{
  throw std::runtime_error("pf_els_n_inner_layer does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_n_outer_layer() const{
  throw std::runtime_error("pf_els_n_outer_layer does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_ndof() const{
  throw std::runtime_error("pf_els_ndof does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_neutralHadronIso() const{
  throw std::runtime_error("pf_els_neutralHadronIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_numlosthits() const{
  throw std::runtime_error("pf_els_numlosthits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_numvalhits() const{
  throw std::runtime_error("pf_els_numvalhits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_phi() const{
  throw std::runtime_error("pf_els_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_phiError() const{
  throw std::runtime_error("pf_els_phiError does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_photonIso() const{
  throw std::runtime_error("pf_els_photonIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_pt() const{
  throw std::runtime_error("pf_els_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_ptError() const{
  throw std::runtime_error("pf_els_ptError does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_px() const{
  throw std::runtime_error("pf_els_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_py() const{
  throw std::runtime_error("pf_els_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_pz() const{
  throw std::runtime_error("pf_els_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_robustHighEnergyId() const{
  throw std::runtime_error("pf_els_robustHighEnergyId does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_robustLooseId() const{
  throw std::runtime_error("pf_els_robustLooseId does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_robustTightId() const{
  throw std::runtime_error("pf_els_robustTightId does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_scE1x5() const{
  throw std::runtime_error("pf_els_scE1x5 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_scE2x5Max() const{
  throw std::runtime_error("pf_els_scE2x5Max does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_scE5x5() const{
  throw std::runtime_error("pf_els_scE5x5 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_scEnergy() const{
  throw std::runtime_error("pf_els_scEnergy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_scEta() const{
  throw std::runtime_error("pf_els_scEta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_scEtaWidth() const{
  throw std::runtime_error("pf_els_scEtaWidth does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_scPhi() const{
  throw std::runtime_error("pf_els_scPhi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_scPhiWidth() const{
  throw std::runtime_error("pf_els_scPhiWidth does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_scRawEnergy() const{
  throw std::runtime_error("pf_els_scRawEnergy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_scSeedEnergy() const{
  throw std::runtime_error("pf_els_scSeedEnergy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_shFracInnerHits() const{
  throw std::runtime_error("pf_els_shFracInnerHits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_sigmaEtaEta() const{
  throw std::runtime_error("pf_els_sigmaEtaEta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_sigmaIEtaIEta() const{
  throw std::runtime_error("pf_els_sigmaIEtaIEta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_simpleEleId60cIso() const{
  throw std::runtime_error("pf_els_simpleEleId60cIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_simpleEleId60relIso() const{
  throw std::runtime_error("pf_els_simpleEleId60relIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_simpleEleId70cIso() const{
  throw std::runtime_error("pf_els_simpleEleId70cIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_simpleEleId70relIso() const{
  throw std::runtime_error("pf_els_simpleEleId70relIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_simpleEleId80cIso() const{
  throw std::runtime_error("pf_els_simpleEleId80cIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_simpleEleId80relIso() const{
  throw std::runtime_error("pf_els_simpleEleId80relIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_simpleEleId85cIso() const{
  throw std::runtime_error("pf_els_simpleEleId85cIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_simpleEleId85relIso() const{
  throw std::runtime_error("pf_els_simpleEleId85relIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_simpleEleId90cIso() const{
  throw std::runtime_error("pf_els_simpleEleId90cIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_simpleEleId90relIso() const{
  throw std::runtime_error("pf_els_simpleEleId90relIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_simpleEleId95cIso() const{
  throw std::runtime_error("pf_els_simpleEleId95cIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_simpleEleId95relIso() const{
  throw std::runtime_error("pf_els_simpleEleId95relIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_status() const{
  throw std::runtime_error("pf_els_status does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_tIso() const{
  throw std::runtime_error("pf_els_tIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_theta() const{
  throw std::runtime_error("pf_els_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_tightId() const{
  throw std::runtime_error("pf_els_tightId does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_tk_charge() const{
  throw std::runtime_error("pf_els_tk_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_tk_eta() const{
  throw std::runtime_error("pf_els_tk_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_tk_phi() const{
  throw std::runtime_error("pf_els_tk_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_tk_pt() const{
  throw std::runtime_error("pf_els_tk_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_tk_pz() const{
  throw std::runtime_error("pf_els_tk_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_vpx() const{
  throw std::runtime_error("pf_els_vpx does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_vpy() const{
  throw std::runtime_error("pf_els_vpy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_vpz() const{
  throw std::runtime_error("pf_els_vpz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_vx() const{
  throw std::runtime_error("pf_els_vx does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_vy() const{
  throw std::runtime_error("pf_els_vy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_els_vz() const{
  throw std::runtime_error("pf_els_vz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cIso() const{
  throw std::runtime_error("pf_mus_cIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_calEnergyEm() const{
  throw std::runtime_error("pf_mus_calEnergyEm does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_calEnergyEmS9() const{
  throw std::runtime_error("pf_mus_calEnergyEmS9 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_calEnergyHad() const{
  throw std::runtime_error("pf_mus_calEnergyHad does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_calEnergyHadS9() const{
  throw std::runtime_error("pf_mus_calEnergyHadS9 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_calEnergyHo() const{
  throw std::runtime_error("pf_mus_calEnergyHo does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_calEnergyHoS9() const{
  throw std::runtime_error("pf_mus_calEnergyHoS9 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_charge() const{
  throw std::runtime_error("pf_mus_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_chargedHadronIso() const{
  throw std::runtime_error("pf_mus_chargedHadronIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_ExpectedHitsInner() const{
  throw std::runtime_error("pf_mus_cm_ExpectedHitsInner does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_ExpectedHitsOuter() const{
  throw std::runtime_error("pf_mus_cm_ExpectedHitsOuter does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_LayersWithMeasurement() const{
  throw std::runtime_error("pf_mus_cm_LayersWithMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_LayersWithoutMeasurement() const{
  throw std::runtime_error("pf_mus_cm_LayersWithoutMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_PixelLayersWithMeasurement() const{
  throw std::runtime_error("pf_mus_cm_PixelLayersWithMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_ValidStripLayersWithMonoAndStereoHit() const{
  throw std::runtime_error("pf_mus_cm_ValidStripLayersWithMonoAndStereoHit does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_chg() const{
  throw std::runtime_error("pf_mus_cm_chg does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_chi2() const{
  throw std::runtime_error("pf_mus_cm_chi2 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_d0dum() const{
  throw std::runtime_error("pf_mus_cm_d0dum does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_d0dumErr() const{
  throw std::runtime_error("pf_mus_cm_d0dumErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_dz() const{
  throw std::runtime_error("pf_mus_cm_dz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_dzErr() const{
  throw std::runtime_error("pf_mus_cm_dzErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_eta() const{
  throw std::runtime_error("pf_mus_cm_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_etaErr() const{
  throw std::runtime_error("pf_mus_cm_etaErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_ndof() const{
  throw std::runtime_error("pf_mus_cm_ndof does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_numlosthits() const{
  throw std::runtime_error("pf_mus_cm_numlosthits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_numvalMuonhits() const{
  throw std::runtime_error("pf_mus_cm_numvalMuonhits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_numvalhits() const{
  throw std::runtime_error("pf_mus_cm_numvalhits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_phi() const{
  throw std::runtime_error("pf_mus_cm_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_phiErr() const{
  throw std::runtime_error("pf_mus_cm_phiErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_pt() const{
  throw std::runtime_error("pf_mus_cm_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_ptErr() const{
  throw std::runtime_error("pf_mus_cm_ptErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_px() const{
  throw std::runtime_error("pf_mus_cm_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_py() const{
  throw std::runtime_error("pf_mus_cm_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_pz() const{
  throw std::runtime_error("pf_mus_cm_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_theta() const{
  throw std::runtime_error("pf_mus_cm_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_vx() const{
  throw std::runtime_error("pf_mus_cm_vx does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_vy() const{
  throw std::runtime_error("pf_mus_cm_vy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_cm_vz() const{
  throw std::runtime_error("pf_mus_cm_vz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_dB() const{
  throw std::runtime_error("pf_mus_dB does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_ecalIso() const{
  throw std::runtime_error("pf_mus_ecalIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_energy() const{
  throw std::runtime_error("pf_mus_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_et() const{
  throw std::runtime_error("pf_mus_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_eta() const{
  throw std::runtime_error("pf_mus_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_et() const{
  throw std::runtime_error("pf_mus_gen_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_eta() const{
  throw std::runtime_error("pf_mus_gen_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_id() const{
  throw std::runtime_error("pf_mus_gen_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_mother_et() const{
  throw std::runtime_error("pf_mus_gen_mother_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_mother_eta() const{
  throw std::runtime_error("pf_mus_gen_mother_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_mother_id() const{
  throw std::runtime_error("pf_mus_gen_mother_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_mother_phi() const{
  throw std::runtime_error("pf_mus_gen_mother_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_mother_pt() const{
  throw std::runtime_error("pf_mus_gen_mother_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_mother_px() const{
  throw std::runtime_error("pf_mus_gen_mother_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_mother_py() const{
  throw std::runtime_error("pf_mus_gen_mother_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_mother_pz() const{
  throw std::runtime_error("pf_mus_gen_mother_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_mother_theta() const{
  throw std::runtime_error("pf_mus_gen_mother_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_phi() const{
  throw std::runtime_error("pf_mus_gen_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_pt() const{
  throw std::runtime_error("pf_mus_gen_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_px() const{
  throw std::runtime_error("pf_mus_gen_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_py() const{
  throw std::runtime_error("pf_mus_gen_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_pz() const{
  throw std::runtime_error("pf_mus_gen_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_gen_theta() const{
  throw std::runtime_error("pf_mus_gen_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_hcalIso() const{
  throw std::runtime_error("pf_mus_hcalIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_id_All() const{
  throw std::runtime_error("pf_mus_id_All does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_id_AllArbitrated() const{
  throw std::runtime_error("pf_mus_id_AllArbitrated does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_id_AllGlobalMuons() const{
  throw std::runtime_error("pf_mus_id_AllGlobalMuons does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_id_AllStandAloneMuons() const{
  throw std::runtime_error("pf_mus_id_AllStandAloneMuons does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_id_AllTrackerMuons() const{
  throw std::runtime_error("pf_mus_id_AllTrackerMuons does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_id_GlobalMuonPromptTight() const{
  throw std::runtime_error("pf_mus_id_GlobalMuonPromptTight does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_id_TM2DCompatibilityLoose() const{
  throw std::runtime_error("pf_mus_id_TM2DCompatibilityLoose does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_id_TM2DCompatibilityTight() const{
  throw std::runtime_error("pf_mus_id_TM2DCompatibilityTight does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_id_TMLastStationLoose() const{
  throw std::runtime_error("pf_mus_id_TMLastStationLoose does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_id_TMLastStationOptimizedLowPtLoose() const{
  throw std::runtime_error("pf_mus_id_TMLastStationOptimizedLowPtLoose does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_id_TMLastStationOptimizedLowPtTight() const{
  throw std::runtime_error("pf_mus_id_TMLastStationOptimizedLowPtTight does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_id_TMLastStationTight() const{
  throw std::runtime_error("pf_mus_id_TMLastStationTight does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_id_TMOneStationLoose() const{
  throw std::runtime_error("pf_mus_id_TMOneStationLoose does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_id_TMOneStationTight() const{
  throw std::runtime_error("pf_mus_id_TMOneStationTight does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_id_TrackerMuonArbitrated() const{
  throw std::runtime_error("pf_mus_id_TrackerMuonArbitrated does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_isCaloMuon() const{
  throw std::runtime_error("pf_mus_isCaloMuon does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_isConvertedPhoton() const{
  throw std::runtime_error("pf_mus_isConvertedPhoton does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_isElectron() const{
  throw std::runtime_error("pf_mus_isElectron does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_isGlobalMuon() const{
  throw std::runtime_error("pf_mus_isGlobalMuon does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_isPFMuon() const{
  throw std::runtime_error("pf_mus_isPFMuon does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_isPhoton() const{
  throw std::runtime_error("pf_mus_isPhoton does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_isStandAloneMuon() const{
  throw std::runtime_error("pf_mus_isStandAloneMuon does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_isTrackerMuon() const{
  throw std::runtime_error("pf_mus_isTrackerMuon does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_iso03_emEt() const{
  throw std::runtime_error("pf_mus_iso03_emEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_iso03_emVetoEt() const{
  throw std::runtime_error("pf_mus_iso03_emVetoEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_iso03_hadEt() const{
  throw std::runtime_error("pf_mus_iso03_hadEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_iso03_hadVetoEt() const{
  throw std::runtime_error("pf_mus_iso03_hadVetoEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_iso03_hoEt() const{
  throw std::runtime_error("pf_mus_iso03_hoEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_iso03_nTracks() const{
  throw std::runtime_error("pf_mus_iso03_nTracks does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_iso03_sumPt() const{
  throw std::runtime_error("pf_mus_iso03_sumPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_iso05_emEt() const{
  throw std::runtime_error("pf_mus_iso05_emEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_iso05_hadEt() const{
  throw std::runtime_error("pf_mus_iso05_hadEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_iso05_hoEt() const{
  throw std::runtime_error("pf_mus_iso05_hoEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_iso05_nTracks() const{
  throw std::runtime_error("pf_mus_iso05_nTracks does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_iso05_sumPt() const{
  throw std::runtime_error("pf_mus_iso05_sumPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_neutralHadronIso() const{
  throw std::runtime_error("pf_mus_neutralHadronIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_num_matches() const{
  throw std::runtime_error("pf_mus_num_matches does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_numberOfMatchedStations() const{
  throw std::runtime_error("pf_mus_numberOfMatchedStations does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pfIsolationR03_sumChargedHadronPt() const{
  throw std::runtime_error("pf_mus_pfIsolationR03_sumChargedHadronPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pfIsolationR03_sumChargedParticlePt() const{
  throw std::runtime_error("pf_mus_pfIsolationR03_sumChargedParticlePt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pfIsolationR03_sumNeutralHadronEt() const{
  throw std::runtime_error("pf_mus_pfIsolationR03_sumNeutralHadronEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pfIsolationR03_sumNeutralHadronEtHighThreshold() const{
  throw std::runtime_error("pf_mus_pfIsolationR03_sumNeutralHadronEtHighThreshold does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pfIsolationR03_sumPUPt() const{
  throw std::runtime_error("pf_mus_pfIsolationR03_sumPUPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pfIsolationR03_sumPhotonEt() const{
  throw std::runtime_error("pf_mus_pfIsolationR03_sumPhotonEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pfIsolationR03_sumPhotonEtHighThreshold() const{
  throw std::runtime_error("pf_mus_pfIsolationR03_sumPhotonEtHighThreshold does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pfIsolationR04_sumChargedHadronPt() const{
  throw std::runtime_error("pf_mus_pfIsolationR04_sumChargedHadronPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pfIsolationR04_sumChargedParticlePt() const{
  throw std::runtime_error("pf_mus_pfIsolationR04_sumChargedParticlePt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pfIsolationR04_sumNeutralHadronEt() const{
  throw std::runtime_error("pf_mus_pfIsolationR04_sumNeutralHadronEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pfIsolationR04_sumNeutralHadronEtHighThreshold() const{
  throw std::runtime_error("pf_mus_pfIsolationR04_sumNeutralHadronEtHighThreshold does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pfIsolationR04_sumPUPt() const{
  throw std::runtime_error("pf_mus_pfIsolationR04_sumPUPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pfIsolationR04_sumPhotonEt() const{
  throw std::runtime_error("pf_mus_pfIsolationR04_sumPhotonEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pfIsolationR04_sumPhotonEtHighThreshold() const{
  throw std::runtime_error("pf_mus_pfIsolationR04_sumPhotonEtHighThreshold does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_phi() const{
  throw std::runtime_error("pf_mus_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_photonIso() const{
  throw std::runtime_error("pf_mus_photonIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_ExpectedHitsInner() const{
  throw std::runtime_error("pf_mus_picky_ExpectedHitsInner does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_ExpectedHitsOuter() const{
  throw std::runtime_error("pf_mus_picky_ExpectedHitsOuter does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_LayersWithMeasurement() const{
  throw std::runtime_error("pf_mus_picky_LayersWithMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_LayersWithoutMeasurement() const{
  throw std::runtime_error("pf_mus_picky_LayersWithoutMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_PixelLayersWithMeasurement() const{
  throw std::runtime_error("pf_mus_picky_PixelLayersWithMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_ValidStripLayersWithMonoAndStereoHit() const{
  throw std::runtime_error("pf_mus_picky_ValidStripLayersWithMonoAndStereoHit does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_chg() const{
  throw std::runtime_error("pf_mus_picky_chg does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_chi2() const{
  throw std::runtime_error("pf_mus_picky_chi2 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_d0dum() const{
  throw std::runtime_error("pf_mus_picky_d0dum does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_d0dumErr() const{
  throw std::runtime_error("pf_mus_picky_d0dumErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_dz() const{
  throw std::runtime_error("pf_mus_picky_dz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_dzErr() const{
  throw std::runtime_error("pf_mus_picky_dzErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_eta() const{
  throw std::runtime_error("pf_mus_picky_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_etaErr() const{
  throw std::runtime_error("pf_mus_picky_etaErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_id() const{
  throw std::runtime_error("pf_mus_picky_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_ndof() const{
  throw std::runtime_error("pf_mus_picky_ndof does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_numlosthits() const{
  throw std::runtime_error("pf_mus_picky_numlosthits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_numvalPixelhits() const{
  throw std::runtime_error("pf_mus_picky_numvalPixelhits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_numvalhits() const{
  throw std::runtime_error("pf_mus_picky_numvalhits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_phi() const{
  throw std::runtime_error("pf_mus_picky_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_phiErr() const{
  throw std::runtime_error("pf_mus_picky_phiErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_pt() const{
  throw std::runtime_error("pf_mus_picky_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_ptErr() const{
  throw std::runtime_error("pf_mus_picky_ptErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_px() const{
  throw std::runtime_error("pf_mus_picky_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_py() const{
  throw std::runtime_error("pf_mus_picky_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_pz() const{
  throw std::runtime_error("pf_mus_picky_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_theta() const{
  throw std::runtime_error("pf_mus_picky_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_vx() const{
  throw std::runtime_error("pf_mus_picky_vx does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_vy() const{
  throw std::runtime_error("pf_mus_picky_vy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_picky_vz() const{
  throw std::runtime_error("pf_mus_picky_vz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pt() const{
  throw std::runtime_error("pf_mus_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_px() const{
  throw std::runtime_error("pf_mus_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_py() const{
  throw std::runtime_error("pf_mus_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_pz() const{
  throw std::runtime_error("pf_mus_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_chg() const{
  throw std::runtime_error("pf_mus_stamu_chg does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_chi2() const{
  throw std::runtime_error("pf_mus_stamu_chi2 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_d0dum() const{
  throw std::runtime_error("pf_mus_stamu_d0dum does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_d0dumErr() const{
  throw std::runtime_error("pf_mus_stamu_d0dumErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_dz() const{
  throw std::runtime_error("pf_mus_stamu_dz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_dzErr() const{
  throw std::runtime_error("pf_mus_stamu_dzErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_eta() const{
  throw std::runtime_error("pf_mus_stamu_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_etaErr() const{
  throw std::runtime_error("pf_mus_stamu_etaErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_ndof() const{
  throw std::runtime_error("pf_mus_stamu_ndof does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_numlosthits() const{
  throw std::runtime_error("pf_mus_stamu_numlosthits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_numvalhits() const{
  throw std::runtime_error("pf_mus_stamu_numvalhits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_phi() const{
  throw std::runtime_error("pf_mus_stamu_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_phiErr() const{
  throw std::runtime_error("pf_mus_stamu_phiErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_pt() const{
  throw std::runtime_error("pf_mus_stamu_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_ptErr() const{
  throw std::runtime_error("pf_mus_stamu_ptErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_px() const{
  throw std::runtime_error("pf_mus_stamu_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_py() const{
  throw std::runtime_error("pf_mus_stamu_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_pz() const{
  throw std::runtime_error("pf_mus_stamu_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_theta() const{
  throw std::runtime_error("pf_mus_stamu_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_vx() const{
  throw std::runtime_error("pf_mus_stamu_vx does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_vy() const{
  throw std::runtime_error("pf_mus_stamu_vy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_stamu_vz() const{
  throw std::runtime_error("pf_mus_stamu_vz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_status() const{
  throw std::runtime_error("pf_mus_status does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tIso() const{
  throw std::runtime_error("pf_mus_tIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_theta() const{
  throw std::runtime_error("pf_mus_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tkHits() const{
  throw std::runtime_error("pf_mus_tkHits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_ExpectedHitsInner() const{
  throw std::runtime_error("pf_mus_tk_ExpectedHitsInner does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_ExpectedHitsOuter() const{
  throw std::runtime_error("pf_mus_tk_ExpectedHitsOuter does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_LayersWithMeasurement() const{
  throw std::runtime_error("pf_mus_tk_LayersWithMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_LayersWithoutMeasurement() const{
  throw std::runtime_error("pf_mus_tk_LayersWithoutMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_PixelLayersWithMeasurement() const{
  throw std::runtime_error("pf_mus_tk_PixelLayersWithMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_ValidStripLayersWithMonoAndStereoHit() const{
  throw std::runtime_error("pf_mus_tk_ValidStripLayersWithMonoAndStereoHit does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_chg() const{
  throw std::runtime_error("pf_mus_tk_chg does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_chi2() const{
  throw std::runtime_error("pf_mus_tk_chi2 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_d0dum() const{
  throw std::runtime_error("pf_mus_tk_d0dum does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_d0dumErr() const{
  throw std::runtime_error("pf_mus_tk_d0dumErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_dz() const{
  throw std::runtime_error("pf_mus_tk_dz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_dzErr() const{
  throw std::runtime_error("pf_mus_tk_dzErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_eta() const{
  throw std::runtime_error("pf_mus_tk_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_etaErr() const{
  throw std::runtime_error("pf_mus_tk_etaErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_id() const{
  throw std::runtime_error("pf_mus_tk_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_ndof() const{
  throw std::runtime_error("pf_mus_tk_ndof does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_numlosthits() const{
  throw std::runtime_error("pf_mus_tk_numlosthits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_numpixelWthMeasr() const{
  throw std::runtime_error("pf_mus_tk_numpixelWthMeasr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_numvalPixelhits() const{
  throw std::runtime_error("pf_mus_tk_numvalPixelhits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_numvalhits() const{
  throw std::runtime_error("pf_mus_tk_numvalhits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_phi() const{
  throw std::runtime_error("pf_mus_tk_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_phiErr() const{
  throw std::runtime_error("pf_mus_tk_phiErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_pt() const{
  throw std::runtime_error("pf_mus_tk_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_ptErr() const{
  throw std::runtime_error("pf_mus_tk_ptErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_px() const{
  throw std::runtime_error("pf_mus_tk_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_py() const{
  throw std::runtime_error("pf_mus_tk_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_pz() const{
  throw std::runtime_error("pf_mus_tk_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_theta() const{
  throw std::runtime_error("pf_mus_tk_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_vx() const{
  throw std::runtime_error("pf_mus_tk_vx does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_vy() const{
  throw std::runtime_error("pf_mus_tk_vy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tk_vz() const{
  throw std::runtime_error("pf_mus_tk_vz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_ExpectedHitsInner() const{
  throw std::runtime_error("pf_mus_tpfms_ExpectedHitsInner does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_ExpectedHitsOuter() const{
  throw std::runtime_error("pf_mus_tpfms_ExpectedHitsOuter does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_LayersWithMeasurement() const{
  throw std::runtime_error("pf_mus_tpfms_LayersWithMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_LayersWithoutMeasurement() const{
  throw std::runtime_error("pf_mus_tpfms_LayersWithoutMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_PixelLayersWithMeasurement() const{
  throw std::runtime_error("pf_mus_tpfms_PixelLayersWithMeasurement does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_ValidStripLayersWithMonoAndStereoHit() const{
  throw std::runtime_error("pf_mus_tpfms_ValidStripLayersWithMonoAndStereoHit does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_chg() const{
  throw std::runtime_error("pf_mus_tpfms_chg does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_chi2() const{
  throw std::runtime_error("pf_mus_tpfms_chi2 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_d0dum() const{
  throw std::runtime_error("pf_mus_tpfms_d0dum does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_d0dumErr() const{
  throw std::runtime_error("pf_mus_tpfms_d0dumErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_dz() const{
  throw std::runtime_error("pf_mus_tpfms_dz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_dzErr() const{
  throw std::runtime_error("pf_mus_tpfms_dzErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_eta() const{
  throw std::runtime_error("pf_mus_tpfms_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_etaErr() const{
  throw std::runtime_error("pf_mus_tpfms_etaErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_id() const{
  throw std::runtime_error("pf_mus_tpfms_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_ndof() const{
  throw std::runtime_error("pf_mus_tpfms_ndof does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_numlosthits() const{
  throw std::runtime_error("pf_mus_tpfms_numlosthits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_numvalPixelhits() const{
  throw std::runtime_error("pf_mus_tpfms_numvalPixelhits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_numvalhits() const{
  throw std::runtime_error("pf_mus_tpfms_numvalhits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_phi() const{
  throw std::runtime_error("pf_mus_tpfms_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_phiErr() const{
  throw std::runtime_error("pf_mus_tpfms_phiErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_pt() const{
  throw std::runtime_error("pf_mus_tpfms_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_ptErr() const{
  throw std::runtime_error("pf_mus_tpfms_ptErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_px() const{
  throw std::runtime_error("pf_mus_tpfms_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_py() const{
  throw std::runtime_error("pf_mus_tpfms_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_pz() const{
  throw std::runtime_error("pf_mus_tpfms_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_theta() const{
  throw std::runtime_error("pf_mus_tpfms_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_vx() const{
  throw std::runtime_error("pf_mus_tpfms_vx does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_vy() const{
  throw std::runtime_error("pf_mus_tpfms_vy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_mus_tpfms_vz() const{
  throw std::runtime_error("pf_mus_tpfms_vz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_chIso() const{
  throw std::runtime_error("pf_photons_chIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_e1x5() const{
  throw std::runtime_error("pf_photons_e1x5 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_e2x5() const{
  throw std::runtime_error("pf_photons_e2x5 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_e3x3() const{
  throw std::runtime_error("pf_photons_e3x3 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_e5x5() const{
  throw std::runtime_error("pf_photons_e5x5 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_energy() const{
  throw std::runtime_error("pf_photons_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_et() const{
  throw std::runtime_error("pf_photons_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_eta() const{
  throw std::runtime_error("pf_photons_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_hadOverEM() const{
  throw std::runtime_error("pf_photons_hadOverEM does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_hadTowOverEM() const{
  throw std::runtime_error("pf_photons_hadTowOverEM does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_hasPixelSeed() const{
  throw std::runtime_error("pf_photons_hasPixelSeed does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_isAlsoElectron() const{
  throw std::runtime_error("pf_photons_isAlsoElectron does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_isConverted() const{
  throw std::runtime_error("pf_photons_isConverted does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_isEBEEGap() const{
  throw std::runtime_error("pf_photons_isEBEEGap does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_isEBGap() const{
  throw std::runtime_error("pf_photons_isEBGap does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_isEBPho() const{
  throw std::runtime_error("pf_photons_isEBPho does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_isEEGap() const{
  throw std::runtime_error("pf_photons_isEEGap does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_isEEPho() const{
  throw std::runtime_error("pf_photons_isEEPho does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_maxEnergyXtal() const{
  throw std::runtime_error("pf_photons_maxEnergyXtal does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_nhIso() const{
  throw std::runtime_error("pf_photons_nhIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_phIso() const{
  throw std::runtime_error("pf_photons_phIso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_phi() const{
  throw std::runtime_error("pf_photons_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_pt() const{
  throw std::runtime_error("pf_photons_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_px() const{
  throw std::runtime_error("pf_photons_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_py() const{
  throw std::runtime_error("pf_photons_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_pz() const{
  throw std::runtime_error("pf_photons_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_r9() const{
  throw std::runtime_error("pf_photons_r9 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_scEnergy() const{
  throw std::runtime_error("pf_photons_scEnergy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_scEta() const{
  throw std::runtime_error("pf_photons_scEta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_scEtaWidth() const{
  throw std::runtime_error("pf_photons_scEtaWidth does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_scPhi() const{
  throw std::runtime_error("pf_photons_scPhi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_scPhiWidth() const{
  throw std::runtime_error("pf_photons_scPhiWidth does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_scRawEnergy() const{
  throw std::runtime_error("pf_photons_scRawEnergy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_sigmaEtaEta() const{
  throw std::runtime_error("pf_photons_sigmaEtaEta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_sigmaIetaIeta() const{
  throw std::runtime_error("pf_photons_sigmaIetaIeta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_status() const{
  throw std::runtime_error("pf_photons_status does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pf_photons_theta() const{
  throw std::runtime_error("pf_photons_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfcand_charge() const{
  throw std::runtime_error("pfcand_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfcand_energy() const{
  throw std::runtime_error("pfcand_energy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfcand_eta() const{
  throw std::runtime_error("pfcand_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfcand_particleId() const{
  throw std::runtime_error("pfcand_particleId does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfcand_pdgId() const{
  throw std::runtime_error("pfcand_pdgId does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfcand_phi() const{
  throw std::runtime_error("pfcand_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfcand_pt() const{
  throw std::runtime_error("pfcand_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfcand_px() const{
  throw std::runtime_error("pfcand_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfcand_py() const{
  throw std::runtime_error("pfcand_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfcand_pz() const{
  throw std::runtime_error("pfcand_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfcand_theta() const{
  throw std::runtime_error("pfcand_theta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfmets_et() const{
  throw std::runtime_error("pfmets_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfmets_ex() const{
  throw std::runtime_error("pfmets_ex does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfmets_ey() const{
  throw std::runtime_error("pfmets_ey does not exist in this cfA version.");
}

Float_t const & cfa_base::pfmets_fullSignif() const{
  throw std::runtime_error("pfmets_fullSignif does not exist in this cfA version.");
}

Float_t const & cfa_base::pfmets_fullSignifCov00() const{
  throw std::runtime_error("pfmets_fullSignifCov00 does not exist in this cfA version.");
}

Float_t const & cfa_base::pfmets_fullSignifCov00_2012() const{
  throw std::runtime_error("pfmets_fullSignifCov00_2012 does not exist in this cfA version.");
}

Float_t const & cfa_base::pfmets_fullSignifCov00_2012_dataRes() const{
  throw std::runtime_error("pfmets_fullSignifCov00_2012_dataRes does not exist in this cfA version.");
}

Float_t const & cfa_base::pfmets_fullSignifCov10() const{
  throw std::runtime_error("pfmets_fullSignifCov10 does not exist in this cfA version.");
}

Float_t const & cfa_base::pfmets_fullSignifCov10_2012() const{
  throw std::runtime_error("pfmets_fullSignifCov10_2012 does not exist in this cfA version.");
}

Float_t const & cfa_base::pfmets_fullSignifCov10_2012_dataRes() const{
  throw std::runtime_error("pfmets_fullSignifCov10_2012_dataRes does not exist in this cfA version.");
}

Float_t const & cfa_base::pfmets_fullSignifCov11() const{
  throw std::runtime_error("pfmets_fullSignifCov11 does not exist in this cfA version.");
}

Float_t const & cfa_base::pfmets_fullSignifCov11_2012() const{
  throw std::runtime_error("pfmets_fullSignifCov11_2012 does not exist in this cfA version.");
}

Float_t const & cfa_base::pfmets_fullSignifCov11_2012_dataRes() const{
  throw std::runtime_error("pfmets_fullSignifCov11_2012_dataRes does not exist in this cfA version.");
}

Float_t const & cfa_base::pfmets_fullSignif_2012() const{
  throw std::runtime_error("pfmets_fullSignif_2012 does not exist in this cfA version.");
}

Float_t const & cfa_base::pfmets_fullSignif_2012_dataRes() const{
  throw std::runtime_error("pfmets_fullSignif_2012_dataRes does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfmets_gen_et() const{
  throw std::runtime_error("pfmets_gen_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfmets_gen_phi() const{
  throw std::runtime_error("pfmets_gen_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfmets_phi() const{
  throw std::runtime_error("pfmets_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfmets_sign() const{
  throw std::runtime_error("pfmets_sign does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfmets_sumEt() const{
  throw std::runtime_error("pfmets_sumEt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfmets_unCPhi() const{
  throw std::runtime_error("pfmets_unCPhi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pfmets_unCPt() const{
  throw std::runtime_error("pfmets_unCPt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::photon_chIsoValues() const{
  throw std::runtime_error("photon_chIsoValues does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::photon_nhIsoValues() const{
  throw std::runtime_error("photon_nhIsoValues does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::photon_passElectronVeto() const{
  throw std::runtime_error("photon_passElectronVeto does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::photon_phIsoValues() const{
  throw std::runtime_error("photon_phIsoValues does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::photons_full5x5sigmaIEtaIEta() const{
  throw std::runtime_error("photons_full5x5sigmaIEtaIEta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::photons_gen_et() const{
  throw std::runtime_error("photons_gen_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::photons_gen_eta() const{
  throw std::runtime_error("photons_gen_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::photons_gen_id() const{
  throw std::runtime_error("photons_gen_id does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::photons_gen_phi() const{
  throw std::runtime_error("photons_gen_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::photons_isAlsoElectron() const{
  throw std::runtime_error("photons_isAlsoElectron does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::photons_isConv() const{
  throw std::runtime_error("photons_isConv does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::photons_isConverted() const{
  throw std::runtime_error("photons_isConverted does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::photons_passElectronVeto() const{
  throw std::runtime_error("photons_passElectronVeto does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::photons_pass_el_veto() const{
  throw std::runtime_error("photons_pass_el_veto does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::photons_pf_ch_iso() const{
  throw std::runtime_error("photons_pf_ch_iso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::photons_pf_nh_iso() const{
  throw std::runtime_error("photons_pf_nh_iso does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::photons_pf_ph_iso() const{
  throw std::runtime_error("photons_pf_ph_iso does not exist in this cfA version.");
}

std::vector<std::vector<float> >* const & cfa_base::puJet_rejectionBeta() const{
  throw std::runtime_error("puJet_rejectionBeta does not exist in this cfA version.");
}

std::vector<std::vector<float> >* const & cfa_base::puJet_rejectionMVA() const{
  throw std::runtime_error("puJet_rejectionMVA does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::pv_tracksSize() const{
  throw std::runtime_error("pv_tracksSize does not exist in this cfA version.");
}

Float_t const & cfa_base::raw_met3() const{
  throw std::runtime_error("raw_met3 does not exist in this cfA version.");
}

Float_t const & cfa_base::raw_met3_phi() const{
  throw std::runtime_error("raw_met3_phi does not exist in this cfA version.");
}

Float_t const & cfa_base::raw_met3_sumEt() const{
  throw std::runtime_error("raw_met3_sumEt does not exist in this cfA version.");
}

Float_t const & cfa_base::raw_met_et() const{
  throw std::runtime_error("raw_met_et does not exist in this cfA version.");
}

Float_t const & cfa_base::raw_met_phi() const{
  throw std::runtime_error("raw_met_phi does not exist in this cfA version.");
}

Float_t const & cfa_base::raw_met_sumEt() const{
  throw std::runtime_error("raw_met_sumEt does not exist in this cfA version.");
}

Float_t const & cfa_base::rho_kt6PFJetsForIsolation2011() const{
  throw std::runtime_error("rho_kt6PFJetsForIsolation2011 does not exist in this cfA version.");
}

Float_t const & cfa_base::rho_kt6PFJetsForIsolation2012() const{
  throw std::runtime_error("rho_kt6PFJetsForIsolation2012 does not exist in this cfA version.");
}

Int_t const & cfa_base::scrapingVeto_decision() const{
  throw std::runtime_error("scrapingVeto_decision does not exist in this cfA version.");
}

Float_t const & cfa_base::softjetUp_dMEx() const{
  throw std::runtime_error("softjetUp_dMEx does not exist in this cfA version.");
}

Float_t const & cfa_base::softjetUp_dMEy() const{
  throw std::runtime_error("softjetUp_dMEy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_CombinedIsolationDeltaBetaCorrRaw3Hits() const{
  throw std::runtime_error("taus_CombinedIsolationDeltaBetaCorrRaw3Hits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_Nprongs() const{
  throw std::runtime_error("taus_Nprongs does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_againstElectron() const{
  throw std::runtime_error("taus_againstElectron does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_againstElectronLoose() const{
  throw std::runtime_error("taus_againstElectronLoose does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::taus_againstElectronLooseMVA5() const{
  throw std::runtime_error("taus_againstElectronLooseMVA5 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_againstElectronMVA() const{
  throw std::runtime_error("taus_againstElectronMVA does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_againstElectronMedium() const{
  throw std::runtime_error("taus_againstElectronMedium does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_againstElectronTight() const{
  throw std::runtime_error("taus_againstElectronTight does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_againstMuon() const{
  throw std::runtime_error("taus_againstMuon does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_againstMuonLoose() const{
  throw std::runtime_error("taus_againstMuonLoose does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::taus_againstMuonLoose3() const{
  throw std::runtime_error("taus_againstMuonLoose3 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_againstMuonMedium() const{
  throw std::runtime_error("taus_againstMuonMedium does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_againstMuonTight() const{
  throw std::runtime_error("taus_againstMuonTight does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::taus_byDecayModeFinding() const{
  throw std::runtime_error("taus_byDecayModeFinding does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::taus_byDecayModeFindingNewDMs() const{
  throw std::runtime_error("taus_byDecayModeFindingNewDMs does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_byIsoUsingLeadingPi() const{
  throw std::runtime_error("taus_byIsoUsingLeadingPi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_byIsolation() const{
  throw std::runtime_error("taus_byIsolation does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::taus_byLooseCombinedIsolationDeltaBetaCorr3Hits() const{
  throw std::runtime_error("taus_byLooseCombinedIsolationDeltaBetaCorr3Hits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_byLooseIsolation() const{
  throw std::runtime_error("taus_byLooseIsolation does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_byLooseIsolationDeltaBetaCorr() const{
  throw std::runtime_error("taus_byLooseIsolationDeltaBetaCorr does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::taus_byMediumCombinedIsolationDeltaBetaCorr3Hits() const{
  throw std::runtime_error("taus_byMediumCombinedIsolationDeltaBetaCorr3Hits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_byMediumIsolation() const{
  throw std::runtime_error("taus_byMediumIsolation does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_byMediumIsolationDeltaBetaCorr() const{
  throw std::runtime_error("taus_byMediumIsolationDeltaBetaCorr does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::taus_byTightCombinedIsolationDeltaBetaCorr3Hits() const{
  throw std::runtime_error("taus_byTightCombinedIsolationDeltaBetaCorr3Hits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_byTightIsolation() const{
  throw std::runtime_error("taus_byTightIsolation does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_byTightIsolationDeltaBetaCorr() const{
  throw std::runtime_error("taus_byTightIsolationDeltaBetaCorr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_byVLooseIsolation() const{
  throw std::runtime_error("taus_byVLooseIsolation does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_byVLooseIsolationDeltaBetaCorr() const{
  throw std::runtime_error("taus_byVLooseIsolationDeltaBetaCorr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_chargedIsoPtSum() const{
  throw std::runtime_error("taus_chargedIsoPtSum does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::taus_decayMode() const{
  throw std::runtime_error("taus_decayMode does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_decayModeFinding() const{
  throw std::runtime_error("taus_decayModeFinding does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_ecalIsoUsingLeadingPi() const{
  throw std::runtime_error("taus_ecalIsoUsingLeadingPi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_ecalIsolation() const{
  throw std::runtime_error("taus_ecalIsolation does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_ecalStripSumEOverPLead() const{
  throw std::runtime_error("taus_ecalStripSumEOverPLead does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::taus_el_ind() const{
  throw std::runtime_error("taus_el_ind does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_elecPreIdDecision() const{
  throw std::runtime_error("taus_elecPreIdDecision does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_elecPreIdOutput() const{
  throw std::runtime_error("taus_elecPreIdOutput does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_emf() const{
  throw std::runtime_error("taus_emf does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_hcal3x3OverPLead() const{
  throw std::runtime_error("taus_hcal3x3OverPLead does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_hcalMaxOverPLead() const{
  throw std::runtime_error("taus_hcalMaxOverPLead does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_hcalTotOverPLead() const{
  throw std::runtime_error("taus_hcalTotOverPLead does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_isoPFChargedHadrCandsPtSum() const{
  throw std::runtime_error("taus_isoPFChargedHadrCandsPtSum does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_isoPFGammaCandsEtSum() const{
  throw std::runtime_error("taus_isoPFGammaCandsEtSum does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_leadChargedHadrCand_charge() const{
  throw std::runtime_error("taus_leadChargedHadrCand_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_leadChargedHadrCand_eta() const{
  throw std::runtime_error("taus_leadChargedHadrCand_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_leadChargedHadrCand_phi() const{
  throw std::runtime_error("taus_leadChargedHadrCand_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_leadChargedHadrCand_pt() const{
  throw std::runtime_error("taus_leadChargedHadrCand_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_leadPFChargedHadrCand_ECAL_eta() const{
  throw std::runtime_error("taus_leadPFChargedHadrCand_ECAL_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_leadPFChargedHadrCand_charge() const{
  throw std::runtime_error("taus_leadPFChargedHadrCand_charge does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_leadPFChargedHadrCand_eta() const{
  throw std::runtime_error("taus_leadPFChargedHadrCand_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_leadPFChargedHadrCand_phi() const{
  throw std::runtime_error("taus_leadPFChargedHadrCand_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_leadPFChargedHadrCand_pt() const{
  throw std::runtime_error("taus_leadPFChargedHadrCand_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_leadingTrackFinding() const{
  throw std::runtime_error("taus_leadingTrackFinding does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_leadingTrackPtCut() const{
  throw std::runtime_error("taus_leadingTrackPtCut does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_muDecision() const{
  throw std::runtime_error("taus_muDecision does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::taus_mu_ind() const{
  throw std::runtime_error("taus_mu_ind does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::taus_n_pfcands() const{
  throw std::runtime_error("taus_n_pfcands does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_neutralIsoPtSum() const{
  throw std::runtime_error("taus_neutralIsoPtSum does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_puCorrPtSum() const{
  throw std::runtime_error("taus_puCorrPtSum does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_signalPFChargedHadrCandsSize() const{
  throw std::runtime_error("taus_signalPFChargedHadrCandsSize does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_taNC() const{
  throw std::runtime_error("taus_taNC does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_taNC_half() const{
  throw std::runtime_error("taus_taNC_half does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_taNC_one() const{
  throw std::runtime_error("taus_taNC_one does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_taNC_quarter() const{
  throw std::runtime_error("taus_taNC_quarter does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_taNC_tenth() const{
  throw std::runtime_error("taus_taNC_tenth does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_tkIsoUsingLeadingPi() const{
  throw std::runtime_error("taus_tkIsoUsingLeadingPi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::taus_trackIsolation() const{
  throw std::runtime_error("taus_trackIsolation does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tcmets_et() const{
  throw std::runtime_error("tcmets_et does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tcmets_ex() const{
  throw std::runtime_error("tcmets_ex does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tcmets_ey() const{
  throw std::runtime_error("tcmets_ey does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tcmets_phi() const{
  throw std::runtime_error("tcmets_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tcmets_sumEt() const{
  throw std::runtime_error("tcmets_sumEt does not exist in this cfA version.");
}

Int_t const & cfa_base::trackercoherentnoisefilter1_decision() const{
  throw std::runtime_error("trackercoherentnoisefilter1_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::trackercoherentnoisefilter2_decision() const{
  throw std::runtime_error("trackercoherentnoisefilter2_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::trackertoomanyclustersfilter_decision() const{
  throw std::runtime_error("trackertoomanyclustersfilter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::trackertoomanyseedsfilter_decision() const{
  throw std::runtime_error("trackertoomanyseedsfilter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::trackertoomanytripletsfilter_decision() const{
  throw std::runtime_error("trackertoomanytripletsfilter_decision does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_chg() const{
  throw std::runtime_error("tracks_chg does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_chi2() const{
  throw std::runtime_error("tracks_chi2 does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_d0dum() const{
  throw std::runtime_error("tracks_d0dum does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_d0dumErr() const{
  throw std::runtime_error("tracks_d0dumErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_dz() const{
  throw std::runtime_error("tracks_dz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_dzErr() const{
  throw std::runtime_error("tracks_dzErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_eta() const{
  throw std::runtime_error("tracks_eta does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_etaErr() const{
  throw std::runtime_error("tracks_etaErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_highPurity() const{
  throw std::runtime_error("tracks_highPurity does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_ndof() const{
  throw std::runtime_error("tracks_ndof does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_numlosthits() const{
  throw std::runtime_error("tracks_numlosthits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_numvalhits() const{
  throw std::runtime_error("tracks_numvalhits does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_phi() const{
  throw std::runtime_error("tracks_phi does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_phiErr() const{
  throw std::runtime_error("tracks_phiErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_pt() const{
  throw std::runtime_error("tracks_pt does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_ptErr() const{
  throw std::runtime_error("tracks_ptErr does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_px() const{
  throw std::runtime_error("tracks_px does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_py() const{
  throw std::runtime_error("tracks_py does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_pz() const{
  throw std::runtime_error("tracks_pz does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_vx() const{
  throw std::runtime_error("tracks_vx does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_vy() const{
  throw std::runtime_error("tracks_vy does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::tracks_vz() const{
  throw std::runtime_error("tracks_vz does not exist in this cfA version.");
}

std::vector<bool>* const & cfa_base::trigger_decision() const{
  throw std::runtime_error("trigger_decision does not exist in this cfA version.");
}

std::vector<std::string>* const & cfa_base::trigger_lastfiltername() const{
  throw std::runtime_error("trigger_lastfiltername does not exist in this cfA version.");
}

std::vector<std::vector<std::string> >* const & cfa_base::triggerobject_collectionname() const{
  throw std::runtime_error("triggerobject_collectionname does not exist in this cfA version.");
}

std::vector<std::vector<float> >* const & cfa_base::triggerobject_energy() const{
  throw std::runtime_error("triggerobject_energy does not exist in this cfA version.");
}

std::vector<std::vector<float> >* const & cfa_base::triggerobject_et() const{
  throw std::runtime_error("triggerobject_et does not exist in this cfA version.");
}

std::vector<std::vector<float> >* const & cfa_base::triggerobject_eta() const{
  throw std::runtime_error("triggerobject_eta does not exist in this cfA version.");
}

std::vector<std::vector<float> >* const & cfa_base::triggerobject_phi() const{
  throw std::runtime_error("triggerobject_phi does not exist in this cfA version.");
}

std::vector<std::vector<float> >* const & cfa_base::triggerobject_pt() const{
  throw std::runtime_error("triggerobject_pt does not exist in this cfA version.");
}

std::vector<std::vector<float> >* const & cfa_base::triggerobject_px() const{
  throw std::runtime_error("triggerobject_px does not exist in this cfA version.");
}

std::vector<std::vector<float> >* const & cfa_base::triggerobject_py() const{
  throw std::runtime_error("triggerobject_py does not exist in this cfA version.");
}

std::vector<std::vector<float> >* const & cfa_base::triggerobject_pz() const{
  throw std::runtime_error("triggerobject_pz does not exist in this cfA version.");
}

Int_t const & cfa_base::trkPOG_logErrorTooManyClustersfilter_decision() const{
  throw std::runtime_error("trkPOG_logErrorTooManyClustersfilter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::trkPOG_manystripclus53Xfilter_decision() const{
  throw std::runtime_error("trkPOG_manystripclus53Xfilter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::trkPOG_toomanystripclus53Xfilter_decision() const{
  throw std::runtime_error("trkPOG_toomanystripclus53Xfilter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::trkPOGfilter_decision() const{
  throw std::runtime_error("trkPOGfilter_decision does not exist in this cfA version.");
}

Int_t const & cfa_base::trk_nTOBTEC() const{
  throw std::runtime_error("trk_nTOBTEC does not exist in this cfA version.");
}

Float_t const & cfa_base::trk_ratioAllTOBTEC() const{
  throw std::runtime_error("trk_ratioAllTOBTEC does not exist in this cfA version.");
}

Float_t const & cfa_base::trk_ratioJetTOBTEC() const{
  throw std::runtime_error("trk_ratioJetTOBTEC does not exist in this cfA version.");
}

std::vector<int>* const & cfa_base::weightIndex() const{
  throw std::runtime_error("weightIndex does not exist in this cfA version.");
}

std::vector<float>* const & cfa_base::weightVector() const{
  throw std::runtime_error("weightVector does not exist in this cfA version.");
}