small_tree_rpv.cpp

Go to the documentation of this file.

// small_tree_rpv: rpv version of small_tree to handle reduce tree ntuples
//File generated with generate_small_tree.exe

#include "small_tree.hpp"

#include "small_tree_rpv.hpp"

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

#include "TTree.h"
#include "TBranch.h"
#include "TChain.h"

using namespace std;

small_tree_rpv::small_tree_rpv():
  small_tree(),
  pass_(0),
  b_pass_(tree_.Branch("pass", &pass_)),
  c_pass_(false),
  eff_trig_(0),
  b_eff_trig_(tree_.Branch("eff_trig", &eff_trig_)),
  c_eff_trig_(false),
  mht_(0),
  b_mht_(tree_.Branch("mht", &mht_)),
  c_mht_(false),
  mj_(0),
  b_mj_(tree_.Branch("mj", &mj_)),
  c_mj_(false),
  mj08_(0),
  b_mj08_(tree_.Branch("mj08", &mj08_)),
  c_mj08_(false),
  w_pu_rpv_(0),
  b_w_pu_rpv_(tree_.Branch("w_pu_rpv", &w_pu_rpv_)),
  c_w_pu_rpv_(false),
  nfjets_(0),
  b_nfjets_(tree_.Branch("nfjets", &nfjets_)),
  c_nfjets_(false),
  nfjets08_(0),
  b_nfjets08_(tree_.Branch("nfjets08", &nfjets08_)),
  c_nfjets08_(false),
  ntruels_(0),
  b_ntruels_(tree_.Branch("ntruels", &ntruels_)),
  c_ntruels_(false),
  ntruleps_(0),
  b_ntruleps_(tree_.Branch("ntruleps", &ntruleps_)),
  c_ntruleps_(false),
  ntrumus_(0),
  b_ntrumus_(tree_.Branch("ntrumus", &ntrumus_)),
  c_ntrumus_(false),
  ntrutaush_(0),
  b_ntrutaush_(tree_.Branch("ntrutaush", &ntrutaush_)),
  c_ntrutaush_(false),
  ntrutausl_(0),
  b_ntrutausl_(tree_.Branch("ntrutausl", &ntrutausl_)),
  c_ntrutausl_(false),
  jets_islep_(0),
  p_jets_islep_(&jets_islep_),
  b_jets_islep_(tree_.Branch("jets_islep", &p_jets_islep_)),
  c_jets_islep_(false),
  trig_(0),
  p_trig_(&trig_),
  b_trig_(tree_.Branch("trig", &p_trig_)),
  c_trig_(false),
  dr_bb_(0),
  p_dr_bb_(&dr_bb_),
  b_dr_bb_(tree_.Branch("dr_bb", &p_dr_bb_)),
  c_dr_bb_(false),
  els_d0_(0),
  p_els_d0_(&els_d0_),
  b_els_d0_(tree_.Branch("els_d0", &p_els_d0_)),
  c_els_d0_(false),
  els_dz_(0),
  p_els_dz_(&els_dz_),
  b_els_dz_(tree_.Branch("els_dz", &p_els_dz_)),
  c_els_dz_(false),
  els_sceta_(0),
  p_els_sceta_(&els_sceta_),
  b_els_sceta_(tree_.Branch("els_sceta", &p_els_sceta_)),
  c_els_sceta_(false),
  fjets08_eta_(0),
  p_fjets08_eta_(&fjets08_eta_),
  b_fjets08_eta_(tree_.Branch("fjets08_eta", &p_fjets08_eta_)),
  c_fjets08_eta_(false),
  fjets08_m_(0),
  p_fjets08_m_(&fjets08_m_),
  b_fjets08_m_(tree_.Branch("fjets08_m", &p_fjets08_m_)),
  c_fjets08_m_(false),
  fjets08_phi_(0),
  p_fjets08_phi_(&fjets08_phi_),
  b_fjets08_phi_(tree_.Branch("fjets08_phi", &p_fjets08_phi_)),
  c_fjets08_phi_(false),
  fjets08_poscsv_(0),
  p_fjets08_poscsv_(&fjets08_poscsv_),
  b_fjets08_poscsv_(tree_.Branch("fjets08_poscsv", &p_fjets08_poscsv_)),
  c_fjets08_poscsv_(false),
  fjets08_pt_(0),
  p_fjets08_pt_(&fjets08_pt_),
  b_fjets08_pt_(tree_.Branch("fjets08_pt", &p_fjets08_pt_)),
  c_fjets08_pt_(false),
  fjets08_sumcsv_(0),
  p_fjets08_sumcsv_(&fjets08_sumcsv_),
  b_fjets08_sumcsv_(tree_.Branch("fjets08_sumcsv", &p_fjets08_sumcsv_)),
  c_fjets08_sumcsv_(false),
  fjets_eta_(0),
  p_fjets_eta_(&fjets_eta_),
  b_fjets_eta_(tree_.Branch("fjets_eta", &p_fjets_eta_)),
  c_fjets_eta_(false),
  fjets_m_(0),
  p_fjets_m_(&fjets_m_),
  b_fjets_m_(tree_.Branch("fjets_m", &p_fjets_m_)),
  c_fjets_m_(false),
  fjets_phi_(0),
  p_fjets_phi_(&fjets_phi_),
  b_fjets_phi_(tree_.Branch("fjets_phi", &p_fjets_phi_)),
  c_fjets_phi_(false),
  fjets_poscsv_(0),
  p_fjets_poscsv_(&fjets_poscsv_),
  b_fjets_poscsv_(tree_.Branch("fjets_poscsv", &p_fjets_poscsv_)),
  c_fjets_poscsv_(false),
  fjets_pt_(0),
  p_fjets_pt_(&fjets_pt_),
  b_fjets_pt_(tree_.Branch("fjets_pt", &p_fjets_pt_)),
  c_fjets_pt_(false),
  fjets_sumcsv_(0),
  p_fjets_sumcsv_(&fjets_sumcsv_),
  b_fjets_sumcsv_(tree_.Branch("fjets_sumcsv", &p_fjets_sumcsv_)),
  c_fjets_sumcsv_(false),
  jets_m_(0),
  p_jets_m_(&jets_m_),
  b_jets_m_(tree_.Branch("jets_m", &p_jets_m_)),
  c_jets_m_(false),
  mus_d0_(0),
  p_mus_d0_(&mus_d0_),
  b_mus_d0_(tree_.Branch("mus_d0", &p_mus_d0_)),
  c_mus_d0_(false),
  mus_dz_(0),
  p_mus_dz_(&mus_dz_),
  b_mus_dz_(tree_.Branch("mus_dz", &p_mus_dz_)),
  c_mus_dz_(false),
  sys_bctag_(0),
  p_sys_bctag_(&sys_bctag_),
  b_sys_bctag_(tree_.Branch("sys_bctag", &p_sys_bctag_)),
  c_sys_bctag_(false),
  fjets08_btags_(0),
  p_fjets08_btags_(&fjets08_btags_),
  b_fjets08_btags_(tree_.Branch("fjets08_btags", &p_fjets08_btags_)),
  c_fjets08_btags_(false),
  fjets08_nconst_(0),
  p_fjets08_nconst_(&fjets08_nconst_),
  b_fjets08_nconst_(tree_.Branch("fjets08_nconst", &p_fjets08_nconst_)),
  c_fjets08_nconst_(false),
  fjets_btags_(0),
  p_fjets_btags_(&fjets_btags_),
  b_fjets_btags_(tree_.Branch("fjets_btags", &p_fjets_btags_)),
  c_fjets_btags_(false),
  fjets_nconst_(0),
  p_fjets_nconst_(&fjets_nconst_),
  b_fjets_nconst_(tree_.Branch("fjets_nconst", &p_fjets_nconst_)),
  c_fjets_nconst_(false),
  jets_fjet08_index_(0),
  p_jets_fjet08_index_(&jets_fjet08_index_),
  b_jets_fjet08_index_(tree_.Branch("jets_fjet08_index", &p_jets_fjet08_index_)),
  c_jets_fjet08_index_(false),
  jets_fjet_index_(0),
  p_jets_fjet_index_(&jets_fjet_index_),
  b_jets_fjet_index_(tree_.Branch("jets_fjet_index", &p_jets_fjet_index_)),
  c_jets_fjet_index_(false){
}

