EGamma_ElectronTrackingValidation/looper/analysis/TrackingNtupleMod.h

//////////////////////////////////////////////////////////
// This class has been automatically generated on
// Sun Jan 21 21:52:41 2018 by ROOT version 6.12/04
// from TTree tree/tree
// found on file: trackingNtuple_1.root
//////////////////////////////////////////////////////////

#ifndef TrackingNtuple_h
#define TrackingNtuple_h

#include <TROOT.h>
#include <TChain.h>
#include <TFile.h>

#include <vector>

class TrackingNtuple {
public :
   TTree          *fChain;   //!pointer to the analyzed TTree or TChain
   Int_t           fCurrent; //!current Tree number in a TChain

// Fixed size dimensions of array or collections stored in the TTree if any.

   // Declaration of leaf types
   ULong64_t       event;
   UInt_t          lumi;
   UInt_t          run;
   std::vector<float>   *trk_px;
   std::vector<float>   *trk_py;
   std::vector<float>   *trk_pz;
   std::vector<float>   *trk_pt;
   std::vector<float>   *trk_inner_px;
   std::vector<float>   *trk_inner_py;
   std::vector<float>   *trk_inner_pz;
   std::vector<float>   *trk_inner_pt;
   std::vector<float>   *trk_outer_px;
   std::vector<float>   *trk_outer_py;
   std::vector<float>   *trk_outer_pz;
   std::vector<float>   *trk_outer_pt;
   std::vector<float>   *trk_eta;
   std::vector<float>   *trk_lambda;
   std::vector<float>   *trk_cotTheta;
   std::vector<float>   *trk_phi;
   std::vector<float>   *trk_dxy;
   std::vector<float>   *trk_dz;
   std::vector<float>   *trk_ptErr;
   std::vector<float>   *trk_etaErr;
   std::vector<float>   *trk_lambdaErr;
   std::vector<float>   *trk_phiErr;
   std::vector<float>   *trk_dxyErr;
   std::vector<float>   *trk_dzErr;
   std::vector<float>   *trk_refpoint_x;
   std::vector<float>   *trk_refpoint_y;
   std::vector<float>   *trk_refpoint_z;
   std::vector<float>   *trk_nChi2;
   std::vector<int>     *trk_q;
   std::vector<unsigned int> *trk_nValid;
   std::vector<unsigned int> *trk_nInvalid;
   std::vector<unsigned int> *trk_nPixel;
   std::vector<unsigned int> *trk_nStrip;
   std::vector<unsigned int> *trk_nPixelLay;
   std::vector<unsigned int> *trk_nStripLay;
   std::vector<unsigned int> *trk_n3DLay;
   std::vector<unsigned int> *trk_nOuterLost;
   std::vector<unsigned int> *trk_nInnerLost;
   std::vector<unsigned int> *trk_algo;
   std::vector<unsigned int> *trk_originalAlgo;
   std::vector<ULong64_t> *trk_algoMask;
   std::vector<unsigned short> *trk_stopReason;
   std::vector<short>   *trk_isHP;
   std::vector<int>     *trk_seedIdx;
   std::vector<float>   *trk_vtxx;
   std::vector<float>   *trk_vtxy;
   std::vector<float>   *trk_vtxz;
   std::vector<std::vector<float> > *trk_shareFrac;
   std::vector<std::vector<int> > *trk_simTrkIdx;
   std::vector<int>     *trk_genIdx;
   std::vector<float>   *trk_genDR;
   std::vector<int>     *sim_event;
   std::vector<int>     *sim_bunchCrossing;
   std::vector<int>     *sim_pdgId;
   std::vector<std::vector<int> > *sim_genPdgIds;
   std::vector<int>     *sim_isFromBHadron;
   std::vector<float>   *sim_px;
   std::vector<float>   *sim_py;
   std::vector<float>   *sim_pz;
   std::vector<float>   *sim_pt;
   std::vector<float>   *sim_eta;
   std::vector<float>   *sim_phi;
   std::vector<float>   *sim_pca_pt;
   std::vector<float>   *sim_pca_eta;
   std::vector<float>   *sim_pca_lambda;
   std::vector<float>   *sim_pca_cotTheta;
   std::vector<float>   *sim_pca_phi;
   std::vector<float>   *sim_pca_dxy;
   std::vector<float>   *sim_pca_dz;
   std::vector<int>     *sim_q;
   std::vector<unsigned int> *sim_nValid;
   std::vector<unsigned int> *sim_nPixel;
   std::vector<unsigned int> *sim_nStrip;
   std::vector<unsigned int> *sim_nLay;
   std::vector<unsigned int> *sim_nPixelLay;
   std::vector<unsigned int> *sim_n3DLay;
   std::vector<std::vector<int> > *sim_trkIdx;
   std::vector<std::vector<float> > *sim_shareFrac;
   std::vector<std::vector<int> > *sim_seedIdx;
   std::vector<int>     *sim_parentVtxIdx;
   std::vector<std::vector<int> > *sim_decayVtxIdx;
   Float_t         bsp_x;
   Float_t         bsp_y;
   Float_t         bsp_z;
   Float_t         bsp_sigmax;
   Float_t         bsp_sigmay;
   Float_t         bsp_sigmaz;
   std::vector<short>   *see_fitok;
   std::vector<float>   *see_px;
   std::vector<float>   *see_py;
   std::vector<float>   *see_pz;
   std::vector<float>   *see_pt;
   std::vector<float>   *see_eta;
   std::vector<float>   *see_phi;
   std::vector<float>   *see_dxy;
   std::vector<float>   *see_dz;
   std::vector<float>   *see_ptErr;
   std::vector<float>   *see_etaErr;
   std::vector<float>   *see_phiErr;
   std::vector<float>   *see_dxyErr;
   std::vector<float>   *see_dzErr;
   std::vector<float>   *see_chi2;
   std::vector<float>   *see_statePt;
   std::vector<float>   *see_stateTrajX;
   std::vector<float>   *see_stateTrajY;
   std::vector<float>   *see_stateTrajPx;
   std::vector<float>   *see_stateTrajPy;
   std::vector<float>   *see_stateTrajPz;
   std::vector<int>     *see_q;
   std::vector<unsigned int> *see_nValid;
   std::vector<unsigned int> *see_nPixel;
   std::vector<unsigned int> *see_nGlued;
   std::vector<unsigned int> *see_nStrip;
   std::vector<unsigned int> *see_nPhase2OT;
   std::vector<unsigned int> *see_algo;
   std::vector<unsigned short> *see_stopReason;
   std::vector<int>     *see_trkIdx;
   std::vector<std::vector<float> > *see_shareFrac;
   std::vector<std::vector<int> > *see_simTrkIdx;
   std::vector<unsigned int> *see_offset;
   std::vector<float> *see_Et;
   std::vector<std::vector<int> > *see_isBarrel;
   std::vector<std::vector<int> > *see_layerOrDiskNr;
   std::vector<std::vector<int> > *see_isValidPos;
   std::vector<std::vector<float> > *see_dRZPos;
   std::vector<std::vector<float> > *see_dPhiPos;
   std::vector<std::vector<int> > *see_isValidNeg;
   std::vector<std::vector<float> > *see_dRZNeg;
   std::vector<std::vector<float> > *see_dPhiNeg;
   std::vector<short> *see_isECALDriven;
   std::vector<float>   *vtx_x;
   std::vector<float>   *vtx_y;
   std::vector<float>   *vtx_z;
   std::vector<float>   *vtx_xErr;
   std::vector<float>   *vtx_yErr;
   std::vector<float>   *vtx_zErr;
   std::vector<float>   *vtx_ndof;
   std::vector<float>   *vtx_chi2;
   std::vector<short>   *vtx_fake;
   std::vector<short>   *vtx_valid;
   std::vector<std::vector<int> > *vtx_trkIdx;
   std::vector<float>   *gen_px;
   std::vector<float>   *gen_py;
   std::vector<float>   *gen_pz;
   std::vector<float>   *gen_charge;
   std::vector<int>     *gen_pdgId;
   std::vector<float>   *gen_vx;
   std::vector<float>   *gen_vy;
   std::vector<float>   *gen_vz;
   std::vector<int>     *gen_status;
   std::vector<int>     *gen_mother;
   std::vector<bool>    *gen_isTauDecayProduct;
   std::vector<bool>    *gen_isDirectHadronDecayProduct;
   std::vector<bool>    *gen_isPrompt;
   std::vector<int>     *simvtx_event;
   std::vector<int>     *simvtx_bunchCrossing;
   std::vector<unsigned int> *simvtx_processType;
   std::vector<float>   *simvtx_x;
   std::vector<float>   *simvtx_y;
   std::vector<float>   *simvtx_z;
   std::vector<std::vector<int> > *simvtx_sourceSimIdx;
   std::vector<std::vector<int> > *simvtx_daughterSimIdx;
   std::vector<int>     *simpv_idx;

