#include "TBranch.h"
#include "TTree.h"
#include "TClonesArray.h"

    // used to flag MC particles
    const int isfinalparton = 1;
    const int isintermediateparton = 2;
    const int isonprimary = 4;
    const int isprompt = 8;
    const int isstable = 16;

    void SetLeafDAddress(TBranch *branch, const char *leafname, double &var);

    void SetLeafFAddress(TBranch *branch, const char *leafname, float &var);

    void SetLeafIAddress(TBranch *branch, const char *leafname, int &var);

    void SetLeaves(TTree *_ttree);
    //Solely for stripping... need this in ROOT 4 or later
    void SetCloneLeaves(TTree *_ttree);


    typedef struct {
      Int_t ntracks;
      Float_t pt[250];
      Float_t phi[250];
      Float_t eta[250];
      Float_t r0[250]; //w.r.t closest vertex
      Float_t z0[250]; //w.r.t closest vertex
      Float_t dca0[250]; //w.r.t pvsel0
      Float_t dca1[250]; //w.r.t pvsel0

      // parameters added for b-tagging pourposes
      Float_t dca0err[250]; //w.r.t pvsel0
      Float_t dca1err[250]; //w.r.t pvsel0
      Float_t chi2[250]; // chisq of the track
      Int_t hmaskw1[250]; //
      Int_t hmaskw2[250]; //  for C.S.I.P.
      Int_t hmaskw3[250]; //


      // 5 track parameters of d0
      Float_t rca[250]; // the traditional dca w.r.t 0,0
      Float_t zca[250]; // the traditional dca w.r.t 0,0
      Float_t phidir[250]; // the traditional dca w.r.t 0,0
      Float_t tanl[250]; // the traditional dca w.r.t 0,0
      Float_t qpt[250]; // the traditional dca w.r.t 0,0

      // covariance
      Float_t drr[250];
      Float_t dzz[250];
      Float_t dpp[250];
      Float_t dtt[250];
      Float_t dqq[250];

      Float_t drp[250];
      Float_t drq[250];
      Float_t dzt[250];
      Float_t dpq[250];

      Int_t smt[250];
      Int_t cft[250];
      Int_t idx[250];
      Int_t vidx[250];

      // energy flow stuff
//       Int_t iso[250];
//       Float_t isoe[250];
//       Float_t isoen[250];
//       Float_t e33[250];
//       Float_t e33em[250];
//       Float_t e33ch[250];
//       Float_t e55[250];
//       Float_t e55em[250];
//       Float_t e55ch[250];
//       Int_t mtc_map[250];
//       Float_t mtc_e[250];
//       Float_t mtc_em1[250];
//       Float_t mtc_em2[250];
//       Float_t mtc_em3[250];
//       Float_t mtc_em4[250];
//       Float_t mtc_fh1[250];
//       Float_t mtc_fh2[250];
//       Float_t mtc_fh3[250];
//       Float_t mtc_fh4[250];
//       Float_t mtc_ch1[250];
//       Float_t mtc_ch2[250];
//       Float_t mtc_ch3[250];
//       Float_t mtc_mgcc[250];
//       Float_t mtc_mgec[250];
//       Float_t mtc_icd[250];
    } TRACKS;

    
    typedef struct {
      Int_t njets;
      Float_t E[100];
      Float_t pt[100];
      Float_t px[100];
      Float_t py[100];
      Float_t pz[100];
      Float_t corr[100];
      Float_t correrr[100];
      Float_t eta[100];
      Float_t phi[100];
      Float_t deta[100];
      Float_t dphi[100];
      Float_t emf[100];
      Float_t chf[100];
      Float_t hotf[100];
      Float_t etawidth[100];
      Float_t phiwidth[100];
      Int_t n90[100];
      Int_t nitm[100];
      Float_t EM1F[100];
      Float_t EM2F[100];
      Float_t EM3F[100];
      Float_t FH1F[100];
      Float_t FH2F[100];
      Float_t FH3F[100];
      Float_t METcorr[100];
      Float_t mcMETcorr[100];
      Float_t ScalarET[100];
      Int_t goodjet[100];
      Int_t elenot[100];
      Int_t L1Confirm[100];
      Float_t l1set[100];
      Float_t l1ratio[100];
      Int_t   taggable[100]; // 0 not taggable 1 taggable -1 taggability not run
      Int_t   svx[100]; // 0 not tagged.. otherwise assocation with svtx array index is made through bits.. i.e. bit 0 -> svtx[0]
      Int_t jlip_tag[100];
      Float_t jlip_prob[100];
      Int_t mu_tag[100];
      Int_t sv_tag[100];
    } JETS;


    typedef struct {
      Int_t nem;
      Float_t E[100];
      Float_t pt[100];
      Float_t px[100];
      Float_t py[100];
      Float_t pz[100];
      Float_t eta[100];
      Float_t phi[100];
      Float_t emf[100];
      Float_t iso[100];
      Float_t chi7[100];
      Float_t chi8[100];
      Float_t q[100];
      Float_t tmass[100];
      Int_t trkidx[100];
      Int_t trkflag[100];
      Int_t fiduflag[100];
      Int_t phifiduflag[100];
      Int_t etafiduflag[100];
      Float_t deteta[100];
      Float_t detphi[100];
      Float_t chi2prob[100];
      Float_t PSfloorY[100];
      Float_t PSfloorZ[100];
      Float_t PSfloorE[100];
      Float_t PSflrS1[100]; //flrS1 is the shower width in Phi
      Float_t PSflrS2[100]; //flrS2 is the shower width in Z
      Float_t EM1floorY[100];
      Float_t EM1floorZ[100];
      Float_t EM1floorE[100];
      Float_t EM1flrS1[100];
      Float_t EM1flrS2[100];
      Float_t EM2floorY[100];
      Float_t EM2floorZ[100];
      Float_t EM2floorE[100];
      Float_t EM2flrS1[100];
      Float_t EM2flrS2[100];
      Float_t EM3floorY[100];
      Float_t EM3floorZ[100];
      Float_t EM3floorE[100];
      Float_t EM3flrS1[100];
      Float_t EM3flrS2[100];
      Float_t EM4floorY[100];
      Float_t EM4floorZ[100];
      Float_t EM4floorE[100];
      Float_t EM4flrS1[100];
      Float_t EM4flrS2[100];
      Float_t FHfloorY[100];
      Float_t FHfloorZ[100];
      Float_t FHfloorE[100];
      Float_t FHflrS1[100];
      Float_t FHflrS2[100];
      Float_t flrS1[100];
      Float_t flrS2[100];
      Int_t goodele[100];
      Float_t llhood[100];    // em likelihood
      Float_t cpsllhood[100]; // CPS likelihood
    } EM;

    typedef struct {
      Int_t nmu;
      Float_t E[100];
      Float_t pt[100];
      Float_t eta[100];
      Float_t phi[100];
      Int_t nseg[100];
      Int_t awhit[100];
      Int_t bcwhit[100];
      Int_t ashit[100];
      Int_t bcshit[100];
      Float_t sctimeA[100];
      Float_t sctimeB[100];
      Float_t sctimeC[100];
      Float_t chi[100];
      Float_t locchi[100];
      Float_t locpt[100];
      Float_t q[100];
      Float_t tmass[100];
      Int_t trkidx[100];
      Int_t ntrkmatch[100];
      Int_t qual[100];
      //isolation
      Float_t e33[100];
      Float_t e55[100];
      Float_t econe1[100];
      Float_t econe15[100];
      Float_t econe2[100];
      Float_t econe4[100];
      Float_t econe6[100];
      Int_t ntrk5[100];
      Float_t ettrk5[100];
      Float_t ethalo[100];
    } MU;

    typedef struct {
      Float_t MET;
      Float_t corrMET;
      Float_t SET;
      Float_t phi;
      Float_t METx;
      Float_t METy;
      Float_t corrMETx;
      Float_t corrMETy;
      Float_t corrphi;
      Float_t calMET;
      Float_t calMETx;
      Float_t calMETy;
      Float_t eleMETx;
      Float_t eleMETy;
      Float_t muoMETx;
      Float_t muoMETy;
      Float_t muoMET;
      Float_t muophi;
    } MET;

    // general MC info
    typedef struct {
        Float_t weight;
        Float_t cross;
        Float_t q2;
        Float_t shat;
        Float_t that;
        Float_t uhat;
    } MCINFO;

    // mc vertex
    typedef struct {
        Int_t   nv;
        Float_t vx[500];
        Float_t vy[500];
        Float_t vz[500];
        Float_t vct[500];
        Int_t vidx[500];
    } MCVTX;

    // MC Particles
    typedef struct {
        Int_t   nptl;
        Float_t px[2000];
        Float_t py[2000];
        Float_t pz[2000];
        Float_t E[2000];
        Int_t pdgid[2000];
        Int_t pidx[2000];
        Int_t parent[2000];
        Int_t status[2000];
        Int_t pvidx[2000];
    } MCPTL;


    typedef struct {
        int nv;
        int nvtrk[100];
        float x[100];
        float y[100];
        float z[100];
        float sumpt[100];
        float avept[100];
        float sumlogpt[100];
        int vtype[100];
    } VERTEX;

    typedef struct {
        int nv;
        int nvtrk[100];
        float x[100];
        float y[100];
        float z[100];
        float covxx[100];
        float covyy[100];
        float covzz[100];
        float covxy[100];
        float covxz[100];
        float covyz[100];
        int vtype[100];
    } PRIMARYVERTEX;

    typedef struct {
        int nv;
        int nvtrk[100];
        float x[100];
        float y[100];
        float z[100];
        float px[100];
        float py[100];
        float pz[100];
        // position covariance
        float covxx[100];
        float covyy[100];
        float covzz[100];
        float covxy[100];
        float covxz[100];
        float covyz[100];
        // momentum covariance
        float covpxx[100];
        float covpyy[100];
        float covpzz[100];
        float covpxy[100];
        float covpxz[100];
        float covpyz[100];
        float mass[100];
        // 2d signed decay length significance
        float dlsig2d[100];
        // 3d signed decay length significance
        float dlsig3d[100];
        // cos opening angle between vertex momentum and pv->sv direction
        float opening[100];
        int vtype[100];
    } SECONDARYVERTEX;

    typedef struct {
        int ndiemcand;
        float diemmass[100];
        float diemtrkmass[100];
        int em1idx[100];
        int em2idx[100];
    } DIEM;
        
    typedef struct {
        int ndimucand;
        float dimumass[100];
        int mu1idx[100];
        int mu2idx[100];
    } DIMU;
        
    typedef struct {
        int prescales[256];
        float l1cal_gbl_em;
        float l1cal_gbl_tot;
        float l1cal_gbl_misspt;
        int l1cal_tot_ntower;
        float l1cal_tot_pt[1280];
        float l1cal_tot_eta[1280];
        float l1cal_tot_phi[1280];
        // number of EM towers .. depends on trigger 
        int l1cal_em_ntower;
        float l1cal_em_pt[1280];
        float l1cal_em_eta[1280];
        float l1cal_em_phi[1280];
        // L1 muo
        int l1muo_cen_id[5];
        int l1muo_n_id[5];
        int l1muo_s_id[5];
        int l1muo_c_trig_oct;
        int l1muo_n_trig_oct;
        int l1muo_s_trig_oct;
        int l1muo_trigs[160];
    } L1;

    typedef struct {
        int l2jet_n;
        float l2jet_et[100];
        int l2jet_ieta[100];
        int l2jet_iphi[100];
        float l2jet_eta[100];
        float l2jet_phi[100];

        int l2em_n;
        float l2em_et[100];
        int l2em_ieta[100];
        int l2em_iphi[100];
        float l2em_eta[100];
        float l2em_phi[100];
        float l2em_emfr[100];
        float l2em_isol[100];

        int l2muo_n;
        float l2muo_et[20];
        float l2muo_eta[20];
        float l2muo_phi[20];
    } L2;

    typedef struct {
        // L3 phys results
        // ELE
        int   l3ele_n;
        float l3ele_et[100];
        float l3ele_eta[100];
        float l3ele_deta[100];
        float l3ele_phi[100];
        float l3ele_emfr[100];
        float l3ele_chi2[100];
        float l3ele_isol[100];
        float l3ele_em1width[100];
        float l3ele_em2width[100];
        float l3ele_em3width[100];
        int   l3ele_cpsmatch[100];
        int   l3ele_trackmatch[100];
        float l3ele_eoverp[100];
        float l3ele_caltrackdphi[100];
        float l3ele_cpstrackdphi[100];
        float l3ele_vertexz[100];

        // Track
        int   l3trk_n;
        float l3trk_pt[100];
        float l3trk_tanl[100];
        float l3trk_phi[100];
        float l3trk_z[100];

        // JET
        int l3jet_n;
        float l3jet_et[100];
        float l3jet_eta[100];
        float l3jet_phi[100];
        float l3jet_px[100];
        float l3jet_py[100];
        float l3jet_pz[100];
        float l3jet_emfr[100];
        float l3jet_chfr[100];
        float l3jet_hotfr[100];

        // MET and HT
        float l3met;
        float l3mht;
        float l3ht;

        // Muon
        //
        int l3muo_n;
        float l3muo_pt[100];
        float l3muo_trkpt[100];
        float l3muo_deta[100];
        float l3muo_eta[100];
        float l3muo_phi[100];
        int   l3muo_octant[100];
        int   l3muo_region[100];
        int   l3muo_qual[100];
        float l3muo_mtcetrack[100];
        float l3muo_mtchfrac[100];
        // L3 event btag
        float l3btag; // ranges from 0 to 1 .. easy

        float l3pvx;
        float l3pvy;
        float l3pvz;

    } L3;

    extern TClonesArray *trignames;
    extern TClonesArray *l1names;
    extern TClonesArray *l2names;
    extern TClonesArray *l3eletoolnames;
    extern TClonesArray *l3jettoolnames;

    extern L1 l1;
    extern L2 l2;
    extern L3 l3;
    extern TRACKS tracks;
    extern JETS jets1;
    extern JETS jets2;
    extern JETS jets3;
    extern EM ems;
    extern MU mus;
    extern MET metstruct;
    extern MCINFO mcinfo;
    extern MCVTX mcvtx;
    extern MCPTL mcptl;
    extern PRIMARYVERTEX pvstruct;
    extern SECONDARYVERTEX svstruct;
    extern DIEM diemstruct; 
    extern DIMU dimustruct; 
    extern int eventNum;
    extern int runNum;
    extern int solpol;
    extern int torpol; 
    extern int lbnblock; // luminosity block number
    extern int tick; // tick number
    extern int emptycrate;
    extern int coherentnoise;
    extern int noonnoise;
    extern int ringoffire;