small_tree_rpv::small_tree_rpv(const string &filename):
  small_tree(filename),
  pass_(0),
  b_pass_(NULL),
  c_pass_(false),
  eff_trig_(0),
  b_eff_trig_(NULL),
  c_eff_trig_(false),
  mht_(0),
  b_mht_(NULL),
  c_mht_(false),
  mj_(0),
  b_mj_(NULL),
  c_mj_(false),
  mj08_(0),
  b_mj08_(NULL),
  c_mj08_(false),
  w_pu_rpv_(0),
  b_w_pu_rpv_(NULL),
  c_w_pu_rpv_(false),
  nfjets_(0),
  b_nfjets_(NULL),
  c_nfjets_(false),
  nfjets08_(0),
  b_nfjets08_(NULL),
  c_nfjets08_(false),
  ntruels_(0),
  b_ntruels_(NULL),
  c_ntruels_(false),
  ntruleps_(0),
  b_ntruleps_(NULL),
  c_ntruleps_(false),
  ntrumus_(0),
  b_ntrumus_(NULL),
  c_ntrumus_(false),
  ntrutaush_(0),
  b_ntrutaush_(NULL),
  c_ntrutaush_(false),
  ntrutausl_(0),
  b_ntrutausl_(NULL),
  c_ntrutausl_(false),
  jets_islep_(0),
  p_jets_islep_(&jets_islep_),
  b_jets_islep_(NULL),
  c_jets_islep_(false),
  trig_(0),
  p_trig_(&trig_),
  b_trig_(NULL),
  c_trig_(false),
  dr_bb_(0),
  p_dr_bb_(&dr_bb_),
  b_dr_bb_(NULL),
  c_dr_bb_(false),
  els_d0_(0),
  p_els_d0_(&els_d0_),
  b_els_d0_(NULL),
  c_els_d0_(false),
  els_dz_(0),
  p_els_dz_(&els_dz_),
  b_els_dz_(NULL),
  c_els_dz_(false),
  els_sceta_(0),
  p_els_sceta_(&els_sceta_),
  b_els_sceta_(NULL),
  c_els_sceta_(false),
  fjets08_eta_(0),
  p_fjets08_eta_(&fjets08_eta_),
  b_fjets08_eta_(NULL),
  c_fjets08_eta_(false),
  fjets08_m_(0),
  p_fjets08_m_(&fjets08_m_),
  b_fjets08_m_(NULL),
  c_fjets08_m_(false),
  fjets08_phi_(0),
  p_fjets08_phi_(&fjets08_phi_),
  b_fjets08_phi_(NULL),
  c_fjets08_phi_(false),
  fjets08_poscsv_(0),
  p_fjets08_poscsv_(&fjets08_poscsv_),
  b_fjets08_poscsv_(NULL),
  c_fjets08_poscsv_(false),
  fjets08_pt_(0),
  p_fjets08_pt_(&fjets08_pt_),
  b_fjets08_pt_(NULL),
  c_fjets08_pt_(false),
  fjets08_sumcsv_(0),
  p_fjets08_sumcsv_(&fjets08_sumcsv_),
  b_fjets08_sumcsv_(NULL),
  c_fjets08_sumcsv_(false),
  fjets_eta_(0),
  p_fjets_eta_(&fjets_eta_),
  b_fjets_eta_(NULL),
  c_fjets_eta_(false),
  fjets_m_(0),
  p_fjets_m_(&fjets_m_),
  b_fjets_m_(NULL),
  c_fjets_m_(false),
  fjets_phi_(0),
  p_fjets_phi_(&fjets_phi_),
  b_fjets_phi_(NULL),
  c_fjets_phi_(false),
  fjets_poscsv_(0),
  p_fjets_poscsv_(&fjets_poscsv_),
  b_fjets_poscsv_(NULL),
  c_fjets_poscsv_(false),
  fjets_pt_(0),
  p_fjets_pt_(&fjets_pt_),
  b_fjets_pt_(NULL),
  c_fjets_pt_(false),
  fjets_sumcsv_(0),
  p_fjets_sumcsv_(&fjets_sumcsv_),
  b_fjets_sumcsv_(NULL),
  c_fjets_sumcsv_(false),
  jets_m_(0),
  p_jets_m_(&jets_m_),
  b_jets_m_(NULL),
  c_jets_m_(false),
  mus_d0_(0),
  p_mus_d0_(&mus_d0_),
  b_mus_d0_(NULL),
  c_mus_d0_(false),
  mus_dz_(0),
  p_mus_dz_(&mus_dz_),
  b_mus_dz_(NULL),
  c_mus_dz_(false),
  sys_bctag_(0),
  p_sys_bctag_(&sys_bctag_),
  b_sys_bctag_(NULL),
  c_sys_bctag_(false),
  fjets08_btags_(0),
  p_fjets08_btags_(&fjets08_btags_),
  b_fjets08_btags_(NULL),
  c_fjets08_btags_(false),
  fjets08_nconst_(0),
  p_fjets08_nconst_(&fjets08_nconst_),
  b_fjets08_nconst_(NULL),
  c_fjets08_nconst_(false),
  fjets_btags_(0),
  p_fjets_btags_(&fjets_btags_),
  b_fjets_btags_(NULL),
  c_fjets_btags_(false),
  fjets_nconst_(0),
  p_fjets_nconst_(&fjets_nconst_),
  b_fjets_nconst_(NULL),
  c_fjets_nconst_(false),
  jets_fjet08_index_(0),
  p_jets_fjet08_index_(&jets_fjet08_index_),
  b_jets_fjet08_index_(NULL),
  c_jets_fjet08_index_(false),
  jets_fjet_index_(0),
  p_jets_fjet_index_(&jets_fjet_index_),
  b_jets_fjet_index_(NULL),
  c_jets_fjet_index_(false){
  chain_.SetBranchAddress("pass", &pass_, &b_pass_);
  chain_.SetBranchAddress("eff_trig", &eff_trig_, &b_eff_trig_);
  chain_.SetBranchAddress("mht", &mht_, &b_mht_);
  chain_.SetBranchAddress("mj", &mj_, &b_mj_);
  chain_.SetBranchAddress("mj08", &mj08_, &b_mj08_);
  chain_.SetBranchAddress("w_pu_rpv", &w_pu_rpv_, &b_w_pu_rpv_);
  chain_.SetBranchAddress("nfjets", &nfjets_, &b_nfjets_);
  chain_.SetBranchAddress("nfjets08", &nfjets08_, &b_nfjets08_);
  chain_.SetBranchAddress("ntruels", &ntruels_, &b_ntruels_);
  chain_.SetBranchAddress("ntruleps", &ntruleps_, &b_ntruleps_);
  chain_.SetBranchAddress("ntrumus", &ntrumus_, &b_ntrumus_);
  chain_.SetBranchAddress("ntrutaush", &ntrutaush_, &b_ntrutaush_);
  chain_.SetBranchAddress("ntrutausl", &ntrutausl_, &b_ntrutausl_);
  chain_.SetBranchAddress("jets_islep", &p_jets_islep_, &b_jets_islep_);
  chain_.SetBranchAddress("trig", &p_trig_, &b_trig_);
  chain_.SetBranchAddress("dr_bb", &p_dr_bb_, &b_dr_bb_);
  chain_.SetBranchAddress("els_d0", &p_els_d0_, &b_els_d0_);
  chain_.SetBranchAddress("els_dz", &p_els_dz_, &b_els_dz_);
  chain_.SetBranchAddress("els_sceta", &p_els_sceta_, &b_els_sceta_);
  chain_.SetBranchAddress("fjets08_eta", &p_fjets08_eta_, &b_fjets08_eta_);
  chain_.SetBranchAddress("fjets08_m", &p_fjets08_m_, &b_fjets08_m_);
  chain_.SetBranchAddress("fjets08_phi", &p_fjets08_phi_, &b_fjets08_phi_);
  chain_.SetBranchAddress("fjets08_poscsv", &p_fjets08_poscsv_, &b_fjets08_poscsv_);
  chain_.SetBranchAddress("fjets08_pt", &p_fjets08_pt_, &b_fjets08_pt_);
  chain_.SetBranchAddress("fjets08_sumcsv", &p_fjets08_sumcsv_, &b_fjets08_sumcsv_);
  chain_.SetBranchAddress("fjets_eta", &p_fjets_eta_, &b_fjets_eta_);
  chain_.SetBranchAddress("fjets_m", &p_fjets_m_, &b_fjets_m_);
  chain_.SetBranchAddress("fjets_phi", &p_fjets_phi_, &b_fjets_phi_);
  chain_.SetBranchAddress("fjets_poscsv", &p_fjets_poscsv_, &b_fjets_poscsv_);
  chain_.SetBranchAddress("fjets_pt", &p_fjets_pt_, &b_fjets_pt_);
  chain_.SetBranchAddress("fjets_sumcsv", &p_fjets_sumcsv_, &b_fjets_sumcsv_);
  chain_.SetBranchAddress("jets_m", &p_jets_m_, &b_jets_m_);
  chain_.SetBranchAddress("mus_d0", &p_mus_d0_, &b_mus_d0_);
  chain_.SetBranchAddress("mus_dz", &p_mus_dz_, &b_mus_dz_);
  chain_.SetBranchAddress("sys_bctag", &p_sys_bctag_, &b_sys_bctag_);
  chain_.SetBranchAddress("fjets08_btags", &p_fjets08_btags_, &b_fjets08_btags_);
  chain_.SetBranchAddress("fjets08_nconst", &p_fjets08_nconst_, &b_fjets08_nconst_);
  chain_.SetBranchAddress("fjets_btags", &p_fjets_btags_, &b_fjets_btags_);
  chain_.SetBranchAddress("fjets_nconst", &p_fjets_nconst_, &b_fjets_nconst_);
  chain_.SetBranchAddress("jets_fjet08_index", &p_jets_fjet08_index_, &b_jets_fjet08_index_);
  chain_.SetBranchAddress("jets_fjet_index", &p_jets_fjet_index_, &b_jets_fjet_index_);
}