   // List of branches
   TBranch        *b_event;   //!
   TBranch        *b_lumi;   //!
   TBranch        *b_run;   //!
   TBranch        *b_trk_px;   //!
   TBranch        *b_trk_py;   //!
   TBranch        *b_trk_pz;   //!
   TBranch        *b_trk_pt;   //!
   TBranch        *b_trk_inner_px;   //!
   TBranch        *b_trk_inner_py;   //!
   TBranch        *b_trk_inner_pz;   //!
   TBranch        *b_trk_inner_pt;   //!
   TBranch        *b_trk_outer_px;   //!
   TBranch        *b_trk_outer_py;   //!
   TBranch        *b_trk_outer_pz;   //!
   TBranch        *b_trk_outer_pt;   //!
   TBranch        *b_trk_eta;   //!
   TBranch        *b_trk_lambda;   //!
   TBranch        *b_trk_cotTheta;   //!
   TBranch        *b_trk_phi;   //!
   TBranch        *b_trk_dxy;   //!
   TBranch        *b_trk_dz;   //!
   TBranch        *b_trk_ptErr;   //!
   TBranch        *b_trk_etaErr;   //!
   TBranch        *b_trk_lambdaErr;   //!
   TBranch        *b_trk_phiErr;   //!
   TBranch        *b_trk_dxyErr;   //!
   TBranch        *b_trk_dzErr;   //!
   TBranch        *b_trk_refpoint_x;   //!
   TBranch        *b_trk_refpoint_y;   //!
   TBranch        *b_trk_refpoint_z;   //!
   TBranch        *b_trk_nChi2;   //!
   TBranch        *b_trk_q;   //!
   TBranch        *b_trk_nValid;   //!
   TBranch        *b_trk_nInvalid;   //!
   TBranch        *b_trk_nPixel;   //!
   TBranch        *b_trk_nStrip;   //!
   TBranch        *b_trk_nPixelLay;   //!
   TBranch        *b_trk_nStripLay;   //!
   TBranch        *b_trk_n3DLay;   //!
   TBranch        *b_trk_nOuterLost;   //!
   TBranch        *b_trk_nInnerLost;   //!
   TBranch        *b_trk_algo;   //!
   TBranch        *b_trk_originalAlgo;   //!
   TBranch        *b_trk_algoMask;   //!
   TBranch        *b_trk_stopReason;   //!
   TBranch        *b_trk_isHP;   //!
   TBranch        *b_trk_seedIdx;   //!
   TBranch        *b_trk_vtxx;   //!
   TBranch        *b_trk_vtxy;   //!
   TBranch        *b_trk_vtxz;   //!
   TBranch        *b_trk_shareFrac;   //!
   TBranch        *b_trk_simTrkIdx;   //!
   TBranch        *b_trk_genIdx;   //!
   TBranch        *b_trk_genDR;   //!
   TBranch        *b_sim_event;   //!
   TBranch        *b_sim_bunchCrossing;   //!
   TBranch        *b_sim_pdgId;   //!
   TBranch        *b_sim_genPdgIds;   //!
   TBranch        *b_sim_isFromBHadron;   //!
   TBranch        *b_sim_px;   //!
   TBranch        *b_sim_py;   //!
   TBranch        *b_sim_pz;   //!
   TBranch        *b_sim_pt;   //!
   TBranch        *b_sim_eta;   //!
   TBranch        *b_sim_phi;   //!
   TBranch        *b_sim_pca_pt;   //!
   TBranch        *b_sim_pca_eta;   //!
   TBranch        *b_sim_pca_lambda;   //!
   TBranch        *b_sim_pca_cotTheta;   //!
   TBranch        *b_sim_pca_phi;   //!
   TBranch        *b_sim_pca_dxy;   //!
   TBranch        *b_sim_pca_dz;   //!
   TBranch        *b_sim_q;   //!
   TBranch        *b_sim_nValid;   //!
   TBranch        *b_sim_nPixel;   //!
   TBranch        *b_sim_nStrip;   //!
   TBranch        *b_sim_nLay;   //!
   TBranch        *b_sim_nPixelLay;   //!
   TBranch        *b_sim_n3DLay;   //!
   TBranch        *b_sim_trkIdx;   //!
   TBranch        *b_sim_shareFrac;   //!
   TBranch        *b_sim_seedIdx;   //!
   TBranch        *b_sim_parentVtxIdx;   //!
   TBranch        *b_sim_decayVtxIdx;   //!
   TBranch        *b_bsp_x;   //!
   TBranch        *b_bsp_y;   //!
   TBranch        *b_bsp_z;   //!
   TBranch        *b_bsp_sigmax;   //!
   TBranch        *b_bsp_sigmay;   //!
   TBranch        *b_bsp_sigmaz;   //!
   TBranch        *b_see_fitok;   //!
   TBranch        *b_see_px;   //!
   TBranch        *b_see_py;   //!
   TBranch        *b_see_pz;   //!
   TBranch        *b_see_pt;   //!
   TBranch        *b_see_eta;   //!
   TBranch        *b_see_phi;   //!
   TBranch        *b_see_dxy;   //!
   TBranch        *b_see_dz;   //!
   TBranch        *b_see_ptErr;   //!
   TBranch        *b_see_etaErr;   //!
   TBranch        *b_see_phiErr;   //!
   TBranch        *b_see_dxyErr;   //!
   TBranch        *b_see_dzErr;   //!
   TBranch        *b_see_chi2;   //!
   TBranch        *b_see_statePt;   //!
   TBranch        *b_see_stateTrajX;   //!
   TBranch        *b_see_stateTrajY;   //!
   TBranch        *b_see_stateTrajPx;   //!
   TBranch        *b_see_stateTrajPy;   //!
   TBranch        *b_see_stateTrajPz;   //!
   TBranch        *b_see_q;   //!
   TBranch        *b_see_nValid;   //!
   TBranch        *b_see_nPixel;   //!
   TBranch        *b_see_nGlued;   //!
   TBranch        *b_see_nStrip;   //!
   TBranch        *b_see_nPhase2OT;   //!
   TBranch        *b_see_algo;   //!
   TBranch        *b_see_stopReason;   //!
   TBranch        *b_see_trkIdx;   //!
   TBranch        *b_see_shareFrac;   //!
   TBranch        *b_see_simTrkIdx;   //!
   TBranch        *b_see_offset;   //!
   TBranch        *b_see_Et;   //!
   TBranch        *b_see_isBarrel;   //!
   TBranch        *b_see_layerOrDiskNr;   //!
   TBranch        *b_see_isValidPos;   //!
   TBranch        *b_see_dRZPos;   //!
   TBranch        *b_see_dPhiPos;   //!
   TBranch        *b_see_isValidNeg;   //!
   TBranch        *b_see_dRZNeg;   //!
   TBranch        *b_see_dPhiNeg;   //!
   TBranch        *b_see_isECALDriven;   //!
   TBranch        *b_vtx_x;   //!
   TBranch        *b_vtx_y;   //!
   TBranch        *b_vtx_z;   //!
   TBranch        *b_vtx_xErr;   //!
   TBranch        *b_vtx_yErr;   //!
   TBranch        *b_vtx_zErr;   //!
   TBranch        *b_vtx_ndof;   //!
   TBranch        *b_vtx_chi2;   //!
   TBranch        *b_vtx_fake;   //!
   TBranch        *b_vtx_valid;   //!
   TBranch        *b_vtx_trkIdx;   //!
   TBranch        *b_gen_px;   //!
   TBranch        *b_gen_py;   //!
   TBranch        *b_gen_pz;   //!
   TBranch        *b_gen_charge;   //!
   TBranch        *b_gen_pdgId;   //!
   TBranch        *b_gen_vx;   //!
   TBranch        *b_gen_vy;   //!
   TBranch        *b_gen_vz;   //!
   TBranch        *b_gen_status;   //!
   TBranch        *b_gen_mother;   //!
   TBranch        *b_gen_isTauDecayProduct;   //!
   TBranch        *b_gen_isDirectHadronDecayProduct;   //!
   TBranch        *b_gen_isPrompt;   //!
   TBranch        *b_simvtx_event;   //!
   TBranch        *b_simvtx_bunchCrossing;   //!
   TBranch        *b_simvtx_processType;   //!
   TBranch        *b_simvtx_x;   //!
   TBranch        *b_simvtx_y;   //!
   TBranch        *b_simvtx_z;   //!
   TBranch        *b_simvtx_sourceSimIdx;   //!
   TBranch        *b_simvtx_daughterSimIdx;   //!
   TBranch        *b_simpv_idx;   //!

