Legacy fiducial and differential xs measurement dev PR

DataFormats/BuildFile.xml

@@ -4,7 +4,6 @@
 <use   name="DataFormats/VertexReco"/>
 <use   name="DataFormats/Common"/>
 <use   name="DataFormats/JetReco"/>
-<use name="rootrflx"/>
 
 <export>
         <lib name="1"/>

DataFormats/interface/GenDiPhoton.h

@@ -23,8 +23,10 @@ namespace flashgg {
 
         virtual GenDiPhoton *clone() const { return ( new GenDiPhoton( *this ) ); }
 
+
         const flashgg::GenPhotonExtra::cand_type* leadingPhoton() const { return   &(leadingPhoton_.cand()); };
         const flashgg::GenPhotonExtra::cand_type* subLeadingPhoton() const { return &(subLeadingPhoton_.cand()); }
+
 
         const reco::GenJet & leadingJet() const { return *leadingJet_; };
         const reco::GenJet & subLeadingJet() const { return *subLeadingJet_; }

DataFormats/interface/GenJetExtra.h

@@ -0,0 +1,50 @@
+#ifndef FLASHgg_GenJetExtra_h
+#define FLASHgg_GenJetExtra_h
+
+//#include "flashgg/DataFormats/interface/Jet.h"
+#include "DataFormats/PatCandidates/interface/PackedGenParticle.h"
+#include "DataFormats/JetReco/interface/GenJet.h"
+#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
+#include "DataFormats/Common/interface/Ptr.h"
+
+#include <string>
+
+namespace flashgg {
+
+    class GenJetExtra : public reco::GenJet
+    {
+
+    public:
+        GenJetExtra(){}
+        GenJetExtra(const reco::GenJet &j) : reco::GenJet(j) {}
+
+        bool hasBottom() const {return hasBottom_;}
+        void setHasBottom( bool x ){hasBottom_ = x;}
+
+        bool hasBquark() const {return hasBquark_;}
+        void setHasBquark( bool x ){hasBquark_ = x;}
+
+        bool deltaRBquarkGenJet() const {return deltaRBquarkGenjet_;}
+        void setDeltaRBquarkGenjet( double x ){deltaRBquarkGenjet_ = x;}
+
+        bool jetPtOverBquarkPt() const {return jetPtOverBquarkPt_;}
+        void setJetPtOverBquarkPt( double x ){jetPtOverBquarkPt_ = x;}
+
+
+    private:
+        bool hasBottom_;
+        bool hasBquark_;
+        double deltaRBquarkGenjet_;
+        double jetPtOverBquarkPt_;
+    };
+}
+
+#endif
+// Local Variables:
+// mode:c++
+// indent-tabs-mode:nil
+// tab-width:4
+// c-basic-offset:4
+// End:
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
+

DataFormats/interface/GenLeptonExtra.h

@@ -0,0 +1,64 @@
+#ifndef FLASHgg_GenLeptonExtra_h
+#define FLASHgg_GenLeptonExtra_h
+
+//#include "flashgg/DataFormats/interface/Lepton.h"
+#include "DataFormats/PatCandidates/interface/PackedGenParticle.h"
+#include "DataFormats/Candidate/interface/ShallowCloneCandidate.h"
+#include "DataFormats/Common/interface/Ptr.h"
+
+#include <string>
+
+namespace flashgg {
+
+    class GenLeptonExtra : public reco::ShallowCloneCandidate
+    {
+
+    public:
+        typedef edm::Ptr<pat::PackedGenParticle> ptr_type;
+        typedef ptr_type::value_type cand_type;
+        //        typedef Lepton::mcMatch_t match_type; //FIXME
+
+        GenLeptonExtra() {}
+        GenLeptonExtra( ptr_type ptr ) : ptr_( ptr ) {}
+
+
+        bool operator==( const ptr_type &rhs ) const { return ptr_ == rhs; }
+        bool operator!=( const ptr_type &rhs ) const { return ptr_ != rhs; }
+
+        const cand_type &cand() const { return *ptr_; }
+        ptr_type ptr() const { return ptr_; }
+        void setPtr( ptr_type x ) { ptr_ = x; }
+
+        float genIso() const { return genIso_; }
+        void setGenIso( float x ) { genIso_ = x; }
+
+        float genIsoAfterDressing() const { return genIsoAfterDressing_; }
+        void setGenIsoAfterDressing( float x ) { genIsoAfterDressing_ = x; }
+
+        //        reco::Particle::LorentzVector dressedP4() const { return dressedP4_; }
+        //        void setDressedP4( reco::Particle::LorentzVector x ) { dressedP4_ = x; }
+        //        void setP4( reco::Particle::LorentzVector x ) { p4_ = x; }
+
+//        void copyTo( flashgg::Lepton &fg, const std::string &postFix = "" ) const
+//        {
+//            fg.addUserFloat( "genIso" + postFix, genIso_ );
+//        }
+
+    private:
+        ptr_type ptr_;
+        float genIso_;
+        float genIsoAfterDressing_;
+        //        reco::Particle::LorentzVector dressedP4_;
+        //        reco::Particle::LorentzVector p4_;
+    };
+}
+
+#endif
+// Local Variables:
+// mode:c++
+// indent-tabs-mode:nil
+// tab-width:4
+// c-basic-offset:4
+// End:
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
+

DataFormats/interface/Jet.h

@@ -16,6 +16,7 @@ namespace flashgg {
     };
 
     enum JetIDLevel {Loose=0, Tight=1, Tight2017=2, Tight2018=3};
+    enum JetPuIdLevel {none=0, loose=1, medium=2, tight=3, mixed=4, forward_loose=5, forward_medium=6, forward_tight=7};
 
     class Jet : public pat::Jet, public WeightedObject
     {
@@ -27,12 +28,15 @@ namespace flashgg {
         void setPuJetId( const edm::Ptr<reco::Vertex> vtx, const PileupJetIdentifier & );
         bool hasPuJetId( const edm::Ptr<reco::Vertex> vtx ) const;
         bool passesPuJetId( const edm::Ptr<reco::Vertex> vtx, PileupJetIdentifier::Id level = PileupJetIdentifier::kLoose ) const;
+        bool passesJetPuId( JetPuIdLevel level = none ) const;
         void setSimpleRMS( float theRMS )  { simpleRMS_ = theRMS; }
         void setSimpleMVA( float theMVA )  { simpleMVA_ = theMVA; }
         float rms() const { return simpleRMS_; }
         float rms( const edm::Ptr<reco::Vertex> vtx ) const;
         float betaStar( const edm::Ptr<reco::Vertex> vtx ) const;
         bool passesPuJetId( const edm::Ptr<DiPhotonCandidate> dipho, PileupJetIdentifier::Id level = PileupJetIdentifier::kLoose )const;
+
+
         float rms( const edm::Ptr<DiPhotonCandidate> dipho ) const;
         float betaStar( const edm::Ptr<DiPhotonCandidate> dipho ) const;
         float puJetIdMVA() const { return simpleMVA_; }
@@ -55,12 +59,17 @@ namespace flashgg {
         void setNeEnergies(std::vector<float> val) { neEnergies_ = val; } 
         void setMuEnergies(std::vector<float> val) { muEnergies_ = val; }
 
+        std::vector<double> _pujid_wp_pt_bin_1;
+        std::vector<double> _pujid_wp_pt_bin_2;
+        std::vector<double> _pujid_wp_pt_bin_3;
+
     private:
         std::map<edm::Ptr<reco::Vertex>, MinimalPileupJetIdentifier> puJetId_;
         float qglikelihood_;
         float simpleRMS_; // simpler storage for PFCHS where this is not vertex-dependent
         float simpleMVA_;
         std::vector<float> chEnergies_, emEnergies_, neEnergies_, muEnergies_;
+        std::vector<std::pair<double,double> > eta_cuts_;
     };
 }
 

DataFormats/interface/Photon.h

@@ -69,7 +69,7 @@ namespace flashgg {
         void updateEnergy( std::string key, float val );
         void shiftAllMvaValuesBy( float val );
         void shiftMvaValueBy( float val, edm::Ptr<reco::Vertex> vtx );
-        void shiftSigmaEOverEValueBy( float val );
+        void shiftSigmaEOverEValueBy( float val, float cutoff=0. );
         void smearSigmaEOverEValueBy( float val );
         //    void setSigEOverE(float val) { sigEOverE_ = val; };
 

DataFormats/interface/SigmaMpTTag.h

@@ -2,6 +2,7 @@
 #define flashgg_SigmaMpTTag
 
 #include "flashgg/DataFormats/interface/DiPhotonTagBase.h"
+#include "DataFormats/Candidate/interface/CompositeCandidate.h"
 
 namespace flashgg {
 
@@ -13,11 +14,16 @@ namespace flashgg {
 
         SigmaMpTTag( edm::Ptr<DiPhotonCandidate>, DiPhotonMVAResult );
         SigmaMpTTag( edm::Ptr<DiPhotonCandidate>, edm::Ptr<DiPhotonMVAResult> );
+
+        SigmaMpTTag( edm::Ptr<DiPhotonCandidate>, DiPhotonMVAResult, std::map<std::string, edm::Ptr<reco::CompositeCandidate> > );
+        SigmaMpTTag( edm::Ptr<DiPhotonCandidate>, edm::Ptr<DiPhotonMVAResult>, std::map<std::string, edm::Ptr<reco::CompositeCandidate> > );
+        const edm::Ptr<reco::CompositeCandidate > getCompCand(const std::string &name) const;
+
         virtual SigmaMpTTag *clone() const override;
         DiPhotonTagBase::tag_t tagEnum() const override {return DiPhotonTagBase::kUntagged; }
 
     private:
-
+        std::map<std::string, edm::Ptr<reco::CompositeCandidate > > compObjMap_;
 
 
     };

DataFormats/interface/TTHLeptonicTag.h

@@ -48,16 +48,16 @@ namespace flashgg {
         int subleadMomMomID() const { return sublead_motherMotherID_; }
         int subleadPassFrix() const { return sublead_passFrix_; }
         double subleadSmallestDr() const { return sublead_smallestDr_; }
-
+        
         void setJets( std::vector<edm::Ptr<Jet> > Jets ) { Jets_ = Jets; }
         void setBJets( std::vector<edm::Ptr<Jet> > BJets )  { BJets_ = BJets;}
         void setMuons( std::vector<edm::Ptr<Muon> > Muons ) {Muons_ = Muons;}
         void setElectrons( std::vector<edm::Ptr<Electron> > Electrons ) {Electrons_ = Electrons;}
-        void setLepPt( std::vector<double> lepPt) { lepPt_ = lepPt; }
-        void setLepE( std::vector<double> lepE) { lepE_ = lepE; }
-        void setLepEta( std::vector<double> lepEta) { lepEta_ = lepEta; }
-        void setLepPhi( std::vector<double> lepPhi) { lepPhi_ = lepPhi; }
-        void setLepType( std::vector<int> lepType) { lepType_ = lepType; }
+        void setLepPt( std::vector<double> lepPt ) { lepPt_ = lepPt; }
+        void setLepE( std::vector<double> lepE ) { lepE_ = lepE; }
+        void setLepEta( std::vector<double> lepEta ) { lepEta_ = lepEta; }
+        void setLepPhi( std::vector<double> lepPhi ) { lepPhi_ = lepPhi; }
+        void setLepType( std::vector<int> lepType ) { lepType_ = lepType; }
 
         void setLeadPrompt(int leadPrompt) { leadPrompt_ = leadPrompt; }
         void setSubleadPrompt(int subleadPrompt) { subleadPrompt_ = subleadPrompt; }
@@ -113,7 +113,6 @@ namespace flashgg {
         int sublead_motherMotherID_;
         int sublead_passFrix_;
         double sublead_smallestDr_;
-
         float mvaRes_;
     };
 }

DataFormats/src/Jet.cc

@@ -8,6 +8,10 @@ Jet::Jet() : pat::Jet()
     qglikelihood_ = -999.;
     simpleMVA_ = -999.;
     puJetId_.clear();
+    eta_cuts_.push_back( std::make_pair (0    ,2.50 ) );
+    eta_cuts_.push_back( std::make_pair (2.50 ,2.75 ) );
+    eta_cuts_.push_back( std::make_pair (2.75 ,3.00 ) );
+    eta_cuts_.push_back( std::make_pair (3.00 ,10) );
 }
 
 Jet::Jet( const pat::Jet &aJet ) : pat::Jet( aJet )
@@ -38,6 +42,8 @@ bool Jet::passesPuJetId( const edm::Ptr<reco::Vertex> vtx, PileupJetIdentifier::
     return true;
 }
 
+
+
 float Jet::rms( const edm::Ptr<reco::Vertex> vtx ) const
 {
     assert( hasPuJetId( vtx ) );
@@ -67,6 +73,117 @@ float Jet::betaStar( const edm::Ptr<DiPhotonCandidate> dipho ) const
     return betaStar( dipho->vtx() );
 }
 
+
+bool Jet::passesJetPuId( JetPuIdLevel level ) const
+{
+//    std::vector<double> _pujid_wp_pt_bin_1;    
+//    std::vector<double> _pujid_wp_pt_bin_2;
+//    std::vector<double> _pujid_wp_pt_bin_3;
+//
+//    if(mva_wp.size() == 3){
+//        std::vector<double> _pujid_wp_pt_bin_1 = mva_wp[0];
+//        std::vector<double> _pujid_wp_pt_bin_2 = mva_wp[1];
+//        std::vector<double> _pujid_wp_pt_bin_3 = mva_wp[2];
+//    }
+//    else{
+//        std::cout << "Error:: wrong size of cuts for mva jet ID !! expected 3 pt bins" << std::endl;
+//        return false;
+//    }
+    flashgg::Jet* ptr  = const_cast<flashgg::Jet*> (this);
+
+    switch(level){
+    case none:
+        {
+            ptr->_pujid_wp_pt_bin_1 = {-1,-1,-1,-1};
+            ptr->_pujid_wp_pt_bin_2 = {-1,-1,-1,-1};
+            ptr->_pujid_wp_pt_bin_3 = {-1,-1,-1,-1};
+        }break;
+    case loose:
+        {
+            ptr->_pujid_wp_pt_bin_1 = {-0.96, -0.64, -0.56, -0.54};
+            ptr->_pujid_wp_pt_bin_2 = {-0.92, -0.56, -0.44, -0.39};
+            ptr->_pujid_wp_pt_bin_3 = {-0.77, -0.31, -0.20, -0.03};
+        }break;
+
+    case medium:
+        {
+            ptr->_pujid_wp_pt_bin_1 = {-0.49, -0.53, -0.44, -0.42};
+            ptr->_pujid_wp_pt_bin_2 = {-0.06, -0.42, -0.30, -0.23};
+            ptr->_pujid_wp_pt_bin_3 = { 0.56, -0.10,  0.01,  0.13};
+        }break;
+    case tight:
+        {
+            ptr->_pujid_wp_pt_bin_1 = {0.26, -0.34, -0.24, -0.26};
+            ptr->_pujid_wp_pt_bin_2 = {0.62, -0.21, -0.07, -0.03};
+            ptr->_pujid_wp_pt_bin_3 = {0.87, 0.17 , 0.25 ,  0.33};
+        }break;
+    case mixed:
+        {
+            ptr->_pujid_wp_pt_bin_1 = {-0.96, -0.34, -0.24, -0.26};
+            ptr->_pujid_wp_pt_bin_2 = {-0.92, -0.21, -0.07, -0.03};
+            ptr->_pujid_wp_pt_bin_3 = {-0.77, 0.17 , 0.25 ,  0.33};
+        }break;
+    case forward_loose:
+        {
+            ptr->_pujid_wp_pt_bin_1 = {-1, -0.64, -0.56, -0.54};
+            ptr->_pujid_wp_pt_bin_2 = {-1, -0.56, -0.44, -0.39};
+            ptr->_pujid_wp_pt_bin_3 = {-1, -0.31, -0.20, -0.03};
+        }break;
+    case forward_medium:
+        {
+            ptr->_pujid_wp_pt_bin_1 = {-1, -0.53, -0.44, -0.42};
+            ptr->_pujid_wp_pt_bin_2 = {-1, -0.42, -0.30, -0.23};
+            ptr->_pujid_wp_pt_bin_3 = {-1, -0.10,  0.01,  0.13};
+        }break;
+    case forward_tight:
+        {
+            ptr->_pujid_wp_pt_bin_1 = {-1, -0.34, -0.24, -0.26};
+            ptr->_pujid_wp_pt_bin_2 = {-1, -0.21, -0.07, -0.03};
+            ptr->_pujid_wp_pt_bin_3 = {-1, 0.17 , 0.25 ,  0.33};
+        }break;
+    default:
+        {
+            std::cout << "error:: wrong level !!" << std::endl;
+        }
+        break;
+    }
+
+
+    bool pass=false;
+    if ( (!_pujid_wp_pt_bin_1.empty())  &&
+         (!_pujid_wp_pt_bin_2.empty())  &&
+         (!_pujid_wp_pt_bin_3.empty())  ){
+        //std::cout << "VBFTagMVA::DEBUG  making the pujid --> "<< _pujid_wp_pt_bin_1.size() << std::endl;
+        for (UInt_t eta_bin=0; eta_bin < _pujid_wp_pt_bin_1.size(); eta_bin++ ){
+            //                        std::cout << inputTagJets_[0] 
+            //        << " eta-bin["<< eta_bin<< "] == " << eta_cuts_[eta_bin].first << "  :: "
+            //        << eta_cuts_[eta_bin].second
+            //        << " pt1: " << _pujid_wp_pt_bin_1[eta_bin]
+            //        << " pt2: " << _pujid_wp_pt_bin_2[eta_bin]
+            //        << " pt3: " << _pujid_wp_pt_bin_3[eta_bin]
+            //        << std::endl;
+            if ( fabs( this->eta() ) >  eta_cuts_[eta_bin].first &&
+                 fabs( this->eta() ) <= eta_cuts_[eta_bin].second){
+                if ( this->pt() >  20 &&
+                     this->pt() <= 30 && this->puJetIdMVA() > _pujid_wp_pt_bin_1[eta_bin] )
+                    pass=true;
+                if ( this->pt() >  30 &&
+                     this->pt() <= 50 && this->puJetIdMVA() > _pujid_wp_pt_bin_2[eta_bin] )
+                    pass=true;
+                if ( this->pt() >  50 &&
+                     this->pt() <= 100&& this->puJetIdMVA() > _pujid_wp_pt_bin_3[eta_bin] )
+                    pass=true;
+                if (this->pt() > 100) pass = true;
+            }
+        }
+        //                    std::cout << inputTagJets_[0] << " pt="<< this->pt() << " :eta: "<< this->eta() << " :mva: "<< this->puJetIdMVA() << "  pass == " << pass << std::endl;
+    }
+
+
+    return pass;
+
+}
+
 bool Jet::passesJetID( JetIDLevel level) const
 {
     float eta      = this->eta();

DataFormats/src/Photon.cc

@@ -282,10 +282,10 @@ void Photon::shiftMvaValueBy( float val, edm::Ptr<reco::Vertex> vtx ) {
 }
 
 //sigmaEOverE systematycs
-void Photon::shiftSigmaEOverEValueBy( float val ) {
+void Photon::shiftSigmaEOverEValueBy( float val, float cutoff ) {
     const LorentzVector pho_p4 = p4(getCandidateP4type());
     float energyError = getCorrectedEnergyError(getCandidateP4type());
-    setP4(getCandidateP4type(), pho_p4, energyError*(1.+val), false);
+    setP4(getCandidateP4type(), pho_p4, energyError + val*(std::max(energyError, cutoff)), false);
 }