void small_tree_rpv::Fill(){
  small_tree::Fill();
  //Resetting variables
  pass_ = static_cast<bool >(bad_val_);
  eff_trig_ = static_cast<float >(bad_val_);
  mht_ = static_cast<float >(bad_val_);
  mj_ = static_cast<float >(bad_val_);
  mj08_ = static_cast<float >(bad_val_);
  w_pu_rpv_ = static_cast<float >(bad_val_);
  nfjets_ = static_cast<int >(bad_val_);
  nfjets08_ = static_cast<int >(bad_val_);
  ntruels_ = static_cast<int >(bad_val_);
  ntruleps_ = static_cast<int >(bad_val_);
  ntrumus_ = static_cast<int >(bad_val_);
  ntrutaush_ = static_cast<int >(bad_val_);
  ntrutausl_ = static_cast<int >(bad_val_);
  jets_islep_.clear();
  trig_.clear();
  dr_bb_.clear();
  els_d0_.clear();
  els_dz_.clear();
  els_sceta_.clear();
  fjets08_eta_.clear();
  fjets08_m_.clear();
  fjets08_phi_.clear();
  fjets08_poscsv_.clear();
  fjets08_pt_.clear();
  fjets08_sumcsv_.clear();
  fjets_eta_.clear();
  fjets_m_.clear();
  fjets_phi_.clear();
  fjets_poscsv_.clear();
  fjets_pt_.clear();
  fjets_sumcsv_.clear();
  jets_m_.clear();
  mus_d0_.clear();
  mus_dz_.clear();
  sys_bctag_.clear();
  fjets08_btags_.clear();
  fjets08_nconst_.clear();
  fjets_btags_.clear();
  fjets_nconst_.clear();
  jets_fjet08_index_.clear();
  jets_fjet_index_.clear();
}

