Full up-to-date MINIAOD analysis on master.

.gitignore

@@ -0,0 +1,2 @@
+*.pyc
+*.py

AnalysisFW/interface/QCDEvent.h

@@ -7,12 +7,12 @@
 #include "SMPJ/AnalysisFW/interface/QCDMET.h"
 #include "SMPJ/AnalysisFW/interface/QCDCaloJet.h"
 #include "SMPJ/AnalysisFW/interface/QCDPFJet.h"
-//#include "SMPJ/AnalysisFW/interface/MyElectron.h"
-//#include "SMPJ/AnalysisFW/interface/MyMuon.h"
 #include "SMPJ/AnalysisFW/interface/QCDEventHdr.h"
 #include "DataFormats/JetReco/interface/Jet.h"
 #include <vector>
 
+using std::vector;
+
 class QCDEvent
 {
     public:
@@ -22,116 +22,82 @@ class QCDEvent
       //------------ Destructor -------------------------------
       ~QCDEvent();
       //------------ Set methods ------------------------------
-      void setCaloMET(const QCDMET& fCaloMET)                     {CaloMet_ = fCaloMET;}
-      void setPFMET(const QCDMET& fPFMET)                         {PFMet_ = fPFMET;}
-      void setMvaMET(const QCDMET& fMvaMET)                         {MvaMet_ = fMvaMET;}
+      void setPFMET(const QCDMET& fPFMET,const QCDMET& fPFMETt0, const QCDMET& fPFMETt0t1) {
+        PFMet_ = fPFMET;
+        PFMetT0_ = fPFMETt0;
+        PFMetT0T1_ = fPFMETt0t1;
+      }
       void setEvtHdr(const QCDEventHdr& fEvtHdr)                  {EvtHdr_ = fEvtHdr;}
-      //void setCaloJets(const std::vector<QCDCaloJet>& fCaloJets);
-      //void setPFJets(const std::vector<QCDPFJet>& fPFJets);
-      void setPFJetsCHS(const std::vector<QCDPFJet>& fPFJetsCHS);
-      //void setElectrons(const std::vector<MyElectron>& fElectron);
-      //void setMuons(const std::vector<MyMuon>& fMuon);
+      void setPFJetsCHS(const vector<QCDPFJet>& fPFJetsCHS);
 
-      //void setFatJets(const std::vector<QCDJet>& fFatJets);
-      void setGenJets(const std::vector<LorentzVector>& fGenJets);
-      void setL1Obj(const std::vector<std::vector<LorentzVector> >& fL1Obj);
-      void setHLTObj(const std::vector<std::vector<LorentzVector> >& fHLTObj);
-      void setFilterId(const std::vector<std::vector<int> >& filterIdList) {filterIdList_ = filterIdList;}
-      void setPrescales(const std::vector<int>& fPreL1, const std::vector<int>& fPreHLT) {L1Prescale_ = fPreL1; HLTPrescale_ = fPreHLT;}
-      void setTrigDecision(const std::vector<int>& fTrigDecision) {TriggerDecision_ = fTrigDecision;}
-      void setTrigPathList(const std::vector<std::string>& trigPathList) {triggerList_ = trigPathList;}
+      void setGenJets(const vector<LorentzVector>& fGenJets);
+      void setL1Obj(const vector<vector<LorentzVector> >& fL1Obj);
+      void setHLTObj(const vector<vector<LorentzVector> >& fHLTObj);
+      void setPrescales(const vector<int>& fPreL1, const vector<int>& fPreHLT) {L1Prescale_ = fPreL1; HLTPrescale_ = fPreHLT;}
+      void setTrigDecision(const vector<int>& fTrigDecision) {TriggerDecision_ = fTrigDecision;}
+      void setFltDecision(const vector<int>& fFltDecision) {FilterDecision_ = fFltDecision;}
 
-      void setGenFlavour(const std::vector<float> GenFlavour){ genFlavour_= GenFlavour; }
-      void setGenHadronFlavour(const std::vector<float> GenFlavourHadron){ genFlavourHadron_= GenFlavourHadron; }
+      void setGenFlavour(          const vector<int>& GenFlavour) {                genFlavour_= GenFlavour;}
+      void setGenFlavourHadron(    const vector<int>& GenFlavourHadron) {          genFlavourHadron_= GenFlavourHadron;}
+      void setGenFlavourPhysicsDef(const vector<int>& GenPartonFlavourPhysicsDef) {genFlavourPartonPhysicsDef_= GenPartonFlavourPhysicsDef;}
+      void setGenBPt(              const vector<float>& fGenBPt) {                 genBPt_ = fGenBPt; }
 
       //------------ Get methods -------------------------------
       unsigned int nTriggers()                         const {return TriggerDecision_.size();}
       unsigned int nL1Obj(int i)                       const {return L1Obj_[i].size();}
       unsigned int nHLTObj(int i)                      const {return HLTObj_[i].size();}
-      //unsigned int nPFJets()                           const {return PFJets_.size();}
       unsigned int nPFJetsCHS()                        const {return PFJetsCHS_.size();}
-      //unsigned int nFatJets()                          const {return FatJets_.size();}
-      //unsigned int nCaloJets()                         const {return CaloJets_.size();}
       unsigned int nGenJets()                          const {return GenJets_.size();}
-      int nGoodJets(int unc, int id, float ymax, float ptmin, std::vector<QCDJet> jets);
+      int nGoodJets(int unc, int id, float ymax, float ptmin, vector<QCDJet> jets);
       int fired(int i)                                 const {return TriggerDecision_[i];}
       int preL1(int i)                                 const {return L1Prescale_[i];}
       int preHLT(int i)                                const {return HLTPrescale_[i];}
-      float pfmjj();
-      //unsigned int nMuons()                           const {return mMuon_.size();}
-      //unsigned int nEelctrons()                           const {return mElectron_.size();}
 
-      float GenJetFlavour(int i)                       const {return genFlavour_[i];}
-      float GenHadronJetFlavour(int i)                       const {return genFlavourHadron_[i];}
+      int GenJetFlavour(int i)                         const {return genFlavour_[i];}
+      int GenHadronJetFlavour(int i)                   const {return genFlavourHadron_[i];}
+      int GenPartonPhysicsDefJetFlavour(int i)         const {return genFlavourPartonPhysicsDef_[i];}
 
-      float calomjj();
+      float pfmjj();
       float genmjj();
       float pfchsmjjcor(int unc);
       float pfchsmjjcor(int unc,int src);
-      //float pfmjjcor(int unc);
-      //float pfmjjcor(int unc,int src);
-      //float fatmjjcor(int unc);
-      //float calomjjcor(int unc);
       float pfmjjgen();
-      //float calomjjgen();
-      const QCDMET&        calomet()                   const {return CaloMet_;}
       const QCDMET&        pfmet()                     const {return PFMet_;}
-      const QCDMET&        mvamet()                     const {return MvaMet_;}
       const LorentzVector& hltobj(int itrig, int iobj) const {return (HLTObj_[itrig])[iobj];}
       const LorentzVector& l1obj(int itrig, int iobj)  const {return (L1Obj_[itrig])[iobj];}
       const LorentzVector& genjet(int i)               const {return GenJets_[i];}
-      //const QCDPFJet&      pfjet(int i)                const {return PFJets_[i];}
       const QCDPFJet&      pfjetchs(int i)             const {return PFJetsCHS_[i];}
-      //const QCDJet&        fatjet(int i)               const {return FatJets_[i];}
-      //const QCDCaloJet&    calojet(int i)              const {return CaloJets_[i];}
       const QCDEventHdr&   evtHdr()                    const {return EvtHdr_;}
 
-      //const MyMuon& muon(int i) const {return mMuon_[i];}
-      //const MyElectron& electron(int i) const {return mElectron_[i];}
-
-      const std::vector<std::vector<LorentzVector>>& HLTObj() const {return HLTObj_;}
-      const std::vector<std::string>& trigPathList() const {return triggerList_;}
-      const std::vector<std::vector<int>>& filterIdList() const {return filterIdList_;}
-      const std::vector<LorentzVector>& hltObjsForPath(int i) const {return HLTObj_[i];}
-      const std::vector<int>& filterIdsForPath(int i) const {return filterIdList_[i];}
+      const vector<vector<LorentzVector>>& HLTObj() const {return HLTObj_;}
+      const vector<LorentzVector>& hltObjsForPath(int i) const {return HLTObj_[i];}
 
     private:
-      std::vector<std::vector<int> > filterIdList_;
-
       //---- event header (contains all the event info) --------------
       QCDEventHdr                              EvtHdr_;
-      //---- CALO met object -----------------------------------------
-      QCDMET                                   CaloMet_;
       //---- PF met object -------------------------------------------
-      QCDMET                                   PFMet_;
-      QCDMET                                   MvaMet_;
+      QCDMET                                   PFMet_; // T1, implicit
+      QCDMET                                   PFMetT0_;
+      QCDMET                                   PFMetT0T1_;
       //---- trigger decision vector ---------------------------------
-      std::vector<int>                         TriggerDecision_;
-      std::vector<std::string>                 triggerList_;
+      vector<int>                         TriggerDecision_;
+      //---- filter decision vector ---------------------------------
+      vector<int>                         FilterDecision_;
       //---- L1 prescale vector --------------------------------------
-      std::vector<int>                         L1Prescale_;
+      vector<int>                         L1Prescale_;
       //---- HLT prescale vector -------------------------------------
-      std::vector<int>                         HLTPrescale_;
+      vector<int>                         HLTPrescale_;
       //---- HLT objects ---------------------------------------------
-      std::vector<std::vector<LorentzVector> > HLTObj_;
+      vector<vector<LorentzVector> > HLTObj_;
       //---- L1 objects ----------------------------------------------
-      std::vector<std::vector<LorentzVector> > L1Obj_;
+      vector<vector<LorentzVector> > L1Obj_;
       //---- Genjets -------------------------------------------------
-      std::vector<LorentzVector>               GenJets_;
-      //---- CaloJets ------------------------------------------------
-      //std::vector<QCDCaloJet>                  CaloJets_;
-      //---- PFJets --------------------------------------------------
-      //std::vector<QCDPFJet>                    PFJets_;
+      vector<LorentzVector>               GenJets_;
       //---- PFJetsCHS -----------------------------------------------
-      std::vector<QCDPFJet>                    PFJetsCHS_;
-      //---- FatJets -------------------------------------------------
-      //std::vector<QCDJet>                      FatJets_;
-      std::vector<float>  genFlavour_;
-      std::vector<float>  genFlavourHadron_;
-
-      //MyMuons
-      //std::vector<MyMuon> mMuon_;
-      //std::vector<MyElectron> mElectron_;
-
+      vector<QCDPFJet>                    PFJetsCHS_;
+      vector<int>  genFlavour_;
+      vector<int>  genFlavourHadron_;
+      vector<int>  genFlavourPartonPhysicsDef_;
+      vector<float> genBPt_;
 };
 #endif