   TrackingNtuple(TTree *tree=0);
   virtual ~TrackingNtuple();
   virtual Int_t    Cut(Long64_t entry);
   virtual Int_t    GetEntry(Long64_t entry);
   virtual Long64_t LoadTree(Long64_t entry);
   virtual void     Init(TTree *tree);
   virtual Bool_t   Notify();
   virtual void     Show(Long64_t entry = -1);
};

TrackingNtuple::TrackingNtuple(TTree *tree) : fChain(0)
{
// if parameter tree is not specified (or zero), connect the file
// used to generate this class and read the Tree.
   if (tree == 0) {
      TFile *f = (TFile*)gROOT->GetListOfFiles()->FindObject("trackingNtuple_1.root");
      if (!f || !f->IsOpen()) {
         f = new TFile("trackingNtuple_1.root");
      }
      TDirectory * dir = (TDirectory*)f->Get("trackingNtuple_1.root:/trackingNtuple");
      dir->GetObject("tree",tree);

   }
   Init(tree);
}

TrackingNtuple::~TrackingNtuple()
{
   if (!fChain) return;
   delete fChain->GetCurrentFile();
}

Int_t TrackingNtuple::GetEntry(Long64_t entry)
{
// Read contents of entry.
   if (!fChain) return 0;
   return fChain->GetEntry(entry);
}
Long64_t TrackingNtuple::LoadTree(Long64_t entry)
{
// Set the environment to read one entry
   if (!fChain) return -5;
   Long64_t centry = fChain->LoadTree(entry);
   if (centry < 0) return centry;
   if (fChain->GetTreeNumber() != fCurrent) {
      fCurrent = fChain->GetTreeNumber();
      Notify();
   }
   return centry;
}