string small_tree_rpv::Type() const{
  return "rpv";
}

small_tree_rpv::~small_tree_rpv(){
}

void small_tree_rpv::GetEntry(const long entry){
  small_tree::GetEntry(entry);

  c_pass_ = false;
  c_eff_trig_ = false;
  c_mht_ = false;
  c_mj_ = false;
  c_mj08_ = false;
  c_w_pu_rpv_ = false;
  c_nfjets_ = false;
  c_nfjets08_ = false;
  c_ntruels_ = false;
  c_ntruleps_ = false;
  c_ntrumus_ = false;
  c_ntrutaush_ = false;
  c_ntrutausl_ = false;
  c_jets_islep_ = false;
  c_trig_ = false;
  c_dr_bb_ = false;
  c_els_d0_ = false;
  c_els_dz_ = false;
  c_els_sceta_ = false;
  c_fjets08_eta_ = false;
  c_fjets08_m_ = false;
  c_fjets08_phi_ = false;
  c_fjets08_poscsv_ = false;
  c_fjets08_pt_ = false;
  c_fjets08_sumcsv_ = false;
  c_fjets_eta_ = false;
  c_fjets_m_ = false;
  c_fjets_phi_ = false;
  c_fjets_poscsv_ = false;
  c_fjets_pt_ = false;
  c_fjets_sumcsv_ = false;
  c_jets_m_ = false;
  c_mus_d0_ = false;
  c_mus_dz_ = false;
  c_sys_bctag_ = false;
  c_fjets08_btags_ = false;
  c_fjets08_nconst_ = false;
  c_fjets_btags_ = false;
  c_fjets_nconst_ = false;
  c_jets_fjet08_index_ = false;
  c_jets_fjet_index_ = false;
}