AnalysisFW/interface/QCDEventHdr.h

@@ -3,6 +3,8 @@
 #ifndef QCDEventHdr_h
 #define QCDEventHdr_h
 
+#include <vector>
+
 class QCDEventHdr 
 {
     public:
@@ -21,43 +23,43 @@ class QCDEventHdr
       void setVertices(int fNVtx, int fNVtxGood)             {mNVtx = fNVtx; mNVtxGood = fNVtxGood;}
       void setPV(bool fIsPVgood, float fndof, float fx, float fy, float fz) {mIsPVgood = fIsPVgood; mPVndof = fndof; mPVx = fx; mPVy = fy; mPVz = fz;}
       void setBS(float fBSx, float fBSy, float fBSz) {mBSx = fBSx; mBSy = fBSy; mBSz = fBSz;}
-      void setHCALNoise(bool fNoise) {mHCALNoise = fNoise;}
       void setHCALNoiseNoMinZ(bool fNoise) {mHCALNoiseNoMinZ = fNoise;}
       void setPU(int fNBX, int fOOTPUEarly, int fOOTPULate, int fINTPU) {mNBX = fNBX; mOOTPUEarly = fOOTPUEarly; mOOTPULate = fOOTPULate; mINTPU = fINTPU;}
       void setTrPu(float fTrPu) {mTrPu = fTrPu;} // setting the true PU 
+      void setPSWeight(size_t idx, float wgt) {
+        if (idx < mPSWeights.size()) mPSWeights[idx] = wgt;
+        else mPSWeights.push_back(wgt);
+      }
       //------------ Get methods ------------------------------
-      int runNo()           const {return mRun;} 
-      long long int event()           const {return mEvent;} 
-      int lumi()            const {return mLumi;}
-      int bunch()           const {return mBunch;}
-      int nVtx()            const {return mNVtx;}
-      int nVtxGood()        const {return mNVtxGood;}
-      int ootpuEarly()      const {return mOOTPUEarly;}
-      int ootpuLate()       const {return mOOTPULate;}
-      int intpu()           const {return mINTPU;}
-      int nbx()             const {return mNBX;} 
-      int pu()              const {return mOOTPUEarly+mOOTPULate+mINTPU;}
-      float trpu()          const {return mTrPu;} // get method for True number of interaction
-      bool isPVgood()       const {return mIsPVgood;}
-      bool hcalNoise()      const {return mHCALNoise;}
-      bool hcalNoiseNoMinZ()      const {return mHCALNoiseNoMinZ;}
-      float PVndof()        const {return mPVndof;} 
-      float PVx()           const {return mPVx;}
-      float PVy()           const {return mPVy;}
-      float PVz()           const {return mPVz;}
-      float BSx()           const {return mBSx;}
-      float BSy()           const {return mBSy;}
-      float BSz()           const {return mBSz;}
-      float pthat()         const {return mPthat;}
-      float weight()        const {return mWeight;}
-      float caloRho()       const {return mCaloRho;} 
-      float pfRho()         const {return mPFRho;} 
+      int runNo()            const {return mRun;} 
+      long long int event()  const {return mEvent;} 
+      int lumi()             const {return mLumi;}
+      int bunch()            const {return mBunch;}
+      int nVtx()             const {return mNVtx;}
+      int nVtxGood()         const {return mNVtxGood;}
+      int ootpuEarly()       const {return mOOTPUEarly;}
+      int ootpuLate()        const {return mOOTPULate;}
+      int intpu()            const {return mINTPU;}
+      int nbx()              const {return mNBX;} 
+      int pu()               const {return mOOTPUEarly+mOOTPULate+mINTPU;}
+      float trpu()           const {return mTrPu;} // get method for True number of interaction
+      bool isPVgood()        const {return mIsPVgood;}
+      bool hcalNoiseNoMinZ() const {return mHCALNoiseNoMinZ;}
+      float PVndof()         const {return mPVndof;} 
+      float PVx()            const {return mPVx;}
+      float PVy()            const {return mPVy;}
+      float PVz()            const {return mPVz;}
+      float BSx()            const {return mBSx;}
+      float BSy()            const {return mBSy;}
+      float BSz()            const {return mBSz;}
+      float pthat()          const {return mPthat;}
+      float weight()         const {return mWeight;}
+      float caloRho()        const {return mCaloRho;} 
+      float pfRho()          const {return mPFRho;} 
       private:
         //---- flag about the PV quality -------------- 
         bool mIsPVgood; 
         //---- flags about the HCAL noise -------------
-        bool mHCALNoise;
-        //---- flags about the HCAL noise -------------
         bool mHCALNoiseNoMinZ;
         //---- run number ----------------------------- 
         int mRun;
@@ -95,6 +97,8 @@ class QCDEventHdr
         float mPthat;
         //---- simulation weight ----------------------
         float mWeight;
+        //---- shower weight ----------------------
+        std::vector<float> mPSWeights;
         //---- median CALO pt density -----------------
         float mCaloRho;
         //---- median PF pt density -------------------

AnalysisFW/interface/QCDJet.h

@@ -15,22 +15,20 @@ class QCDJet
      ~QCDJet() {}
      //------------ Sett methods -----------------------------
   //   void clear() {pfParticles_.clear();}
-     void setP4(LorentzVector fP4) {P4_ = fP4;}
-     void setGen(LorentzVector fP4, float fgenR) {genP4_ = fP4;genR_ = fgenR;}
-     void setCor(float fCor)                     {cor_  = fCor;} 
-     void setUnc(float fUnc)                     {unc_  = fUnc;} 
-     void setUncSrc(std::vector<float> fUncSrc)  {uncSrc_ = fUncSrc;}
-     void setJecLabels(std::vector<double> fJecLabels) {jecLabels_ = fJecLabels;}
-     void setArea(float fArea)                   {area_ = fArea;}
-     void setLooseID(bool fLooseID)              {looseID_ = fLooseID;} 
-     void setTightID(bool fTightID)              {tightID_ = fTightID;}
+     void setP4(LorentzVector fP4)               { P4_ = fP4; }
+     void setGen(int fIdx, float fgenR)          { genIdx_ = fIdx; genR_ = fgenR; }
+     void setCor(float fCor)                     { cor_  = fCor; }
+     void setUnc(float fUnc)                     { unc_  = fUnc; }
+     void setUncSrc(std::vector<float> fUncSrc)  { uncSrc_ = fUncSrc; }
+     void setJecLabels(std::vector<double> fJecLabels) { jecLabels_ = fJecLabels; }
+     void setArea(float fArea)                   { area_ = fArea; }
+     void setLooseID(bool fLooseID)              { looseID_ = fLooseID; } 
+     void setTightID(bool fTightID)              { tightID_ = fTightID; }
 //     void setPFParticles(std::vector<LorentzVector> fpfFParticles) {pfParticles_ = fpfFParticles;}
      //------------ Get methods ------------------------------
      const LorentzVector& p4()    const {return P4_;}
-     const LorentzVector& genp4() const {return genP4_;}
      float pt()                   const {return P4_.pt()/cor_;}
-     float genpt()                const {return genP4_.pt();}
-     float geneta()               const {return genP4_.eta();} 
+     int genidx()                 const {return genIdx_;}
      float genR()                 const {return genR_;} 
      float ptCor()                const {return P4_.pt();}
      float e()                    const {return P4_.energy()/cor_;}
@@ -51,8 +49,8 @@ class QCDJet
    private:
      //------ jet 4-momentum vector------------------
      LorentzVector P4_;
-     //------ matched genjet 4-momentum vector-------
-     LorentzVector genP4_;
+     //------ matched genjet index-------------------
+     int genIdx_;
      //------ matching radius -----------------------
      float genR_;
      //------ jec factor ----------------------------
@@ -69,7 +67,5 @@ class QCDJet
      bool  looseID_;
      //------ tight ID flag -------------------------
      bool  tightID_;
-     //------ LorentzVector For PF PARTICLES
-  //   std::vector<LorentzVector> pfParticles_;
  };
 #endif

AnalysisFW/interface/QCDMET.h

@@ -13,18 +13,15 @@ class QCDMET
      ~QCDMET() {}
      //------- Set method ------------------------------------
      void setVar(float fEt, float fSumEt, float fPhi) {et_ = fEt; sumEt_ = fSumEt; phi_ = fPhi;} 
-     void setCaloMet(float fCaloMetPt) {CaloMetPt_ = fCaloMetPt;}
      //------- Get methods -----------------------------------
      float met()         const {return et_;}
-     float calometpt()         const {return CaloMetPt_;}
      float phi()         const {return phi_;}
      float sumet()       const {return sumEt_;}
      float met_o_sumet() const {return et_/sumEt_;}
 
    private:
      //---- size of MET vector ----------
      float et_;
-     float CaloMetPt_;
      //---- sumET -----------------------
      float sumEt_;
      //---- phi of MET vector -----------