Reference Manual

Go to the documentation of this file.
00001 #ifndef RecoJets_JetPlusTrack_JetPlusTrackCorrector_h
00002 #define RecoJets_JetPlusTrack_JetPlusTrackCorrector_h
00003 
00004 #include "DataFormats/Common/interface/Handle.h"
00005 #include "DataFormats/Common/interface/ValueMap.h"
00006 #include "DataFormats/Common/interface/View.h"
00007 #include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
00008 #include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"
00009 #include "DataFormats/JetReco/interface/JetTracksAssociation.h"
00010 #include "DataFormats/Math/interface/LorentzVector.h"
00011 #include "DataFormats/MuonReco/interface/Muon.h"
00012 #include "DataFormats/MuonReco/interface/MuonFwd.h"
00013 #include "DataFormats/TrackReco/interface/Track.h"
00014 #include "DataFormats/TrackReco/interface/TrackFwd.h"
00015 #include "DataFormats/VertexReco/interface/VertexFwd.h"
00016 #include "DataFormats/VertexReco/interface/Vertex.h"
00017 #include "FWCore/Utilities/interface/InputTag.h"
00018 
00019 #include "boost/range/iterator_range.hpp"
00020 #include <sstream>
00021 #include <string>
00022 
00023 namespace edm {
00024   class Event;
00025   class EventSetup;
00026   class ParameterSet;
00027 }
00028 
00029 // --------------------------------------------------------
00030 // -------------------- Helper classes --------------------
00031 // --------------------------------------------------------
00032 
00033 
00034 namespace jpt {
00035   
00037   class Map {
00038 
00039   public:
00040 
00041     Map( std::string, bool verbose = false );
00042     Map();
00043     ~Map();
00044     
00045     uint32_t nEtaBins() const;
00046     uint32_t nPtBins() const;
00047     
00048     double eta( uint32_t ) const;
00049     double pt( uint32_t ) const;
00050 
00051     uint32_t etaBin( double eta ) const;
00052     uint32_t ptBin( double pt ) const;
00053     
00054     double value( uint32_t eta_bin, uint32_t pt_bin ) const;
00055 
00056     double binCenterEta( uint32_t ) const;
00057     double binCenterPt( uint32_t ) const;
00058     
00059     void clear();
00060     void print( std::stringstream& ss ) const;
00061 
00062   private:
00063 
00064     class Element {
00065     public:
00066       Element() : ieta_(0), ipt_(0), eta_(0.), pt_(0.), val_(0.) {;} 
00067       uint32_t ieta_;
00068       uint32_t ipt_;
00069       double eta_;
00070       double pt_;
00071       double val_;
00072     };
00073     
00074     typedef std::vector<double> VDouble;
00075     typedef std::vector<VDouble> VVDouble;
00076     
00077     std::vector<double> eta_;
00078     std::vector<double> pt_;
00079     VVDouble data_;
00080     
00081   };
00082 
00083   inline uint32_t Map::nEtaBins() const { return eta_.size(); }
00084   inline uint32_t Map::nPtBins() const { return pt_.size(); }
00085   
00087   class Efficiency {
00088 
00089   public:
00090 
00091     Efficiency( const jpt::Map& response,
00092                 const jpt::Map& efficiency,
00093                 const jpt::Map& leakage );
00094       
00095     typedef std::pair<uint16_t,double> Pair;
00096     
00097     uint16_t nTrks( uint32_t eta_bin, uint32_t pt_bin ) const;
00098     
00099     double inConeCorr( uint32_t eta_bin, uint32_t pt_bin ) const;
00100     double outOfConeCorr( uint32_t eta_bin, uint32_t pt_bin ) const;
00101     
00102     uint32_t nEtaBins() const;
00103     uint32_t nPtBins() const;
00104 
00105     uint32_t size() const;
00106     bool empty() const;
00107     
00108     void addE( uint32_t eta_bin, uint32_t pt_bin, double energy );
00109     void reset();
00110     
00111     void print() const;
00112     
00113   private:
00114     
00115     Efficiency();
00116 
00117     double sumE( uint32_t eta_bin, uint32_t pt_bin ) const;
00118     double meanE( uint32_t eta_bin, uint32_t pt_bin ) const;
00119 
00120     bool check( uint32_t eta_bin, uint32_t pt_bin, std::string name = "check" ) const;
00121 
00122     typedef std::vector<Pair> VPair;
00123     typedef std::vector<VPair> VVPair;
00124     VVPair data_;
00125 
00126     const jpt::Map& response_;
00127     const jpt::Map& efficiency_;
00128     const jpt::Map& leakage_;
00129     
00130   };
00131   
00132   inline uint32_t Efficiency::nEtaBins() const { return response_.nEtaBins(); }
00133   inline uint32_t Efficiency::nPtBins() const { return response_.nPtBins(); }
00134   inline uint32_t Efficiency::size() const { return data_.size(); }
00135   inline bool Efficiency::empty() const { return data_.empty(); }
00136 
00138   class JetTracks {
00139   public:
00140     JetTracks();
00141     ~JetTracks();
00142     void clear();
00143     reco::TrackRefVector vertex_;
00144     reco::TrackRefVector caloFace_;
00145   };
00146 
00148   class MatchedTracks {
00149   public:
00150     MatchedTracks();
00151     ~MatchedTracks();
00152     void clear();
00153     reco::TrackRefVector inVertexInCalo_;
00154     reco::TrackRefVector outOfVertexInCalo_;
00155     reco::TrackRefVector inVertexOutOfCalo_; 
00156   };
00157   
00158 //class Sum {
00159 //public:
00160 //  Sum() { theResponseOfChargedWithEff = 0.; theResponseOfChargedFull = 0.;}
00161 //  void set( double a, double b) const {theResponseOfChargedWithEff=a;theResponseOfChargedFull=b;}
00162 //  double theResponseOfChargedWithEff;
00163 //  double theResponseOfChargedFull;
00164 //};
00165 
00166 }
00167 
00168 
00169 // -------------------------------------------------------
00170 // -------------------- JPT algorithm --------------------
00171 // -------------------------------------------------------
00172 
00176 class JetPlusTrackCorrector {
00177 
00178   // ---------- Public interface ----------
00179   
00180  public: 
00181 
00183   JetPlusTrackCorrector( const edm::ParameterSet& );
00184 
00186   virtual ~JetPlusTrackCorrector();
00187 
00188   // Typedefs for 4-momentum
00189   typedef math::XYZTLorentzVector       P4;
00190   typedef math::PtEtaPhiELorentzVectorD PtEtaPhiE;
00191   typedef math::PtEtaPhiMLorentzVectorD PtEtaPhiM;
00192   
00194   double correction( const reco::Jet&, const reco::Jet&, const edm::Event&, const edm::EventSetup&, P4& ) const;
00195   
00197   double correction( const reco::Jet&, const reco::Jet&, const edm::Event&, const edm::EventSetup& ) const;
00198   
00200   double correction( const reco::Jet& ) const;
00201 
00203   double correction( const P4& ) const;
00204 
00206   
00207 //  double correctAA(  const reco::Jet&, const reco::TrackRefVector&, double&, const reco::TrackRefVector&,const reco::TrackRefVector&, double&) const;
00208   double correctAA(  const reco::Jet&, const reco::TrackRefVector&, double&, const reco::TrackRefVector&,const reco::TrackRefVector&,
00209                                                            double,
00210                                                            const reco::TrackRefVector&) const;
00211 
00212   
00214   bool eventRequired() const;
00215   
00217   bool vectorialCorrection() const;
00218   
00219   // ---------- Extended interface ----------
00220 
00222 
00223   double getResponseOfChargedWithEff() {return theResponseOfChargedWithEff;}
00224   double getResponseOfChargedWithoutEff() {return theResponseOfChargedWithoutEff;}
00225   double getSumPtWithEff() {return theSumPtWithEff;}
00226   double getSumPtWithoutEff() {return theSumPtWithoutEff;}
00227   double getSumEnergyWithEff() {return theSumEnergyWithEff;}
00228   double getSumEnergyWithoutEff() {return theSumEnergyWithoutEff;}
00229 
00230 
00232   bool canCorrect( const reco::Jet& ) const;
00233   
00235   bool matchTracks( const reco::Jet&, 
00236                     const edm::Event&, 
00237                     const edm::EventSetup&,
00238                     jpt::MatchedTracks& pions, 
00239                     jpt::MatchedTracks& muons, 
00240                     jpt::MatchedTracks& elecs ) const;
00241   
00243   P4 pionCorrection( const P4& jet, const jpt::MatchedTracks& pions ) const;
00244   
00246   P4 muonCorrection( const P4& jet, const jpt::MatchedTracks& muons ) const;
00247   
00249   P4 elecCorrection( const P4& jet, const jpt::MatchedTracks& elecs ) const;
00250 
00252    
00253 //  double theResponseOfChargedWithEff;
00254 //  double theResponseOfChargedFull;
00255 //  double setResp(double a) const {return a;}
00256 //  double getChargedResponsesWithEff() { return theResponseOfChargedWithEff;}
00257 //  double getChargedResponsesFull() { return theResponseOfChargedFull;}
00258   
00259   // ---------- Protected interface ----------
00260 
00261  protected: 
00262 
00263   // Some useful typedefs
00264   typedef reco::MuonCollection RecoMuons;
00265   typedef reco::GsfElectronCollection RecoElectrons;
00266   typedef edm::ValueMap<float> RecoElectronIds;
00267   typedef reco::JetTracksAssociation::Container JetTracksAssociations;
00268   typedef reco::TrackRefVector TrackRefs;
00269 
00271   virtual bool jetTrackAssociation( const reco::Jet&, 
00272                                     const edm::Event&, 
00273                                     const edm::EventSetup&,
00274                                     jpt::JetTracks& ) const;
00275   
00277   bool jtaUsingEventData( const reco::Jet&, 
00278                           const edm::Event&, 
00279                           jpt::JetTracks& ) const;
00280   
00282   virtual void matchTracks( const jpt::JetTracks&,
00283                             const edm::Event&, 
00284                             jpt::MatchedTracks& pions, 
00285                             jpt::MatchedTracks& muons, 
00286                             jpt::MatchedTracks& elecs ) const;
00287 
00289   P4 pionCorrection( const P4& jet, 
00290                      const TrackRefs& pions, 
00291                      jpt::Efficiency&,
00292                      bool in_cone_at_vertex,
00293                      bool in_cone_at_calo_face ) const; 
00294 
00296   P4 muonCorrection( const P4& jet, 
00297                      const TrackRefs& muons, 
00298                      bool in_cone_at_vertex,
00299                      bool in_cone_at_calo_face ) const;
00300   
00302   P4 elecCorrection( const P4& jet, 
00303                      const TrackRefs& elecs, 
00304                      bool in_cone_at_vertex,
00305                      bool in_cone_at_calo_face ) const;
00306 
00308   P4 jetDirFromTracks( const P4& jet, 
00309                        const jpt::MatchedTracks& pions,
00310                        const jpt::MatchedTracks& muons,
00311                        const jpt::MatchedTracks& elecs ) const;
00312   
00314   P4 calculateCorr( const P4& jet, 
00315                     const TrackRefs&, 
00316                     jpt::Efficiency&,
00317                     bool in_cone_at_vertex,
00318                     bool in_cone_at_calo_face,
00319                     double mass,
00320                     bool is_pion,
00321                     double mip ) const;
00322   
00324   P4 pionEfficiency( const P4& jet, 
00325                      const jpt::Efficiency&,
00326                      bool in_cone_at_calo_face ) const;
00327   
00329   double checkScale( const P4& jet, P4& corrected ) const;
00330   
00332   bool getMuons( const edm::Event&, edm::Handle<RecoMuons>& ) const;
00333 
00335   bool getElectrons( const edm::Event&, 
00336                      edm::Handle<RecoElectrons>&, 
00337                      edm::Handle<RecoElectronIds>& ) const;
00338   
00340   bool matchMuons( TrackRefs::const_iterator,
00341                    const edm::Handle<RecoMuons>& ) const;
00342   
00344   bool matchElectrons( TrackRefs::const_iterator,
00345                        const edm::Handle<RecoElectrons>&, 
00346                        const edm::Handle<RecoElectronIds>& ) const;
00347   
00349   bool failTrackQuality( TrackRefs::const_iterator ) const;
00350 
00352   bool findTrack( const jpt::JetTracks&, 
00353                   TrackRefs::const_iterator,
00354                   TrackRefs::iterator& ) const;
00355 
00357   bool findTrack( const jpt::MatchedTracks& pions, 
00358                   const jpt::MatchedTracks& muons,
00359                   const jpt::MatchedTracks& electrons,
00360                   TrackRefs::const_iterator ) const;
00361 
00363   bool tracksInCalo( const jpt::MatchedTracks& pions, 
00364                      const jpt::MatchedTracks& muons,
00365                      const jpt::MatchedTracks& elecs ) const;
00366   
00368   void rebuildJta( const reco::Jet&, 
00369                    const JetTracksAssociations&, 
00370                    TrackRefs& included,
00371                    TrackRefs& excluded ) const;
00372   
00374   void excludeJta( const reco::Jet&, 
00375                    const JetTracksAssociations&, 
00376                    TrackRefs& included,
00377                    const TrackRefs& excluded ) const;
00378   
00379   const jpt::Map& responseMap() const;
00380   const jpt::Map& efficiencyMap() const;
00381   const jpt::Map& leakageMap() const;
00382   
00384   JetPlusTrackCorrector() {;}
00385 
00386   // ---------- Protected member data ----------
00387 
00388  protected:
00389   
00390   // Some general configuration
00391   bool verbose_;
00392   bool vectorial_;
00393   bool vecResponse_;
00394   bool useInConeTracks_;
00395   bool useOutOfConeTracks_;
00396   bool useOutOfVertexTracks_;
00397   bool usePions_;
00398   bool useEff_;
00399   bool useMuons_;
00400   bool useElecs_;
00401   bool useTrackQuality_;
00402   
00403   // Jet-track association
00404   edm::InputTag jetTracksAtVertex_;
00405   edm::InputTag jetTracksAtCalo_;
00406   int jetSplitMerge_;
00407   edm::InputTag srcPVs_;
00408   double ptErrorQuality_;
00409   double dzVertexCut_;
00410   mutable reco::Particle::Point vertex_;
00411 
00412   // Muons and electrons
00413   edm::InputTag muons_;
00414   edm::InputTag electrons_; 
00415   edm::InputTag electronIds_;
00416   
00417   // Filter tracks by quality
00418   reco::TrackBase::TrackQuality trackQuality_;
00419 
00420   // Response and efficiency maps  
00421   const jpt::Map response_;
00422   const jpt::Map efficiency_;
00423   const jpt::Map leakage_;
00424 
00425   // Mass    
00426   double pionMass_;
00427   double muonMass_;
00428   double elecMass_;
00429 
00430   // Jet-related
00431   double maxEta_;
00432   mutable float theResponseOfChargedWithEff;
00433   mutable float theResponseOfChargedWithoutEff;
00434   mutable float theSumPtWithEff;
00435   mutable float theSumPtWithoutEff;
00436   mutable float theSumEnergyWithEff;
00437   mutable float theSumEnergyWithoutEff;
00438   
00439 };
00440 
00441 // ---------- Inline methods ----------
00442 
00443 inline double JetPlusTrackCorrector::correction( const reco::Jet& fJet, const reco::Jet& fJetcalo,
00444                                                  const edm::Event& event,
00445                                                  const edm::EventSetup& setup ) const {
00446   P4 not_used_for_scalar_correction;
00447   return correction( fJet, fJetcalo, event, setup, not_used_for_scalar_correction );
00448 }
00449 
00450 inline bool JetPlusTrackCorrector::eventRequired() const { return true; }
00451 inline bool JetPlusTrackCorrector::vectorialCorrection() const { return vectorial_; }
00452 inline bool JetPlusTrackCorrector::canCorrect( const reco::Jet& jet ) const { return ( fabs( jet.eta() ) <= maxEta_ ); }
00453 
00454 inline JetPlusTrackCorrector::P4 JetPlusTrackCorrector::pionCorrection( const P4& jet, 
00455                                                                         const TrackRefs& pions, 
00456                                                                         jpt::Efficiency& eff,
00457                                                                         bool in_cone_at_vertex,
00458                                                                         bool in_cone_at_calo_face ) const {
00459   return calculateCorr( jet, pions, eff, in_cone_at_vertex, in_cone_at_calo_face, pionMass_, true, -1. );
00460 }
00461 
00462 inline JetPlusTrackCorrector::P4 JetPlusTrackCorrector::muonCorrection( const P4& jet, 
00463                                                                         const TrackRefs& muons, 
00464                                                                         bool in_cone_at_vertex,
00465                                                                         bool in_cone_at_calo_face ) const {
00466   static jpt::Efficiency not_used( responseMap(), efficiencyMap(), leakageMap() );
00467   return calculateCorr( jet, muons, not_used, in_cone_at_vertex, in_cone_at_calo_face, muonMass_, false, 2. );
00468 } 
00469 
00470 inline JetPlusTrackCorrector::P4 JetPlusTrackCorrector::elecCorrection( const P4& jet, 
00471                                                                         const TrackRefs& elecs, 
00472                                                                         bool in_cone_at_vertex,
00473                                                                         bool in_cone_at_calo_face ) const {
00474   static jpt::Efficiency not_used( responseMap(), efficiencyMap(), leakageMap() );
00475   return calculateCorr( jet, elecs, not_used, in_cone_at_vertex, in_cone_at_calo_face, elecMass_, false, 0. ); 
00476 } 
00477 
00478 inline double JetPlusTrackCorrector::checkScale( const P4& jet, P4& corrected ) const {
00479   if ( jet.energy() > 0. && ( corrected.energy() / jet.energy() ) < 0. ) { 
00480     corrected = jet; 
00481   }
00482   return corrected.energy() / jet.energy();
00483 }
00484 
00485 inline const jpt::Map& JetPlusTrackCorrector::responseMap() const { return response_; }
00486 inline const jpt::Map& JetPlusTrackCorrector::efficiencyMap() const { return efficiency_; }
00487 inline const jpt::Map& JetPlusTrackCorrector::leakageMap() const { return leakage_; }
00488 
00489 #endif // RecoJets_JetPlusTracks_JetPlusTrackCorrector_h
/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/RecoJets/JetPlusTracks/interface/JetPlusTrackCorrector.h