bool  const & small_tree_rpv::pass() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_pass_ && b_pass_){
    b_pass_->GetEntry(entry_);
    c_pass_ = true;
  }
  return pass_;
}

float  const & small_tree_rpv::eff_trig() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_eff_trig_ && b_eff_trig_){
    b_eff_trig_->GetEntry(entry_);
    c_eff_trig_ = true;
  }
  return eff_trig_;
}

float  const & small_tree_rpv::mht() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_mht_ && b_mht_){
    b_mht_->GetEntry(entry_);
    c_mht_ = true;
  }
  return mht_;
}

float  const & small_tree_rpv::mj() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_mj_ && b_mj_){
    b_mj_->GetEntry(entry_);
    c_mj_ = true;
  }
  return mj_;
}

float  const & small_tree_rpv::mj08() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_mj08_ && b_mj08_){
    b_mj08_->GetEntry(entry_);
    c_mj08_ = true;
  }
  return mj08_;
}

float  const & small_tree_rpv::w_pu_rpv() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_w_pu_rpv_ && b_w_pu_rpv_){
    b_w_pu_rpv_->GetEntry(entry_);
    c_w_pu_rpv_ = true;
  }
  return w_pu_rpv_;
}

int  const & small_tree_rpv::nfjets() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_nfjets_ && b_nfjets_){
    b_nfjets_->GetEntry(entry_);
    c_nfjets_ = true;
  }
  return nfjets_;
}

int  const & small_tree_rpv::nfjets08() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_nfjets08_ && b_nfjets08_){
    b_nfjets08_->GetEntry(entry_);
    c_nfjets08_ = true;
  }
  return nfjets08_;
}

int  const & small_tree_rpv::ntruels() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_ntruels_ && b_ntruels_){
    b_ntruels_->GetEntry(entry_);
    c_ntruels_ = true;
  }
  return ntruels_;
}

int  const & small_tree_rpv::ntruleps() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_ntruleps_ && b_ntruleps_){
    b_ntruleps_->GetEntry(entry_);
    c_ntruleps_ = true;
  }
  return ntruleps_;
}

int  const & small_tree_rpv::ntrumus() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_ntrumus_ && b_ntrumus_){
    b_ntrumus_->GetEntry(entry_);
    c_ntrumus_ = true;
  }
  return ntrumus_;
}

int  const & small_tree_rpv::ntrutaush() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_ntrutaush_ && b_ntrutaush_){
    b_ntrutaush_->GetEntry(entry_);
    c_ntrutaush_ = true;
  }
  return ntrutaush_;
}

int  const & small_tree_rpv::ntrutausl() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_ntrutausl_ && b_ntrutausl_){
    b_ntrutausl_->GetEntry(entry_);
    c_ntrutausl_ = true;
  }
  return ntrutausl_;
}

std::vector<bool>  const & small_tree_rpv::jets_islep() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_jets_islep_ && b_jets_islep_){
    b_jets_islep_->GetEntry(entry_);
    c_jets_islep_ = true;
  }
  return jets_islep_;
}

std::vector<bool>  const & small_tree_rpv::trig() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_trig_ && b_trig_){
    b_trig_->GetEntry(entry_);
    c_trig_ = true;
  }
  return trig_;
}

std::vector<float>  const & small_tree_rpv::dr_bb() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_dr_bb_ && b_dr_bb_){
    b_dr_bb_->GetEntry(entry_);
    c_dr_bb_ = true;
  }
  return dr_bb_;
}

std::vector<float>  const & small_tree_rpv::els_d0() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_els_d0_ && b_els_d0_){
    b_els_d0_->GetEntry(entry_);
    c_els_d0_ = true;
  }
  return els_d0_;
}

std::vector<float>  const & small_tree_rpv::els_dz() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_els_dz_ && b_els_dz_){
    b_els_dz_->GetEntry(entry_);
    c_els_dz_ = true;
  }
  return els_dz_;
}

std::vector<float>  const & small_tree_rpv::els_sceta() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_els_sceta_ && b_els_sceta_){
    b_els_sceta_->GetEntry(entry_);
    c_els_sceta_ = true;
  }
  return els_sceta_;
}

std::vector<float>  const & small_tree_rpv::fjets08_eta() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets08_eta_ && b_fjets08_eta_){
    b_fjets08_eta_->GetEntry(entry_);
    c_fjets08_eta_ = true;
  }
  return fjets08_eta_;
}

std::vector<float>  const & small_tree_rpv::fjets08_m() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets08_m_ && b_fjets08_m_){
    b_fjets08_m_->GetEntry(entry_);
    c_fjets08_m_ = true;
  }
  return fjets08_m_;
}