void TrackingNtuple::Init(TTree *tree)
{
   // The Init() function is called when the selector needs to initialize
   // a new tree or chain. Typically here the branch addresses and branch
   // pointers of the tree will be set.
   // It is normally not necessary to make changes to the generated
   // code, but the routine can be extended by the user if needed.
   // Init() will be called many times when running on PROOF
   // (once per file to be processed).

   // Set object pointer
   trk_px = 0;
   trk_py = 0;
   trk_pz = 0;
   trk_pt = 0;
   trk_inner_px = 0;
   trk_inner_py = 0;
   trk_inner_pz = 0;
   trk_inner_pt = 0;
   trk_outer_px = 0;
   trk_outer_py = 0;
   trk_outer_pz = 0;
   trk_outer_pt = 0;
   trk_eta = 0;
   trk_lambda = 0;
   trk_cotTheta = 0;
   trk_phi = 0;
   trk_dxy = 0;
   trk_dz = 0;
   trk_ptErr = 0;
   trk_etaErr = 0;
   trk_lambdaErr = 0;
   trk_phiErr = 0;
   trk_dxyErr = 0;
   trk_dzErr = 0;
   trk_refpoint_x = 0;
   trk_refpoint_y = 0;
   trk_refpoint_z = 0;
   trk_nChi2 = 0;
   trk_q = 0;
   trk_nValid = 0;
   trk_nInvalid = 0;
   trk_nPixel = 0;
   trk_nStrip = 0;
   trk_nPixelLay = 0;
   trk_nStripLay = 0;
   trk_n3DLay = 0;
   trk_nOuterLost = 0;
   trk_nInnerLost = 0;
   trk_algo = 0;
   trk_originalAlgo = 0;
   trk_algoMask = 0;
   trk_stopReason = 0;
   trk_isHP = 0;
   trk_seedIdx = 0;
   trk_vtxx = 0;
   trk_vtxy = 0;
   trk_vtxz = 0;
   trk_shareFrac = 0;
   trk_simTrkIdx = 0;
   trk_genIdx = 0;
   trk_genDR = 0;
   sim_event = 0;
   sim_bunchCrossing = 0;
   sim_pdgId = 0;
   sim_genPdgIds = 0;
   sim_isFromBHadron = 0;
   sim_px = 0;
   sim_py = 0;
   sim_pz = 0;
   sim_pt = 0;
   sim_eta = 0;
   sim_phi = 0;
   sim_pca_pt = 0;
   sim_pca_eta = 0;
   sim_pca_lambda = 0;
   sim_pca_cotTheta = 0;
   sim_pca_phi = 0;
   sim_pca_dxy = 0;
   sim_pca_dz = 0;
   sim_q = 0;
   sim_nValid = 0;
   sim_nPixel = 0;
   sim_nStrip = 0;
   sim_nLay = 0;
   sim_nPixelLay = 0;
   sim_n3DLay = 0;
   sim_trkIdx = 0;
   sim_shareFrac = 0;
   sim_seedIdx = 0;
   sim_parentVtxIdx = 0;
   sim_decayVtxIdx = 0;
   see_fitok = 0;
   see_px = 0;
   see_py = 0;
   see_pz = 0;
   see_pt = 0;
   see_eta = 0;
   see_phi = 0;
   see_dxy = 0;
   see_dz = 0;
   see_ptErr = 0;
   see_etaErr = 0;
   see_phiErr = 0;
   see_dxyErr = 0;
   see_dzErr = 0;
   see_chi2 = 0;
   see_statePt = 0;
   see_stateTrajX = 0;
   see_stateTrajY = 0;
   see_stateTrajPx = 0;
   see_stateTrajPy = 0;
   see_stateTrajPz = 0;
   see_q = 0;
   see_nValid = 0;
   see_nPixel = 0;
   see_nGlued = 0;
   see_nStrip = 0;
   see_nPhase2OT = 0;
   see_algo = 0;
   see_stopReason = 0;
   see_trkIdx = 0;
   see_shareFrac = 0;
   see_simTrkIdx = 0;
   see_offset = 0;
   see_Et = 0;
   see_isBarrel = 0;
   see_layerOrDiskNr = 0;
   see_isValidPos = 0;
   see_dRZPos = 0;
   see_dPhiPos = 0;
   see_isValidNeg = 0;
   see_dRZNeg = 0;
   see_dPhiNeg = 0;
   see_isECALDriven = 0;
   vtx_x = 0;
   vtx_y = 0;
   vtx_z = 0;
   vtx_xErr = 0;
   vtx_yErr = 0;
   vtx_zErr = 0;
   vtx_ndof = 0;
   vtx_chi2 = 0;
   vtx_fake = 0;
   vtx_valid = 0;
   vtx_trkIdx = 0;
   gen_px = 0;
   gen_py = 0;
   gen_pz = 0;
   gen_charge = 0;
   gen_pdgId = 0;
   gen_vx = 0;
   gen_vy = 0;
   gen_vz = 0;
   gen_status = 0;
   gen_mother = 0;
   gen_isTauDecayProduct = 0;
   gen_isDirectHadronDecayProduct = 0;
   gen_isPrompt = 0;
   simvtx_event = 0;
   simvtx_bunchCrossing = 0;
   simvtx_processType = 0;
   simvtx_x = 0;
   simvtx_y = 0;
   simvtx_z = 0;
   simvtx_sourceSimIdx = 0;
   simvtx_daughterSimIdx = 0;
   simpv_idx = 0;
   // Set branch addresses and branch pointers
   if (!tree) return;
   fChain = tree;
   fCurrent = -1;
   fChain->SetMakeClass(1);

   fChain->SetBranchAddress("event", &event, &b_event);
   fChain->SetBranchAddress("lumi", &lumi, &b_lumi);
   fChain->SetBranchAddress("run", &run, &b_run);
   fChain->SetBranchAddress("trk_px", &trk_px, &b_trk_px);
   fChain->SetBranchAddress("trk_py", &trk_py, &b_trk_py);
   fChain->SetBranchAddress("trk_pz", &trk_pz, &b_trk_pz);
   fChain->SetBranchAddress("trk_pt", &trk_pt, &b_trk_pt);
   fChain->SetBranchAddress("trk_inner_px", &trk_inner_px, &b_trk_inner_px);
   fChain->SetBranchAddress("trk_inner_py", &trk_inner_py, &b_trk_inner_py);
   fChain->SetBranchAddress("trk_inner_pz", &trk_inner_pz, &b_trk_inner_pz);
   fChain->SetBranchAddress("trk_inner_pt", &trk_inner_pt, &b_trk_inner_pt);
   fChain->SetBranchAddress("trk_outer_px", &trk_outer_px, &b_trk_outer_px);
   fChain->SetBranchAddress("trk_outer_py", &trk_outer_py, &b_trk_outer_py);
   fChain->SetBranchAddress("trk_outer_pz", &trk_outer_pz, &b_trk_outer_pz);
   fChain->SetBranchAddress("trk_outer_pt", &trk_outer_pt, &b_trk_outer_pt);
   fChain->SetBranchAddress("trk_eta", &trk_eta, &b_trk_eta);
   fChain->SetBranchAddress("trk_lambda", &trk_lambda, &b_trk_lambda);
   fChain->SetBranchAddress("trk_cotTheta", &trk_cotTheta, &b_trk_cotTheta);
   fChain->SetBranchAddress("trk_phi", &trk_phi, &b_trk_phi);
   fChain->SetBranchAddress("trk_dxy", &trk_dxy, &b_trk_dxy);
   fChain->SetBranchAddress("trk_dz", &trk_dz, &b_trk_dz);
   fChain->SetBranchAddress("trk_ptErr", &trk_ptErr, &b_trk_ptErr);
   fChain->SetBranchAddress("trk_etaErr", &trk_etaErr, &b_trk_etaErr);
   fChain->SetBranchAddress("trk_lambdaErr", &trk_lambdaErr, &b_trk_lambdaErr);
   fChain->SetBranchAddress("trk_phiErr", &trk_phiErr, &b_trk_phiErr);
   fChain->SetBranchAddress("trk_dxyErr", &trk_dxyErr, &b_trk_dxyErr);
   fChain->SetBranchAddress("trk_dzErr", &trk_dzErr, &b_trk_dzErr);
   fChain->SetBranchAddress("trk_refpoint_x", &trk_refpoint_x, &b_trk_refpoint_x);
   fChain->SetBranchAddress("trk_refpoint_y", &trk_refpoint_y, &b_trk_refpoint_y);
   fChain->SetBranchAddress("trk_refpoint_z", &trk_refpoint_z, &b_trk_refpoint_z);
   fChain->SetBranchAddress("trk_nChi2", &trk_nChi2, &b_trk_nChi2);
   fChain->SetBranchAddress("trk_q", &trk_q, &b_trk_q);
   fChain->SetBranchAddress("trk_nValid", &trk_nValid, &b_trk_nValid);
   fChain->SetBranchAddress("trk_nInvalid", &trk_nInvalid, &b_trk_nInvalid);
   fChain->SetBranchAddress("trk_nPixel", &trk_nPixel, &b_trk_nPixel);
   fChain->SetBranchAddress("trk_nStrip", &trk_nStrip, &b_trk_nStrip);
   fChain->SetBranchAddress("trk_nPixelLay", &trk_nPixelLay, &b_trk_nPixelLay);
   fChain->SetBranchAddress("trk_nStripLay", &trk_nStripLay, &b_trk_nStripLay);
   fChain->SetBranchAddress("trk_n3DLay", &trk_n3DLay, &b_trk_n3DLay);
   fChain->SetBranchAddress("trk_nOuterLost", &trk_nOuterLost, &b_trk_nOuterLost);
   fChain->SetBranchAddress("trk_nInnerLost", &trk_nInnerLost, &b_trk_nInnerLost);
   fChain->SetBranchAddress("trk_algo", &trk_algo, &b_trk_algo);
   fChain->SetBranchAddress("trk_originalAlgo", &trk_originalAlgo, &b_trk_originalAlgo);
   fChain->SetBranchAddress("trk_algoMask", &trk_algoMask, &b_trk_algoMask);
   fChain->SetBranchAddress("trk_stopReason", &trk_stopReason, &b_trk_stopReason);
   fChain->SetBranchAddress("trk_isHP", &trk_isHP, &b_trk_isHP);
   fChain->SetBranchAddress("trk_seedIdx", &trk_seedIdx, &b_trk_seedIdx);
   fChain->SetBranchAddress("trk_vtxx", &trk_vtxx, &b_trk_vtxx);
   fChain->SetBranchAddress("trk_vtxy", &trk_vtxy, &b_trk_vtxy);
   fChain->SetBranchAddress("trk_vtxz", &trk_vtxz, &b_trk_vtxz);
   fChain->SetBranchAddress("trk_shareFrac", &trk_shareFrac, &b_trk_shareFrac);
   fChain->SetBranchAddress("trk_simTrkIdx", &trk_simTrkIdx, &b_trk_simTrkIdx);
   fChain->SetBranchAddress("trk_genIdx", &trk_genIdx, &b_trk_genIdx);
   fChain->SetBranchAddress("trk_genDR", &trk_genDR, &b_trk_genDR);
   fChain->SetBranchAddress("sim_event", &sim_event, &b_sim_event);
   fChain->SetBranchAddress("sim_bunchCrossing", &sim_bunchCrossing, &b_sim_bunchCrossing);
   fChain->SetBranchAddress("sim_pdgId", &sim_pdgId, &b_sim_pdgId);
   fChain->SetBranchAddress("sim_genPdgIds", &sim_genPdgIds, &b_sim_genPdgIds);
   fChain->SetBranchAddress("sim_isFromBHadron", &sim_isFromBHadron, &b_sim_isFromBHadron);
   fChain->SetBranchAddress("sim_px", &sim_px, &b_sim_px);
   fChain->SetBranchAddress("sim_py", &sim_py, &b_sim_py);
   fChain->SetBranchAddress("sim_pz", &sim_pz, &b_sim_pz);
   fChain->SetBranchAddress("sim_pt", &sim_pt, &b_sim_pt);
   fChain->SetBranchAddress("sim_eta", &sim_eta, &b_sim_eta);
   fChain->SetBranchAddress("sim_phi", &sim_phi, &b_sim_phi);
   fChain->SetBranchAddress("sim_pca_pt", &sim_pca_pt, &b_sim_pca_pt);
   fChain->SetBranchAddress("sim_pca_eta", &sim_pca_eta, &b_sim_pca_eta);
   fChain->SetBranchAddress("sim_pca_lambda", &sim_pca_lambda, &b_sim_pca_lambda);
   fChain->SetBranchAddress("sim_pca_cotTheta", &sim_pca_cotTheta, &b_sim_pca_cotTheta);
   fChain->SetBranchAddress("sim_pca_phi", &sim_pca_phi, &b_sim_pca_phi);
   fChain->SetBranchAddress("sim_pca_dxy", &sim_pca_dxy, &b_sim_pca_dxy);
   fChain->SetBranchAddress("sim_pca_dz", &sim_pca_dz, &b_sim_pca_dz);
   fChain->SetBranchAddress("sim_q", &sim_q, &b_sim_q);
   fChain->SetBranchAddress("sim_nValid", &sim_nValid, &b_sim_nValid);
   fChain->SetBranchAddress("sim_nPixel", &sim_nPixel, &b_sim_nPixel);
   fChain->SetBranchAddress("sim_nStrip", &sim_nStrip, &b_sim_nStrip);
   fChain->SetBranchAddress("sim_nLay", &sim_nLay, &b_sim_nLay);
   fChain->SetBranchAddress("sim_nPixelLay", &sim_nPixelLay, &b_sim_nPixelLay);
   fChain->SetBranchAddress("sim_n3DLay", &sim_n3DLay, &b_sim_n3DLay);
   fChain->SetBranchAddress("sim_trkIdx", &sim_trkIdx, &b_sim_trkIdx);
   fChain->SetBranchAddress("sim_shareFrac", &sim_shareFrac, &b_sim_shareFrac);
   fChain->SetBranchAddress("sim_seedIdx", &sim_seedIdx, &b_sim_seedIdx);
   fChain->SetBranchAddress("sim_parentVtxIdx", &sim_parentVtxIdx, &b_sim_parentVtxIdx);
   fChain->SetBranchAddress("sim_decayVtxIdx", &sim_decayVtxIdx, &b_sim_decayVtxIdx);
   fChain->SetBranchAddress("bsp_x", &bsp_x, &b_bsp_x);
   fChain->SetBranchAddress("bsp_y", &bsp_y, &b_bsp_y);
   fChain->SetBranchAddress("bsp_z", &bsp_z, &b_bsp_z);
   fChain->SetBranchAddress("bsp_sigmax", &bsp_sigmax, &b_bsp_sigmax);
   fChain->SetBranchAddress("bsp_sigmay", &bsp_sigmay, &b_bsp_sigmay);
   fChain->SetBranchAddress("bsp_sigmaz", &bsp_sigmaz, &b_bsp_sigmaz);
   fChain->SetBranchAddress("see_fitok", &see_fitok, &b_see_fitok);
   fChain->SetBranchAddress("see_px", &see_px, &b_see_px);
   fChain->SetBranchAddress("see_py", &see_py, &b_see_py);
   fChain->SetBranchAddress("see_pz", &see_pz, &b_see_pz);
   fChain->SetBranchAddress("see_pt", &see_pt, &b_see_pt);
   fChain->SetBranchAddress("see_eta", &see_eta, &b_see_eta);
   fChain->SetBranchAddress("see_phi", &see_phi, &b_see_phi);
   fChain->SetBranchAddress("see_dxy", &see_dxy, &b_see_dxy);
   fChain->SetBranchAddress("see_dz", &see_dz, &b_see_dz);
   fChain->SetBranchAddress("see_ptErr", &see_ptErr, &b_see_ptErr);
   fChain->SetBranchAddress("see_etaErr", &see_etaErr, &b_see_etaErr);
   fChain->SetBranchAddress("see_phiErr", &see_phiErr, &b_see_phiErr);
   fChain->SetBranchAddress("see_dxyErr", &see_dxyErr, &b_see_dxyErr);
   fChain->SetBranchAddress("see_dzErr", &see_dzErr, &b_see_dzErr);
   fChain->SetBranchAddress("see_chi2", &see_chi2, &b_see_chi2);
   fChain->SetBranchAddress("see_statePt", &see_statePt, &b_see_statePt);
   fChain->SetBranchAddress("see_stateTrajX", &see_stateTrajX, &b_see_stateTrajX);
   fChain->SetBranchAddress("see_stateTrajY", &see_stateTrajY, &b_see_stateTrajY);
   fChain->SetBranchAddress("see_stateTrajPx", &see_stateTrajPx, &b_see_stateTrajPx);
   fChain->SetBranchAddress("see_stateTrajPy", &see_stateTrajPy, &b_see_stateTrajPy);
   fChain->SetBranchAddress("see_stateTrajPz", &see_stateTrajPz, &b_see_stateTrajPz);
   fChain->SetBranchAddress("see_q", &see_q, &b_see_q);
   fChain->SetBranchAddress("see_nValid", &see_nValid, &b_see_nValid);
   fChain->SetBranchAddress("see_nPixel", &see_nPixel, &b_see_nPixel);
   fChain->SetBranchAddress("see_nGlued", &see_nGlued, &b_see_nGlued);
   fChain->SetBranchAddress("see_nStrip", &see_nStrip, &b_see_nStrip);
   fChain->SetBranchAddress("see_nPhase2OT", &see_nPhase2OT, &b_see_nPhase2OT);
   fChain->SetBranchAddress("see_algo", &see_algo, &b_see_algo);
   fChain->SetBranchAddress("see_stopReason", &see_stopReason, &b_see_stopReason);
   fChain->SetBranchAddress("see_trkIdx", &see_trkIdx, &b_see_trkIdx);
   fChain->SetBranchAddress("see_shareFrac", &see_shareFrac, &b_see_shareFrac);
   fChain->SetBranchAddress("see_simTrkIdx", &see_simTrkIdx, &b_see_simTrkIdx);
   fChain->SetBranchAddress("see_offset", &see_offset, &b_see_offset);
   fChain->SetBranchAddress("see_Et", &see_Et, &b_see_Et);
   fChain->SetBranchAddress("see_isBarrel", &see_isBarrel, &b_see_isBarrel);
   fChain->SetBranchAddress("see_layerOrDiskNr", &see_layerOrDiskNr, &b_see_layerOrDiskNr);
   fChain->SetBranchAddress("see_isValidPos", &see_isValidPos, &b_see_isValidPos);
   fChain->SetBranchAddress("see_dRZPos", &see_dRZPos, &b_see_dRZPos);
   fChain->SetBranchAddress("see_dPhiPos", &see_dPhiPos, &b_see_dPhiPos);
   fChain->SetBranchAddress("see_isValidNeg", &see_isValidNeg, &b_see_isValidNeg);
   fChain->SetBranchAddress("see_dRZNeg", &see_dRZNeg, &b_see_dRZNeg);
   fChain->SetBranchAddress("see_dPhiNeg", &see_dPhiNeg, &b_see_dPhiNeg);
   fChain->SetBranchAddress("see_isECALDriven", &see_isECALDriven, &b_see_isECALDriven);
   fChain->SetBranchAddress("vtx_x", &vtx_x, &b_vtx_x);
   fChain->SetBranchAddress("vtx_y", &vtx_y, &b_vtx_y);
   fChain->SetBranchAddress("vtx_z", &vtx_z, &b_vtx_z);
   fChain->SetBranchAddress("vtx_xErr", &vtx_xErr, &b_vtx_xErr);
   fChain->SetBranchAddress("vtx_yErr", &vtx_yErr, &b_vtx_yErr);
   fChain->SetBranchAddress("vtx_zErr", &vtx_zErr, &b_vtx_zErr);
   fChain->SetBranchAddress("vtx_ndof", &vtx_ndof, &b_vtx_ndof);
   fChain->SetBranchAddress("vtx_chi2", &vtx_chi2, &b_vtx_chi2);
   fChain->SetBranchAddress("vtx_fake", &vtx_fake, &b_vtx_fake);
   fChain->SetBranchAddress("vtx_valid", &vtx_valid, &b_vtx_valid);
   fChain->SetBranchAddress("vtx_trkIdx", &vtx_trkIdx, &b_vtx_trkIdx);
   fChain->SetBranchAddress("gen_px", &gen_px, &b_gen_px);
   fChain->SetBranchAddress("gen_py", &gen_py, &b_gen_py);
   fChain->SetBranchAddress("gen_pz", &gen_pz, &b_gen_pz);
   fChain->SetBranchAddress("gen_charge", &gen_charge, &b_gen_charge);
   fChain->SetBranchAddress("gen_pdgId", &gen_pdgId, &b_gen_pdgId);
   fChain->SetBranchAddress("gen_vx", &gen_vx, &b_gen_vx);
   fChain->SetBranchAddress("gen_vy", &gen_vy, &b_gen_vy);
   fChain->SetBranchAddress("gen_vz", &gen_vz, &b_gen_vz);
   fChain->SetBranchAddress("gen_status", &gen_status, &b_gen_status);
   fChain->SetBranchAddress("gen_mother", &gen_mother, &b_gen_mother);
   fChain->SetBranchAddress("gen_isTauDecayProduct", &gen_isTauDecayProduct, &b_gen_isTauDecayProduct);
   fChain->SetBranchAddress("gen_isDirectHadronDecayProduct", &gen_isDirectHadronDecayProduct, &b_gen_isDirectHadronDecayProduct);
   fChain->SetBranchAddress("gen_isPrompt", &gen_isPrompt, &b_gen_isPrompt);
   fChain->SetBranchAddress("simvtx_event", &simvtx_event, &b_simvtx_event);
   fChain->SetBranchAddress("simvtx_bunchCrossing", &simvtx_bunchCrossing, &b_simvtx_bunchCrossing);
   fChain->SetBranchAddress("simvtx_processType", &simvtx_processType, &b_simvtx_processType);
   fChain->SetBranchAddress("simvtx_x", &simvtx_x, &b_simvtx_x);
   fChain->SetBranchAddress("simvtx_y", &simvtx_y, &b_simvtx_y);
   fChain->SetBranchAddress("simvtx_z", &simvtx_z, &b_simvtx_z);
   fChain->SetBranchAddress("simvtx_sourceSimIdx", &simvtx_sourceSimIdx, &b_simvtx_sourceSimIdx);
   fChain->SetBranchAddress("simvtx_daughterSimIdx", &simvtx_daughterSimIdx, &b_simvtx_daughterSimIdx);
   fChain->SetBranchAddress("simpv_idx", &simpv_idx, &b_simpv_idx);
   Notify();
}

Bool_t TrackingNtuple::Notify()
{
   // The Notify() function is called when a new file is opened. This
   // can be either for a new TTree in a TChain or when when a new TTree
   // is started when using PROOF. It is normally not necessary to make changes
   // to the generated code, but the routine can be extended by the
   // user if needed. The return value is currently not used.

   return kTRUE;
}

void TrackingNtuple::Show(Long64_t entry)
{
// Print contents of entry.
// If entry is not specified, print current entry
   if (!fChain) return;
   fChain->Show(entry);
}
Int_t TrackingNtuple::Cut(Long64_t entry)
{
// This function may be called from Loop.
// returns  1 if entry is accepted.
// returns -1 otherwise.
   return 1;
}
#endif // #ifdef TrackingNtuple_h