////////////////////////////////////////////////////////// // This class has been automatically generated on // updated 13.02.2018 by ROOT version 5.32/00 // from TTree FourMuon_Data/FourMuon Data // found on file: FourMuon_2016_ntuple.root ////////////////////////////////////////////////////////// #ifndef MyFourMuonAnalyzer_h #define MyFourMuonAnalyzer_h #include #include #include #include #include #include #include #include #include #include #include "TPoint.h" #include #include #include #include // Fixed size dimensions of array or collections stored in the TTree if any. using namespace std; class MyFourMuonAnalyzer { public : TTree *fChain; //!pointer to the analyzed TTree or TChain Int_t fCurrent; //!current Tree number in a TChain //TFile *oFile1; //TFile *oFile2; /// Histograms //TH1F* myFourMuonMass; //TH1F* myFourMuonMass_passTrigCut; //TH1F* myFourMuonMass_passVtxCut; //TH1F* myFourMuonMass_passPtCut; //TH1F* myFourMuonMass_passEtaCut; //TH1F* myFourMuonMass_passTrigMatchCut; //TH1F* myFourMuonMass_With1Ups; //TH1F* myFourMuonMass_remLowMes; ////////////////////////////// // Declaration of leaf types vector *TrigRes; vector *TrigNames; vector *MatchUpsTriggerNames; vector *L1TrigRes; UInt_t evtNum; UInt_t runNum; UInt_t lumiNum; Float_t priVtxX; Float_t priVtxY; Float_t priVtxZ; Float_t priVtxXE; Float_t priVtxYE; Float_t priVtxZE; Float_t priVtxChiNorm; Float_t priVtxChi; Float_t priVtxCL; vector *PriVtxXCorrX; vector *PriVtxXCorrY; vector *PriVtxXCorrZ; vector *PriVtxXCorrEX; vector *PriVtxXCorrEY; vector *PriVtxXCorrEZ; vector *PriVtxXCorrC2; vector *PriVtxXCorrCL; UInt_t nMu; vector *muPt; vector *muEta; vector *muPx; vector *muPy; vector *muPz; vector *muD0; vector *muD0E; vector *muDz; vector *muChi2; vector *muGlChi2; vector *mufHits; // vector *muFirstBarrel; //vector *muFirstEndCap; vector *muDzVtx; vector *muDxyVtx; vector *muNDF; vector *muGlNDF; vector *muPhits; vector *muShits; vector *muGlMuHits; vector *muType; vector *muQual; vector *muTrack; vector *muCharge; vector *munMatchedSeg; //new muon Ids for RunII 2016 Data vector *muIsGoodSoftMuon; vector *muIsGoodStandMediumMuon; vector *muIsGoodMediumMuon; // vector *muIsGoodTightMuon; UInt_t nMyFourMuon; vector *MyFourMuonMass; vector *MyFourMuonMassErr; vector *MyFourMuonCTau; vector *MyFourMuonCTauErr; vector *MyMu1TrigMatchVtxSD; vector *MyMu2TrigMatchVtxSD; vector *MyMu3TrigMatchVtxSD; vector *MyMu4TrigMatchVtxSD; //vector *MyMu1TrigMatchL3FilterSD; //vector *MyMu2TrigMatchL3FilterSD; //vector *MyMu3TrigMatchL3FilterSD; //vector *MyMu4TrigMatchL3FilterSD; vector *My1234MuPMuMDisXY; vector *My1324MuPMuMDisXY; vector *My1423MuPMuMDisXY; vector *My1234MuPMuMDisZ; vector *My1324MuPMuMDisZ; vector *My1423MuPMuMDisZ; vector *MyMuPMuM1CTau_Mu12; vector *MyMuPMuM1CTauErr_Mu12; vector *MyMuPMuM1ChiProb_Mu12; vector *MyMuPMuM2CTau_Mu34; vector *MyMuPMuM2CTauErr_Mu34; vector *MyMuPMuM2ChiProb_Mu34; vector *MyMuPMuM3CTau_Mu13; vector *MyMuPMuM3CTauErr_Mu13; vector *MyMuPMuM3ChiProb_Mu13; vector *MyMuPMuM4CTau_Mu24; vector *MyMuPMuM4CTauErr_Mu24; vector *MyMuPMuM4ChiProb_Mu24; vector *MyMuPMuM5CTau_Mu14; vector *MyMuPMuM5CTauErr_Mu14; vector *MyMuPMuM5ChiProb_Mu14; vector *MyMuPMuM6CTau_Mu23; vector *MyMuPMuM6CTauErr_Mu23; vector *MyMuPMuM6ChiProb_Mu23; vector *MyMuPMuM1Mass_Mu12; vector *MyMuPMuM1MassErr_Mu12; vector *MyMuPMuM2Mass_Mu34; vector *MyMuPMuM2MassErr_Mu34; vector *MyMuPMuM3Mass_Mu13; vector *MyMuPMuM3MassErr_Mu13; vector *MyMuPMuM4Mass_Mu24; vector *MyMuPMuM4MassErr_Mu24; vector *MyMuPMuM5Mass_Mu14; vector *MyMuPMuM5MassErr_Mu14; vector *MyMuPMuM6Mass_Mu23; vector *MyMuPMuM6MassErr_Mu23; vector *MyFourMuonSharedSeg12; vector *MyFourMuonSharedSeg13; vector *MyFourMuonSharedSeg14; vector *MyFourMuonSharedSeg23; vector *MyFourMuonSharedSeg24; vector *MyFourMuonSharedSeg34; vector *MyFourMuonVtxCL; vector *MyFourMuonVtxC2; vector *MyFourMuonPx; vector *MyFourMuonPy; vector *MyFourMuonPz; vector *MyFourMuonDecayVtxX; vector *MyFourMuonDecayVtxY; vector *MyFourMuonDecayVtxZ; vector *MyFourMuonDecayVtxXE; vector *MyFourMuonDecayVtxYE; vector *MyFourMuonDecayVtxZE; vector *MyFourMuonMu1Idx; vector *MyFourMuonMu2Idx; vector *MyFourMuonMu2Px; vector *MyFourMuonMu2Py; vector *MyFourMuonMu2Pz; vector *MyFourMuonMu1Px; vector *MyFourMuonMu1Py; vector *MyFourMuonMu1Pz; vector *MyFourMuonMu2fChi2; vector *MyFourMuonMu2fNDF; vector *MyFourMuonMu1fChi2; vector *MyFourMuonMu1fNDF; vector *MyFourMuoncosAlpha; vector *MyFourMuonFLSig; vector *MyFourMuonrVtxMag2D; vector *MyFourMuonsigmaRvtxMag2D; vector *MyFourMuonTrkIsoOverFourMuSumpt; vector *MyFourMuonTrkIsoOverFourMuVectpt; vector *MyFourMuonMu3fNDF; vector *MyFourMuonMu3Idx; vector *MyFourMuonMu3Px; vector *MyFourMuonMu3Py; vector *MyFourMuonMu3Pz; vector *MyFourMuonMu3fChi2; vector *MyFourMuonMu4fNDF; vector *MyFourMuonMu4Idx; vector *MyFourMuonMu4Px; vector *MyFourMuonMu4Py; vector *MyFourMuonMu4Pz; vector *MyFourMuonMu4fChi2; // List of branches TBranch *b_TrigRes; //! TBranch *b_TrigNames; //! TBranch *b_MatchUpsTriggerNames; //! TBranch *b_L1TrigRes; //! TBranch *b_evtNum; //! TBranch *b_runNum; //! TBranch *b_lumiNum; //! TBranch *b_priVtxX; //! TBranch *b_priVtxY; //! TBranch *b_priVtxZ; //! TBranch *b_priVtxXE; //! TBranch *b_priVtxYE; //! TBranch *b_priVtxZE; //! TBranch *b_priVtxChiNorm; //! TBranch *b_priVtxChi; //! TBranch *b_priVtxCL; //! TBranch *b_PriVtxXCorrX; //! TBranch *b_PriVtxXCorrY; //! TBranch *b_PriVtxXCorrZ; //! TBranch *b_PriVtxXCorrEX; //! TBranch *b_PriVtxXCorrEY; //! TBranch *b_PriVtxXCorrEZ; //! TBranch *b_PriVtxXCorrC2; //! TBranch *b_PriVtxXCorrCL; //! TBranch *b_nMu; //! TBranch *b_muPt; //! TBranch *b_muEta; //! TBranch *b_muPx; //! TBranch *b_muPy; //! TBranch *b_muPz; //! TBranch *b_muD0; //! TBranch *b_muD0E; //! TBranch *b_muDz; //! TBranch *b_muChi2; //! TBranch *b_muGlChi2; //! TBranch *b_mufHits; //! //TBranch *b_muFirstBarrel; //! // TBranch *b_muFirstEndCap; //! TBranch *b_muDzVtx; //! TBranch *b_muDxyVtx; //! TBranch *b_muNDF; //! TBranch *b_muGlNDF; //! TBranch *b_muPhits; //! TBranch *b_muShits; //! TBranch *b_muGlMuHits; //! TBranch *b_muType; //! TBranch *b_muQual; //! TBranch *b_muTrack; //! TBranch *b_muCharge; //! TBranch *b_munMatchedSeg; //! TBranch *b_muIsGoodSoftMuon; //! TBranch *b_muIsGoodMediumMuon; //! TBranch *b_muIsGoodStandMediumMuon; //! TBranch *b_nMyFourMuon; //! TBranch *b_MyFourMuonMass; //! TBranch *b_MyFourMuonMassErr; //! TBranch *b_MyFourMuonCTau; //! TBranch *b_MyFourMuonCTauErr; //! TBranch *b_MyMu1TrigMatchVtxSD; //! TBranch *b_MyMu2TrigMatchVtxSD; //! TBranch *b_MyMu3TrigMatchVtxSD; //! TBranch *b_MyMu4TrigMatchVtxSD; //! // TBranch *b_MyMu1TrigMatchL3FilterSD; //! // TBranch *b_MyMu2TrigMatchL3FilterSD; //! //TBranch *b_MyMu3TrigMatchL3FilterSD; //! //TBranch *b_MyMu4TrigMatchL3FilterSD; //! TBranch *b_My1234MuPMuMDisXY; //! TBranch *b_My1324MuPMuMDisXY; //! TBranch *b_My1423MuPMuMDisXY; //! TBranch *b_My1234MuPMuMDisZ; //! TBranch *b_My1324MuPMuMDisZ; //! TBranch *b_My1423MuPMuMDisZ; //! TBranch *b_MyMuPMuM1CTau_Mu12; //! TBranch *b_MyMuPMuM1CTauErr_Mu12; //! TBranch *b_MyMuPMuM1ChiProb_Mu12; //! TBranch *b_MyMuPMuM2CTau_Mu34; //! TBranch *b_MyMuPMuM2CTauErr_Mu34; //! TBranch *b_MyMuPMuM2ChiProb_Mu34; //! TBranch *b_MyMuPMuM3CTau_Mu13; //! TBranch *b_MyMuPMuM3CTauErr_Mu13; //! TBranch *b_MyMuPMuM3ChiProb_Mu13; //! TBranch *b_MyMuPMuM4CTau_Mu24; //! TBranch *b_MyMuPMuM4CTauErr_Mu24; //! TBranch *b_MyMuPMuM4ChiProb_Mu24; //! TBranch *b_MyMuPMuM5CTau_Mu14; //! TBranch *b_MyMuPMuM5CTauErr_Mu14; //! TBranch *b_MyMuPMuM5ChiProb_Mu14; //! TBranch *b_MyMuPMuM6CTau_Mu23; //! TBranch *b_MyMuPMuM6CTauErr_Mu23; //! TBranch *b_MyMuPMuM6ChiProb_Mu23; //! TBranch *b_MyMuPMuM1Mass_Mu12; //! TBranch *b_MyMuPMuM1MassErr_Mu12; //! TBranch *b_MyMuPMuM2Mass_Mu34; //! TBranch *b_MyMuPMuM2MassErr_Mu34; //! TBranch *b_MyMuPMuM3Mass_Mu13; //! TBranch *b_MyMuPMuM3MassErr_Mu13; //! TBranch *b_MyMuPMuM4Mass_Mu24; //! TBranch *b_MyMuPMuM4MassErr_Mu24; //! TBranch *b_MyMuPMuM5Mass_Mu14; //! TBranch *b_MyMuPMuM5MassErr_Mu14; //! TBranch *b_MyMuPMuM6Mass_Mu23; //! TBranch *b_MyMuPMuM6MassErr_Mu23; //! TBranch *b_MyFourMuonSharedSeg12; //! TBranch *b_MyFourMuonSharedSeg13; //! TBranch *b_MyFourMuonSharedSeg14; //! TBranch *b_MyFourMuonSharedSeg23; //! TBranch *b_MyFourMuonSharedSeg24; //! TBranch *b_MyFourMuonSharedSeg34; //! TBranch *b_MyFourMuonVtxCL; //! TBranch *b_MyFourMuonVtxC2; //! TBranch *b_MyFourMuonPx; //! TBranch *b_MyFourMuonPy; //! TBranch *b_MyFourMuonPz; //! TBranch *b_MyFourMuonDecayVtxX; //! TBranch *b_MyFourMuonDecayVtxY; //! TBranch *b_MyFourMuonDecayVtxZ; //! TBranch *b_MyFourMuonDecayVtxXE; //! TBranch *b_MyFourMuonDecayVtxYE; //! TBranch *b_MyFourMuonDecayVtxZE; //! TBranch *b_MyFourMuonMu1Idx; //! TBranch *b_MyFourMuonMu2Idx; //! TBranch *b_MyFourMuonMu2Px; //! TBranch *b_MyFourMuonMu2Py; //! TBranch *b_MyFourMuonMu2Pz; //! TBranch *b_MyFourMuonMu1Px; //! TBranch *b_MyFourMuonMu1Py; //! TBranch *b_MyFourMuonMu1Pz; //! TBranch *b_MyFourMuonMu2fChi2; //! TBranch *b_MyFourMuonMu2fNDF; //! TBranch *b_MyFourMuonMu1fChi2; //! TBranch *b_MyFourMuonMu1fNDF; //! TBranch *b_MyFourMuoncosAlpha; //! TBranch *b_MyFourMuonFLSig; //! TBranch *b_MyFourMuonrVtxMag2D; //! TBranch *b_MyFourMuonsigmaRvtxMag2D; //! TBranch *b_MyFourMuonTrkIsoOverFourMuSumpt; //! TBranch *b_MyFourMuonTrkIsoOverFourMuVectpt; //! TBranch *b_MyFourMuonMu3fNDF; //! TBranch *b_MyFourMuonMu3Idx; //! TBranch *b_MyFourMuonMu3Px; //! TBranch *b_MyFourMuonMu3Py; //! TBranch *b_MyFourMuonMu3Pz; //! TBranch *b_MyFourMuonMu3fChi2; //! TBranch *b_MyFourMuonMu4fNDF; //! TBranch *b_MyFourMuonMu4Idx; //! TBranch *b_MyFourMuonMu4Px; //! TBranch *b_MyFourMuonMu4Py; //! TBranch *b_MyFourMuonMu4Pz; //! TBranch *b_MyFourMuonMu4fChi2; //! //MyFourMuonAnalyzer(TTree *tree=0); MyFourMuonAnalyzer(const TString &inputFileList="input.txt",const char *outTxtName1 = "output1.txt", const char *outTxtName2 = "output2.txt" ,const char *outTxtName3 = "output3.txt", const char *outTxtName4 = "output4.txt",const char *outTxtName5 = "output5.txt", const char *outTxtName6 = "output6.txt",const char *outTxtName7 = "output7.txt", const char *outTxtName8 = "output8.txt",const char *outTxtName9 = "output9.txt", const char *outTxtName10= "output10.txt", const char *outTxtName11= "output11.txt", const char *outTxtName12= "output12.txt", const char *outTxtName13= "output13.txt", const char *outTxtName14= "output14.txt", const char *outTxtName15= "output15.txt"); virtual ~MyFourMuonAnalyzer(); // void BookHistogram(const char *, const char *); virtual Int_t Cut(Long64_t entry); virtual Int_t GetEntry(Long64_t entry); virtual Long64_t LoadTree(Long64_t entry); virtual void Init(TChain *tree); virtual void Loop(const char *, const char *,const char *, const char *,const char *, const char *,const char *, const char *,const char *, const char *, const char *,const char *, const char *,const char *, const char * ); virtual Bool_t Notify(); virtual void Show(Long64_t entry = -1); Bool_t FillChain(TChain *chain, const TString &inputFileList); }; #endif #ifdef MyFourMuonAnalyzer_cxx //MyFourMuonAnalyzer::MyFourMuonAnalyzer(TTree *tree) : fChain(0) MyFourMuonAnalyzer::MyFourMuonAnalyzer(const TString &inputFileList, const char *outTxtName1, const char *outTxtName2,const char *outTxtName3, const char *outTxtName4, const char *outTxtName5, const char *outTxtName6, const char *outTxtName7, const char *outTxtName8,const char *outTxtName9, const char *outTxtName10,const char *outTxtName11, const char *outTxtName12, const char *outTxtName13, const char *outTxtName14, const char *outTxtName15 ) { // if parameter tree is not specified (or zero), connect the file // used to generate this class and read the Tree. //BookHistogram(outFileName1,outFileName2); TChain *tree = new TChain("/mkcands/FourMuon_Data"); if( ! FillChain(tree, inputFileList) ) { //std::cerr << "Cannot get the tree " << std::endl; } Init(tree); } MyFourMuonAnalyzer::~MyFourMuonAnalyzer() { if (!fChain) return; delete fChain->GetCurrentFile(); } Int_t MyFourMuonAnalyzer::GetEntry(Long64_t entry) { // Read contents of entry. if (!fChain) return 0; return fChain->GetEntry(entry); } Long64_t MyFourMuonAnalyzer::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; } Bool_t MyFourMuonAnalyzer::FillChain(TChain *chain, const TString &inputFileList) { ifstream infile(inputFileList); std::string buffer; if(!infile.is_open()) { //std::cerr << "** ERROR: Can't open '" << inputFileList << "' for input" << std::endl; return kFALSE; } //std::cout << "TreeUtilities : FillChain " << std::endl; while(1) { infile >> buffer; if(!infile.good()) break; //std::cout << "Adding tree from " << buffer.c_str() << std::endl; chain->Add(buffer.c_str()); } //std::cout << "No. of Entries in this tree : " << chain->GetEntries() << std::endl; return kTRUE; } void MyFourMuonAnalyzer::Init(TChain *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 TrigRes = 0; TrigNames = 0; MatchUpsTriggerNames = 0; L1TrigRes = 0; PriVtxXCorrX = 0; PriVtxXCorrY = 0; PriVtxXCorrZ = 0; PriVtxXCorrEX = 0; PriVtxXCorrEY = 0; PriVtxXCorrEZ = 0; PriVtxXCorrC2 = 0; PriVtxXCorrCL = 0; muPt = 0; muEta = 0; muPx = 0; muPy = 0; muPz = 0; muD0 = 0; muD0E = 0; muDz = 0; muChi2 = 0; muGlChi2 = 0; mufHits = 0; //muFirstBarrel = 0; // muFirstEndCap = 0; muDzVtx = 0; muDxyVtx = 0; muNDF = 0; muGlNDF = 0; muPhits = 0; muShits = 0; muGlMuHits = 0; muType = 0; muQual = 0; muTrack = 0; muCharge = 0; munMatchedSeg = 0; muIsGoodSoftMuon = 0; muIsGoodStandMediumMuon= 0; muIsGoodMediumMuon=0; MyFourMuonMass = 0; MyFourMuonMassErr = 0; MyFourMuonCTau = 0; MyFourMuonCTauErr = 0; MyMu1TrigMatchVtxSD = 0; MyMu2TrigMatchVtxSD = 0; MyMu3TrigMatchVtxSD = 0; MyMu4TrigMatchVtxSD = 0; //MyMu1TrigMatchL3FilterSD = 0; // MyMu2TrigMatchL3FilterSD = 0; //MyMu3TrigMatchL3FilterSD = 0; //MyMu4TrigMatchL3FilterSD = 0; My1234MuPMuMDisXY = 0; My1324MuPMuMDisXY = 0; My1423MuPMuMDisXY = 0; My1234MuPMuMDisZ = 0; My1324MuPMuMDisZ = 0; My1423MuPMuMDisZ = 0; MyMuPMuM1CTau_Mu12 = 0; MyMuPMuM1CTauErr_Mu12 = 0; MyMuPMuM1ChiProb_Mu12 = 0; MyMuPMuM2CTau_Mu34 = 0; MyMuPMuM2CTauErr_Mu34 = 0; MyMuPMuM2ChiProb_Mu34 = 0; MyMuPMuM3CTau_Mu13 = 0; MyMuPMuM3CTauErr_Mu13 = 0; MyMuPMuM3ChiProb_Mu13 = 0; MyMuPMuM4CTau_Mu24 = 0; MyMuPMuM4CTauErr_Mu24 = 0; MyMuPMuM4ChiProb_Mu24 = 0; MyMuPMuM5CTau_Mu14 = 0; MyMuPMuM5CTauErr_Mu14 = 0; MyMuPMuM5ChiProb_Mu14 = 0; MyMuPMuM6CTau_Mu23 = 0; MyMuPMuM6CTauErr_Mu23 = 0; MyMuPMuM6ChiProb_Mu23 = 0; MyMuPMuM1Mass_Mu12 = 0; MyMuPMuM1MassErr_Mu12 = 0; MyMuPMuM2Mass_Mu34 = 0; MyMuPMuM2MassErr_Mu34 = 0; MyMuPMuM3Mass_Mu13 = 0; MyMuPMuM3MassErr_Mu13 = 0; MyMuPMuM4Mass_Mu24 = 0; MyMuPMuM4MassErr_Mu24 = 0; MyMuPMuM5Mass_Mu14 = 0; MyMuPMuM5MassErr_Mu14 = 0; MyMuPMuM6Mass_Mu23 = 0; MyMuPMuM6MassErr_Mu23 = 0; MyFourMuonSharedSeg12 = 0; MyFourMuonSharedSeg13 = 0; MyFourMuonSharedSeg14 = 0; MyFourMuonSharedSeg23 = 0; MyFourMuonSharedSeg24 = 0; MyFourMuonSharedSeg34 = 0; MyFourMuonVtxCL = 0; MyFourMuonVtxC2 = 0; MyFourMuonPx = 0; MyFourMuonPy = 0; MyFourMuonPz = 0; MyFourMuonDecayVtxX = 0; MyFourMuonDecayVtxY = 0; MyFourMuonDecayVtxZ = 0; MyFourMuonDecayVtxXE = 0; MyFourMuonDecayVtxYE = 0; MyFourMuonDecayVtxZE = 0; MyFourMuonMu1Idx = 0; MyFourMuonMu2Idx = 0; MyFourMuonMu2Px = 0; MyFourMuonMu2Py = 0; MyFourMuonMu2Pz = 0; MyFourMuonMu1Px = 0; MyFourMuonMu1Py = 0; MyFourMuonMu1Pz = 0; MyFourMuonMu2fChi2 = 0; MyFourMuonMu2fNDF = 0; MyFourMuonMu1fChi2 = 0; MyFourMuonMu1fNDF = 0; MyFourMuoncosAlpha = 0; MyFourMuonFLSig = 0; MyFourMuonrVtxMag2D = 0; MyFourMuonsigmaRvtxMag2D = 0; MyFourMuonTrkIsoOverFourMuSumpt = 0; MyFourMuonTrkIsoOverFourMuVectpt = 0; MyFourMuonMu3fNDF = 0; MyFourMuonMu3Idx = 0; MyFourMuonMu3Px = 0; MyFourMuonMu3Py = 0; MyFourMuonMu3Pz = 0; MyFourMuonMu3fChi2 = 0; MyFourMuonMu4fNDF = 0; MyFourMuonMu4Idx = 0; MyFourMuonMu4Px = 0; MyFourMuonMu4Py = 0; MyFourMuonMu4Pz = 0; MyFourMuonMu4fChi2 = 0; // Set branch addresses and branch pointers if (!tree) return; fChain = tree; fCurrent = -1; fChain->SetMakeClass(1); fChain->SetBranchAddress("TrigRes", &TrigRes, &b_TrigRes); fChain->SetBranchAddress("TrigNames", &TrigNames, &b_TrigNames); fChain->SetBranchAddress("MatchUpsTriggerNames", &MatchUpsTriggerNames, &b_MatchUpsTriggerNames); fChain->SetBranchAddress("L1TrigRes", &L1TrigRes, &b_L1TrigRes); fChain->SetBranchAddress("evtNum", &evtNum, &b_evtNum); fChain->SetBranchAddress("runNum", &runNum, &b_runNum); fChain->SetBranchAddress("lumiNum", &lumiNum, &b_lumiNum); fChain->SetBranchAddress("priVtxX", &priVtxX, &b_priVtxX); fChain->SetBranchAddress("priVtxY", &priVtxY, &b_priVtxY); fChain->SetBranchAddress("priVtxZ", &priVtxZ, &b_priVtxZ); fChain->SetBranchAddress("priVtxXE", &priVtxXE, &b_priVtxXE); fChain->SetBranchAddress("priVtxYE", &priVtxYE, &b_priVtxYE); fChain->SetBranchAddress("priVtxZE", &priVtxZE, &b_priVtxZE); fChain->SetBranchAddress("priVtxChiNorm", &priVtxChiNorm, &b_priVtxChiNorm); fChain->SetBranchAddress("priVtxChi", &priVtxChi, &b_priVtxChi); fChain->SetBranchAddress("priVtxCL", &priVtxCL, &b_priVtxCL); fChain->SetBranchAddress("PriVtxXCorrX", &PriVtxXCorrX, &b_PriVtxXCorrX); fChain->SetBranchAddress("PriVtxXCorrY", &PriVtxXCorrY, &b_PriVtxXCorrY); fChain->SetBranchAddress("PriVtxXCorrZ", &PriVtxXCorrZ, &b_PriVtxXCorrZ); fChain->SetBranchAddress("PriVtxXCorrEX", &PriVtxXCorrEX, &b_PriVtxXCorrEX); fChain->SetBranchAddress("PriVtxXCorrEY", &PriVtxXCorrEY, &b_PriVtxXCorrEY); fChain->SetBranchAddress("PriVtxXCorrEZ", &PriVtxXCorrEZ, &b_PriVtxXCorrEZ); fChain->SetBranchAddress("PriVtxXCorrC2", &PriVtxXCorrC2, &b_PriVtxXCorrC2); fChain->SetBranchAddress("PriVtxXCorrCL", &PriVtxXCorrCL, &b_PriVtxXCorrCL); fChain->SetBranchAddress("nMu", &nMu, &b_nMu); fChain->SetBranchAddress("muPt", &muPt, &b_muPt); fChain->SetBranchAddress("muEta", &muEta, &b_muEta); fChain->SetBranchAddress("muPx", &muPx, &b_muPx); fChain->SetBranchAddress("muPy", &muPy, &b_muPy); fChain->SetBranchAddress("muPz", &muPz, &b_muPz); fChain->SetBranchAddress("muD0", &muD0, &b_muD0); fChain->SetBranchAddress("muD0E", &muD0E, &b_muD0E); fChain->SetBranchAddress("muDz", &muDz, &b_muDz); fChain->SetBranchAddress("muChi2", &muChi2, &b_muChi2); fChain->SetBranchAddress("muGlChi2", &muGlChi2, &b_muGlChi2); fChain->SetBranchAddress("mufHits", &mufHits, &b_mufHits); //fChain->SetBranchAddress("muFirstBarrel", &muFirstBarrel, &b_muFirstBarrel); //fChain->SetBranchAddress("muFirstEndCap", &muFirstEndCap, &b_muFirstEndCap); fChain->SetBranchAddress("muDzVtx", &muDzVtx, &b_muDzVtx); fChain->SetBranchAddress("muDxyVtx", &muDxyVtx, &b_muDxyVtx); fChain->SetBranchAddress("muNDF", &muNDF, &b_muNDF); fChain->SetBranchAddress("muGlNDF", &muGlNDF, &b_muGlNDF); fChain->SetBranchAddress("muPhits", &muPhits, &b_muPhits); fChain->SetBranchAddress("muShits", &muShits, &b_muShits); fChain->SetBranchAddress("muGlMuHits", &muGlMuHits, &b_muGlMuHits); fChain->SetBranchAddress("muType", &muType, &b_muType); fChain->SetBranchAddress("muQual", &muQual, &b_muQual); fChain->SetBranchAddress("muTrack", &muTrack, &b_muTrack); fChain->SetBranchAddress("muCharge", &muCharge, &b_muCharge); fChain->SetBranchAddress("munMatchedSeg", &munMatchedSeg, &b_munMatchedSeg); fChain->SetBranchAddress("muIsGoodSoftMuon", &muIsGoodSoftMuon, &b_muIsGoodSoftMuon); fChain->SetBranchAddress("muIsGoodStandMediumMuon", &muIsGoodStandMediumMuon, &b_muIsGoodStandMediumMuon); fChain->SetBranchAddress("muIsGoodMediumMuon", &muIsGoodMediumMuon, &b_muIsGoodMediumMuon); fChain->SetBranchAddress("nMyFourMuon", &nMyFourMuon, &b_nMyFourMuon); fChain->SetBranchAddress("MyFourMuonMass", &MyFourMuonMass, &b_MyFourMuonMass); fChain->SetBranchAddress("MyFourMuonMassErr", &MyFourMuonMassErr, &b_MyFourMuonMassErr); fChain->SetBranchAddress("MyFourMuonCTau", &MyFourMuonCTau, &b_MyFourMuonCTau); fChain->SetBranchAddress("MyFourMuonCTauErr", &MyFourMuonCTauErr, &b_MyFourMuonCTauErr); fChain->SetBranchAddress("MyMu1TrigMatchVtxSD", &MyMu1TrigMatchVtxSD, &b_MyMu1TrigMatchVtxSD); fChain->SetBranchAddress("MyMu2TrigMatchVtxSD", &MyMu2TrigMatchVtxSD, &b_MyMu2TrigMatchVtxSD); fChain->SetBranchAddress("MyMu3TrigMatchVtxSD", &MyMu3TrigMatchVtxSD, &b_MyMu3TrigMatchVtxSD); fChain->SetBranchAddress("MyMu4TrigMatchVtxSD", &MyMu4TrigMatchVtxSD, &b_MyMu4TrigMatchVtxSD); //fChain->SetBranchAddress("MyMu1TrigMatchL3FilterSD", &MyMu1TrigMatchL3FilterSD, &b_MyMu1TrigMatchL3FilterSD); // fChain->SetBranchAddress("MyMu2TrigMatchL3FilterSD", &MyMu2TrigMatchL3FilterSD, &b_MyMu2TrigMatchL3FilterSD); //fChain->SetBranchAddress("MyMu3TrigMatchL3FilterSD", &MyMu3TrigMatchL3FilterSD, &b_MyMu3TrigMatchL3FilterSD); //fChain->SetBranchAddress("MyMu4TrigMatchL3FilterSD", &MyMu4TrigMatchL3FilterSD, &b_MyMu4TrigMatchL3FilterSD); fChain->SetBranchAddress("My1234MuPMuMDisXY", &My1234MuPMuMDisXY, &b_My1234MuPMuMDisXY); fChain->SetBranchAddress("My1324MuPMuMDisXY", &My1324MuPMuMDisXY, &b_My1324MuPMuMDisXY); fChain->SetBranchAddress("My1423MuPMuMDisXY", &My1423MuPMuMDisXY, &b_My1423MuPMuMDisXY); fChain->SetBranchAddress("My1234MuPMuMDisZ", &My1234MuPMuMDisZ, &b_My1234MuPMuMDisZ); fChain->SetBranchAddress("My1324MuPMuMDisZ", &My1324MuPMuMDisZ, &b_My1324MuPMuMDisZ); fChain->SetBranchAddress("My1423MuPMuMDisZ", &My1423MuPMuMDisZ, &b_My1423MuPMuMDisZ); fChain->SetBranchAddress("MyMuPMuM1CTau_Mu12", &MyMuPMuM1CTau_Mu12, &b_MyMuPMuM1CTau_Mu12); fChain->SetBranchAddress("MyMuPMuM1CTauErr_Mu12", &MyMuPMuM1CTauErr_Mu12, &b_MyMuPMuM1CTauErr_Mu12); fChain->SetBranchAddress("MyMuPMuM1ChiProb_Mu12", &MyMuPMuM1ChiProb_Mu12, &b_MyMuPMuM1ChiProb_Mu12); fChain->SetBranchAddress("MyMuPMuM2CTau_Mu34", &MyMuPMuM2CTau_Mu34, &b_MyMuPMuM2CTau_Mu34); fChain->SetBranchAddress("MyMuPMuM2CTauErr_Mu34", &MyMuPMuM2CTauErr_Mu34, &b_MyMuPMuM2CTauErr_Mu34); fChain->SetBranchAddress("MyMuPMuM2ChiProb_Mu34", &MyMuPMuM2ChiProb_Mu34, &b_MyMuPMuM2ChiProb_Mu34); fChain->SetBranchAddress("MyMuPMuM3CTau_Mu13", &MyMuPMuM3CTau_Mu13, &b_MyMuPMuM3CTau_Mu13); fChain->SetBranchAddress("MyMuPMuM3CTauErr_Mu13", &MyMuPMuM3CTauErr_Mu13, &b_MyMuPMuM3CTauErr_Mu13); fChain->SetBranchAddress("MyMuPMuM3ChiProb_Mu13", &MyMuPMuM3ChiProb_Mu13, &b_MyMuPMuM3ChiProb_Mu13); fChain->SetBranchAddress("MyMuPMuM4CTau_Mu24", &MyMuPMuM4CTau_Mu24, &b_MyMuPMuM4CTau_Mu24); fChain->SetBranchAddress("MyMuPMuM4CTauErr_Mu24", &MyMuPMuM4CTauErr_Mu24, &b_MyMuPMuM4CTauErr_Mu24); fChain->SetBranchAddress("MyMuPMuM4ChiProb_Mu24", &MyMuPMuM4ChiProb_Mu24, &b_MyMuPMuM4ChiProb_Mu24); fChain->SetBranchAddress("MyMuPMuM5CTau_Mu14", &MyMuPMuM5CTau_Mu14, &b_MyMuPMuM5CTau_Mu14); fChain->SetBranchAddress("MyMuPMuM5CTauErr_Mu14", &MyMuPMuM5CTauErr_Mu14, &b_MyMuPMuM5CTauErr_Mu14); fChain->SetBranchAddress("MyMuPMuM5ChiProb_Mu14", &MyMuPMuM5ChiProb_Mu14, &b_MyMuPMuM5ChiProb_Mu14); fChain->SetBranchAddress("MyMuPMuM6CTau_Mu23", &MyMuPMuM6CTau_Mu23, &b_MyMuPMuM6CTau_Mu23); fChain->SetBranchAddress("MyMuPMuM6CTauErr_Mu23", &MyMuPMuM6CTauErr_Mu23, &b_MyMuPMuM6CTauErr_Mu23); fChain->SetBranchAddress("MyMuPMuM6ChiProb_Mu23", &MyMuPMuM6ChiProb_Mu23, &b_MyMuPMuM6ChiProb_Mu23); fChain->SetBranchAddress("MyMuPMuM1Mass_Mu12", &MyMuPMuM1Mass_Mu12, &b_MyMuPMuM1Mass_Mu12); fChain->SetBranchAddress("MyMuPMuM1MassErr_Mu12", &MyMuPMuM1MassErr_Mu12, &b_MyMuPMuM1MassErr_Mu12); fChain->SetBranchAddress("MyMuPMuM2Mass_Mu34", &MyMuPMuM2Mass_Mu34, &b_MyMuPMuM2Mass_Mu34); fChain->SetBranchAddress("MyMuPMuM2MassErr_Mu34", &MyMuPMuM2MassErr_Mu34, &b_MyMuPMuM2MassErr_Mu34); fChain->SetBranchAddress("MyMuPMuM3Mass_Mu13", &MyMuPMuM3Mass_Mu13, &b_MyMuPMuM3Mass_Mu13); fChain->SetBranchAddress("MyMuPMuM3MassErr_Mu13", &MyMuPMuM3MassErr_Mu13, &b_MyMuPMuM3MassErr_Mu13); fChain->SetBranchAddress("MyMuPMuM4Mass_Mu24", &MyMuPMuM4Mass_Mu24, &b_MyMuPMuM4Mass_Mu24); fChain->SetBranchAddress("MyMuPMuM4MassErr_Mu24", &MyMuPMuM4MassErr_Mu24, &b_MyMuPMuM4MassErr_Mu24); fChain->SetBranchAddress("MyMuPMuM5Mass_Mu14", &MyMuPMuM5Mass_Mu14, &b_MyMuPMuM5Mass_Mu14); fChain->SetBranchAddress("MyMuPMuM5MassErr_Mu14", &MyMuPMuM5MassErr_Mu14, &b_MyMuPMuM5MassErr_Mu14); fChain->SetBranchAddress("MyMuPMuM6Mass_Mu23", &MyMuPMuM6Mass_Mu23, &b_MyMuPMuM6Mass_Mu23); fChain->SetBranchAddress("MyMuPMuM6MassErr_Mu23", &MyMuPMuM6MassErr_Mu23, &b_MyMuPMuM6MassErr_Mu23); fChain->SetBranchAddress("MyFourMuonSharedSeg12", &MyFourMuonSharedSeg12, &b_MyFourMuonSharedSeg12); fChain->SetBranchAddress("MyFourMuonSharedSeg13", &MyFourMuonSharedSeg13, &b_MyFourMuonSharedSeg13); fChain->SetBranchAddress("MyFourMuonSharedSeg14", &MyFourMuonSharedSeg14, &b_MyFourMuonSharedSeg14); fChain->SetBranchAddress("MyFourMuonSharedSeg23", &MyFourMuonSharedSeg23, &b_MyFourMuonSharedSeg23); fChain->SetBranchAddress("MyFourMuonSharedSeg24", &MyFourMuonSharedSeg24, &b_MyFourMuonSharedSeg24); fChain->SetBranchAddress("MyFourMuonSharedSeg34", &MyFourMuonSharedSeg34, &b_MyFourMuonSharedSeg34); fChain->SetBranchAddress("MyFourMuonVtxCL", &MyFourMuonVtxCL, &b_MyFourMuonVtxCL); fChain->SetBranchAddress("MyFourMuonVtxC2", &MyFourMuonVtxC2, &b_MyFourMuonVtxC2); fChain->SetBranchAddress("MyFourMuonPx", &MyFourMuonPx, &b_MyFourMuonPx); fChain->SetBranchAddress("MyFourMuonPy", &MyFourMuonPy, &b_MyFourMuonPy); fChain->SetBranchAddress("MyFourMuonPz", &MyFourMuonPz, &b_MyFourMuonPz); fChain->SetBranchAddress("MyFourMuonDecayVtxX", &MyFourMuonDecayVtxX, &b_MyFourMuonDecayVtxX); fChain->SetBranchAddress("MyFourMuonDecayVtxY", &MyFourMuonDecayVtxY, &b_MyFourMuonDecayVtxY); fChain->SetBranchAddress("MyFourMuonDecayVtxZ", &MyFourMuonDecayVtxZ, &b_MyFourMuonDecayVtxZ); fChain->SetBranchAddress("MyFourMuonDecayVtxXE", &MyFourMuonDecayVtxXE, &b_MyFourMuonDecayVtxXE); fChain->SetBranchAddress("MyFourMuonDecayVtxYE", &MyFourMuonDecayVtxYE, &b_MyFourMuonDecayVtxYE); fChain->SetBranchAddress("MyFourMuonDecayVtxZE", &MyFourMuonDecayVtxZE, &b_MyFourMuonDecayVtxZE); fChain->SetBranchAddress("MyFourMuonMu1Idx", &MyFourMuonMu1Idx, &b_MyFourMuonMu1Idx); fChain->SetBranchAddress("MyFourMuonMu2Idx", &MyFourMuonMu2Idx, &b_MyFourMuonMu2Idx); fChain->SetBranchAddress("MyFourMuonMu2Px", &MyFourMuonMu2Px, &b_MyFourMuonMu2Px); fChain->SetBranchAddress("MyFourMuonMu2Py", &MyFourMuonMu2Py, &b_MyFourMuonMu2Py); fChain->SetBranchAddress("MyFourMuonMu2Pz", &MyFourMuonMu2Pz, &b_MyFourMuonMu2Pz); fChain->SetBranchAddress("MyFourMuonMu1Px", &MyFourMuonMu1Px, &b_MyFourMuonMu1Px); fChain->SetBranchAddress("MyFourMuonMu1Py", &MyFourMuonMu1Py, &b_MyFourMuonMu1Py); fChain->SetBranchAddress("MyFourMuonMu1Pz", &MyFourMuonMu1Pz, &b_MyFourMuonMu1Pz); fChain->SetBranchAddress("MyFourMuonMu2fChi2", &MyFourMuonMu2fChi2, &b_MyFourMuonMu2fChi2); fChain->SetBranchAddress("MyFourMuonMu2fNDF", &MyFourMuonMu2fNDF, &b_MyFourMuonMu2fNDF); fChain->SetBranchAddress("MyFourMuonMu1fChi2", &MyFourMuonMu1fChi2, &b_MyFourMuonMu1fChi2); fChain->SetBranchAddress("MyFourMuonMu1fNDF", &MyFourMuonMu1fNDF, &b_MyFourMuonMu1fNDF); fChain->SetBranchAddress("MyFourMuoncosAlpha", &MyFourMuoncosAlpha, &b_MyFourMuoncosAlpha); fChain->SetBranchAddress("MyFourMuonFLSig", &MyFourMuonFLSig, &b_MyFourMuonFLSig); fChain->SetBranchAddress("MyFourMuonrVtxMag2D", &MyFourMuonrVtxMag2D, &b_MyFourMuonrVtxMag2D); fChain->SetBranchAddress("MyFourMuonsigmaRvtxMag2D", &MyFourMuonsigmaRvtxMag2D, &b_MyFourMuonsigmaRvtxMag2D); fChain->SetBranchAddress("MyFourMuonTrkIsoOverFourMuSumpt", &MyFourMuonTrkIsoOverFourMuSumpt, &b_MyFourMuonTrkIsoOverFourMuSumpt); fChain->SetBranchAddress("MyFourMuonTrkIsoOverFourMuVectpt", &MyFourMuonTrkIsoOverFourMuVectpt, &b_MyFourMuonTrkIsoOverFourMuVectpt); fChain->SetBranchAddress("MyFourMuonMu3fNDF", &MyFourMuonMu3fNDF, &b_MyFourMuonMu3fNDF); fChain->SetBranchAddress("MyFourMuonMu3Idx", &MyFourMuonMu3Idx, &b_MyFourMuonMu3Idx); fChain->SetBranchAddress("MyFourMuonMu3Px", &MyFourMuonMu3Px, &b_MyFourMuonMu3Px); fChain->SetBranchAddress("MyFourMuonMu3Py", &MyFourMuonMu3Py, &b_MyFourMuonMu3Py); fChain->SetBranchAddress("MyFourMuonMu3Pz", &MyFourMuonMu3Pz, &b_MyFourMuonMu3Pz); fChain->SetBranchAddress("MyFourMuonMu3fChi2", &MyFourMuonMu3fChi2, &b_MyFourMuonMu3fChi2); fChain->SetBranchAddress("MyFourMuonMu4fNDF", &MyFourMuonMu4fNDF, &b_MyFourMuonMu4fNDF); fChain->SetBranchAddress("MyFourMuonMu4Idx", &MyFourMuonMu4Idx, &b_MyFourMuonMu4Idx); fChain->SetBranchAddress("MyFourMuonMu4Px", &MyFourMuonMu4Px, &b_MyFourMuonMu4Px); fChain->SetBranchAddress("MyFourMuonMu4Py", &MyFourMuonMu4Py, &b_MyFourMuonMu4Py); fChain->SetBranchAddress("MyFourMuonMu4Pz", &MyFourMuonMu4Pz, &b_MyFourMuonMu4Pz); fChain->SetBranchAddress("MyFourMuonMu4fChi2", &MyFourMuonMu4fChi2, &b_MyFourMuonMu4fChi2); Notify(); } Bool_t MyFourMuonAnalyzer::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 MyFourMuonAnalyzer::Show(Long64_t entry) { // Print contents of entry. // If entry is not specified, print current entry if (!fChain) return; fChain->Show(entry); } Int_t MyFourMuonAnalyzer::Cut(Long64_t entry) { // This function may be called from Loop. // returns 1 if entry is accepted. // returns -1 otherwise. return 1; } #endif // #ifdef MyFourMuonAnalyzer_cxx