std::vector<float>  const & small_tree_rpv::fjets08_phi() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets08_phi_ && b_fjets08_phi_){
    b_fjets08_phi_->GetEntry(entry_);
    c_fjets08_phi_ = true;
  }
  return fjets08_phi_;
}

std::vector<float>  const & small_tree_rpv::fjets08_poscsv() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets08_poscsv_ && b_fjets08_poscsv_){
    b_fjets08_poscsv_->GetEntry(entry_);
    c_fjets08_poscsv_ = true;
  }
  return fjets08_poscsv_;
}

std::vector<float>  const & small_tree_rpv::fjets08_pt() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets08_pt_ && b_fjets08_pt_){
    b_fjets08_pt_->GetEntry(entry_);
    c_fjets08_pt_ = true;
  }
  return fjets08_pt_;
}

std::vector<float>  const & small_tree_rpv::fjets08_sumcsv() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets08_sumcsv_ && b_fjets08_sumcsv_){
    b_fjets08_sumcsv_->GetEntry(entry_);
    c_fjets08_sumcsv_ = true;
  }
  return fjets08_sumcsv_;
}

std::vector<float>  const & small_tree_rpv::fjets_eta() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets_eta_ && b_fjets_eta_){
    b_fjets_eta_->GetEntry(entry_);
    c_fjets_eta_ = true;
  }
  return fjets_eta_;
}

std::vector<float>  const & small_tree_rpv::fjets_m() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets_m_ && b_fjets_m_){
    b_fjets_m_->GetEntry(entry_);
    c_fjets_m_ = true;
  }
  return fjets_m_;
}

std::vector<float>  const & small_tree_rpv::fjets_phi() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets_phi_ && b_fjets_phi_){
    b_fjets_phi_->GetEntry(entry_);
    c_fjets_phi_ = true;
  }
  return fjets_phi_;
}

std::vector<float>  const & small_tree_rpv::fjets_poscsv() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets_poscsv_ && b_fjets_poscsv_){
    b_fjets_poscsv_->GetEntry(entry_);
    c_fjets_poscsv_ = true;
  }
  return fjets_poscsv_;
}

std::vector<float>  const & small_tree_rpv::fjets_pt() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets_pt_ && b_fjets_pt_){
    b_fjets_pt_->GetEntry(entry_);
    c_fjets_pt_ = true;
  }
  return fjets_pt_;
}

std::vector<float>  const & small_tree_rpv::fjets_sumcsv() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets_sumcsv_ && b_fjets_sumcsv_){
    b_fjets_sumcsv_->GetEntry(entry_);
    c_fjets_sumcsv_ = true;
  }
  return fjets_sumcsv_;
}

std::vector<float>  const & small_tree_rpv::jets_m() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_jets_m_ && b_jets_m_){
    b_jets_m_->GetEntry(entry_);
    c_jets_m_ = true;
  }
  return jets_m_;
}

std::vector<float>  const & small_tree_rpv::mus_d0() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_mus_d0_ && b_mus_d0_){
    b_mus_d0_->GetEntry(entry_);
    c_mus_d0_ = true;
  }
  return mus_d0_;
}

std::vector<float>  const & small_tree_rpv::mus_dz() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_mus_dz_ && b_mus_dz_){
    b_mus_dz_->GetEntry(entry_);
    c_mus_dz_ = true;
  }
  return mus_dz_;
}

std::vector<float>  const & small_tree_rpv::sys_bctag() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_sys_bctag_ && b_sys_bctag_){
    b_sys_bctag_->GetEntry(entry_);
    c_sys_bctag_ = true;
  }
  return sys_bctag_;
}

std::vector<int>  const & small_tree_rpv::fjets08_btags() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets08_btags_ && b_fjets08_btags_){
    b_fjets08_btags_->GetEntry(entry_);
    c_fjets08_btags_ = true;
  }
  return fjets08_btags_;
}

std::vector<int>  const & small_tree_rpv::fjets08_nconst() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets08_nconst_ && b_fjets08_nconst_){
    b_fjets08_nconst_->GetEntry(entry_);
    c_fjets08_nconst_ = true;
  }
  return fjets08_nconst_;
}

std::vector<int>  const & small_tree_rpv::fjets_btags() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets_btags_ && b_fjets_btags_){
    b_fjets_btags_->GetEntry(entry_);
    c_fjets_btags_ = true;
  }
  return fjets_btags_;
}

std::vector<int>  const & small_tree_rpv::fjets_nconst() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_fjets_nconst_ && b_fjets_nconst_){
    b_fjets_nconst_->GetEntry(entry_);
    c_fjets_nconst_ = true;
  }
  return fjets_nconst_;
}

std::vector<int>  const & small_tree_rpv::jets_fjet08_index() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_jets_fjet08_index_ && b_jets_fjet08_index_){
    b_jets_fjet08_index_->GetEntry(entry_);
    c_jets_fjet08_index_ = true;
  }
  return jets_fjet08_index_;
}

std::vector<int>  const & small_tree_rpv::jets_fjet_index() const{
  if(!read_only_){
    throw std::logic_error("Trying to write to const tree.");
  }
  if(!c_jets_fjet_index_ && b_jets_fjet_index_){
    b_jets_fjet_index_->GetEntry(entry_);
    c_jets_fjet_index_ = true;
  }
  return jets_fjet_index_;
}

bool  & small_tree_rpv::pass(){
  if(read_only_ && !c_pass_ && b_pass_){
    b_pass_->GetEntry(entry_);
    c_pass_ = true;
  }
  return pass_;
}

