Jet.h

Go to the documentation of this file.

#ifndef Analysis_Tools_Jet_h
#define Analysis_Tools_Jet_h 1

// -*- C++ -*-
//
// Package:    Analysis/Tools
// Class:      Jet
// 
//
// Original Author:  Roberval Walsh Bastos Rangel
//         Created:  Mon, 20 Oct 2014 14:24:08 GMT
//
//

// system include files
#include <memory>
#include <boost/any.hpp>
//

// 
// user include files
#include "Analysis/Tools/interface/Candidate.h"
#include "Analysis/Tools/interface/Muon.h"
#include "Analysis/Tools/interface/GenParticle.h"
#include "Analysis/Tools/interface/GenJet.h"
#include "Analysis/Tools/interface/BTagCalibrationStandalone.h"
#include "Analysis/Tools/interface/Utils.h"


//
// class declaration
//



using namespace JME;

namespace analysis {
   namespace tools {
      
      struct JERCorrections
      {
         float nominal;
         float up;
         float down;
      };
      
      class Jet : public Candidate {
         public:
            Jet();
            Jet(const float & pt, const float & eta, const float & phi, const float & e);
            Jet(const TLorentzVector & p4);
           ~Jet();
           
            // Gets
           
            bool  isPuppi()                     const;
//            float btag()                        const;
            float btag(const std::string & )    const;
            int   flavour()                     const;
            int   flavour(const std::string & ) const;
            bool  idLoose()                     const;
            bool  idTight()                     const;
            bool  id(const std::string & wp = "tight" )  const;
            float jecUncert()                   const;
            std::vector<int> flavours()         const;
            std::string extendedFlavour()       const;
            std::vector< std::shared_ptr<GenParticle> > partons() const;
            float jerPtResolution() const;
            float jerPtResolution(const JetResolution &) const;
            float jerSF() const;
            float jerSF(const JetResolutionScaleFactor &) const;
            float jerSFdown() const;
            float jerSFdown(const JetResolutionScaleFactor &) const;
            float jerSFup() const;
            float jerSFup(const JetResolutionScaleFactor &) const;
            
            bool jerMatch(const std::string &);
            bool jerMatch(const float & drmin=0.2);
            bool jerMatch() const;
            
            void jerCorrections();
            float jerCorrection(const std::string & var = "nominal", const float & nsig = 1) const;
            
            float neutralHadronFraction()  const ;
            float neutralEmFraction()      const ;
            float neutralMultiplicity()    const ;
            float chargedHadronFraction()  const ;
            float chargedEmFraction()      const ;
            float chargedMultiplicity()    const ;
            float muonFraction()           const ;
            float constituents()           const ;
            
            float qgLikelihood()  const;
            
            float pileupJetIdFullDiscriminant() const;
            int pileupJetIdFullId() const;
            bool pileupJetIdFullId(const std::string & wp) const;
            
            float bRegCorr() const;
            float bRegRes()  const;
            
            double rho() const;
            
            double btagSF    (std::shared_ptr<BTagCalibrationReader> reader, const std::string & flavalgo = "Hadron") const;
            double btagSFup  (std::shared_ptr<BTagCalibrationReader> reader, const float & nsig = 1, const std::string & flavalgo = "Hadron") const;
            double btagSFdown(std::shared_ptr<BTagCalibrationReader> reader, const float & nsig = 1, const std::string & flavalgo = "Hadron") const;
            double btagSFsys (std::shared_ptr<BTagCalibrationReader> reader, const std::string & systype  = "central", const std::string & flavalgo = "Hadron") const;
            
            Jet * fsrJet();
            
            std::shared_ptr<Muon> muon() const;
            
            std::shared_ptr<GenJet> generatedJet() const;
//            GenJet * generatedJet(const std::vector<GenJet*> &, const float &);
               