float  & small_tree_rpv::eff_trig(){
  if(read_only_ && !c_eff_trig_ && b_eff_trig_){
    b_eff_trig_->GetEntry(entry_);
    c_eff_trig_ = true;
  }
  return eff_trig_;
}

float  & small_tree_rpv::mht(){
  if(read_only_ && !c_mht_ && b_mht_){
    b_mht_->GetEntry(entry_);
    c_mht_ = true;
  }
  return mht_;
}

float  & small_tree_rpv::mj(){
  if(read_only_ && !c_mj_ && b_mj_){
    b_mj_->GetEntry(entry_);
    c_mj_ = true;
  }
  return mj_;
}

float  & small_tree_rpv::mj08(){
  if(read_only_ && !c_mj08_ && b_mj08_){
    b_mj08_->GetEntry(entry_);
    c_mj08_ = true;
  }
  return mj08_;
}

float  & small_tree_rpv::w_pu_rpv(){
  if(read_only_ && !c_w_pu_rpv_ && b_w_pu_rpv_){
    b_w_pu_rpv_->GetEntry(entry_);
    c_w_pu_rpv_ = true;
  }
  return w_pu_rpv_;
}

int  & small_tree_rpv::nfjets(){
  if(read_only_ && !c_nfjets_ && b_nfjets_){
    b_nfjets_->GetEntry(entry_);
    c_nfjets_ = true;
  }
  return nfjets_;
}

int  & small_tree_rpv::nfjets08(){
  if(read_only_ && !c_nfjets08_ && b_nfjets08_){
    b_nfjets08_->GetEntry(entry_);
    c_nfjets08_ = true;
  }
  return nfjets08_;
}

int  & small_tree_rpv::ntruels(){
  if(read_only_ && !c_ntruels_ && b_ntruels_){
    b_ntruels_->GetEntry(entry_);
    c_ntruels_ = true;
  }
  return ntruels_;
}

int  & small_tree_rpv::ntruleps(){
  if(read_only_ && !c_ntruleps_ && b_ntruleps_){
    b_ntruleps_->GetEntry(entry_);
    c_ntruleps_ = true;
  }
  return ntruleps_;
}

int  & small_tree_rpv::ntrumus(){
  if(read_only_ && !c_ntrumus_ && b_ntrumus_){
    b_ntrumus_->GetEntry(entry_);
    c_ntrumus_ = true;
  }
  return ntrumus_;
}

int  & small_tree_rpv::ntrutaush(){
  if(read_only_ && !c_ntrutaush_ && b_ntrutaush_){
    b_ntrutaush_->GetEntry(entry_);
    c_ntrutaush_ = true;
  }
  return ntrutaush_;
}

int  & small_tree_rpv::ntrutausl(){
  if(read_only_ && !c_ntrutausl_ && b_ntrutausl_){
    b_ntrutausl_->GetEntry(entry_);
    c_ntrutausl_ = true;
  }
  return ntrutausl_;
}

std::vector<bool>  & small_tree_rpv::jets_islep(){
  if(read_only_ && !c_jets_islep_ && b_jets_islep_){
    b_jets_islep_->GetEntry(entry_);
    c_jets_islep_ = true;
  }
  return jets_islep_;
}

std::vector<bool>  & small_tree_rpv::trig(){
  if(read_only_ && !c_trig_ && b_trig_){
    b_trig_->GetEntry(entry_);
    c_trig_ = true;
  }
  return trig_;
}

std::vector<float>  & small_tree_rpv::dr_bb(){
  if(read_only_ && !c_dr_bb_ && b_dr_bb_){
    b_dr_bb_->GetEntry(entry_);
    c_dr_bb_ = true;
  }
  return dr_bb_;
}

std::vector<float>  & small_tree_rpv::els_d0(){
  if(read_only_ && !c_els_d0_ && b_els_d0_){
    b_els_d0_->GetEntry(entry_);
    c_els_d0_ = true;
  }
  return els_d0_;
}

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

std::vector<float>  & small_tree_rpv::els_sceta(){
  if(read_only_ && !c_els_sceta_ && b_els_sceta_){
    b_els_sceta_->GetEntry(entry_);
    c_els_sceta_ = true;
  }
  return els_sceta_;
}

std::vector<float>  & small_tree_rpv::fjets08_eta(){
  if(read_only_ && !c_fjets08_eta_ && b_fjets08_eta_){
    b_fjets08_eta_->GetEntry(entry_);
    c_fjets08_eta_ = true;
  }
  return fjets08_eta_;
}

std::vector<float>  & small_tree_rpv::fjets08_m(){
  if(read_only_ && !c_fjets08_m_ && b_fjets08_m_){
    b_fjets08_m_->GetEntry(entry_);
    c_fjets08_m_ = true;
  }
  return fjets08_m_;
}

std::vector<float>  & small_tree_rpv::fjets08_phi(){
  if(read_only_ && !c_fjets08_phi_ && b_fjets08_phi_){
    b_fjets08_phi_->GetEntry(entry_);
    c_fjets08_phi_ = true;
  }
  return fjets08_phi_;
}

std::vector<float>  & small_tree_rpv::fjets08_poscsv(){
  if(read_only_ && !c_fjets08_poscsv_ && b_fjets08_poscsv_){
    b_fjets08_poscsv_->GetEntry(entry_);
    c_fjets08_poscsv_ = true;
  }
  return fjets08_poscsv_;
}

std::vector<float>  & small_tree_rpv::fjets08_pt(){
  if(read_only_ && !c_fjets08_pt_ && b_fjets08_pt_){
    b_fjets08_pt_->GetEntry(entry_);
    c_fjets08_pt_ = true;
  }
  return fjets08_pt_;
}

std::vector<float>  & small_tree_rpv::fjets08_sumcsv(){
  if(read_only_ && !c_fjets08_sumcsv_ && b_fjets08_sumcsv_){
    b_fjets08_sumcsv_->GetEntry(entry_);
    c_fjets08_sumcsv_ = true;
  }
  return fjets08_sumcsv_;
}

std::vector<float>  & small_tree_rpv::fjets_eta(){
  if(read_only_ && !c_fjets_eta_ && b_fjets_eta_){
    b_fjets_eta_->GetEntry(entry_);
    c_fjets_eta_ = true;
  }
  return fjets_eta_;
}

std::vector<float>  & small_tree_rpv::fjets_m(){
  if(read_only_ && !c_fjets_m_ && b_fjets_m_){
    b_fjets_m_->GetEntry(entry_);
    c_fjets_m_ = true;
  }
  return fjets_m_;
}

std::vector<float>  & small_tree_rpv::fjets_phi(){
  if(read_only_ && !c_fjets_phi_ && b_fjets_phi_){
    b_fjets_phi_->GetEntry(entry_);
    c_fjets_phi_ = true;
  }
  return fjets_phi_;
}

std::vector<float>  & small_tree_rpv::fjets_poscsv(){
  if(read_only_ && !c_fjets_poscsv_ && b_fjets_poscsv_){
    b_fjets_poscsv_->GetEntry(entry_);
    c_fjets_poscsv_ = true;
  }
  return fjets_poscsv_;
}

std::vector<float>  & small_tree_rpv::fjets_pt(){
  if(read_only_ && !c_fjets_pt_ && b_fjets_pt_){
    b_fjets_pt_->GetEntry(entry_);
    c_fjets_pt_ = true;
  }
  return fjets_pt_;
}

std::vector<float>  & small_tree_rpv::fjets_sumcsv(){
  if(read_only_ && !c_fjets_sumcsv_ && b_fjets_sumcsv_){
    b_fjets_sumcsv_->GetEntry(entry_);
    c_fjets_sumcsv_ = true;
  }
  return fjets_sumcsv_;
}

std::vector<float>  & small_tree_rpv::jets_m(){
  if(read_only_ && !c_jets_m_ && b_jets_m_){
    b_jets_m_->GetEntry(entry_);
    c_jets_m_ = true;
  }
  return jets_m_;
}

std::vector<float>  & small_tree_rpv::mus_d0(){
  if(read_only_ && !c_mus_d0_ && b_mus_d0_){
    b_mus_d0_->GetEntry(entry_);
    c_mus_d0_ = true;
  }
  return mus_d0_;
}

std::vector<float>  & small_tree_rpv::mus_dz(){
  if(read_only_ && !c_mus_dz_ && b_mus_dz_){
    b_mus_dz_->GetEntry(entry_);
    c_mus_dz_ = true;
  }
  return mus_dz_;
}

std::vector<float>  & small_tree_rpv::sys_bctag(){
  if(read_only_ && !c_sys_bctag_ && b_sys_bctag_){
    b_sys_bctag_->GetEntry(entry_);
    c_sys_bctag_ = true;
  }
  return sys_bctag_;
}

std::vector<int>  & small_tree_rpv::fjets08_btags(){
  if(read_only_ && !c_fjets08_btags_ && b_fjets08_btags_){
    b_fjets08_btags_->GetEntry(entry_);
    c_fjets08_btags_ = true;
  }
  return fjets08_btags_;
}

std::vector<int>  & small_tree_rpv::fjets08_nconst(){
  if(read_only_ && !c_fjets08_nconst_ && b_fjets08_nconst_){
    b_fjets08_nconst_->GetEntry(entry_);
    c_fjets08_nconst_ = true;
  }
  return fjets08_nconst_;
}

std::vector<int>  & small_tree_rpv::fjets_btags(){
  if(read_only_ && !c_fjets_btags_ && b_fjets_btags_){
    b_fjets_btags_->GetEntry(entry_);
    c_fjets_btags_ = true;
  }
  return fjets_btags_;
}

std::vector<int>  & small_tree_rpv::fjets_nconst(){
  if(read_only_ && !c_fjets_nconst_ && b_fjets_nconst_){
    b_fjets_nconst_->GetEntry(entry_);
    c_fjets_nconst_ = true;
  }
  return fjets_nconst_;
}

std::vector<int>  & small_tree_rpv::jets_fjet08_index(){
  if(read_only_ && !c_jets_fjet08_index_ && b_jets_fjet08_index_){
    b_jets_fjet08_index_->GetEntry(entry_);
    c_jets_fjet08_index_ = true;
  }
  return jets_fjet08_index_;
}

std::vector<int>  & small_tree_rpv::jets_fjet_index(){
  if(read_only_ && !c_jets_fjet_index_ && b_jets_fjet_index_){
    b_jets_fjet_index_->GetEntry(entry_);
    c_jets_fjet_index_ = true;
  }
  return jets_fjet_index_;
}