            // Sets
            void  isPuppi(const bool &);
            void  btag(const float &);
            void  btag(const std::string &, const float &);
            void  btagAlgo(const std::string & );
            void  flavour(const int &);
            void  flavour(const std::string & definition, const int & value);
            void  idLoose(const bool &);
            void  idTight(const bool &);
            void  jecUncert(const float &);
            void jerPtResolution(const float &);
            void jerSF(const float &);
            void jerSFup(const float &);
            void jerSFdown(const float &);
            
            void jerInfo(const JetResolutionInfo &, const std::string &);
            void jerInfo(const JetResolutionInfo &, const float & drmin=0.2);
            void applyJER(const JetResolutionInfo &, const float & drmin=0.2);
            
            void addParton(const std::shared_ptr<GenParticle> &);
            int removeParton(const int &);
            
            void neutralHadronFraction(const float & nHadFrac);
            void neutralEmFraction(const float & nEmFrac);
            void neutralMultiplicity(const float & nMult);
            void chargedHadronFraction(const float & cHadFrac);
            void chargedEmFraction(const float & cEmFrac);
            void chargedMultiplicity(const float & cMult);
            void muonFraction(const float & muFrac);
            
//             void id(const float & nHadFrac,
//                     const float & nEmFrac ,
//                     const float & nMult   ,
//                     const float & cHadFrac,
//                     const float & cEmFrac ,
//                     const float & cMult   ,
//                     const float & muFrac  );
            
            void id(const float & nHadFrac,
                    const float & nEmFrac ,
                    const float & nMult   ,
                    const float & cHadFrac,
                    const float & cEmFrac ,
                    const float & cMult   ,
                    const float & muFrac  ,
                    const float & puppi   );
            
            void qgLikelihood(const float & discr);
            
            void pileupJetIdFullDiscriminant(const float & discr);
            void pileupJetIdFullId(const int & id);
            
            void bRegCorr(const float &);
            void bRegRes(const float &);
            
            void applyBjetRegression();
            
            void rho(const double &);
            
            
            void associatePartons(const std::vector< std::shared_ptr<GenParticle> > &, const float & dRmax = 0.5, const float & ptMin = 1., const bool & pythi8 = true );
//            using Candidate::set; // in case needed to overload the function set
            
            void genJets(const std::vector< std::shared_ptr<GenJet> > &);
            
            void addFSR(Jet*);
            void rmFSR();
            
            void addMuon(std::shared_ptr<Muon>);
            void addMuon(std::vector< std::shared_ptr<Muon> > muons, const float & dr = 0.4);
            void rmMuon();
            
            void generatedJet(std::shared_ptr<GenJet>);
            
            
         protected:
            // ----------member data ---------------------------
            //
               
            // Jet type
            bool isPuppi_;
            float btag_ ;
            std::map<std::string, float> btags_ ;
            std::string btagAlgo_;
            std::map<std::string, int> flavour_;
            std::vector<int> flavours_;
            std::string extendedFlavour_;
            std::vector< std::shared_ptr<GenParticle> > partons_;
            bool  idloose_;
            bool  idtight_;
            float jecUnc_;
            float jersf_;
            float jersfup_;
            float jersfdown_;
            float jerptres_;
            bool jermatch_;
            JERCorrections jercorr_;
            JetResolutionInfo jerinfo_;
            
            float nHadFrac_;
            float nEmFrac_;
            float nMult_;
            float cHadFrac_;
            float cEmFrac_;
            float cMult_;
            float muFrac_;
            float nConst_;
            float qgLikelihood_;
            float puJetIdFullDisc_;
            int   puJetIdFullId_;
            
            float bRegCorr_;
            float bRegRes_;
            
            double rho_;
            
            Jet * fsr_;
            TLorentzVector uncorrJetp4_;
            
            std::shared_ptr<GenJet> genjet_;
            
            std::vector< std::shared_ptr<GenJet> > genjets_;
            
            
            std::shared_ptr<Muon> muon_;
            
            
         private:
            // ----------member data ---------------------------
            
      };
   }
}

#endif  // Analysis_Tools_Jet_h