From d26f82d844d2697714bcbe154d7368551f6b7785 Mon Sep 17 00:00:00 2001 From: Olga Kodolova Date: Mon, 8 Jun 2020 16:28:50 +0200 Subject: [PATCH 01/14] TrackJet seeds adding --- .../plugins/JetPlusTrackAddonSeedProducer.cc | 234 ++++++++++++++++++ .../plugins/JetPlusTrackAddonSeedProducer.h | 69 ++++++ .../plugins/TrackFromPFProducer.cc | 62 +++++ .../plugins/TrackFromPFProducer.h | 28 +++ .../python/PATJetPlusTrackCorrections_cff.py | 87 +++++++ 5 files changed, 480 insertions(+) create mode 100644 RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc create mode 100644 RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.h create mode 100644 RecoJets/JetPlusTracks/plugins/TrackFromPFProducer.cc create mode 100644 RecoJets/JetPlusTracks/plugins/TrackFromPFProducer.h create mode 100644 RecoJets/JetPlusTracks/python/PATJetPlusTrackCorrections_cff.py diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc new file mode 100644 index 0000000000000..80024a3144fe7 --- /dev/null +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc @@ -0,0 +1,234 @@ +// -*- C++ -*- +// +// Package: JetPlusTracks +// Class: JetPlusTrackProducer +// +/**\class JetPlusTrackProducer JetPlusTrackProducer.cc JetPlusTrackProducer.cc + + Description: [one line class summary] + + Implementation: + [Notes on implementation] +*/ +// +// Original Author: Olga Kodolova,40 R-A12,+41227671273, +// Created: Fri Feb 19 10:14:02 CET 2010 +// +// + + +// system include files +#include + +// user include files + +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.h" +#include "DataFormats/JetReco/interface/CaloJetCollection.h" +#include "DataFormats/JetReco/interface/CaloJet.h" +#include "DataFormats/JetReco/interface/JPTJetCollection.h" +#include "DataFormats/JetReco/interface/JPTJet.h" +#include "DataFormats/JetReco/interface/TrackJetCollection.h" +#include "DataFormats/JetReco/interface/TrackJet.h" +#include "DataFormats/TrackReco/interface/TrackFwd.h" +#include "DataFormats/TrackReco/interface/Track.h" +#include "DataFormats/JetReco/interface/Jet.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/Math/interface/deltaPhi.h" +#include "DataFormats/Math/interface/deltaR.h" + +#include + +using namespace std; + +// +// constants, enums and typedefs +// + + +// +// static data member definitions +// + +// +// constructors and destructor +// +JetPlusTrackAddonSeedProducer::JetPlusTrackAddonSeedProducer(const edm::ParameterSet& iConfig) +{ + //register your products + srcCaloJets = iConfig.getParameter("srcCaloJets"); + srcTrackJets = iConfig.getParameter("srcTrackJets"); + srcPVs_ = iConfig.getParameter("srcPVs"); + ptCUT = iConfig.getParameter("ptCUT"); + usePAT = iConfig.getParameter("UsePAT"); + + produces("ak4CaloJetsJPTSeed"); + + input_jets_token_ = consumes >(srcCaloJets); + input_trackjets_token_ = consumes >(srcTrackJets); + input_vertex_token_ = consumes(srcPVs_); + tokenPFCandidates_ = consumes(iConfig.getParameter("PFCandidates")); + input_ctw_token_ = consumes(iConfig.getParameter("towerMaker")); +} + + +JetPlusTrackAddonSeedProducer::~JetPlusTrackAddonSeedProducer() +{ + + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) + +} + + +// +// member functions +// + +// ------------ method called to produce the data ------------ +void +JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + using namespace edm; + + + // std::cout<<" RecoJets::JetPlusTrackAddonSeedProducer::produce "< > jets_h; + iEvent.getByToken (input_jets_token_, jets_h); + + edm::Handle > jetsTrackJets; + iEvent.getByToken(input_trackjets_token_, jetsTrackJets); + + auto pCaloOut = std::make_unique(); + + if (jetsTrackJets.isValid()) { + if(jetsTrackJets->size() > 0 ) { + // std::cout<<" AddonSeed::The size of trackjets "<size()<<" "<size()<size(); ++ijet) { + const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet))); + int iflag = 0; + for (unsigned i = 0; i < jets_h->size(); ++i) { + const reco::CaloJet* oldjet = &(*(jets_h->refAt(i))); + double deta = fabs(jet->eta()-oldjet->eta()); + double dphi = fabs(jet->phi()-oldjet->phi()); + if(dphi>4.*atan(1.)) dphi = 8.*atan(1.) - dphi; + double dr = sqrt(dphi*dphi+deta*deta); + if(dr<0.4) iflag = 1; + } // Calojets + + if(iflag == 1) continue; + // std::cout<<" AddonSeed::There is the additional trackjet seed "<pt()<<" "<eta()<< + // " "<phi()< pfCandidates; + iEvent.getByToken( tokenPFCandidates_, pfCandidates); + if(!pfCandidates.isValid()) { + // std::cout<<" No PFCandidate collection "<size(); i < n; ++i) { + const pat::PackedCandidate &pf = (*pfCandidates)[i]; + double deta=(*jet).eta()-pf.eta(); + double dphi=(*jet).phi()-pf.phi(); + + if(dphi > 4.*atan(1.) ) dphi = dphi-8.*atan(1.); + if(dphi < -1.*4.*atan(1.) ) dphi = dphi+8.*atan(1.); + double dr = sqrt(dphi*dphi+deta*deta); + if(dr>0.4) continue; + // jetconstit + caloen = caloen + pf.energy()*pf.caloFraction(); + hadinho += 0.; + if(fabs(pf.eta())<=1.4) hadinhb += pf.energy()*pf.caloFraction()*pf.hcalFraction(); + if(fabs(pf.eta())<3.&&(fabs(pf.eta())>3.)>1.4) hadinhe += pf.energy()*pf.caloFraction()*pf.hcalFraction(); + if(fabs(pf.eta())>=3.) hadinhf += pf.energy()*pf.caloFraction()*pf.hcalFraction(); + if(fabs(pf.eta())<=1.4) emineb += pf.energy()*pf.caloFraction()*(1.-pf.hcalFraction()); + if(fabs(pf.eta())<3.&&(fabs(pf.eta())>3.)>1.4) eminee += pf.energy()*pf.caloFraction()*(1.-pf.hcalFraction()); + if(fabs(pf.eta())>=3.) eminhf += pf.energy()*pf.caloFraction()*(1.-pf.hcalFraction()); + ncand++; + } // Calojet + } + } else { + // std::cout<<" RECO "< ct; + bool getFromFwdPtr = iEvent.getByToken(input_ctw_token_, ct); + for(CaloTowerCollection::const_iterator it = ct->begin();it != ct->end(); it++) { + double deta=(*jet).eta()-(*it).eta(); + double dphi=(*jet).phi()-(*it).phi(); + if(dphi > 4.*atan(1.) ) dphi = dphi-8.*atan(1.); + if(dphi < -1.*4.*atan(1.) ) dphi = dphi+8.*atan(1.); + double dr = sqrt(dphi*dphi+deta*deta); + if(dr>0.4) continue; + caloen = caloen + (*it).energy(); + hadinho += (*it).energyInHO(); + hadinhb += (*it).energyInHB(); + hadinhe += (*it).energyInHE(); + hadinhf += 0.5*(*it).energyInHF(); + emineb += (*it).energy()-(*it).energyInHB(); + eminee += (*it).energy()-(*it).energyInHE(); + eminhf += 0.5*(*it).energyInHF(); + double eeen = 2.*(*it).energy()-(*it).energyInHB()-(*it).energyInHE(); + double hcen = (*it).energyInHB()+(*it).energyInHE()+(*it).energyInHO()+0.5*(*it).energyInHF(); + ncand++; + } + } + eefraction = (emineb+eminee)/caloen; + hhfraction = (hadinhb+hadinhe+hadinhf+hadinho)/caloen; + + double trackp = sqrt(pow(jet->pt(),2)+pow(jet->pz(),2)); + // std::cout<<" Caloenergy "<jetArea()<px()/trackp, + caloen*jet->py()/trackp, + caloen*jet->pz()/trackp, + caloen); + reco::CaloJet::Specific calospe; + calospe.mTowersArea = -1*ncand; + calospe.mHadEnergyInHO=hadinho; + calospe.mHadEnergyInHB=hadinhb; + calospe.mHadEnergyInHE=hadinhe; + calospe.mHadEnergyInHF=hadinhf; + calospe.mEmEnergyInEB=emineb; + calospe.mEmEnergyInEE=eminee; + calospe.mEmEnergyInHF=eminhf; + calospe.mEnergyFractionEm=eefraction/caloen; + calospe.mEnergyFractionHadronic=hhfraction/caloen; + + reco::CaloJet mycalo(pcalo4,jet->primaryVertex()->position(),calospe); + mycalo.setJetArea(0.5024); + + //std::cout<<" AddonSeed::New Calojet "<jetArea()<push_back(mycalo); + + } // trackjets + } // jets + } // There is trackjet collection + + // std::cout<<" AddonSeed::size of collection "<size()< + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/JetReco/interface/CaloJet.h" +#include "DataFormats/JetReco/interface/TrackJet.h" +#include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/JetReco/interface/TrackExtrapolation.h" +#include "DataFormats/PatCandidates/interface/Electron.h" +#include "DataFormats/PatCandidates/interface/Jet.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" +#include "DataFormats/CaloTowers/interface/CaloTowerCollection.h" +#include "DataFormats/PatCandidates/interface/VIDCutFlowResult.h" +#include "DataFormats/PatCandidates/interface/Muon.h" + +#include + +// +// class declaration +// + +class JetPlusTrackAddonSeedProducer : public edm::stream::EDProducer<> { + public: + explicit JetPlusTrackAddonSeedProducer(const edm::ParameterSet&); + ~JetPlusTrackAddonSeedProducer() override; + void produce(edm::Event&, const edm::EventSetup&) override; + + // ---------- private data members --------------------------- + private: + + edm::InputTag srcCaloJets; + edm::InputTag srcTrackJets; + edm::InputTag srcPVs_; + + std::string alias; + double ptCUT; + bool usePAT; + edm::EDGetTokenT > input_jets_token_; + edm::EDGetTokenT > input_trackjets_token_; + edm::EDGetTokenT input_vertex_token_; + edm::EDGetTokenT > tokenPFCandidates_; + edm::EDGetTokenT input_ctw_token_; + +}; diff --git a/RecoJets/JetPlusTracks/plugins/TrackFromPFProducer.cc b/RecoJets/JetPlusTracks/plugins/TrackFromPFProducer.cc new file mode 100644 index 0000000000000..24954ce361c26 --- /dev/null +++ b/RecoJets/JetPlusTracks/plugins/TrackFromPFProducer.cc @@ -0,0 +1,62 @@ +#include "RecoJets/JetPlusTracks/plugins/TrackFromPFProducer.h" +// system include files +#include +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "TrackingTools/GeomPropagators/interface/Propagator.h" +#include "TrackingTools/PatternTools/interface/Trajectory.h" + +#include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h" + +#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" + +#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" +#include "Geometry/Records/interface/TrackerTopologyRcd.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +TrackFromPFProducer::TrackFromPFProducer(const edm::ParameterSet& iConfig) +{ + tokenPFCandidates_=consumes(iConfig.getParameter( "PFCandidates" )); + tokenPFCandidatesLostTracks_=consumes(iConfig.getParameter( "PFCandidatesLostTracks" )); + produces("tracksFromPF"); +} + + +void TrackFromPFProducer::produce(edm::Event& theEvent, const edm::EventSetup& setup) +{ + // + // create empty output collections + // + auto outputTColl = std::make_unique(); + + // std::cout<<" TrackFromPFProducer::produce "< pfCandidates; + theEvent.getByToken( tokenPFCandidates_, pfCandidates); + + for(unsigned int i = 0, n = pfCandidates->size(); i < n; ++i) { + const pat::PackedCandidate &pf = (*pfCandidates)[i]; + if(pf.hasTrackDetails()){ + reco::Track mytrack = pf.pseudoTrack(); + + // std::cout<<" Track "<push_back(mytrack); + } + //else { + // if(pf.charge()>0) std::cout< { +public: + + /// Constructor + explicit TrackFromPFProducer(const edm::ParameterSet& iConfig); + + /// Implementation of produce method + void produce(edm::Event&, const edm::EventSetup&) override; + +private: + edm::EDGetTokenT > tokenPFCandidates_; + edm::EDGetTokenT > tokenPFCandidatesLostTracks_; + +}; + +#endif diff --git a/RecoJets/JetPlusTracks/python/PATJetPlusTrackCorrections_cff.py b/RecoJets/JetPlusTracks/python/PATJetPlusTrackCorrections_cff.py new file mode 100644 index 0000000000000..be33f6785c73c --- /dev/null +++ b/RecoJets/JetPlusTracks/python/PATJetPlusTrackCorrections_cff.py @@ -0,0 +1,87 @@ +import FWCore.ParameterSet.Config as cms +# ---------- Add assigned jet-track association + +from RecoJets.JetAssociationProducers.trackExtrapolator_cfi import * +trackExtrapolator.trackSrc = cms.InputTag("produceTracks:tracksFromPF") +trackExtrapolator.trackQuality = cms.string('highPurity') + +from RecoJets.JetAssociationProducers.ak4JTA_cff import * +ak4JetTracksAssociatorAtVertexJPTPAT = ak4JetTracksAssociatorAtVertex.clone() +ak4JetTracksAssociatorAtVertexJPTPAT.useAssigned = cms.bool(True) +ak4JetTracksAssociatorAtVertexJPTPAT.pvSrc = cms.InputTag("offlineSlimmedPrimaryVertices") +ak4JetTracksAssociatorAtVertexJPTPAT.jets = cms.InputTag("slimmedCaloJets") +ak4JetTracksAssociatorAtVertexJPTPAT.tracks = cms.InputTag("produceTracks:tracksFromPF") +ak4JetTracksAssociatorAtCaloFaceJPTPAT = ak4JetTracksAssociatorAtCaloFace.clone() +ak4JetTracksAssociatorAtCaloFaceJPTPAT.jets = cms.InputTag("slimmedCaloJets") +ak4JetTracksAssociatorAtCaloFaceJPTPAT.tracks = cms.InputTag("produceTracks:tracksFromPF") +ak4JetExtenderJPTPAT = ak4JetExtender.clone() +ak4JetExtenderJPTPAT.jets = cms.InputTag("slimmedCaloJets") +ak4JetExtenderJPTPAT.jet2TracksAtCALO = cms.InputTag("ak4JetTracksAssociatorAtCaloFaceJPTPAT") +ak4JetExtenderJPTPAT.jet2TracksAtVX = cms.InputTag("ak4JetTracksAssociatorAtVertexJPTPAT") + +recoJetAssociationsAntiKt4JPTPAT = cms.Sequence( + trackExtrapolator* + ak4JetTracksAssociatorAtVertexJPTPAT* + ak4JetTracksAssociatorAtCaloFaceJPTPAT* + ak4JetExtenderJPTPAT +) + +# ---------- Tight Electron ID +# commented, needed for CMSSW80X and earlier +#from RecoEgamma.ElectronIdentification.electronIdSequence_cff import eidTight +#JPTeidTightPAT = eidTight.clone() +#from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq +#setupEgammaPostRecoSeq(process, +# era='2017-Nov17ReReco') +# +# ---------- Module definition +from RecoJets.JetPlusTracks.JetPlusTrackCorrections_cfi import * + +JetPlusTrackZSPCorJetAntiKt4PAT = cms.EDProducer( + "JetPlusTrackProducer", + cms.PSet(JPTZSPCorrectorAntiKt4), + src = cms.InputTag("slimmedCaloJets"), + srcTrackJets = cms.InputTag("ak4TrackJets"), + srcAddCaloJets = cms.InputTag('JetPlusTrackAddonSeedPAT:CaloJetAddonSeed'), + extrapolations = cms.InputTag("trackExtrapolator"), + tagName = cms.vstring('ZSP_CMSSW390_Akt_05_PU0'), + tagNameOffset = cms.vstring(), + PU = cms.int32(-1), + FixedPU = cms.int32(0), + UseZSP = cms.bool(False), + srcPVs = cms.InputTag('offlineSlimmedPrimaryVertices'), + alias = cms.untracked.string('JetPlusTrackZSPCorJetAntiKt4'), + ptCUT = cms.double(15.), + PAT = cms.bool(True) + ) + +JetPlusTrackZSPCorJetAntiKt4PAT.JetTracksAssociationAtVertex = cms.InputTag("ak4JetTracksAssociatorAtVertexJPTPAT") +JetPlusTrackZSPCorJetAntiKt4PAT.JetTracksAssociationAtCaloFace = cms.InputTag("ak4JetTracksAssociatorAtCaloFaceJPTPAT") +JetPlusTrackZSPCorJetAntiKt4PAT.Muons = cms.InputTag("slimmedMuons") +JetPlusTrackZSPCorJetAntiKt4PAT.Electrons = cms.InputTag("slimmedElectrons") +JetPlusTrackZSPCorJetAntiKt4PAT.JetSplitMerge = cms.int32(2) +JetPlusTrackZSPCorJetAntiKt4PAT.UseReco = cms.bool(False) +### ---------- Sequences + +#from RecoJets.JetProducers.TracksForJets_cff import * +#from RecoJets.Configuration.RecoTrackJets_cff import * +#from CommonTools.RecoAlgos.TrackWithVertexSelector_cfi import * +#from CommonTools.RecoAlgos.TrackWithVertexSelectorParams_cff import * +#trackWithVertexSelectorParams.vertexTag = cms.InputTag('offlineSlimmedPrimaryVertices') +#trackWithVertexSelectorParams.src = cms.InputTag('produceTracks:tracksFromPF') + +# Anti-Kt + +JetPlusTrackCorrectionsAntiKt4TaskPAT = cms.Task( + trackExtrapolator, + ak4JetTracksAssociatorAtVertexJPTPAT, + ak4JetTracksAssociatorAtCaloFaceJPTPAT, + ak4JetExtenderJPTPAT, + JetPlusTrackZSPCorJetAntiKt4PAT + ) + +JetPlusTrackCorrectionsAntiKt4PAT = cms.Sequence(JetPlusTrackCorrectionsAntiKt4TaskPAT) + +# For backward-compatiblity (but to be deprecated!) + +JetPlusTrackCorrectionsPAT = cms.Sequence(JetPlusTrackCorrectionsAntiKt4PAT) From 64ff2b8d5451e39f9a0418325b8bc185aef2db47 Mon Sep 17 00:00:00 2001 From: Olga Kodolova Date: Mon, 8 Jun 2020 16:29:28 +0200 Subject: [PATCH 02/14] TrackJet seeds adding --- .../plugins/JetPlusTrackCorrector.cc | 2357 +++++++++-------- .../plugins/JetPlusTrackCorrector.h | 503 ++-- 2 files changed, 1598 insertions(+), 1262 deletions(-) diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc index d5177e8b9e7a4..e047764c2abbc 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc @@ -19,99 +19,140 @@ using namespace jpt; // ----------------------------------------------------------------------------- // -JetPlusTrackCorrector::JetPlusTrackCorrector(const edm::ParameterSet& pset, edm::ConsumesCollector&& iC) - : verbose_(pset.getParameter("Verbose")), - vectorial_(pset.getParameter("VectorialCorrection")), - vecResponse_(pset.getParameter("UseResponseInVecCorr")), - useInConeTracks_(pset.getParameter("UseInConeTracks")), - useOutOfConeTracks_(pset.getParameter("UseOutOfConeTracks")), - useOutOfVertexTracks_(pset.getParameter("UseOutOfVertexTracks")), - usePions_(pset.getParameter("UsePions")), - useEff_(pset.getParameter("UseEfficiency")), - useMuons_(pset.getParameter("UseMuons")), - useElecs_(pset.getParameter("UseElectrons")), - useTrackQuality_(pset.getParameter("UseTrackQuality")), - jetTracksAtVertex_(pset.getParameter("JetTracksAssociationAtVertex")), - jetTracksAtCalo_(pset.getParameter("JetTracksAssociationAtCaloFace")), - jetSplitMerge_(pset.getParameter("JetSplitMerge")), - srcPVs_(pset.getParameter("srcPVs")), - ptErrorQuality_(pset.getParameter("PtErrorQuality")), - dzVertexCut_(pset.getParameter("DzVertexCut")), - muons_(pset.getParameter("Muons")), - electrons_(pset.getParameter("Electrons")), - electronIds_(pset.getParameter("ElectronIds")), - trackQuality_(reco::TrackBase::qualityByName(pset.getParameter("TrackQuality"))), - response_(Map(pset.getParameter("ResponseMap"), verbose_)), - efficiency_(Map(pset.getParameter("EfficiencyMap"), verbose_)), - leakage_(Map(pset.getParameter("LeakageMap"), verbose_)), - pionMass_(0.140), - muonMass_(0.105), - elecMass_(0.000511), - maxEta_(pset.getParameter("MaxJetEta")) { - if (verbose_) { +JetPlusTrackCorrector::JetPlusTrackCorrector( const edm::ParameterSet& pset, edm::ConsumesCollector&& iC ) + : verbose_( pset.getParameter("Verbose") ), + usereco_( pset.getParameter("UseReco") ), + vectorial_( pset.getParameter("VectorialCorrection") ), + vecResponse_( pset.getParameter("UseResponseInVecCorr") ), + useInConeTracks_( pset.getParameter("UseInConeTracks") ), + useOutOfConeTracks_( pset.getParameter("UseOutOfConeTracks") ), + useOutOfVertexTracks_( pset.getParameter("UseOutOfVertexTracks") ), + usePions_( pset.getParameter("UsePions") ), + useEff_( pset.getParameter("UseEfficiency") ), + useMuons_( pset.getParameter("UseMuons") ), + useElecs_( pset.getParameter("UseElectrons") ), + useTrackQuality_( pset.getParameter("UseTrackQuality") ), + jetTracksAtVertex_( pset.getParameter("JetTracksAssociationAtVertex") ), + jetTracksAtCalo_( pset.getParameter("JetTracksAssociationAtCaloFace") ), + jetSplitMerge_( pset.getParameter("JetSplitMerge") ), + srcPVs_(pset.getParameter("srcPVs") ), + ptErrorQuality_( pset.getParameter("PtErrorQuality") ), + dzVertexCut_( pset.getParameter("DzVertexCut") ), + muons_( pset.getParameter("Muons") ), + electrons_( pset.getParameter("Electrons") ), + electronIds_( pset.getParameter("ElectronIds") ), + patmuons_( pset.getParameter("PatMuons") ), + patelectrons_( pset.getParameter("PatElectrons") ), + trackQuality_( reco::TrackBase::qualityByName( pset.getParameter("TrackQuality") ) ), + response_( Map( pset.getParameter("ResponseMap"), verbose_ ) ), + efficiency_( Map( pset.getParameter("EfficiencyMap"), verbose_ ) ), + leakage_( Map( pset.getParameter("LeakageMap"), verbose_ ) ), + pionMass_(0.140), + muonMass_(0.105), + elecMass_(0.000511), + maxEta_( pset.getParameter("MaxJetEta") ) +{ + + if ( verbose_ ) { std::stringstream ss; ss << "[JetPlusTrackCorrector::" << __func__ << "] Configuration for JPT corrector: " << std::endl << " Particles" << std::endl - << " UsePions : " << (usePions_ ? "true" : "false") << std::endl - << " UseMuons : " << (useMuons_ ? "true" : "false") << std::endl - << " UseElecs : " << (useElecs_ ? "true" : "false") << std::endl - << " Corrections" << std::endl - << " UseInConeTracks : " << (useInConeTracks_ ? "true" : "false") << std::endl - << " UseOutOfConeTracks : " << (useOutOfConeTracks_ ? "true" : "false") << std::endl - << " UseOutOfVertexTracks : " << (useOutOfVertexTracks_ ? "true" : "false") << std::endl + << " UsePions : " << ( usePions_ ? "true" : "false" ) << std::endl + << " UseMuons : " << ( useMuons_ ? "true" : "false" ) << std::endl + << " UseElecs : " << ( useElecs_ ? "true" : "false" ) << std::endl + << " Corrections" << std::endl + << " UseInConeTracks : " << ( useInConeTracks_ ? "true" : "false" ) << std::endl + << " UseOutOfConeTracks : " << ( useOutOfConeTracks_ ? "true" : "false" ) << std::endl + << " UseOutOfVertexTracks : " << ( useOutOfVertexTracks_ ? "true" : "false" ) << std::endl << " ResponseMap : " << pset.getParameter("ResponseMap") << std::endl << " Efficiency" << std::endl - << " UsePionEfficiency : " << (useEff_ ? "true" : "false") << std::endl + << " UsePionEfficiency : " << ( useEff_ ? "true" : "false" ) << std::endl << " EfficiencyMap : " << pset.getParameter("EfficiencyMap") << std::endl << " LeakageMap : " << pset.getParameter("LeakageMap") << std::endl << " Tracks" << std::endl << " JetTracksAtVertex : " << jetTracksAtVertex_ << std::endl << " JetTracksAtCalo : " << jetTracksAtCalo_ << std::endl << " JetSplitMerge : " << jetSplitMerge_ << std::endl - << " UseTrackQuality : " << (useTrackQuality_ ? "true" : "false") << std::endl + << " UseTrackQuality : " << ( useTrackQuality_ ? "true" : "false" ) << std::endl << " Collections" << std::endl << " Muons : " << muons_ << std::endl << " Electrons : " << electrons_ << std::endl << " Vectorial" << std::endl - << " UseTracksAndResponse : " << ((vectorial_ && vecResponse_) ? "true" : "false") << std::endl - << " UseTracksOnly : " << ((vectorial_ && !vecResponse_) ? "true" : "false"); + << " UseTracksAndResponse : " << ( ( vectorial_ && vecResponse_ ) ? "true" : "false" ) << std::endl + << " UseTracksOnly : " << ( ( vectorial_ && !vecResponse_ ) ? "true" : "false" ); edm::LogInfo("JetPlusTrackCorrector") << ss.str(); } - if (!useInConeTracks_ || !useOutOfConeTracks_ || !useOutOfVertexTracks_) { + if ( !useInConeTracks_ || + !useOutOfConeTracks_ || + !useOutOfVertexTracks_ ) { std::stringstream ss; ss << "[JetPlusTrackCorrector::" << __func__ << "]" << " You are using JPT algorithm in a non-standard way!" << std::endl - << " UseInConeTracks : " << (useInConeTracks_ ? "true" : "false") << std::endl - << " UseOutOfConeTracks : " << (useOutOfConeTracks_ ? "true" : "false") << std::endl - << " UseOutOfVertexTracks : " << (useOutOfVertexTracks_ ? "true" : "false"); + << " UseInConeTracks : " << ( useInConeTracks_ ? "true" : "false" ) << std::endl + << " UseOutOfConeTracks : " << ( useOutOfConeTracks_ ? "true" : "false" ) << std::endl + << " UseOutOfVertexTracks : " << ( useOutOfVertexTracks_ ? "true" : "false" ); edm::LogWarning("JetPlusTrackCorrector") << ss.str(); } - input_jetTracksAtVertex_token_ = iC.consumes(jetTracksAtVertex_); + input_jetTracksAtVertex_token_ = iC.consumes(jetTracksAtVertex_); input_jetTracksAtCalo_token_ = iC.consumes(jetTracksAtCalo_); - inut_reco_muons_token_ = iC.consumes(muons_); input_pvCollection_token_ = iC.consumes(srcPVs_); + + input_reco_muons_token_ = iC.consumes (muons_); input_reco_elecs_token_ = iC.consumes(electrons_); - input_reco_elec_ids_token_ = iC.consumes(electronIds_); + input_reco_elec_ids_token_ = iC.consumes( electronIds_); + + input_pat_muons_token_ = iC.consumes (patmuons_); + input_pat_elecs_token_ = iC.consumes(patelectrons_); + } // ----------------------------------------------------------------------------- // -JetPlusTrackCorrector::~JetPlusTrackCorrector() { ; } +JetPlusTrackCorrector::~JetPlusTrackCorrector() {;} +// ----------------------------------------------------------------------------- +// +double JetPlusTrackCorrector::correction( const reco::Jet& fJet, const reco::Jet& fJetcalo, + const edm::Event& event, + const edm::EventSetup& setup, + const reco::TrackRefVector& tracksinvert, + const reco::TrackRefVector& tracksincalo, + P4& corrected, + MatchedTracks &pions, + MatchedTracks &muons, + MatchedTracks &elecs + ) +{ + double scale = 1.; + corrected = fJet.p4(); + bool validMatches = matchTracks( fJetcalo, event, setup, tracksinvert, tracksincalo, pions, muons, elecs ); + if ( !validMatches ) { return 1.; } + if(usereco_) { + if ( usePions_ ) { corrected += pionCorrection( fJet.p4(), pions ); } + if ( useMuons_ ) { corrected += muonCorrection( fJet.p4(), muons ); } + if ( useElecs_ ) { corrected += elecCorrection( fJet.p4(), elecs ); } + } else { + corrected += fJetcalo.p4(); + } + scale = checkScale( fJet.p4(), corrected ); +return scale; +} + // ----------------------------------------------------------------------------- // -double JetPlusTrackCorrector::correction(const reco::Jet& fJet, - const reco::Jet& fJetcalo, - const edm::Event& event, - const edm::EventSetup& setup, - P4& corrected, - MatchedTracks& pions, - MatchedTracks& muons, - MatchedTracks& elecs, - bool& validMatches) { - // std::cout<<" JetPlusTrackCorrector::correction "< 0. ? corrected.Et() / fJet.et() : 1.); // << std::endl + << " Scalar correction to Et : " << ( fJet.et() > 0. ? corrected.Et() / fJet.et() : 1. );// << std::endl edm::LogVerbatim("JetPlusTrackCorrector") << ss.str(); } + /* + std::cout << " mScale= " << scale + << " NewResponse " << corrected.energy() + << " Jet energy " << fJet.energy() + << " event " << event.id().event() << std::endl; - // std::cout << " mScale= " << scale - // << " NewResponse " << corrected.energy() - // << " Jet energy " << fJet.energy() - // << " event " << event.id().event() << std::endl; - /* std::cout<<" Correction::Corrections for jet "<< theResponseOfChargedWithEff <<" "<< theResponseOfChargedWithoutEff <<" "<< theSumPtWithEff <<" "<< @@ -203,201 +250,297 @@ double JetPlusTrackCorrector::correction(const reco::Jet& fJet, theSumEnergyWithoutEff < jetTracksAtVertex; - event.getByToken(input_jetTracksAtVertex_token_, jetTracksAtVertex); - - if (!jetTracksAtVertex.isValid() || jetTracksAtVertex.failedToGet()) { - if (verbose_ && edm::isDebugEnabled()) { + event.getByToken(input_jetTracksAtVertex_token_, jetTracksAtVertex ); + + //std::cout<<"JetPlusTrackCorrector::jtaUsingEventData" < jetTracksAtCalo; - event.getByToken(input_jetTracksAtCalo_token_, jetTracksAtCalo); + event.getByToken(input_jetTracksAtCalo_token_, jetTracksAtCalo ); - if (!jetTracksAtCalo.isValid() || jetTracksAtCalo.failedToGet()) { - if (verbose_ && edm::isDebugEnabled()) { + if ( !jetTracksAtCalo.isValid() || jetTracksAtCalo.failedToGet() ) { + if ( verbose_ && edm::isDebugEnabled() ) { edm::LogWarning("JetPlusTrackCorrector") - << "[JetPlusTrackCorrector::" << __func__ << "]" - << " Invalid handle to reco::JetTracksAssociation::Container (for CaloFace)" - << " with InputTag (label:instance:process) \"" << jetTracksAtCalo_.label() << ":" - << jetTracksAtCalo_.instance() << ":" << jetTracksAtCalo_.process() << "\""; + << "[JetPlusTrackCorrector::" << __func__ << "]" + << " Invalid handle to reco::JetTracksAssociation::Container (for CaloFace)" + << " with InputTag (label:instance:process) \"" + << jetTracksAtCalo_.label() << ":" + << jetTracksAtCalo_.instance() << ":" + << jetTracksAtCalo_.process() << "\""; } - return false; + return false; } - + // Retrieve jet-tracks association for given jet - const reco::JetTracksAssociation::Container jtC = *(jetTracksAtCalo.product()); - if (jetSplitMerge_ < 0) { - trks.caloFace_ = reco::JetTracksAssociation::getValue(jtC, fJet); - } else { - excludeJta(fJet, jtC, trks.caloFace_, excluded); - } - - // std::cout<<" JTA:Tracks in vertex "<& reco_muons) const { - event.getByToken(inut_reco_muons_token_, reco_muons); - if (!reco_muons.isValid() || reco_muons.failedToGet()) { - edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]" - << " Invalid handle to reco::Muon collection" - << " with InputTag (label:instance:process) \"" << muons_.label() << ":" - << muons_.instance() << ":" << muons_.process() << "\""; +bool JetPlusTrackCorrector::getMuons( const edm::Event& event, edm::Handle& reco_muons ) const { + event.getByToken(input_reco_muons_token_, reco_muons ); + if ( !reco_muons.isValid() || reco_muons.failedToGet() ) { + edm::LogError("JetPlusTrackCorrector") + << "[JetPlusTrackCorrector::" << __func__ << "]" + << " Invalid handle to reco::Muon collection" + << " with InputTag (label:instance:process) \"" + << muons_.label() << ":" + << muons_.instance() << ":" + << muons_.process() << "\""; + return false; + } + return true; +} + +bool JetPlusTrackCorrector::getMuons( const edm::Event& event, edm::Handle& reco_muons ) const { + event.getByToken(input_pat_muons_token_, reco_muons ); + if ( !reco_muons.isValid() || reco_muons.failedToGet() ) { + edm::LogError("JetPlusTrackCorrector") + << "[JetPlusTrackCorrector::" << __func__ << "]" + << " Invalid handle to reco::Muon collection" + << " with InputTag (label:instance:process) \"" + << muons_.label() << ":" + << muons_.instance() << ":" + << muons_.process() << "\""; return false; } return true; } + // ----------------------------------------------------------------------------- // -void JetPlusTrackCorrector::matchTracks(const JetTracks& jet_tracks, - const edm::Event& event, - MatchedTracks& pions, - MatchedTracks& muons, - MatchedTracks& elecs) { - // Some init - pions.clear(); - muons.clear(); - elecs.clear(); +void JetPlusTrackCorrector::matchTracks( const JetTracks& jet_tracks, + const edm::Event& event, + MatchedTracks& pions, + MatchedTracks& muons, + MatchedTracks& elecs ) { + // Some init + pions.clear(); + muons.clear(); + elecs.clear(); // Need vertex for track cleaning - vertex_ = reco::Particle::Point(0, 0, 0); - edm::Handle pvCollection; - event.getByToken(input_pvCollection_token_, pvCollection); - if (pvCollection.isValid() && !pvCollection->empty()) - vertex_ = pvCollection->begin()->position(); + vertex_=reco::Particle::Point(0,0,0); + edm::Handle pvCollection; + event.getByToken(input_pvCollection_token_, pvCollection); + if ( pvCollection.isValid() && !pvCollection->empty() ) vertex_=pvCollection->begin()->position(); // Get RECO muons edm::Handle reco_muons; + edm::Handle pat_muons; bool found_reco_muons = true; - if (useMuons_) { - getMuons(event, reco_muons); - } + bool found_pat_muons = true; + if ( useMuons_ ) {if(usereco_) {getMuons( event, reco_muons );} + else {getMuons( event, pat_muons ); + found_reco_muons = false;}} + // Get RECO electrons and their ids edm::Handle reco_elecs; + edm::Handle pat_elecs; edm::Handle reco_elec_ids; bool found_reco_elecs = true; - if (useElecs_) { - getElectrons(event, reco_elecs, reco_elec_ids); - } + bool found_pat_elecs = true; + if ( useElecs_ ) { if(usereco_) {getElectrons( event, reco_elecs, reco_elec_ids );} + else {getElectrons(event, pat_elecs); + found_reco_elecs = false; }} + + // std::cout<<" Found elec/muo "<quality(trackQuality_) && theSumPtForBetaOld <= 0.) - theSumPtForBeta += (**itrk).pt(); - // - // Track either belongs to PV or do not belong to any vertex + // std::cout<<" MatchTracks::InVertex "<size()<quality(trackQuality_) && theSumPtForBetaOld<=0. ) + theSumPtForBeta += (**itrk).pt(); +// +// Track either belongs to PV or do not belong to any vertex - int numpv = 0; + const reco::TrackBaseRef ttr1(*itrk); - int itrack_belong = -1; + int numpv=0; - for (reco::VertexCollection::const_iterator iv = pvCollection->begin(); iv != pvCollection->end(); iv++) { + int itrack_belong = -1; + + for( reco::VertexCollection::const_iterator iv = pvCollection->begin(); iv != pvCollection->end(); iv++) { numpv++; - std::vector::const_iterator rr = find((*iv).tracks_begin(), (*iv).tracks_end(), ttr1); - if (rr != (*iv).tracks_end()) { - itrack_belong++; - // std::cout<<" Numpv "< 1 && itrack_belong == 0) { - // std::cout<<" Drop track "<::const_iterator rr = + find((*iv).tracks_begin(), + (*iv).tracks_end(), + ttr1); + if( rr != (*iv).tracks_end() ) { + itrack_belong++; + // std::cout<<" Numpv "< 1 && itrack_belong == 0 ) { + // std::cout<<" Drop track "<& reco_elecs, - edm::Handle& reco_elec_ids) const { - event.getByToken(input_reco_elecs_token_, reco_elecs); - if (!reco_elecs.isValid() || reco_elecs.failedToGet()) { - edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]" - << " Invalid handle to reco::GsfElectron collection" - << " with InputTag (label:instance:process) \"" << electrons_.label() << ":" - << electrons_.instance() << ":" << electrons_.process() << "\""; +bool JetPlusTrackCorrector::getElectrons( const edm::Event& event, + edm::Handle& reco_elecs, + edm::Handle& reco_elec_ids ) const { + event.getByToken(input_reco_elecs_token_, reco_elecs ); + if ( !reco_elecs.isValid() || reco_elecs.failedToGet() ) { + edm::LogError("JetPlusTrackCorrector") + << "[JetPlusTrackCorrector::" << __func__ << "]" + << " Invalid handle to reco::GsfElectron collection" + << " with InputTag (label:instance:process) \"" + << electrons_.label() << ":" + << electrons_.instance() << ":" + << electrons_.process() << "\""; return false; } - event.getByToken(input_reco_elec_ids_token_, reco_elec_ids); - if (!reco_elec_ids.isValid() || reco_elec_ids.failedToGet()) { - edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]" - << " Invalid handle to reco::GsfElectron collection" - << " with InputTag (label:instance:process) \"" << electronIds_.label() - << ":" << electronIds_.instance() << ":" << electronIds_.process() << "\""; + event.getByToken(input_reco_elec_ids_token_, reco_elec_ids ); + if ( !reco_elec_ids.isValid() || reco_elec_ids.failedToGet() ) { + edm::LogError("JetPlusTrackCorrector") + << "[JetPlusTrackCorrector::" << __func__ << "]" + << " Invalid handle to reco::GsfElectron collection" + << " with InputTag (label:instance:process) \"" + << electronIds_.label() << ":" + << electronIds_.instance() << ":" + << electronIds_.process() << "\""; + return false; + } + return true; +} + +bool JetPlusTrackCorrector::getElectrons( + const edm::Event& event, + edm::Handle& reco_elecs + ) const { + event.getByToken(input_pat_elecs_token_, reco_elecs ); + if ( !reco_elecs.isValid() || reco_elecs.failedToGet() ) { + edm::LogError("JetPlusTrackCorrector") + << "[JetPlusTrackCorrector::" << __func__ << "]" + << " Invalid handle to reco::GsfElectron collection" + << " with InputTag (label:instance:process) \"" + << electrons_.label() << ":" + << electrons_.instance() << ":" + << electrons_.process() << "\""; return false; } return true; } + + // ----------------------------------------------------------------------------- // -bool JetPlusTrackCorrector::failTrackQuality(TrackRefs::const_iterator& itrk) const { - // if ( useTrackQuality_ && !(*itrk)->quality(trackQuality_) ) { return true; } - // else { return false; } +bool JetPlusTrackCorrector::failTrackQuality( TrackRefs::const_iterator& itrk ) const { +// if ( useTrackQuality_ && !(*itrk)->quality(trackQuality_) ) { return true; } +// else { return false; } + + bool retcode = false; - bool retcode = false; + // std::cout<<"JetPlusTrackCorrector::failTrackQuality "<< (*itrk)->quality(trackQuality_)<quality(trackQuality_)) { - retcode = true; - return retcode; - } - if (((*itrk)->ptError() / (*itrk)->pt()) > ptErrorQuality_) { - retcode = true; - return retcode; - } - if (fabs((*itrk)->dz(vertex_)) > dzVertexCut_) { - retcode = true; - return retcode; - } + if ( useTrackQuality_ && !(*itrk)->quality(trackQuality_) ) { + // std::cout<<" Fail quality cut "<ptError()/(*itrk)->pt()) > ptErrorQuality_) { + // std::cout<<" Fail pterr "<<(*itrk)->pt()<<" "<<((*itrk)->ptError()/(*itrk)->pt())<<" "<< + // ptErrorQuality_<dz(vertex_)) > dzVertexCut_) { + //std::cout<<" Fail dz "<dz(vertex_))<<" "<pt(), (*itrk)->eta(), (*itrk)->phi(), 0.); - // tracks_present = true; + for ( ; itrk != jtrk; ++itrk ) { + corr += PtEtaPhiM( (*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0. ); +// tracks_present = true; tracks_present_inin = true; } } - if (!pions.inVertexOutOfCalo_.empty()) { + if ( !pions.inVertexOutOfCalo_.empty() ) { TrackRefs::iterator itrk = pions.inVertexOutOfCalo_.begin(); TrackRefs::iterator jtrk = pions.inVertexOutOfCalo_.end(); - for (; itrk != jtrk; ++itrk) { - corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.); - // tracks_present = true; + for ( ; itrk != jtrk; ++itrk ) { + corr += PtEtaPhiM( (*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0. ); +// tracks_present = true; } } // Correct using muons in-cone at vertex - if (!muons.inVertexInCalo_.empty()) { + if ( !muons.inVertexInCalo_.empty() ) { TrackRefs::iterator itrk = muons.inVertexInCalo_.begin(); TrackRefs::iterator jtrk = muons.inVertexInCalo_.end(); - for (; itrk != jtrk; ++itrk) { - corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.); - // tracks_present = true; + for ( ; itrk != jtrk; ++itrk ) { + corr += PtEtaPhiM( (*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0. ); +// tracks_present = true; } } - if (!muons.inVertexOutOfCalo_.empty()) { + if ( !muons.inVertexOutOfCalo_.empty() ) { TrackRefs::iterator itrk = muons.inVertexOutOfCalo_.begin(); TrackRefs::iterator jtrk = muons.inVertexOutOfCalo_.end(); - for (; itrk != jtrk; ++itrk) { - corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.); - // tracks_present = true; + for ( ; itrk != jtrk; ++itrk ) { + corr += PtEtaPhiM( (*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0. ); +// tracks_present = true; } } // Correct using electrons in-cone at vertex - if (!elecs.inVertexInCalo_.empty()) { + if ( !elecs.inVertexInCalo_.empty() ) { TrackRefs::iterator itrk = elecs.inVertexInCalo_.begin(); TrackRefs::iterator jtrk = elecs.inVertexInCalo_.end(); - for (; itrk != jtrk; ++itrk) { - corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.); - // tracks_present = true; + for ( ; itrk != jtrk; ++itrk ) { + corr += PtEtaPhiM( (*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0. ); +// tracks_present = true; } } - - if (!elecs.inVertexOutOfCalo_.empty()) { + + if ( !elecs.inVertexOutOfCalo_.empty() ) { TrackRefs::iterator itrk = elecs.inVertexOutOfCalo_.begin(); TrackRefs::iterator jtrk = elecs.inVertexOutOfCalo_.end(); - for (; itrk != jtrk; ++itrk) { - corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.); - // tracks_present = true; + for ( ; itrk != jtrk; ++itrk ) { + corr += PtEtaPhiM( (*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0. ); +// tracks_present = true; } } - + // Adjust direction if in cone tracks are present - - if (!tracks_present_inin) { - corr = corrected; - } else { - corr *= (corr.P() > 0. ? corrected.P() / corr.P() : 1.); - corr = P4(corr.px(), corr.py(), corr.pz(), corrected.energy()); + + if ( !tracks_present_inin ) { corr = corrected; } + else { + corr *= ( corr.P() > 0. ? corrected.P() / corr.P() : 1. ); + corr = P4( corr.px(), corr.py(), corr.pz(), corrected.energy() ); } - + return corr; + } // ----------------------------------------------------------------------------- // -JetPlusTrackCorrector::P4 JetPlusTrackCorrector::calculateCorr(const P4& jet, - const TrackRefs& tracks, - jpt::Efficiency& eff, - bool in_cone_at_vertex, - bool in_cone_at_calo_face, - double mass, - bool is_pion, - double mip) { +JetPlusTrackCorrector::P4 JetPlusTrackCorrector::calculateCorr( const P4& jet, + const TrackRefs& tracks, + jpt::Efficiency& eff, + bool in_cone_at_vertex, + bool in_cone_at_calo_face, + double mass, + bool is_pion, + double mip ) { + // Correction to be applied to jet 4-momentum P4 correction; - /* +/* std::cout<<" >>>>> Jet "<pt() >= 50.) { - continue; - } - + if ( in_cone_at_calo_face && is_pion && (*itrk)->pt() >= 50. ) { continue; } + // Inner track 4-momentum P4 inner; - if (vectorial_ && vecResponse_) { - inner = PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), mass); - } else { - double energy = sqrt((*itrk)->px() * (*itrk)->px() + (*itrk)->py() * (*itrk)->py() + - (*itrk)->pz() * (*itrk)->pz() + mass * mass); - inner = (jet.energy() > 0. ? energy / jet.energy() : 1.) * jet; - } - + if ( vectorial_ && vecResponse_ ) { + inner = PtEtaPhiM( (*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), mass ); + } else { + double energy = sqrt( (*itrk)->px() * (*itrk)->px() + + (*itrk)->py() * (*itrk)->py() + + (*itrk)->pz() * (*itrk)->pz() + + mass * mass ); + inner = ( jet.energy() > 0. ? energy / jet.energy() : 1. ) * jet; + } + // Add track momentum (if in-cone at vertex) - if (in_cone_at_vertex) { - correction += inner; - } - + if ( in_cone_at_vertex ) { correction += inner; } + // Find appropriate eta/pt bin for given track - double eta = fabs((*itrk)->eta()); - double pt = fabs((*itrk)->pt()); - uint32_t ieta = response_.etaBin(eta); - uint32_t ipt = response_.ptBin(pt); + double eta = fabs( (*itrk)->eta() ); + double pt = fabs( (*itrk)->pt() ); + uint32_t ieta = response_.etaBin( eta ); + uint32_t ipt = response_.ptBin( pt ); // Check bins (not for mips) - if (is_pion && (ieta == response_.nEtaBins() || ipt == response_.nPtBins())) { - continue; - } - - // Outer track 4-momentum + if ( is_pion && ( ieta == response_.nEtaBins() || ipt == response_.nPtBins() ) ) { continue; } + + // Outer track 4-momentum P4 outer; - if (in_cone_at_calo_face) { - if (vectorial_ && vecResponse_) { - // Build 4-momentum from outer track (SHOULD USE IMPACT POINT?!) - double outer_pt = (*itrk)->pt(); - double outer_eta = (*itrk)->eta(); - double outer_phi = (*itrk)->phi(); - if ((*itrk)->extra().isNonnull()) { - outer_pt = (*itrk)->pt(); - outer_eta = (*itrk)->outerPosition().eta(); //@@ outerMomentum().eta() - outer_phi = (*itrk)->outerPosition().phi(); //@@ outerMomentum().phi() - } - outer = PtEtaPhiM(outer_pt, outer_eta, outer_phi, mass); - // Check if mip or not - if (!is_pion) { - outer *= (outer.energy() > 0. ? mip / outer.energy() : 1.); - } //@@ Scale to mip energy - else { - outer *= (outer.energy() > 0. ? inner.energy() / outer.energy() : 1.); - } //@@ Scale to inner track energy - } else { - // Check if mip or not - if (!is_pion) { - outer = (jet.energy() > 0. ? mip / jet.energy() : 1.) * jet; - } //@@ Jet 4-mom scaled by mip energy - else { - outer = inner; - } //@@ Set to inner track 4-momentum - } - if (is_pion) { - outer *= response_.value(ieta, ipt); - } //@@ Scale by pion response - correction -= outer; //@@ Subtract - - // Calculate the sum of responses - theSumResp += response_.value(ieta, ipt); + if ( in_cone_at_calo_face ) { + if ( vectorial_ && vecResponse_ ) { + // Build 4-momentum from outer track (SHOULD USE IMPACT POINT?!) + double outer_pt = (*itrk)->pt(); + double outer_eta = (*itrk)->eta(); + double outer_phi = (*itrk)->phi(); + if ( (*itrk)->extra().isNonnull() ) { + outer_pt = (*itrk)->pt(); + outer_eta = (*itrk)->outerPosition().eta(); //@@ outerMomentum().eta() + outer_phi = (*itrk)->outerPosition().phi(); //@@ outerMomentum().phi() + } + outer = PtEtaPhiM( outer_pt, outer_eta, outer_phi, mass ); + // Check if mip or not + if ( !is_pion ) { outer *= ( outer.energy() > 0. ? mip / outer.energy() : 1. ); } //@@ Scale to mip energy + else { outer *= ( outer.energy() > 0. ? inner.energy() / outer.energy() : 1. ); } //@@ Scale to inner track energy + } else { + // Check if mip or not + if ( !is_pion ) { outer = ( jet.energy() > 0. ? mip / jet.energy() : 1. ) * jet; } //@@ Jet 4-mom scaled by mip energy + else { outer = inner; } //@@ Set to inner track 4-momentum + } + if ( is_pion ) { outer *= response_.value(ieta,ipt); } //@@ Scale by pion response + correction -= outer; //@@ Subtract + +// Calculate the sum of responses + theSumResp += response_.value(ieta,ipt); } - - // Calculate the sum of pt and energies - theSumPt += inner.pt(); - theSumEnergy += inner.energy(); - + +// Calculate the sum of pt and energies + theSumPt += inner.pt(); + theSumEnergy += inner.energy(); + // Record inner track energy for pion efficiency correction - if (is_pion) { - eff.addE(ieta, ipt, inner.energy()); - } - + if ( is_pion ) { eff.addE( ieta, ipt, inner.energy() ); } + // Debug - if (verbose_ && edm::isDebugEnabled()) { - std::stringstream temp; - temp << " Response[" << ieta << "," << ipt << "]"; - std::stringstream ss; - ss << "[JetPlusTrackCorrector::" << __func__ << "]" << std::endl - << " Track eta / pt : " << eta << " / " << pt << std::endl - << temp.str() << std::setw(21 - temp.str().size()) << " : " << response_.value(ieta, ipt) << std::endl - << " Track momentum added : " << inner.energy() << std::endl - << " Response subtracted : " << outer.energy() << std::endl - << " Energy correction : " << correction.energy(); - LogDebug("JetPlusTrackCorrector") << ss.str(); + if ( verbose_ && edm::isDebugEnabled() ) { + std::stringstream temp; + temp << " Response[" << ieta << "," << ipt << "]"; + std::stringstream ss; + ss << "[JetPlusTrackCorrector::" << __func__ << "]" << std::endl + << " Track eta / pt : " << eta << " / " << pt << std::endl + << temp.str() << std::setw(21-temp.str().size()) << " : " + << response_.value(ieta,ipt) << std::endl + << " Track momentum added : " << inner.energy() << std::endl + << " Response subtracted : " << outer.energy() << std::endl + << " Energy correction : " << correction.energy(); + LogDebug("JetPlusTrackCorrector") << ss.str(); } - - } // loop through tracks - } // ntracks != 0 - - if (in_cone_at_vertex) { - theResponseOfChargedWithEff += theSumResp; - theResponseOfChargedWithoutEff += theSumResp; - theSumPtWithEff += theSumPt; - theSumPtWithoutEff += theSumPt; - theSumEnergyWithEff += theSumEnergy; - theSumEnergyWithoutEff += theSumEnergy; - } - /* + + } // loop through tracks + } // ntracks != 0 + + if( in_cone_at_vertex ) { + + theResponseOfChargedWithEff += theSumResp; + theResponseOfChargedWithoutEff += theSumResp; + theSumPtWithEff += theSumPt; + theSumPtWithoutEff += theSumPt; + theSumEnergyWithEff += theSumEnergy; + theSumEnergyWithoutEff += theSumEnergy; + + } +/* std::cout<<" calculateCorr End::Corrections for jet "<< theResponseOfChargedWithEff <<" "<< theResponseOfChargedWithoutEff <<" "<< theSumPtWithEff <<" "<< @@ -988,70 +1199,62 @@ JetPlusTrackCorrector::P4 JetPlusTrackCorrector::calculateCorr(const P4& jet, theSumEnergyWithoutEff < 0. ? corr / corr_p4.energy() : 1. ); //@@ p4 scaled up by mean energy for bin + } else { + corr_p4 = ( jet.energy() > 0. ? corr / jet.energy() : 1. ) * jet; + } + + // Apply correction + if ( ii == 0 ) { correction += corr_p4; theSumPt += corr_p4.pt(); theSumEnergy += corr_p4.energy();} //@@ Add out-of-cone + else if ( ii == 1 ) { correction -= corr_p4; theSumResp += corr_p4.energy();} //@@ Subtract in-cone + + } - for (uint16_t ii = 0; ii < 2; ++ii) { - // Check which correction should be applied - double corr = 0.; - if (ii == 0) { - corr = eff.outOfConeCorr(ieta, ipt); - } else if (ii == 1 && in_cone_at_calo_face) { - corr = eff.inConeCorr(ieta, ipt); - } else { - continue; - } - - // Calculate correction to be applied - P4 corr_p4; - if (vectorial_ && vecResponse_) { - double corr_eta = response_.binCenterEta(ieta); - double corr_phi = jet.phi(); //@@ jet phi! - double corr_pt = response_.binCenterPt(ipt); - corr_p4 = - PtEtaPhiM(corr_pt, corr_eta, corr_phi, pionMass_); //@@ E^2 = p^2 + m_pion^2, |p| calc'ed from pt bin - corr_p4 *= (corr_p4.energy() > 0. ? corr / corr_p4.energy() : 1.); //@@ p4 scaled up by mean energy for bin - } else { - corr_p4 = (jet.energy() > 0. ? corr / jet.energy() : 1.) * jet; - } - - // Apply correction - if (ii == 0) { - correction += corr_p4; - theSumPt += corr_p4.pt(); - theSumEnergy += corr_p4.energy(); - } //@@ Add out-of-cone - else if (ii == 1) { - correction -= corr_p4; - theSumResp += corr_p4.energy(); - } //@@ Subtract in-cone - } } } - theResponseOfChargedWithEff += theSumResp; - theSumPtWithEff += theSumPt; - theSumEnergyWithEff += theSumEnergy; - /* + theResponseOfChargedWithEff += theSumResp; + theSumPtWithEff += theSumPt; + theSumEnergyWithEff += theSumEnergy; +/* std::cout<<" Efficiency correction End::Corrections for jet "<< theResponseOfChargedWithEff <<" "<< theResponseOfChargedWithoutEff <<" "<< theSumPtWithEff <<" "<< @@ -1060,93 +1263,141 @@ JetPlusTrackCorrector::P4 JetPlusTrackCorrector::pionEfficiency(const P4& jet, theSumEnergyWithoutEff <& muons) const { - if (muons->empty()) { - return false; +bool JetPlusTrackCorrector::matchMuons( TrackRefs::const_iterator& itrk, + const edm::Handle& muons ) const { + + if ( muons->empty() ) { return false; } + + RecoMuons::const_iterator imuon = muons->begin(); + RecoMuons::const_iterator jmuon = muons->end(); + for ( ; imuon != jmuon; ++imuon ) { + + if ( imuon->innerTrack().isNull() || + !muon::isGoodMuon(*imuon,muon::TMLastStationTight) || + imuon->innerTrack()->pt() < 3.0 ) { continue; } + + if ( itrk->id() != imuon->innerTrack().id() ) { + edm::LogError("JetPlusTrackCorrector") + << "[JetPlusTrackCorrector::" << __func__ << "]" + << "Product id of the tracks associated to the jet " << itrk->id() + <<" is different from the product id of the inner track used for muons " << imuon->innerTrack().id() + << "!" << std::endl + << "Cannot compare tracks from different collection. Configuration Error!"; + return false; + } + + if ( *itrk == imuon->innerTrack() ) return true; } + + return false; + +} - RecoMuons::const_iterator imuon = muons->begin(); - RecoMuons::const_iterator jmuon = muons->end(); - for (; imuon != jmuon; ++imuon) { - if (imuon->innerTrack().isNull() || !muon::isGoodMuon(*imuon, muon::TMLastStationTight) || - imuon->innerTrack()->pt() < 3.0) { - continue; - } +bool JetPlusTrackCorrector::matchMuons( TrackRefs::const_iterator& itrk, + const edm::Handle& muons ) const { - if (itrk->id() != imuon->innerTrack().id()) { - edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]" - << "Product id of the tracks associated to the jet " << itrk->id() - << " is different from the product id of the inner track used for muons " - << imuon->innerTrack().id() << "!" << std::endl - << "Cannot compare tracks from different collection. Configuration Error!"; - return false; - } + if ( muons->empty() ) { return false; } - if (*itrk == imuon->innerTrack()) { - return true; - } + pat::MuonCollection::const_iterator imuon = muons->begin(); + pat::MuonCollection::const_iterator jmuon = muons->end(); + + for ( ; imuon != jmuon; ++imuon ) { + if(imuon->innerTrack().isNull() == 1 ) continue; + // std::cout<<"JetPlusTrackCorrector::matchMuons::Track "<<(**itrk).pt()<<" " + // <<(**itrk).eta()<<" "<<(**itrk).phi()<<" Muon "<< + // (*(imuon->innerTrack())).pt()<<" "<< (*(imuon->innerTrack())).eta()<<" "<< + // (*(imuon->innerTrack())).phi()<innerTrack())).pt())<0.1 && + fabs((**itrk).eta()-(*(imuon->innerTrack())).eta())<0.001 && + fabs((**itrk).phi()-(*(imuon->innerTrack())).phi())<0.001) { + // std::cout<<" Needed muon-track "<<(**itrk).pt()<<" "<< + // (**itrk).eta()<<" "<<(**itrk).phi()<& elecs, - const edm::Handle& elec_ids) const { - if (elecs->empty()) { - return false; - } - +bool JetPlusTrackCorrector::matchElectrons( TrackRefs::const_iterator& itrk, + const edm::Handle& elecs, + const edm::Handle& elec_ids ) const { + + if ( elecs->empty() ) { return false; } + double deltaR = 999.; double deltaRMIN = 999.; - + uint32_t electron_index = 0; - RecoElectrons::const_iterator ielec = elecs->begin(); - RecoElectrons::const_iterator jelec = elecs->end(); - for (; ielec != jelec; ++ielec) { - edm::Ref electron_ref(elecs, electron_index); + RecoElectrons::const_iterator ielec = elecs->begin(); + RecoElectrons::const_iterator jelec = elecs->end(); + for ( ; ielec != jelec; ++ielec ) { + + edm::Ref electron_ref( elecs, electron_index ); electron_index++; - - if ((*elec_ids)[electron_ref] < 1.e-6) { - continue; - } //@@ Check for null value - + + if ( (*elec_ids)[electron_ref] < 1.e-6 ) { continue; } //@@ Check for null value + // DR matching b/w electron and track - double deltaphi = fabs(ielec->phi() - (*itrk)->momentum().phi()); - if (deltaphi > 6.283185308) - deltaphi -= 6.283185308; - if (deltaphi > 3.141592654) - deltaphi = 6.283185308 - deltaphi; - deltaR = abs(sqrt(pow((ielec->eta() - (*itrk)->momentum().eta()), 2) + pow(deltaphi, 2))); - if (deltaR < deltaRMIN) { - deltaRMIN = deltaR; - } + double deltaphi = fabs( ielec->phi() - (*itrk)->momentum().phi() ); + if ( deltaphi > 6.283185308 ) deltaphi -= 6.283185308; + if ( deltaphi > 3.141592654 ) deltaphi = 6.283185308 - deltaphi; + deltaR = abs( sqrt( pow( (ielec->eta() - (*itrk)->momentum().eta()), 2 ) + + pow( deltaphi , 2 ) ) ); + if ( deltaR < deltaRMIN ) { deltaRMIN = deltaR; } + } + + if ( deltaRMIN < 0.02 ) return true; + else return false; + +} - if (deltaR < 0.02) - return true; - else - return false; +bool JetPlusTrackCorrector::matchElectrons( TrackRefs::const_iterator& itrk, + const edm::Handle& elecs + ) const { + if ( elecs->empty() ) { return false; } + // std::cout<<"JetPlusTrackCorrector::matchElectrons "<begin(); + pat::ElectronCollection::const_iterator jelec = elecs->end(); + for ( ; ielec != jelec; ++ielec ) { + // std::cout<<"Electron "<eta()<<" "<phi()<<" Track "<<(*itrk)->momentum().eta()<<" "<< + // (*itrk)->momentum().phi()<<" PT "<pt()<<" "<<(*itrk)->pt()<phi() - (*itrk)->momentum().phi() ); + if ( deltaphi > 6.283185308 ) deltaphi -= 6.283185308; + if ( deltaphi > 3.141592654 ) deltaphi = 6.283185308 - deltaphi; + deltaR = abs( sqrt( pow( (ielec->eta() - (*itrk)->momentum().eta()), 2 ) + + pow( deltaphi , 2 ) ) ); + if ( deltaR < deltaRMIN ) { deltaRMIN = deltaR; } + } + // std::cout<<" matchElectrons:DeltaR "<::iterator JetBaseRefIterator; std::vector theJets = reco::JetTracksAssociation::allJets(jtV0); @@ -1154,297 +1405,292 @@ void JetPlusTrackCorrector::rebuildJta(const reco::Jet& fJet, TrackRefs tracks = tracksthis; tracksthis.clear(); - // std::cout<<" Size of initial vector "<4.*atan(1.))dfi = 8.*atan(1.)-dfi; - // double deta = fJet.eta() - (**it).eta(); - // double dR2check = sqrt(dfi*dfi+deta*deta); - - double scalethis = dR2this; - if (jetSplitMerge_ == 0) - scalethis = 1. * jetEtIn; - if (jetSplitMerge_ == 2) - scalethis = dR2this * jetEtIn; - tr++; - int flag = 1; - for (JetBaseRefIterator ii = theJets.begin(); ii != theJets.end(); ii++) { - if (&(**ii) == &fJet) { - continue; - } - double dR2 = deltaR2((*ii)->eta(), (*ii)->phi(), trkEta, trkPhi); - double scale = dR2; - if (jetSplitMerge_ == 0) - scale = 1. / (**ii).et(); - if (jetSplitMerge_ == 2) - scale = dR2 / (**ii).et(); - if (scale < scalethis) - flag = 0; - - if (flag == 0) { - //std::cout<<" Track belong to another jet also "<et()<<" "<<(*ii)->eta()<<" "<< (*ii)->phi()<<" Track "<<(**it).eta()<<" "<<(**it).phi()<<" "<4.*atan(1.))dfi = 8.*atan(1.)-dfi; + // double deta = fJet.eta() - (**it).eta(); + // double dR2check = sqrt(dfi*dfi+deta*deta); + + double scalethis = dR2this; + if(jetSplitMerge_ == 0) scalethis = 1.*jetEtIn; + if(jetSplitMerge_ == 2) scalethis = dR2this*jetEtIn; + tr++; + int flag = 1; + for(JetBaseRefIterator ii = theJets.begin(); ii != theJets.end(); ii++) + { + if(&(**ii) == &fJet ) {continue;} + double dR2 = deltaR2( (*ii)->eta(), (*ii)->phi(), trkEta, trkPhi ); + double scale = dR2; + if(jetSplitMerge_ == 0) scale = 1./(**ii).et(); + if(jetSplitMerge_ == 2) scale = dR2/(**ii).et(); + if(scale < scalethis) flag = 0; + + if(flag == 0) { + //std::cout<<" Track belong to another jet also "<et()<<" "<<(*ii)->eta()<<" "<< (*ii)->phi()<<" Track "<<(**it).eta()<<" "<<(**it).phi()<<" "< - - for (reco::TrackRefVector::iterator iBgtC = trBgOutOfCalo.begin(); iBgtC != trBgOutOfCalo.end(); iBgtC++) { - // Temporary solution>>>>>> Remove tracks with pt>50 GeV - // if( (**iBgtC).pt() >= 50. ) continue; - //response_.value(ieta,ipt); - double eta = fabs((**iBgtC).eta()); - double pt = fabs((**iBgtC).pt()); - uint32_t ieta = response_.etaBin(eta); - uint32_t ipt = response_.ptBin(pt); - - if (fabs(fJet.eta() - (**iBgtC).eta()) > mConeSize) - continue; - - // Check bins (not for mips) - if (ieta >= response_.nEtaBins()) { - continue; - } - if (ipt >= response_.nPtBins()) { - ipt = response_.nPtBins() - 1; - } - - double echarBg = sqrt((**iBgtC).px() * (**iBgtC).px() + (**iBgtC).py() * (**iBgtC).py() + - (**iBgtC).pz() * (**iBgtC).pz() + 0.14 * 0.14); - - ResponseOfBackgroundCharged += echarBg * response_.value(ieta, ipt) / efficiency_.value(ieta, ipt); - - // std::cout<<" Efficiency of bg tracks "< + + for( reco::TrackRefVector::iterator iBgtC = trBgOutOfCalo.begin(); iBgtC != trBgOutOfCalo.end(); iBgtC++) + { + // Temporary solution>>>>>> Remove tracks with pt>50 GeV + // if( (**iBgtC).pt() >= 50. ) continue; + //response_.value(ieta,ipt); + double eta = fabs( (**iBgtC).eta() ); + double pt = fabs( (**iBgtC).pt() ); + uint32_t ieta = response_.etaBin( eta ); + uint32_t ipt = response_.ptBin( pt ); + + if(fabs(fJet.eta() -(**iBgtC).eta()) > mConeSize) continue; - } // Response of BG tracks + // Check bins (not for mips) + if ( ieta >= response_.nEtaBins() ) { continue; } + if ( ipt >= response_.nPtBins() ) { ipt = response_.nPtBins() - 1; } - //=================================================================> + double echarBg=sqrt((**iBgtC).px()*(**iBgtC).px()+(**iBgtC).py()*(**iBgtC).py()+(**iBgtC).pz()*(**iBgtC).pz()+0.14*0.14); - //=================================================================> - // Look for in-out tracks + ResponseOfBackgroundCharged += echarBg*response_.value(ieta,ipt)/efficiency_.value(ieta,ipt); - double en = 0.; - double px = 0.; - double py = 0.; - double pz = 0.; +// std::cout<<" Efficiency of bg tracks "< eta(ieta) && (ieta + 1 == nEtaBins() || val < eta(ieta + 1))) { - return ieta; - } +uint32_t Map::etaBin( double val ) const { + val = fabs( val ); + for ( uint32_t ieta = 0; ieta < nEtaBins()-1; ++ieta ) { //@@ "-1" is bug? + if ( val > eta(ieta) && ( ieta+1 == nEtaBins() || val < eta(ieta+1) ) ) { return ieta; } } return nEtaBins(); } // ----------------------------------------------------------------------------- // -uint32_t Map::ptBin(double val) const { - val = fabs(val); - for (uint32_t ipt = 0; ipt < nPtBins() - 1; ++ipt) { //@@ "-1" is bug? - if (val > pt(ipt) && ((ipt + 1) == nPtBins() || val < pt(ipt + 1))) { - return ipt; - } +uint32_t Map::ptBin( double val ) const { + val = fabs( val ); + for ( uint32_t ipt = 0; ipt < nPtBins()-1; ++ipt ) { //@@ "-1" is bug? + if ( val > pt(ipt) && ( (ipt+1) == nPtBins() || val < pt(ipt+1) ) ) { return ipt; } } return nPtBins(); } // ----------------------------------------------------------------------------- // -double Map::value(uint32_t eta_bin, uint32_t pt_bin) const { - if (eta_bin < data_.size() && pt_bin < (data_.empty() ? 0 : data_[0].size())) { - return data_[eta_bin][pt_bin]; - } else { - // edm::LogWarning("JetPlusTrackCorrector") - // << "[jpt::Map::" << __func__ << "]" - // << " Trying to access element (" << eta_bin << "," << pt_bin << ")" - // << " of a vector with size (" << data_.size() << "," << ( data_.empty() ? 0 : data_[0].size() ) << ")" - // << "!"; - return 1.; +double Map::value( uint32_t eta_bin, uint32_t pt_bin ) const { + if ( eta_bin < data_.size() && + pt_bin < ( data_.empty() ? 0 : data_[0].size() ) ) { return data_[eta_bin][pt_bin]; } + else { +// edm::LogWarning("JetPlusTrackCorrector") +// << "[jpt::Map::" << __func__ << "]" +// << " Trying to access element (" << eta_bin << "," << pt_bin << ")" +// << " of a vector with size (" << data_.size() << "," << ( data_.empty() ? 0 : data_[0].size() ) << ")" +// << "!"; + return 1.; } } // ----------------------------------------------------------------------------- // -void Map::print(std::stringstream& ss) const { - ss << " Number of bins in eta : " << data_.size() << std::endl - << " Number of bins in pt : " << (data_.empty() ? 0 : data_[0].size()) << std::endl; +void Map::print( std::stringstream& ss ) const { + ss << " Number of bins in eta : " << data_.size() << std::endl + << " Number of bins in pt : " << ( data_.empty() ? 0 : data_[0].size() ) << std::endl; VVDouble::const_iterator ieta = data_.begin(); VVDouble::const_iterator jeta = data_.end(); - for (; ieta != jeta; ++ieta) { + for ( ; ieta != jeta; ++ieta ) { VDouble::const_iterator ipt = ieta->begin(); VDouble::const_iterator jpt = ieta->end(); - for (; ipt != jpt; ++ipt) { - uint32_t eta_bin = static_cast(ieta - data_.begin()); - uint32_t pt_bin = static_cast(ipt - ieta->begin()); - ss << " EtaBinNumber: " << eta_bin << " PtBinNumber: " << pt_bin << " EtaValue: " << eta_[eta_bin] - << " PtValue: " << pt_[pt_bin] << " Value: " << data_[eta_bin][pt_bin] << std::endl; + for ( ; ipt != jpt; ++ipt ) { + uint32_t eta_bin = static_cast( ieta - data_.begin() ); + uint32_t pt_bin = static_cast( ipt - ieta->begin() ); + ss << " EtaBinNumber: " << eta_bin + << " PtBinNumber: " << pt_bin + << " EtaValue: " << eta_[ eta_bin ] + << " PtValue: " << pt_[ pt_bin ] + << " Value: " << data_[eta_bin][pt_bin] + << std::endl; } } } // ----------------------------------------------------------------------------- // -MatchedTracks::MatchedTracks() : inVertexInCalo_(), outOfVertexInCalo_(), inVertexOutOfCalo_() { clear(); } +MatchedTracks::MatchedTracks() + : inVertexInCalo_(), + outOfVertexInCalo_(), + inVertexOutOfCalo_() +{ + clear(); +} // ----------------------------------------------------------------------------- // -MatchedTracks::~MatchedTracks() { clear(); } +MatchedTracks::~MatchedTracks() { + clear(); +} // ----------------------------------------------------------------------------- // @@ -1610,14 +1871,21 @@ void MatchedTracks::clear() { outOfVertexInCalo_.clear(); inVertexOutOfCalo_.clear(); } - + // ----------------------------------------------------------------------------- // -JetTracks::JetTracks() : vertex_(), caloFace_() { clear(); } +JetTracks::JetTracks() + : vertex_(), + caloFace_() +{ + clear(); +} // ----------------------------------------------------------------------------- // -JetTracks::~JetTracks() { clear(); } +JetTracks::~JetTracks() { + clear(); +} // ----------------------------------------------------------------------------- // @@ -1628,107 +1896,98 @@ void JetTracks::clear() { // ----------------------------------------------------------------------------- // -Efficiency::Efficiency(const jpt::Map& response, const jpt::Map& efficiency, const jpt::Map& leakage) - : response_(response), efficiency_(efficiency), leakage_(leakage) { +Efficiency::Efficiency( const jpt::Map& response, + const jpt::Map& efficiency, + const jpt::Map& leakage ) + : response_(response), + efficiency_(efficiency), + leakage_(leakage) +{ reset(); } // ----------------------------------------------------------------------------- // -double Efficiency::inConeCorr(uint32_t eta_bin, uint32_t pt_bin) const { - if (check(eta_bin, pt_bin, __func__)) { - return (outOfConeCorr(eta_bin, pt_bin) * leakage_.value(eta_bin, pt_bin) * response_.value(eta_bin, pt_bin)); - } else { - return 0.; - } +double Efficiency::inConeCorr( uint32_t eta_bin, uint32_t pt_bin ) const { + if ( check(eta_bin,pt_bin,__func__) ) { + return ( outOfConeCorr( eta_bin, pt_bin ) * + leakage_.value( eta_bin, pt_bin ) * + response_.value( eta_bin, pt_bin ) ); + } else { return 0.; } } // ----------------------------------------------------------------------------- // -double Efficiency::outOfConeCorr(uint32_t eta_bin, uint32_t pt_bin) const { - if (check(eta_bin, pt_bin, __func__)) { - uint16_t ntrks = nTrks(eta_bin, pt_bin); - double mean = meanE(eta_bin, pt_bin); - double eff = (1. - efficiency_.value(eta_bin, pt_bin)) / efficiency_.value(eta_bin, pt_bin); - if (!ntrks) { - return 0.; - } - return (ntrks * eff * mean); - } else { - return 0.; - } +double Efficiency::outOfConeCorr( uint32_t eta_bin, uint32_t pt_bin ) const { + if ( check(eta_bin,pt_bin,__func__) ) { + uint16_t ntrks = nTrks( eta_bin, pt_bin ); + double mean = meanE( eta_bin, pt_bin ); + double eff = ( 1. - efficiency_.value( eta_bin, pt_bin ) ) / efficiency_.value( eta_bin, pt_bin ); + if ( !ntrks ) { return 0.; } + return ( ntrks * eff * mean ); + } else { return 0.; } } // ----------------------------------------------------------------------------- // -uint16_t Efficiency::nTrks(uint32_t eta_bin, uint32_t pt_bin) const { - if (check(eta_bin, pt_bin, __func__)) { - return data_[eta_bin][pt_bin].first; - } else { - return 0; - } +uint16_t Efficiency::nTrks( uint32_t eta_bin, uint32_t pt_bin ) const { + if ( check(eta_bin,pt_bin,__func__) ) { + return data_[eta_bin][pt_bin].first; + } else { return 0; } } // ----------------------------------------------------------------------------- // -double Efficiency::sumE(uint32_t eta_bin, uint32_t pt_bin) const { - if (check(eta_bin, pt_bin, __func__)) { - return data_[eta_bin][pt_bin].second; - } else { - return 0.; - } +double Efficiency::sumE( uint32_t eta_bin, uint32_t pt_bin ) const { + if ( check(eta_bin,pt_bin,__func__) ) { + return data_[eta_bin][pt_bin].second; + } else { return 0.; } } // ----------------------------------------------------------------------------- // -double Efficiency::meanE(uint32_t eta_bin, uint32_t pt_bin) const { - if (check(eta_bin, pt_bin, __func__)) { - Pair tmp = data_[eta_bin][pt_bin]; - if (tmp.first) { - return tmp.second / tmp.first; - } else { - return 0.; - } - } else { - return 0.; - } +double Efficiency::meanE( uint32_t eta_bin, uint32_t pt_bin ) const { + if ( check(eta_bin,pt_bin,__func__) ) { + Pair tmp = data_[eta_bin][pt_bin]; + if ( tmp.first ) { return tmp.second / tmp.first; } + else { return 0.; } + } else { return 0.; } } // ----------------------------------------------------------------------------- // -void Efficiency::addE(uint32_t eta_bin, uint32_t pt_bin, double energy) { - if (check(eta_bin, pt_bin, __func__)) { - data_[eta_bin][pt_bin].first++; +void Efficiency::addE( uint32_t eta_bin, uint32_t pt_bin, double energy ) { + if ( check(eta_bin,pt_bin,__func__) ) { + data_[eta_bin][pt_bin].first++; data_[eta_bin][pt_bin].second += energy; - } + } } // ----------------------------------------------------------------------------- // -bool Efficiency::check(uint32_t eta_bin, uint32_t pt_bin, std::string method) const { - if (eta_bin < data_.size() && pt_bin < (data_.empty() ? 0 : data_[0].size())) { - return true; - } else { - // edm::LogWarning("JetPlusTrackCorrector") - // << "[jpt::Efficiency::" << method << "]" - // << " Trying to access element (" << eta_bin << "," << pt_bin << ")" - // << " of a vector with size (" << data_.size() << "," << ( data_.empty() ? 0 : data_[0].size() ) << ")" - // << "!"; - return false; +bool Efficiency::check( uint32_t eta_bin, uint32_t pt_bin, std::string method ) const { + if ( eta_bin < data_.size() && pt_bin < ( data_.empty() ? 0 : data_[0].size() ) ) { return true; } + else { +// edm::LogWarning("JetPlusTrackCorrector") +// << "[jpt::Efficiency::" << method << "]" +// << " Trying to access element (" << eta_bin << "," << pt_bin << ")" +// << " of a vector with size (" << data_.size() << "," << ( data_.empty() ? 0 : data_[0].size() ) << ")" +// << "!"; + return false; } } // ----------------------------------------------------------------------------- // -void Efficiency::reset() { +void Efficiency::reset() { data_.clear(); - data_.resize(response_.nEtaBins(), VPair(response_.nPtBins(), Pair(0, 0.))); + data_.resize( response_.nEtaBins(), VPair( response_.nPtBins(), Pair(0,0.) ) ); } // ----------------------------------------------------------------------------- // -void Efficiency::print() const { - if (edm::isDebugEnabled()) { +void Efficiency::print() const { + if ( edm::isDebugEnabled() ) { std::stringstream ss; ss << "[jpt::Efficiency::" << __func__ << "]" << " Contents of maps:" << std::endl; @@ -1739,5 +1998,5 @@ void Efficiency::print() const { ss << "Leakage map: " << std::endl; leakage_.print(ss); LogTrace("JetPlusTrackCorrector") << ss.str(); - } + } } diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.h b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.h index daa0d68cfc3eb..cbc7c103ede92 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.h +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.h @@ -19,6 +19,11 @@ #include "DataFormats/TrackReco/interface/TrackFwd.h" #include "DataFormats/VertexReco/interface/VertexFwd.h" #include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/PatCandidates/interface/Electron.h" +#include "DataFormats/PatCandidates/interface/Jet.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" +#include "DataFormats/PatCandidates/interface/VIDCutFlowResult.h" +#include "DataFormats/PatCandidates/interface/Muon.h" #include "boost/range/iterator_range.hpp" #include @@ -28,90 +33,100 @@ namespace edm { class Event; class EventSetup; class ParameterSet; -} // namespace edm +} // -------------------------------------------------------- // -------------------- Helper classes -------------------- // -------------------------------------------------------- -namespace jpt { +namespace jpt { + /// Container class for response & efficiency maps class Map { + public: - Map(std::string, bool verbose = false); + + Map( std::string, bool verbose = false ); Map(); ~Map(); - + uint32_t nEtaBins() const; uint32_t nPtBins() const; - - double eta(uint32_t) const; - double pt(uint32_t) const; - - uint32_t etaBin(double eta) const; - uint32_t ptBin(double pt) const; - - double value(uint32_t eta_bin, uint32_t pt_bin) const; - - double binCenterEta(uint32_t) const; - double binCenterPt(uint32_t) const; - + + double eta( uint32_t ) const; + double pt( uint32_t ) const; + + uint32_t etaBin( double eta ) const; + uint32_t ptBin( double pt ) const; + + double value( uint32_t eta_bin, uint32_t pt_bin ) const; + + double binCenterEta( uint32_t ) const; + double binCenterPt( uint32_t ) const; + void clear(); - void print(std::stringstream& ss) const; + void print( std::stringstream& ss ) const; private: + class Element { public: - Element() : ieta_(0), ipt_(0), eta_(0.), pt_(0.), val_(0.) { ; } + Element() : ieta_(0), ipt_(0), eta_(0.), pt_(0.), val_(0.) {;} uint32_t ieta_; uint32_t ipt_; double eta_; double pt_; double val_; }; - + typedef std::vector VDouble; typedef std::vector VVDouble; - + std::vector eta_; std::vector pt_; VVDouble data_; + }; inline uint32_t Map::nEtaBins() const { return eta_.size(); } inline uint32_t Map::nPtBins() const { return pt_.size(); } - - /// Generic container class + + /// Generic container class class Efficiency { - public: - Efficiency(const jpt::Map& response, const jpt::Map& efficiency, const jpt::Map& leakage); - - typedef std::pair Pair; - - uint16_t nTrks(uint32_t eta_bin, uint32_t pt_bin) const; - double inConeCorr(uint32_t eta_bin, uint32_t pt_bin) const; - double outOfConeCorr(uint32_t eta_bin, uint32_t pt_bin) const; + public: + Efficiency( const jpt::Map& response, + const jpt::Map& efficiency, + const jpt::Map& leakage ); + + typedef std::pair Pair; + + uint16_t nTrks( uint32_t eta_bin, uint32_t pt_bin ) const; + + double inConeCorr( uint32_t eta_bin, uint32_t pt_bin ) const; + double outOfConeCorr( uint32_t eta_bin, uint32_t pt_bin ) const; + uint32_t nEtaBins() const; uint32_t nPtBins() const; uint32_t size() const; bool empty() const; - - void addE(uint32_t eta_bin, uint32_t pt_bin, double energy); + + void addE( uint32_t eta_bin, uint32_t pt_bin, double energy ); void reset(); - + void print() const; - + private: + Efficiency() = delete; - double sumE(uint32_t eta_bin, uint32_t pt_bin) const; - double meanE(uint32_t eta_bin, uint32_t pt_bin) const; + double sumE( uint32_t eta_bin, uint32_t pt_bin ) const; + double meanE( uint32_t eta_bin, uint32_t pt_bin ) const; - bool check(uint32_t eta_bin, uint32_t pt_bin, std::string name = "check") const; + bool check( uint32_t eta_bin, uint32_t pt_bin, std::string name = "check" ) const; typedef std::vector VPair; typedef std::vector VVPair; @@ -120,8 +135,9 @@ namespace jpt { const jpt::Map& response_; const jpt::Map& efficiency_; const jpt::Map& leakage_; + }; - + inline uint32_t Efficiency::nEtaBins() const { return response_.nEtaBins(); } inline uint32_t Efficiency::nPtBins() const { return response_.nPtBins(); } inline uint32_t Efficiency::size() const { return data_.size(); } @@ -145,18 +161,19 @@ namespace jpt { void clear(); reco::TrackRefVector inVertexInCalo_; reco::TrackRefVector outOfVertexInCalo_; - reco::TrackRefVector inVertexOutOfCalo_; + reco::TrackRefVector inVertexOutOfCalo_; }; + +//class Sum { +//public: +// Sum() { theResponseOfChargedWithEff = 0.; theResponseOfChargedFull = 0.;} +// void set( double a, double b) const {theResponseOfChargedWithEff=a;theResponseOfChargedFull=b;} +// double theResponseOfChargedWithEff; +// double theResponseOfChargedFull; +//}; - //class Sum { - //public: - // Sum() { theResponseOfChargedWithEff = 0.; theResponseOfChargedFull = 0.;} - // void set( double a, double b) const {theResponseOfChargedWithEff=a;theResponseOfChargedFull=b;} - // double theResponseOfChargedWithEff; - // double theResponseOfChargedFull; - //}; +} -} // namespace jpt // ------------------------------------------------------- // -------------------- JPT algorithm -------------------- @@ -166,107 +183,120 @@ namespace jpt { \brief Jet energy correction algorithm using tracks */ class JetPlusTrackCorrector { + // ---------- Public interface ---------- + + public: -public: /// Constructor - JetPlusTrackCorrector(const edm::ParameterSet& iPS, edm::ConsumesCollector&& iC); + JetPlusTrackCorrector( const edm::ParameterSet& iPS, edm::ConsumesCollector&& iC ); /// Destructor virtual ~JetPlusTrackCorrector(); // Typedefs for 4-momentum - typedef math::XYZTLorentzVector P4; + typedef math::XYZTLorentzVector P4; typedef math::PtEtaPhiELorentzVectorD PtEtaPhiE; typedef math::PtEtaPhiMLorentzVectorD PtEtaPhiM; - + /// Vectorial correction method (corrected 4-momentum passed by reference) - double correction(const reco::Jet&, - const reco::Jet&, - const edm::Event&, - const edm::EventSetup&, - P4&, - jpt::MatchedTracks& pions, - jpt::MatchedTracks& muons, - jpt::MatchedTracks& elecs, - bool& validMatches); - + double correction( const reco::Jet&, const reco::Jet&, const edm::Event&, const edm::EventSetup&, P4&, + jpt::MatchedTracks &pions, + jpt::MatchedTracks &muons, + jpt::MatchedTracks &elecs, + bool &validMatches) ; + double correction( const reco::Jet&, const reco::Jet&, const edm::Event&, + const edm::EventSetup&, + const reco::TrackRefVector& tracksinvert, + const reco::TrackRefVector& tracksincalo, + P4&, + jpt::MatchedTracks &pions, + jpt::MatchedTracks &muons, + jpt::MatchedTracks &elecs + ) ; + /// Scalar correction method - double correction(const reco::Jet&, - const reco::Jet&, - const edm::Event&, - const edm::EventSetup&, - jpt::MatchedTracks& pions, - jpt::MatchedTracks& muons, - jpt::MatchedTracks& elecs, - bool& validMatches); - + double correction( const reco::Jet&, const reco::Jet&, const edm::Event&, const edm::EventSetup&, + jpt::MatchedTracks &pions, + jpt::MatchedTracks &muons, + jpt::MatchedTracks &elecs, + bool &validMatches) ; + /// Correction method (not used) - double correction(const reco::Jet&) const; + double correction( const reco::Jet& ) const; /// Correction method (not used) - double correction(const P4&) const; + double correction( const P4& ) const; /// For AA - correct in tracker + +// double correctAA( const reco::Jet&, const reco::TrackRefVector&, double&, const reco::TrackRefVector&,const reco::TrackRefVector&, double&) const; + double correctAA( const reco::Jet&, const reco::TrackRefVector&, double&, const reco::TrackRefVector&,const reco::TrackRefVector&, + double, + const reco::TrackRefVector&) const; - // double correctAA( const reco::Jet&, const reco::TrackRefVector&, double&, const reco::TrackRefVector&,const reco::TrackRefVector&, double&) const; - double correctAA(const reco::Jet&, - const reco::TrackRefVector&, - double&, - const reco::TrackRefVector&, - const reco::TrackRefVector&, - double, - const reco::TrackRefVector&) const; - + /// Returns true bool eventRequired() const; - + /// Returns value of configurable bool vectorialCorrection() const; - + // ---------- Extended interface ---------- /// Get responses/sumPT/SumEnergy with and without Efficiency correction - double getResponseOfChargedWithEff() { return theResponseOfChargedWithEff; } - double getResponseOfChargedWithoutEff() { return theResponseOfChargedWithoutEff; } - double getSumPtWithEff() { return theSumPtWithEff; } - double getSumPtWithoutEff() { return theSumPtWithoutEff; } - double getSumEnergyWithEff() { return theSumEnergyWithEff; } - double getSumEnergyWithoutEff() { return theSumEnergyWithoutEff; } - double getSumPtForBeta() { return theSumPtForBeta; } + double getResponseOfChargedWithEff() {return theResponseOfChargedWithEff;} + double getResponseOfChargedWithoutEff() {return theResponseOfChargedWithoutEff;} + double getSumPtWithEff() {return theSumPtWithEff;} + double getSumPtWithoutEff() {return theSumPtWithoutEff;} + double getSumEnergyWithEff() {return theSumEnergyWithEff;} + double getSumEnergyWithoutEff() {return theSumEnergyWithoutEff;} + double getSumPtForBeta() {return theSumPtForBeta;} - /// Can jet be JPT-corrected? - bool canCorrect(const reco::Jet&) const; - /// Matches tracks to different particle types - bool matchTracks(const reco::Jet&, - const edm::Event&, - const edm::EventSetup&, - jpt::MatchedTracks& pions, - jpt::MatchedTracks& muons, - jpt::MatchedTracks& elecs); + /// Can jet be JPT-corrected? + bool canCorrect( const reco::Jet& ) const; + + /// Matches tracks to different particle types + bool matchTracks( const reco::Jet&, + const edm::Event&, + const edm::EventSetup&, + jpt::MatchedTracks& pions, + jpt::MatchedTracks& muons, + jpt::MatchedTracks& elecs ) ; + + bool matchTracks( const reco::Jet&, + const edm::Event&, + const edm::EventSetup&, + const reco::TrackRefVector& tracksinvert, + const reco::TrackRefVector& tracksincalo, + jpt::MatchedTracks& pions, + jpt::MatchedTracks& muons, + jpt::MatchedTracks& elecs ) ; + /// Calculates corrections to be applied using pions - P4 pionCorrection(const P4& jet, const jpt::MatchedTracks& pions); - + P4 pionCorrection( const P4& jet, const jpt::MatchedTracks& pions ) ; + /// Calculates correction to be applied using muons - P4 muonCorrection(const P4& jet, const jpt::MatchedTracks& muons); - + P4 muonCorrection( const P4& jet, const jpt::MatchedTracks& muons ) ; + /// Calculates correction to be applied using electrons - P4 elecCorrection(const P4& jet, const jpt::MatchedTracks& elecs) const; + P4 elecCorrection( const P4& jet, const jpt::MatchedTracks& elecs ) const; /// Get reponses - - // double theResponseOfChargedWithEff; - // double theResponseOfChargedFull; - // double setResp(double a) const {return a;} - // double getChargedResponsesWithEff() { return theResponseOfChargedWithEff;} - // double getChargedResponsesFull() { return theResponseOfChargedFull;} - + +// double theResponseOfChargedWithEff; +// double theResponseOfChargedFull; +// double setResp(double a) const {return a;} +// double getChargedResponsesWithEff() { return theResponseOfChargedWithEff;} +// double getChargedResponsesFull() { return theResponseOfChargedFull;} + // ---------- Protected interface ---------- -protected: + protected: + // Some useful typedefs typedef reco::MuonCollection RecoMuons; typedef reco::GsfElectronCollection RecoElectrons; @@ -275,99 +305,139 @@ class JetPlusTrackCorrector { typedef reco::TrackRefVector TrackRefs; /// Associates tracks to jets (overriden in derived class) - virtual bool jetTrackAssociation(const reco::Jet&, const edm::Event&, const edm::EventSetup&, jpt::JetTracks&) const; - + virtual bool jetTrackAssociation( const reco::Jet&, + const edm::Event&, + const edm::EventSetup&, + jpt::JetTracks& ) const; + /// JTA using collections from event - bool jtaUsingEventData(const reco::Jet&, const edm::Event&, jpt::JetTracks&) const; - + bool jtaUsingEventData( const reco::Jet&, + const edm::Event&, + jpt::JetTracks& ) const; + /// Matches tracks to different particle types (overriden in derived class) - virtual void matchTracks(const jpt::JetTracks&, - const edm::Event&, - jpt::MatchedTracks& pions, - jpt::MatchedTracks& muons, - jpt::MatchedTracks& elecs); + virtual void matchTracks( const jpt::JetTracks&, + const edm::Event&, + jpt::MatchedTracks& pions, + jpt::MatchedTracks& muons, + jpt::MatchedTracks& elecs ) ; /// Calculates individual pion corrections - P4 pionCorrection( - const P4& jet, const TrackRefs& pions, jpt::Efficiency&, bool in_cone_at_vertex, bool in_cone_at_calo_face); + P4 pionCorrection( const P4& jet, + const TrackRefs& pions, + jpt::Efficiency&, + bool in_cone_at_vertex, + bool in_cone_at_calo_face ) ; /// Calculates individual muons corrections - P4 muonCorrection(const P4& jet, const TrackRefs& muons, bool in_cone_at_vertex, bool in_cone_at_calo_face); - + P4 muonCorrection( const P4& jet, + const TrackRefs& muons, + bool in_cone_at_vertex, + bool in_cone_at_calo_face ) ; + /// Calculates individual electron corrections - P4 elecCorrection(const P4& jet, const TrackRefs& elecs, bool in_cone_at_vertex, bool in_cone_at_calo_face); + P4 elecCorrection( const P4& jet, + const TrackRefs& elecs, + bool in_cone_at_vertex, + bool in_cone_at_calo_face ) ; /// Calculates vectorial correction using total track 3-momentum - P4 jetDirFromTracks(const P4& jet, - const jpt::MatchedTracks& pions, - const jpt::MatchedTracks& muons, - const jpt::MatchedTracks& elecs) const; - + P4 jetDirFromTracks( const P4& jet, + const jpt::MatchedTracks& pions, + const jpt::MatchedTracks& muons, + const jpt::MatchedTracks& elecs ) const; + /// Generic method to calculates 4-momentum correction to be applied - P4 calculateCorr(const P4& jet, - const TrackRefs&, - jpt::Efficiency&, - bool in_cone_at_vertex, - bool in_cone_at_calo_face, - double mass, - bool is_pion, - double mip); - - /// Correction to be applied using tracking efficiency - P4 pionEfficiency(const P4& jet, const jpt::Efficiency&, bool in_cone_at_calo_face); - + P4 calculateCorr( const P4& jet, + const TrackRefs&, + jpt::Efficiency&, + bool in_cone_at_vertex, + bool in_cone_at_calo_face, + double mass, + bool is_pion, + double mip ) ; + + /// Correction to be applied using tracking efficiency + P4 pionEfficiency( const P4& jet, + const jpt::Efficiency&, + bool in_cone_at_calo_face ) ; + /// Check corrected 4-momentum does not give negative scale - double checkScale(const P4& jet, P4& corrected) const; - + double checkScale( const P4& jet, P4& corrected ) const; + /// Get RECO muons - bool getMuons(const edm::Event&, edm::Handle&) const; + bool getMuons( const edm::Event&, edm::Handle& ) const; + + bool getMuons( const edm::Event&, edm::Handle& ) const; /// Get RECO electrons - bool getElectrons(const edm::Event&, edm::Handle&, edm::Handle&) const; + bool getElectrons( const edm::Event&, + edm::Handle&, + edm::Handle& ) const; + bool getElectrons( const edm::Event&, + edm::Handle&) const; + /// Matches tracks to RECO muons - bool matchMuons(TrackRefs::const_iterator&, const edm::Handle&) const; - + bool matchMuons( TrackRefs::const_iterator&, + const edm::Handle& ) const; + bool matchMuons( TrackRefs::const_iterator&, + const edm::Handle& ) const; + + /// Matches tracks to RECO electrons - bool matchElectrons(TrackRefs::const_iterator&, - const edm::Handle&, - const edm::Handle&) const; - + bool matchElectrons( TrackRefs::const_iterator&, + const edm::Handle&, + const edm::Handle& ) const; + bool matchElectrons( TrackRefs::const_iterator&, + const edm::Handle& + ) const; + /// Check on track quality - bool failTrackQuality(TrackRefs::const_iterator&) const; + bool failTrackQuality( TrackRefs::const_iterator& ) const; /// Find track in JetTracks collection - bool findTrack(const jpt::JetTracks&, TrackRefs::const_iterator&, TrackRefs::iterator&) const; + bool findTrack( const jpt::JetTracks&, + TrackRefs::const_iterator&, + TrackRefs::iterator& ) const; /// Find track in MatchedTracks collections - bool findTrack(const jpt::MatchedTracks& pions, - const jpt::MatchedTracks& muons, - const jpt::MatchedTracks& electrons, - TrackRefs::const_iterator&) const; + bool findTrack( const jpt::MatchedTracks& pions, + const jpt::MatchedTracks& muons, + const jpt::MatchedTracks& electrons, + TrackRefs::const_iterator& ) const; /// Determines if any tracks in cone at CaloFace - bool tracksInCalo(const jpt::MatchedTracks& pions, - const jpt::MatchedTracks& muons, - const jpt::MatchedTracks& elecs) const; - - /// Rebuild jet-track association - void rebuildJta(const reco::Jet&, const JetTracksAssociations&, TrackRefs& included, TrackRefs& excluded) const; - - /// Exclude jet-track association - void excludeJta(const reco::Jet&, const JetTracksAssociations&, TrackRefs& included, const TrackRefs& excluded) const; - + bool tracksInCalo( const jpt::MatchedTracks& pions, + const jpt::MatchedTracks& muons, + const jpt::MatchedTracks& elecs ) const; + + /// Rebuild jet-track association + void rebuildJta( const reco::Jet&, + const JetTracksAssociations&, + TrackRefs& included, + TrackRefs& excluded ) const; + + /// Exclude jet-track association + void excludeJta( const reco::Jet&, + const JetTracksAssociations&, + TrackRefs& included, + const TrackRefs& excluded ) const; + const jpt::Map& responseMap() const; const jpt::Map& efficiencyMap() const; const jpt::Map& leakageMap() const; - + /// Default constructor - JetPlusTrackCorrector() { ; } + JetPlusTrackCorrector() {;} // ---------- Protected member data ---------- -protected: + protected: + // Some general configuration bool verbose_; + bool usereco_; bool vectorial_; bool vecResponse_; bool useInConeTracks_; @@ -378,7 +448,7 @@ class JetPlusTrackCorrector { bool useMuons_; bool useElecs_; bool useTrackQuality_; - + // Jet-track association edm::InputTag jetTracksAtVertex_; edm::InputTag jetTracksAtCalo_; @@ -390,18 +460,20 @@ class JetPlusTrackCorrector { // Muons and electrons edm::InputTag muons_; - edm::InputTag electrons_; + edm::InputTag electrons_; edm::InputTag electronIds_; - + edm::InputTag patmuons_; + edm::InputTag patelectrons_; + // Filter tracks by quality reco::TrackBase::TrackQuality trackQuality_; - // Response and efficiency maps + // Response and efficiency maps const jpt::Map response_; const jpt::Map efficiency_; const jpt::Map leakage_; - // Mass + // Mass double pionMass_; double muonMass_; double elecMass_; @@ -415,59 +487,64 @@ class JetPlusTrackCorrector { float theSumEnergyWithEff; float theSumEnergyWithoutEff; float theSumPtForBeta; - jpt::Efficiency not_used{response_, efficiency_, leakage_}; + jpt::Efficiency not_used{response_,efficiency_,leakage_}; // ---------- Private data members ---------- -private: + private: edm::EDGetTokenT input_jetTracksAtVertex_token_; edm::EDGetTokenT input_jetTracksAtCalo_token_; - edm::EDGetTokenT inut_reco_muons_token_; + edm::EDGetTokenT input_reco_muons_token_; edm::EDGetTokenT input_pvCollection_token_; - edm::EDGetTokenT input_reco_elecs_token_; + edm::EDGetTokenT input_reco_elecs_token_; edm::EDGetTokenT input_reco_elec_ids_token_; + edm::EDGetTokenT input_pat_muons_token_; + edm::EDGetTokenT input_pat_elecs_token_; + }; // ---------- Inline methods ---------- -inline double JetPlusTrackCorrector::correction(const reco::Jet& fJet, - const reco::Jet& fJetcalo, - const edm::Event& event, - const edm::EventSetup& setup, - jpt::MatchedTracks& pions, - jpt::MatchedTracks& muons, - jpt::MatchedTracks& elecs, - bool& validMatches) { +inline double JetPlusTrackCorrector::correction( const reco::Jet& fJet, const reco::Jet& fJetcalo, + const edm::Event& event, + const edm::EventSetup& setup, + jpt::MatchedTracks &pions, + jpt::MatchedTracks &muons, + jpt::MatchedTracks &elecs, + bool &validMatches) { P4 not_used_for_scalar_correction; - return correction(fJet, fJetcalo, event, setup, not_used_for_scalar_correction, pions, muons, elecs, validMatches); + return correction( fJet, fJetcalo, event, setup, not_used_for_scalar_correction,pions,muons,elecs,validMatches ); } inline bool JetPlusTrackCorrector::eventRequired() const { return true; } inline bool JetPlusTrackCorrector::vectorialCorrection() const { return vectorial_; } -inline bool JetPlusTrackCorrector::canCorrect(const reco::Jet& jet) const { return (fabs(jet.eta()) <= maxEta_); } - -inline JetPlusTrackCorrector::P4 JetPlusTrackCorrector::pionCorrection( - const P4& jet, const TrackRefs& pions, jpt::Efficiency& eff, bool in_cone_at_vertex, bool in_cone_at_calo_face) { - return calculateCorr(jet, pions, eff, in_cone_at_vertex, in_cone_at_calo_face, pionMass_, true, -1.); -} - -inline JetPlusTrackCorrector::P4 JetPlusTrackCorrector::muonCorrection(const P4& jet, - const TrackRefs& muons, - bool in_cone_at_vertex, - bool in_cone_at_calo_face) { - return calculateCorr(jet, muons, not_used, in_cone_at_vertex, in_cone_at_calo_face, muonMass_, false, 2.); -} - -inline JetPlusTrackCorrector::P4 JetPlusTrackCorrector::elecCorrection(const P4& jet, - const TrackRefs& elecs, - bool in_cone_at_vertex, - bool in_cone_at_calo_face) { - return calculateCorr(jet, elecs, not_used, in_cone_at_vertex, in_cone_at_calo_face, elecMass_, false, 0.); +inline bool JetPlusTrackCorrector::canCorrect( const reco::Jet& jet ) const { return ( fabs( jet.eta() ) <= maxEta_ ); } + +inline JetPlusTrackCorrector::P4 JetPlusTrackCorrector::pionCorrection( const P4& jet, + const TrackRefs& pions, + jpt::Efficiency& eff, + bool in_cone_at_vertex, + bool in_cone_at_calo_face ) { + return calculateCorr( jet, pions, eff, in_cone_at_vertex, in_cone_at_calo_face, pionMass_, true, -1. ); } -inline double JetPlusTrackCorrector::checkScale(const P4& jet, P4& corrected) const { - if (jet.energy() > 0. && (corrected.energy() / jet.energy()) < 0.) { - corrected = jet; +inline JetPlusTrackCorrector::P4 JetPlusTrackCorrector::muonCorrection( const P4& jet, + const TrackRefs& muons, + bool in_cone_at_vertex, + bool in_cone_at_calo_face ) { + return calculateCorr( jet, muons, not_used, in_cone_at_vertex, in_cone_at_calo_face, muonMass_, false, 2. ); +} + +inline JetPlusTrackCorrector::P4 JetPlusTrackCorrector::elecCorrection( const P4& jet, + const TrackRefs& elecs, + bool in_cone_at_vertex, + bool in_cone_at_calo_face ) { + return calculateCorr( jet, elecs, not_used, in_cone_at_vertex, in_cone_at_calo_face, elecMass_, false, 0. ); +} + +inline double JetPlusTrackCorrector::checkScale( const P4& jet, P4& corrected ) const { + if ( jet.energy() > 0. && ( corrected.energy() / jet.energy() ) < 0. ) { + corrected = jet; } return corrected.energy() / jet.energy(); } @@ -476,4 +553,4 @@ inline const jpt::Map& JetPlusTrackCorrector::responseMap() const { return respo inline const jpt::Map& JetPlusTrackCorrector::efficiencyMap() const { return efficiency_; } inline const jpt::Map& JetPlusTrackCorrector::leakageMap() const { return leakage_; } -#endif // RecoJets_JetPlusTracks_JetPlusTrackCorrector_h +#endif // RecoJets_JetPlusTracks_JetPlusTrackCorrector_h From f7ff65e4efe374cec4027500e2becd41168370b2 Mon Sep 17 00:00:00 2001 From: Olga Kodolova Date: Mon, 8 Jun 2020 16:29:43 +0200 Subject: [PATCH 03/14] TrackJet seeds adding --- .../plugins/JetPlusTrackProducer.cc | 483 +++++++++++------- .../plugins/JetPlusTrackProducer.h | 47 +- 2 files changed, 327 insertions(+), 203 deletions(-) diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc index 5ebd0b5878f23..8c14058af5a09 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc @@ -2,7 +2,7 @@ // // Package: JetPlusTracks // Class: JetPlusTrackProducer -// +// /**\class JetPlusTrackProducer JetPlusTrackProducer.cc JetPlusTrackProducer.cc Description: [one line class summary] @@ -16,6 +16,7 @@ // // + // system include files #include @@ -30,6 +31,8 @@ #include "DataFormats/JetReco/interface/CaloJet.h" #include "DataFormats/JetReco/interface/JPTJetCollection.h" #include "DataFormats/JetReco/interface/JPTJet.h" +#include "DataFormats/JetReco/interface/TrackJetCollection.h" +#include "DataFormats/JetReco/interface/TrackJet.h" #include "DataFormats/TrackReco/interface/TrackFwd.h" #include "DataFormats/TrackReco/interface/Track.h" #include "DataFormats/JetReco/interface/Jet.h" @@ -47,6 +50,7 @@ using namespace jpt; // constants, enums and typedefs // + // // static data member definitions // @@ -54,95 +58,212 @@ using namespace jpt; // // constructors and destructor // -JetPlusTrackProducer::JetPlusTrackProducer(const edm::ParameterSet& iConfig) { - //register your products - src = iConfig.getParameter("src"); - alias = iConfig.getUntrackedParameter("alias"); - srcPVs_ = iConfig.getParameter("srcPVs"); - vectorial_ = iConfig.getParameter("VectorialCorrection"); - useZSP = iConfig.getParameter("UseZSP"); - ptCUT = iConfig.getParameter("ptCUT"); - mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector()); - if (useZSP) - mZSPalgo = new ZSPJPTJetCorrector(iConfig); - - produces().setBranchAlias(alias); - - input_jets_token_ = consumes >(src); - input_vertex_token_ = consumes(srcPVs_); +JetPlusTrackProducer::JetPlusTrackProducer(const edm::ParameterSet& iConfig) +{ + //register your products + src = iConfig.getParameter("src"); + srcTrackJets = iConfig.getParameter("srcTrackJets"); + alias = iConfig.getUntrackedParameter("alias"); + srcPVs_ = iConfig.getParameter("srcPVs"); + vectorial_ = iConfig.getParameter("VectorialCorrection"); + useZSP = iConfig.getParameter("UseZSP"); + ptCUT = iConfig.getParameter("ptCUT"); + + mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector()); + if(useZSP) mZSPalgo = new ZSPJPTJetCorrector(iConfig); + + produces().setBranchAlias(alias); + produces().setBranchAlias("ak4CaloJetsJPT"); + + input_jets_token_ = consumes >(src); + input_addjets_token_ = consumes >(iConfig.getParameter("srcAddCaloJets")); + input_trackjets_token_ = consumes >(srcTrackJets); + input_vertex_token_ = consumes(srcPVs_); + mExtrapolations = consumes > + (iConfig.getParameter ("extrapolations")); } -JetPlusTrackProducer::~JetPlusTrackProducer() { - // do anything here that needs to be done at desctruction time - // (e.g. close files, deallocate resources etc.) + +JetPlusTrackProducer::~JetPlusTrackProducer() +{ + + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) + } + // // member functions // +bool sort_by_pt (reco::JPTJet a,reco::JPTJet b) { return (a.pt()>b.pt());} // ------------ method called to produce the data ------------ -void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { - using namespace edm; +void +JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + using namespace edm; - // std::cout<<" RecoJets::JetPlusTrackProducer::produce "< > jets_h; - iEvent.getByToken(input_jets_token_, jets_h); - - // auto pOut = std::make_unique(); - auto pOut = std::make_unique(); +// get stuff from Event + edm::Handle > jets_h; + iEvent.getByToken (input_jets_token_, jets_h); - for (unsigned i = 0; i < jets_h->size(); ++i) { - const reco::CaloJet* oldjet = &(*(jets_h->refAt(i))); +//JetPlusTrackAddonSeed + edm::Handle > addjets_h; + iEvent.getByToken (input_addjets_token_, addjets_h); - reco::CaloJet corrected = *oldjet; + //std::cout<<" Additional Calojets "<size()< > jetsTrackJets; + iEvent.getByToken(input_trackjets_token_, jetsTrackJets); - double factorZSP = 1.; - if (useZSP) - factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup); + //std::cout<<" Additional Trackjets "<size()< > iExtrapolations; + iEvent.getByToken (mExtrapolations, iExtrapolations); - // JPT corrections + edm::RefProd pOut1RefProd = + iEvent.getRefBeforePut(); + edm::Ref::key_type idxCaloJet = 0; + + auto pOut = std::make_unique(); + auto pOut1 = std::make_unique(); double scaleJPT = 1.; + std::vector theJPTJets; + if (jetsTrackJets.isValid()) { + if(jetsTrackJets->size() > 0 ) { + for (unsigned ijet = 0; ijet < jetsTrackJets->size(); ++ijet) { + const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet))); + int icalo = -1; + if(addjets_h.isValid()) { + for (unsigned i = 0; i < addjets_h->size(); ++i) { + const reco::CaloJet* oldjet = &(*(addjets_h->refAt(i))); + double deta = fabs(jet->eta()-oldjet->eta()); + double dphi = fabs(jet->phi()-oldjet->phi()); + if(dphi>4.*atan(1.)) dphi = 8.*atan(1.) - dphi; + double dr = sqrt(dphi*dphi+deta*deta); + if(dr<=0.4) {icalo=i;} + } // Calojets + } + if(icalo < 0) continue; + const reco::CaloJet* mycalo = &(*(addjets_h->refAt(icalo))); + // std::cout<<" Additional CaloJet "<pt()<<" "<eta()<< + // " "<phi()< > tracksinjet = jet->tracks(); + reco::TrackRefVector tracksincalo; + reco::TrackRefVector tracksinvert; + for(std::vector >::iterator itrack = tracksinjet.begin(); + itrack != tracksinjet.end(); itrack++) { + for ( std::vector::const_iterator xtrpBegin = iExtrapolations->begin(), + xtrpEnd = iExtrapolations->end(), ixtrp = xtrpBegin; + ixtrp != xtrpEnd; ++ixtrp ) + { + if ( ixtrp->positions().empty() ) continue; + double mydphi =fabs(ixtrp->track()->phi()-(**itrack).phi()); + if(mydphi>4.*atan(1.)) mydphi = 8.*atan(1)-mydphi; + if(fabs(ixtrp->track()->pt()-(**itrack).pt()) > 0.001 || + fabs(ixtrp->track()->eta()-(**itrack).eta()) > 0.001 || mydphi > 0.001) continue; + tracksinvert.push_back(ixtrp->track()); + reco::TrackBase::Point const & point = ixtrp->positions().at(0); + + double dr = reco::deltaR( jet->eta(), jet->phi(), point.eta(), point.phi() ); + if(dr <= 0.4) { + /*std::cout<<" TrackINcalo "<track()); + } + } // Track extrapolations + } // tracks + + reco::TrackJet corrected = *jet; + math::XYZTLorentzVector p4; + jpt::MatchedTracks pions; + jpt::MatchedTracks muons; + jpt::MatchedTracks elecs; + + scaleJPT = mJPTalgo->correction( corrected, *mycalo, iEvent, iSetup, + tracksinvert, tracksincalo, p4, pions, muons, elecs); + // std::cout<<" JetPlusTrackProducer::AddSeedJet "<< (*mycalo).pt()<<" "<< (*mycalo).eta()<<" "<< + // (*mycalo).phi()<<" "<<(*mycalo).jetArea()<<" Corr "<< + // p4.pt()<<" "< ptCUT) { + reco::JPTJet::Specific jptspe; + jptspe.pionsInVertexInCalo = pions.inVertexInCalo_; + jptspe.pionsInVertexOutCalo = pions.inVertexOutOfCalo_; + jptspe.pionsOutVertexInCalo = pions.outOfVertexInCalo_; + jptspe.muonsInVertexInCalo = muons.inVertexInCalo_; + jptspe.muonsInVertexOutCalo = muons.inVertexOutOfCalo_; + jptspe.muonsOutVertexInCalo = muons.outOfVertexInCalo_; + jptspe.elecsInVertexInCalo = elecs.inVertexInCalo_; + jptspe.elecsInVertexOutCalo = elecs.inVertexOutOfCalo_; + jptspe.elecsOutVertexInCalo = elecs.outOfVertexInCalo_; + reco::CaloJetRef myjet(pOut1RefProd, idxCaloJet++); + jptspe.theCaloJetRef = edm::RefToBase(myjet); + jptspe.mZSPCor = 1.; + reco::JPTJet fJet(p4, jet->primaryVertex()->position(), jptspe, mycalo->getJetConstituents()); + pOut->push_back(fJet); + pOut1->push_back(*mycalo); + theJPTJets.push_back(fJet); + } + } // trackjets + } // jets + } // There is trackjet collection + + for (unsigned i = 0; i < jets_h->size(); ++i) { + + const reco::CaloJet* oldjet = &(*(jets_h->refAt(i))); + reco::CaloJet corrected = *oldjet; + +// ZSP corrections + + double factorZSP = 1.; + if(useZSP) factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup); + corrected.scaleEnergy (factorZSP); + +// JPT corrections + scaleJPT = 1.; + + math::XYZTLorentzVector p4; + + jpt::MatchedTracks pions; + jpt::MatchedTracks muons; + jpt::MatchedTracks elecs; + bool ok=false; + + if ( !vectorial_ ) { + + scaleJPT = mJPTalgo->correction ( corrected, *oldjet, iEvent, iSetup, pions, muons, elecs,ok ); + p4 = math::XYZTLorentzVector( corrected.px()*scaleJPT, + corrected.py()*scaleJPT, + corrected.pz()*scaleJPT, + corrected.energy()*scaleJPT ); + // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< (*oldjet).phi()<< + // " "<correction( corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs,ok ); + // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< + // (*oldjet).phi()<<" "<<(*oldjet).jetArea()<<" Corr "<< + // p4.pt()<<" "<correction(corrected, *oldjet, iEvent, iSetup, pions, muons, elecs, ok); - p4 = math::XYZTLorentzVector(corrected.px() * scaleJPT, - corrected.py() * scaleJPT, - corrected.pz() * scaleJPT, - corrected.energy() * scaleJPT); - } else { - scaleJPT = mJPTalgo->correction(corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs, ok); - } - - reco::JPTJet::Specific specific; - - if (ok) { - specific.pionsInVertexInCalo = pions.inVertexInCalo_; - specific.pionsInVertexOutCalo = pions.inVertexOutOfCalo_; - specific.pionsOutVertexInCalo = pions.outOfVertexInCalo_; - specific.muonsInVertexInCalo = muons.inVertexInCalo_; - specific.muonsInVertexOutCalo = muons.inVertexOutOfCalo_; - specific.muonsOutVertexInCalo = muons.outOfVertexInCalo_; - specific.elecsInVertexInCalo = elecs.inVertexInCalo_; - specific.elecsInVertexOutCalo = elecs.inVertexOutOfCalo_; - specific.elecsOutVertexInCalo = elecs.outOfVertexInCalo_; - } - - // Fill JPT Specific +// Fill JPT Specific edm::RefToBase myjet = (edm::RefToBase)jets_h->refAt(i); specific.theCaloJetRef = myjet; specific.mZSPCor = factorZSP; @@ -154,123 +275,117 @@ void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iS specific.mSumEnergyOfChargedWithoutEff = (float)mJPTalgo->getSumEnergyWithoutEff(); specific.mChargedHadronEnergy = (float)mJPTalgo->getSumEnergyWithoutEff(); - // Fill Charged Jet shape parameters - double deR2Tr = 0.; - double deEta2Tr = 0.; - double dePhi2Tr = 0.; - double Zch = 0.; - double Pout2 = 0.; - double Pout = 0.; - double denominator_tracks = 0.; - int ntracks = 0; - - for (reco::TrackRefVector::const_iterator it = pions.inVertexInCalo_.begin(); it != pions.inVertexInCalo_.end(); - it++) { - double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); - double deEta = (*it)->eta() - p4.eta(); - double dePhi = deltaPhi((*it)->phi(), p4.phi()); - if ((**it).ptError() / (**it).pt() < 0.1) { - deR2Tr = deR2Tr + deR * deR * (*it)->pt(); - deEta2Tr = deEta2Tr + deEta * deEta * (*it)->pt(); - dePhi2Tr = dePhi2Tr + dePhi * dePhi * (*it)->pt(); - denominator_tracks = denominator_tracks + (*it)->pt(); - Zch = Zch + (*it)->pt(); - - Pout2 = Pout2 + (**it).p() * (**it).p() - (Zch * p4.P()) * (Zch * p4.P()); - ntracks++; - } - } - - for (reco::TrackRefVector::const_iterator it = muons.inVertexInCalo_.begin(); it != muons.inVertexInCalo_.end(); - it++) { - double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); - double deEta = (*it)->eta() - p4.eta(); - double dePhi = deltaPhi((*it)->phi(), p4.phi()); - if ((**it).ptError() / (**it).pt() < 0.1) { - deR2Tr = deR2Tr + deR * deR * (*it)->pt(); - deEta2Tr = deEta2Tr + deEta * deEta * (*it)->pt(); - dePhi2Tr = dePhi2Tr + dePhi * dePhi * (*it)->pt(); - denominator_tracks = denominator_tracks + (*it)->pt(); - Zch = Zch + (*it)->pt(); - - Pout2 = Pout2 + (**it).p() * (**it).p() - (Zch * p4.P()) * (Zch * p4.P()); - ntracks++; - } - } - for (reco::TrackRefVector::const_iterator it = elecs.inVertexInCalo_.begin(); it != elecs.inVertexInCalo_.end(); - it++) { - double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); - double deEta = (*it)->eta() - p4.eta(); - double dePhi = deltaPhi((*it)->phi(), p4.phi()); - if ((**it).ptError() / (**it).pt() < 0.1) { - deR2Tr = deR2Tr + deR * deR * (*it)->pt(); - deEta2Tr = deEta2Tr + deEta * deEta * (*it)->pt(); - dePhi2Tr = dePhi2Tr + dePhi * dePhi * (*it)->pt(); - denominator_tracks = denominator_tracks + (*it)->pt(); - Zch = Zch + (*it)->pt(); - - Pout2 = Pout2 + (**it).p() * (**it).p() - (Zch * p4.P()) * (Zch * p4.P()); - ntracks++; - } - } - for (reco::TrackRefVector::const_iterator it = pions.inVertexOutOfCalo_.begin(); - it != pions.inVertexOutOfCalo_.end(); - it++) { - Zch = Zch + (*it)->pt(); - } - for (reco::TrackRefVector::const_iterator it = muons.inVertexOutOfCalo_.begin(); - it != muons.inVertexOutOfCalo_.end(); - it++) { - Zch = Zch + (*it)->pt(); - } - for (reco::TrackRefVector::const_iterator it = elecs.inVertexOutOfCalo_.begin(); - it != elecs.inVertexOutOfCalo_.end(); - it++) { - Zch = Zch + (*it)->pt(); - } - - if (mJPTalgo->getSumPtForBeta() > 0.) - Zch = Zch / mJPTalgo->getSumPtForBeta(); - - // std::cout<<" Zch "<< Zch<<" "<getSumPtForBeta()< 0) { - Pout = sqrt(fabs(Pout2)) / ntracks; - } - if (denominator_tracks != 0) { - deR2Tr = deR2Tr / denominator_tracks; - deEta2Tr = deEta2Tr / denominator_tracks; - dePhi2Tr = dePhi2Tr / denominator_tracks; - } - - specific.R2momtr = deR2Tr; - specific.Eta2momtr = deEta2Tr; - specific.Phi2momtr = dePhi2Tr; - specific.Pout = Pout; - specific.Zch = Zch; - - // std::cout<<" Moments for charged component "< pvCollection; - iEvent.getByToken(input_vertex_token_, pvCollection); - if (pvCollection.isValid() && !pvCollection->empty()) - vertex_ = pvCollection->begin()->position(); - - reco::JPTJet fJet(p4, vertex_, specific, corrected.getJetConstituents()); - - // fJet.printJet(); - - // Output module - if (fJet.pt() > ptCUT) - pOut->push_back(fJet); +// Fill Charged Jet shape parameters + double deR2Tr = 0.; + double deEta2Tr = 0.; + double dePhi2Tr = 0.; + double Zch = 0.; + double Pout2 = 0.; + double Pout = 0.; + double denominator_tracks = 0.; + int ntracks = 0; + + for( reco::TrackRefVector::const_iterator it = pions.inVertexInCalo_.begin(); it != pions.inVertexInCalo_.end(); it++) { + double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); + double deEta = (*it)->eta() - p4.eta(); + double dePhi = deltaPhi((*it)->phi(), p4.phi()); + if((**it).ptError()/(**it).pt() < 0.1) { + deR2Tr = deR2Tr + deR*deR*(*it)->pt(); + deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); + dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); + denominator_tracks = denominator_tracks + (*it)->pt(); + Zch = Zch + (*it)->pt(); + + Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); + ntracks++; + } + } + + for( reco::TrackRefVector::const_iterator it = muons.inVertexInCalo_.begin(); it != muons.inVertexInCalo_.end(); it++) { + double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); + double deEta = (*it)->eta() - p4.eta(); + double dePhi = deltaPhi((*it)->phi(), p4.phi()); + if((**it).ptError()/(**it).pt() < 0.1) { + deR2Tr = deR2Tr + deR*deR*(*it)->pt(); + deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); + dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); + denominator_tracks = denominator_tracks + (*it)->pt(); + Zch = Zch + (*it)->pt(); + + Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); + ntracks++; + } + } + for( reco::TrackRefVector::const_iterator it = elecs.inVertexInCalo_.begin(); it != elecs.inVertexInCalo_.end(); it++) { + double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); + double deEta = (*it)->eta() - p4.eta(); + double dePhi = deltaPhi((*it)->phi(), p4.phi()); + if((**it).ptError()/(**it).pt() < 0.1) { + deR2Tr = deR2Tr + deR*deR*(*it)->pt(); + deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); + dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); + denominator_tracks = denominator_tracks + (*it)->pt(); + Zch = Zch + (*it)->pt(); + + Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); + ntracks++; + } + } + for( reco::TrackRefVector::const_iterator it = pions.inVertexOutOfCalo_.begin(); it != pions.inVertexOutOfCalo_.end(); it++) { + Zch = Zch + (*it)->pt(); + } + for( reco::TrackRefVector::const_iterator it = muons.inVertexOutOfCalo_.begin(); it != muons.inVertexOutOfCalo_.end(); it++) { + Zch = Zch + (*it)->pt(); + } + for( reco::TrackRefVector::const_iterator it = elecs.inVertexOutOfCalo_.begin(); it != elecs.inVertexOutOfCalo_.end(); it++) { + Zch = Zch + (*it)->pt(); + } + + if(mJPTalgo->getSumPtForBeta()> 0.) Zch = Zch/mJPTalgo->getSumPtForBeta(); + +// std::cout<<" Zch "<< Zch<<" "<getSumPtForBeta()< 0) { + Pout = sqrt(fabs(Pout2))/ntracks; + } + if (denominator_tracks!=0){ + deR2Tr = deR2Tr/denominator_tracks; + deEta2Tr= deEta2Tr/denominator_tracks; + dePhi2Tr= dePhi2Tr/denominator_tracks; + } + + specific.R2momtr = deR2Tr; + specific.Eta2momtr = deEta2Tr; + specific.Phi2momtr = dePhi2Tr; + specific.Pout = Pout; + specific.Zch = Zch; + + +// std::cout<<" Moments for charged component "< pvCollection; + iEvent.getByToken(input_vertex_token_, pvCollection); + if ( pvCollection.isValid() && !pvCollection->empty() ) vertex_=pvCollection->begin()->position(); + + reco::JPTJet fJet(p4, vertex_, specific, corrected.getJetConstituents()); + + // fJet.printJet(); + +// Output module + if(fJet.pt()>ptCUT) pOut->push_back(fJet); } + std::sort(pOut->begin(),pOut->end(),sort_by_pt); + //std::cout<<"Size of the additional jets "<size()< @@ -30,7 +31,9 @@ #include "ZSPJPTJetCorrector.h" #include "DataFormats/JetReco/interface/CaloJet.h" +#include "DataFormats/JetReco/interface/TrackJet.h" #include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/JetReco/interface/TrackExtrapolation.h" #include @@ -39,22 +42,28 @@ // class JetPlusTrackProducer : public edm::stream::EDProducer<> { -public: - explicit JetPlusTrackProducer(const edm::ParameterSet&); - ~JetPlusTrackProducer() override; - void produce(edm::Event&, const edm::EventSetup&) override; - - // ---------- private data members --------------------------- -private: - JetPlusTrackCorrector* mJPTalgo; - ZSPJPTJetCorrector* mZSPalgo; - edm::InputTag src; - edm::InputTag srcPVs_; - std::string alias; - bool vectorial_; - bool useZSP; - double ptCUT; - - edm::EDGetTokenT > input_jets_token_; - edm::EDGetTokenT input_vertex_token_; + public: + explicit JetPlusTrackProducer(const edm::ParameterSet&); + ~JetPlusTrackProducer() override; + void produce(edm::Event&, const edm::EventSetup&) override; + + // ---------- private data members --------------------------- + private: + + JetPlusTrackCorrector* mJPTalgo; + ZSPJPTJetCorrector* mZSPalgo; + edm::InputTag src; + edm::InputTag srcTrackJets; + edm::InputTag srcPVs_; + std::string alias; + bool vectorial_; + bool useZSP; + double ptCUT; + + edm::EDGetTokenT > input_jets_token_; + edm::EDGetTokenT > input_addjets_token_; + edm::EDGetTokenT > input_trackjets_token_; + edm::EDGetTokenT input_vertex_token_; + edm::EDGetTokenT > mExtrapolations; + }; From d8df825bdbda998332f8bfadf5e853cd28c191e2 Mon Sep 17 00:00:00 2001 From: Olga Kodolova Date: Mon, 8 Jun 2020 16:30:06 +0200 Subject: [PATCH 04/14] TrackJet seeds adding --- .../python/JetPlusTrackCorrectionsAA_cff.py | 45 +++++++++---------- .../python/JetPlusTrackCorrections_cff.py | 17 ++++++- .../python/JetPlusTrackCorrections_cfi.py | 5 ++- 3 files changed, 40 insertions(+), 27 deletions(-) diff --git a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrectionsAA_cff.py b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrectionsAA_cff.py index b5c4cbdb590db..0f541e6b1bf6d 100644 --- a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrectionsAA_cff.py +++ b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrectionsAA_cff.py @@ -162,52 +162,47 @@ JPTAntiKtPu5JetExtender.jet2TracksAtCALO = cms.InputTag("JPTAntiKtPu5JetTracksAssociatorAtCaloFace") JPTAntiKtPu5JetExtender.jet2TracksAtVX = cms.InputTag("JPTAntiKtPu5JetTracksAssociatorAtVertex") -### ---------- Task, Sequences +### ---------- Sequences # IC5 -JPTrecoJetAssociationsIconePu5Task = cms.Task( - trackExtrapolator, - JPTiterativeConePu5JetTracksAssociatorAtVertex, - JPTiterativeConePu5JetTracksAssociatorAtCaloFace, +JPTrecoJetAssociationsIconePu5 = cms.Sequence( + trackExtrapolator* +### JPTtrackExtrapolatorAA* + JPTiterativeConePu5JetTracksAssociatorAtVertex* + JPTiterativeConePu5JetTracksAssociatorAtCaloFace* JPTiterativeConePu5JetExtender ) -JPTrecoJetAssociationsIconePu5 = cms.Sequence(JPTrecoJetAssociationsIconePu5Task) -JetPlusTrackCorrectionsIconePu5Task = cms.Task( - JPTrecoJetAssociationsIconePu5, +JetPlusTrackCorrectionsIconePu5 = cms.Sequence( + JPTrecoJetAssociationsIconePu5* JetPlusTrackZSPCorJetIconePu5 ) -JetPlusTrackCorrectionsIconePu5 = cms.Sequence(JetPlusTrackCorrectionsIconePu5Task) # SC5 -JPTrecoJetAssociationsSisConePu5Task = cms.Task( - trackExtrapolator, - JPTSisConePu5JetTracksAssociatorAtVertex, - JPTSisConePu5JetTracksAssociatorAtCaloFace, +JPTrecoJetAssociationsSisConePu5 = cms.Sequence( + trackExtrapolator* + JPTSisConePu5JetTracksAssociatorAtVertex* + JPTSisConePu5JetTracksAssociatorAtCaloFace* JPTSisConePu5JetExtender ) -JPTrecoJetAssociationsSisConePu5 = cms.Sequence(JPTrecoJetAssociationsSisConePu5Task) -JetPlusTrackCorrectionsSisConePu5Task = cms.Task( - JPTrecoJetAssociationsSisConePu5, +JetPlusTrackCorrectionsSisConePu5 = cms.Sequence( + JPTrecoJetAssociationsSisConePu5* JetPlusTrackZSPCorJetSisconePu5 ) -JetPlusTrackCorrectionsSisConePu5 = cms.Sequence(JetPlusTrackCorrectionsSisConePu5Task) # Anti-Kt -JPTrecoJetAssociationsAntiKtPu5Task = cms.Task( - trackExtrapolator, - JPTAntiKtPu5JetTracksAssociatorAtVertex, - JPTAntiKtPu5JetTracksAssociatorAtCaloFace, +JPTrecoJetAssociationsAntiKtPu5 = cms.Sequence( + trackExtrapolator* + JPTAntiKtPu5JetTracksAssociatorAtVertex* + JPTAntiKtPu5JetTracksAssociatorAtCaloFace* JPTAntiKtPu5JetExtender ) -JPTrecoJetAssociationsAntiKtPu5 = cms.Sequence(JPTrecoJetAssociationsAntiKtPu5Task) -JetPlusTrackCorrectionsAntiKtPu5Task = cms.Task( - JPTrecoJetAssociationsAntiKtPu5, +JetPlusTrackCorrectionsAntiKtPu5 = cms.Sequence( + JPTrecoJetAssociationsAntiKtPu5* JetPlusTrackZSPCorJetAntiKtPu5 ) -JetPlusTrackCorrectionsAntiKtPu5 = cms.Sequence(JetPlusTrackCorrectionsAntiKtPu5Task) diff --git a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py index adeff742c8e63..a27ec66699b37 100644 --- a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py +++ b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py @@ -11,15 +11,29 @@ from RecoEgamma.ElectronIdentification.electronIdSequence_cff import eidTight JPTeidTight = eidTight.clone() +# ---------- Seeds from TrackJets + +JetPlusTrackAddonSeedReco = cms.EDProducer( + "JetPlusTrackAddonSeedProducer", + srcCaloJets = cms.InputTag("ak4CaloJets"), + srcTrackJets = cms.InputTag("ak4TrackJets"), + srcPVs = cms.InputTag('offlinePrimaryVertices'), + ptCUT = cms.double(15.), + PFCandidates = cms.InputTag('packedPFCandidates'), + towerMaker = cms.InputTag('towerMaker'), + UsePAT = cms.bool(False) +) # ---------- Module definition from RecoJets.JetPlusTracks.JetPlusTrackCorrections_cfi import * - JetPlusTrackZSPCorJetAntiKt4 = cms.EDProducer( "JetPlusTrackProducer", cms.PSet(JPTZSPCorrectorAntiKt4), src = cms.InputTag("ak4CaloJets"), + srcTrackJets = cms.InputTag("ak4TrackJets"), + srcAddCaloJets = cms.InputTag('JetPlusTrackAddonSeedReco:ak4CaloJetsJPTSeed'), + extrapolations = cms.InputTag("trackExtrapolator"), tagName = cms.vstring('ZSP_CMSSW390_Akt_05_PU0'), tagNameOffset = cms.vstring(), PU = cms.int32(-1), @@ -40,6 +54,7 @@ JetPlusTrackCorrectionsAntiKt4Task = cms.Task( JPTeidTight, + JetPlusTrackAddonSeedReco, ak4JetTracksAssociatorAtVertexJPT, ak4JetTracksAssociatorAtCaloFace, JetPlusTrackZSPCorJetAntiKt4 diff --git a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cfi.py b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cfi.py index d2e66bbef9ef0..2d11ce91c62ad 100644 --- a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cfi.py +++ b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cfi.py @@ -6,6 +6,7 @@ # General Configuration Verbose = cms.bool(True), + UseReco = cms.bool(True), # Vectorial corrections VectorialCorrection = cms.bool(True), @@ -30,14 +31,16 @@ # Muons UseMuons = cms.bool(True), Muons = cms.InputTag("muons"), + PatMuons = cms.InputTag("slimmedMuons"), # Electrons UseElectrons = cms.bool(True), Electrons = cms.InputTag("gedGsfElectrons"), ElectronIds = cms.InputTag("JPTeidTight"), + PatElectrons = cms.InputTag("slimmedElectrons"), # Filtering tracks using quality - UseTrackQuality = cms.bool(True), + UseTrackQuality = cms.bool(False), TrackQuality = cms.string('highPurity'), PtErrorQuality = cms.double(0.05), DzVertexCut = cms.double(0.2), From 620d7e7e2cceca28fda0885d4f71ae473f2a1534 Mon Sep 17 00:00:00 2001 From: Olga Kodolova Date: Mon, 8 Jun 2020 16:53:17 +0200 Subject: [PATCH 05/14] TrackJet seeding --- RecoJets/JetPlusTracks/plugins/BuildFile.xml | 58 +- .../plugins/JetPlusTrackAddonSeedProducer.cc | 11 +- .../plugins/JetPlusTrackProducerAA.cc | 644 +++++++++--------- .../plugins/JetPlusTrackProducerAA.h | 72 +- .../plugins/SimpleZSPJPTJetCorrector.cc | 133 ++-- .../plugins/SimpleZSPJPTJetCorrector.h | 30 +- .../plugins/ZSPJPTJetCorrector.cc | 82 ++- .../plugins/ZSPJPTJetCorrector.h | 26 +- 8 files changed, 555 insertions(+), 501 deletions(-) diff --git a/RecoJets/JetPlusTracks/plugins/BuildFile.xml b/RecoJets/JetPlusTracks/plugins/BuildFile.xml index 1c95307fa4c2e..d27b7f845e85d 100644 --- a/RecoJets/JetPlusTracks/plugins/BuildFile.xml +++ b/RecoJets/JetPlusTracks/plugins/BuildFile.xml @@ -1,16 +1,48 @@ - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc index 80024a3144fe7..42ef4329e35bb 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc @@ -169,8 +169,10 @@ JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::EventSetup } else { // std::cout<<" RECO "< ct; - bool getFromFwdPtr = iEvent.getByToken(input_ctw_token_, ct); - for(CaloTowerCollection::const_iterator it = ct->begin();it != ct->end(); it++) { + iEvent.getByToken(input_ctw_token_, ct); + if(ct.isValid()) { + for(CaloTowerCollection::const_iterator it = ct->begin(); + it != ct->end(); it++) { double deta=(*jet).eta()-(*it).eta(); double dphi=(*jet).phi()-(*it).phi(); if(dphi > 4.*atan(1.) ) dphi = dphi-8.*atan(1.); @@ -185,10 +187,9 @@ JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::EventSetup emineb += (*it).energy()-(*it).energyInHB(); eminee += (*it).energy()-(*it).energyInHE(); eminhf += 0.5*(*it).energyInHF(); - double eeen = 2.*(*it).energy()-(*it).energyInHB()-(*it).energyInHE(); - double hcen = (*it).energyInHB()+(*it).energyInHE()+(*it).energyInHO()+0.5*(*it).energyInHF(); ncand++; - } + } + } // tower collection is valid. } eefraction = (emineb+eminee)/caloen; hhfraction = (hadinhb+hadinhe+hadinhf+hadinho)/caloen; diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc index 50f1f5508fd8e..cdd8f6c03dde1 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc @@ -2,7 +2,7 @@ // // Package: JetPlusTrack // Class: JetPlusTrack -// +// /**\class JetPlusTrackProducer JetPlusTrackProducer.cc JetPlusTrackProducer.cc Description: [one line class summary] @@ -16,6 +16,7 @@ // // + // system include files #include @@ -67,6 +68,7 @@ using namespace jpt; // constants, enums and typedefs // + // // static data member definitions // @@ -74,127 +76,140 @@ using namespace jpt; // // constructors and destructor // -JetPlusTrackProducerAA::JetPlusTrackProducerAA(const edm::ParameterSet& iConfig) { - //register your products - src = iConfig.getParameter("src"); - alias = iConfig.getUntrackedParameter("alias"); - mTracks = iConfig.getParameter("tracks"); - srcPVs_ = iConfig.getParameter("srcPVs"); - vectorial_ = iConfig.getParameter("VectorialCorrection"); - useZSP = iConfig.getParameter("UseZSP"); - std::string tq = iConfig.getParameter("TrackQuality"); - trackQuality_ = reco::TrackBase::qualityByName(tq); - mConeSize = iConfig.getParameter("coneSize"); - //=> - mExtrapolations = iConfig.getParameter("extrapolations"); - //=> - mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector()); - if (useZSP) - mZSPalgo = new ZSPJPTJetCorrector(iConfig); - - produces().setBranchAlias(alias); - - input_jets_token_ = consumes >(src); - input_vertex_token_ = consumes(srcPVs_); - input_tracks_token_ = consumes(mTracks); - input_extrapolations_token_ = consumes >(mExtrapolations); +JetPlusTrackProducerAA::JetPlusTrackProducerAA(const edm::ParameterSet& iConfig) +{ + //register your products + src = iConfig.getParameter("src"); + alias = iConfig.getUntrackedParameter("alias"); + mTracks = iConfig.getParameter ("tracks"); + srcPVs_ = iConfig.getParameter("srcPVs"); + vectorial_ = iConfig.getParameter("VectorialCorrection"); + useZSP = iConfig.getParameter("UseZSP"); + std::string tq = iConfig.getParameter("TrackQuality"); + trackQuality_ = reco::TrackBase::qualityByName(tq); + mConeSize = iConfig.getParameter ("coneSize"); +//=> + mExtrapolations = iConfig.getParameter ("extrapolations"); +//=> + mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector()); + if(useZSP) mZSPalgo = new ZSPJPTJetCorrector(iConfig); + + produces().setBranchAlias(alias); + + input_jets_token_ = consumes >(src); + input_vertex_token_ = consumes(srcPVs_); + input_tracks_token_ = consumes(mTracks); + input_extrapolations_token_ = consumes >(mExtrapolations); } -JetPlusTrackProducerAA::~JetPlusTrackProducerAA() { - // do anything here that needs to be done at desctruction time - // (e.g. close files, deallocate resources etc.) + +JetPlusTrackProducerAA::~JetPlusTrackProducerAA() +{ + + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) + } + // // member functions // // ------------ method called to produce the data ------------ -void JetPlusTrackProducerAA::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { - using namespace edm; - - // std::cout<<" RecoJets::JetPlusTrackProducerAA::produce "< > jets_h; - iEvent.getByToken(input_jets_token_, jets_h); - - edm::Handle tracks_h; - iEvent.getByToken(input_tracks_token_, tracks_h); - - std::vector fTracks; - fTracks.reserve(tracks_h->size()); +void +JetPlusTrackProducerAA::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + using namespace edm; + + +// std::cout<<" RecoJets::JetPlusTrackProducerAA::produce "< > jets_h; + iEvent.getByToken (input_jets_token_, jets_h); + + edm::Handle tracks_h; + iEvent.getByToken (input_tracks_token_, tracks_h); + + std::vector fTracks; + fTracks.reserve (tracks_h->size()); for (unsigned i = 0; i < tracks_h->size(); ++i) { - fTracks.push_back(reco::TrackRef(tracks_h, i)); - } + fTracks.push_back (reco::TrackRef (tracks_h, i)); + } - //=> - edm::Handle > extrapolations_h; +//=> + edm::Handle > extrapolations_h; iEvent.getByToken(input_extrapolations_token_, extrapolations_h); - // std::cout<<"JetPlusTrackProducerAA::produce, extrapolations_h="<size()< +// std::cout<<"JetPlusTrackProducerAA::produce, extrapolations_h="<size()< auto pOut = std::make_unique(); - + reco::JPTJetCollection tmpColl; for (unsigned i = 0; i < jets_h->size(); ++i) { - const reco::CaloJet* oldjet = &(*(jets_h->refAt(i))); - - reco::CaloJet corrected = *oldjet; - // ZSP corrections - - double factorZSP = 1.; - if (useZSP) - factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup); - - // std::cout << " UseZSP = "<correction(corrected, *oldjet, iEvent, iSetup, pions, muons, elecs, ok); - p4 = math::XYZTLorentzVector(corrected.px() * scaleJPT, - corrected.py() * scaleJPT, - corrected.pz() * scaleJPT, - corrected.energy() * scaleJPT); - } else { - scaleJPT = mJPTalgo->correction(corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs, ok); - } - - reco::JPTJet::Specific specific; - - if (ok) { - // std::cout<<" Size of Pion in-in "<et()<<" factorZSP "<refAt(i))); + + reco::CaloJet corrected = *oldjet; + +// ZSP corrections + + double factorZSP = 1.; + if(useZSP) factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup); + +// std::cout << " UseZSP = "<correction ( corrected, *oldjet, iEvent, iSetup, pions, muons, elecs, ok ); + p4 = math::XYZTLorentzVector( corrected.px()*scaleJPT, + corrected.py()*scaleJPT, + corrected.pz()*scaleJPT, + corrected.energy()*scaleJPT ); + } else { + scaleJPT = mJPTalgo->correction( corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs, ok ); + } + + + + reco::JPTJet::Specific specific; + + if(ok) { +// std::cout<<" Size of Pion in-in "<et()<<" factorZSP "< myjet = (edm::RefToBase)jets_h->refAt(i); specific.theCaloJetRef = myjet; specific.mZSPCor = factorZSP; @@ -205,269 +220,272 @@ void JetPlusTrackProducerAA::produce(edm::Event& iEvent, const edm::EventSetup& specific.mSumEnergyOfChargedWithEff = (float)mJPTalgo->getSumEnergyWithEff(); specific.mSumEnergyOfChargedWithoutEff = (float)mJPTalgo->getSumEnergyWithoutEff(); specific.mChargedHadronEnergy = (float)mJPTalgo->getSumEnergyWithoutEff(); - // Fill Charged Jet shape parameters - double deR2Tr = 0.; - double deEta2Tr = 0.; - double dePhi2Tr = 0.; - double Zch = 0.; - double Pout2 = 0.; - double Pout = 0.; - double denominator_tracks = 0.; - int ntracks = 0; - - for (reco::TrackRefVector::const_iterator it = pions.inVertexInCalo_.begin(); it != pions.inVertexInCalo_.end(); - it++) { - double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); - double deEta = (*it)->eta() - p4.eta(); - double dePhi = deltaPhi((*it)->phi(), p4.phi()); - if ((**it).ptError() / (**it).pt() < 0.1) { - deR2Tr = deR2Tr + deR * deR * (*it)->pt(); - deEta2Tr = deEta2Tr + deEta * deEta * (*it)->pt(); - dePhi2Tr = dePhi2Tr + dePhi * dePhi * (*it)->pt(); - denominator_tracks = denominator_tracks + (*it)->pt(); - Zch = Zch + (*it)->pt(); - - Pout2 = Pout2 + (**it).p() * (**it).p() - (Zch * p4.P()) * (Zch * p4.P()); - ntracks++; - } - } - for (reco::TrackRefVector::const_iterator it = muons.inVertexInCalo_.begin(); it != muons.inVertexInCalo_.end(); - it++) { - double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); - double deEta = (*it)->eta() - p4.eta(); - double dePhi = deltaPhi((*it)->phi(), p4.phi()); - if ((**it).ptError() / (**it).pt() < 0.1) { - deR2Tr = deR2Tr + deR * deR * (*it)->pt(); - deEta2Tr = deEta2Tr + deEta * deEta * (*it)->pt(); - dePhi2Tr = dePhi2Tr + dePhi * dePhi * (*it)->pt(); - denominator_tracks = denominator_tracks + (*it)->pt(); - Zch = Zch + (*it)->pt(); - - Pout2 = Pout2 + (**it).p() * (**it).p() - (Zch * p4.P()) * (Zch * p4.P()); - ntracks++; - } - } - for (reco::TrackRefVector::const_iterator it = elecs.inVertexInCalo_.begin(); it != elecs.inVertexInCalo_.end(); - it++) { - double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); - double deEta = (*it)->eta() - p4.eta(); - double dePhi = deltaPhi((*it)->phi(), p4.phi()); - if ((**it).ptError() / (**it).pt() < 0.1) { - deR2Tr = deR2Tr + deR * deR * (*it)->pt(); - deEta2Tr = deEta2Tr + deEta * deEta * (*it)->pt(); - dePhi2Tr = dePhi2Tr + dePhi * dePhi * (*it)->pt(); - denominator_tracks = denominator_tracks + (*it)->pt(); - Zch = Zch + (*it)->pt(); - - Pout2 = Pout2 + (**it).p() * (**it).p() - (Zch * p4.P()) * (Zch * p4.P()); - ntracks++; - } - } - for (reco::TrackRefVector::const_iterator it = pions.inVertexOutOfCalo_.begin(); - it != pions.inVertexOutOfCalo_.end(); - it++) { - Zch = Zch + (*it)->pt(); - } - for (reco::TrackRefVector::const_iterator it = muons.inVertexOutOfCalo_.begin(); - it != muons.inVertexOutOfCalo_.end(); - it++) { - Zch = Zch + (*it)->pt(); - } - for (reco::TrackRefVector::const_iterator it = elecs.inVertexOutOfCalo_.begin(); - it != elecs.inVertexOutOfCalo_.end(); - it++) { - Zch = Zch + (*it)->pt(); - } - - if (mJPTalgo->getSumPtForBeta() > 0.) - Zch = Zch / mJPTalgo->getSumPtForBeta(); - - // std::cout<<" Zch "<< Zch<<" "<getSumPtForBeta()< 0) { - Pout = sqrt(fabs(Pout2)) / ntracks; - } - - if (denominator_tracks != 0) { - deR2Tr = deR2Tr / denominator_tracks; - deEta2Tr = deEta2Tr / denominator_tracks; - dePhi2Tr = dePhi2Tr / denominator_tracks; - } +// Fill Charged Jet shape parameters + double deR2Tr = 0.; + double deEta2Tr = 0.; + double dePhi2Tr = 0.; + double Zch = 0.; + double Pout2 = 0.; + double Pout = 0.; + double denominator_tracks = 0.; + int ntracks = 0; + + for( reco::TrackRefVector::const_iterator it = pions.inVertexInCalo_.begin(); it != pions.inVertexInCalo_.end(); it++) { + double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); + double deEta = (*it)->eta() - p4.eta(); + double dePhi = deltaPhi((*it)->phi(), p4.phi()); + if((**it).ptError()/(**it).pt() < 0.1) { + deR2Tr = deR2Tr + deR*deR*(*it)->pt(); + deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); + dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); + denominator_tracks = denominator_tracks + (*it)->pt(); + Zch = Zch + (*it)->pt(); + + Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); + ntracks++; + } + } + for( reco::TrackRefVector::const_iterator it = muons.inVertexInCalo_.begin(); it != muons.inVertexInCalo_.end(); it++) { + double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); + double deEta = (*it)->eta() - p4.eta(); + double dePhi = deltaPhi((*it)->phi(), p4.phi()); + if((**it).ptError()/(**it).pt() < 0.1) { + deR2Tr = deR2Tr + deR*deR*(*it)->pt(); + deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); + dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); + denominator_tracks = denominator_tracks + (*it)->pt(); + Zch = Zch + (*it)->pt(); + + Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); + ntracks++; + } + } + for( reco::TrackRefVector::const_iterator it = elecs.inVertexInCalo_.begin(); it != elecs.inVertexInCalo_.end(); it++) { + double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); + double deEta = (*it)->eta() - p4.eta(); + double dePhi = deltaPhi((*it)->phi(), p4.phi()); + if((**it).ptError()/(**it).pt() < 0.1) { + deR2Tr = deR2Tr + deR*deR*(*it)->pt(); + deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); + dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); + denominator_tracks = denominator_tracks + (*it)->pt(); + Zch = Zch + (*it)->pt(); + + Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); + ntracks++; + } + } + for( reco::TrackRefVector::const_iterator it = pions.inVertexOutOfCalo_.begin(); it != pions.inVertexOutOfCalo_.end(); it++) { + Zch = Zch + (*it)->pt(); + } + for( reco::TrackRefVector::const_iterator it = muons.inVertexOutOfCalo_.begin(); it != muons.inVertexOutOfCalo_.end(); it++) { + Zch = Zch + (*it)->pt(); + } + for( reco::TrackRefVector::const_iterator it = elecs.inVertexOutOfCalo_.begin(); it != elecs.inVertexOutOfCalo_.end(); it++) { + Zch = Zch + (*it)->pt(); + } + + if(mJPTalgo->getSumPtForBeta()> 0.) Zch = Zch/mJPTalgo->getSumPtForBeta(); + + // std::cout<<" Zch "<< Zch<<" "<getSumPtForBeta()< 0) { + Pout = sqrt(fabs(Pout2))/ntracks; + } - specific.R2momtr = deR2Tr; - specific.Eta2momtr = deEta2Tr; - specific.Phi2momtr = dePhi2Tr; - specific.Pout = Pout; - specific.Zch = Zch; - // Create JPT jet + if (denominator_tracks!=0){ + deR2Tr = deR2Tr/denominator_tracks; + deEta2Tr= deEta2Tr/denominator_tracks; + dePhi2Tr= dePhi2Tr/denominator_tracks; + } - reco::Particle::Point vertex_ = reco::Jet::Point(0, 0, 0); + specific.R2momtr = deR2Tr; + specific.Eta2momtr = deEta2Tr; + specific.Phi2momtr = dePhi2Tr; + specific.Pout = Pout; + specific.Zch = Zch; - // If we add primary vertex - edm::Handle pvCollection; - iEvent.getByToken(input_vertex_token_, pvCollection); - if (pvCollection.isValid() && !pvCollection->empty()) - vertex_ = pvCollection->begin()->position(); +// Create JPT jet - reco::JPTJet fJet(p4, vertex_, specific, corrected.getJetConstituents()); - // fJet.printJet(); + reco::Particle::Point vertex_=reco::Jet::Point(0,0,0); + +// If we add primary vertex + edm::Handle pvCollection; + iEvent.getByToken(input_vertex_token_, pvCollection); + if ( pvCollection.isValid() && !pvCollection->empty() ) vertex_=pvCollection->begin()->position(); + + reco::JPTJet fJet(p4, vertex_, specific, corrected.getJetConstituents()); + // fJet.printJet(); - // Temporarily collection before correction for background +// Temporarily collection before correction for background + + tmpColl.push_back(fJet); - tmpColl.push_back(fJet); } - //=======================================================================================================> - // Correction for background +//=======================================================================================================> +// Correction for background reco::TrackRefVector trBgOutOfCalo; - reco::TrackRefVector trBgOutOfVertex = calculateBGtracksJet(tmpColl, fTracks, extrapolations_h, trBgOutOfCalo); - - //===> Area without Jets - std::map AreaNonJet; - - for (reco::JPTJetCollection::iterator ij1 = tmpColl.begin(); ij1 != tmpColl.end(); ij1++) { - int nj1 = 1; - for (reco::JPTJetCollection::iterator ij2 = tmpColl.begin(); ij2 != tmpColl.end(); ij2++) { - if (ij2 == ij1) - continue; - if (fabs((*ij1).eta() - (*ij2).eta()) > 0.5) - continue; - nj1++; - } - - AreaNonJet[ij1] = 4 * M_PI * mConeSize - nj1 * 4 * mConeSize * mConeSize; - - // std::cout<<"+++AreaNonJet[ij1]="<second; + reco::TrackRefVector trBgOutOfVertex = calculateBGtracksJet(tmpColl,fTracks,extrapolations_h,trBgOutOfCalo); + +//===> Area without Jets + std::map AreaNonJet; + + for(reco::JPTJetCollection::iterator ij1=tmpColl.begin(); ij1!=tmpColl.end(); ij1++) + { + int nj1 = 1; + for(reco::JPTJetCollection::iterator ij2=tmpColl.begin(); ij2!=tmpColl.end(); ij2++) + { + if(ij2 == ij1) continue; + if(fabs((*ij1).eta() - (*ij2).eta()) > 0.5 ) continue; + nj1++; - // std::cout<<"+++ ja="< - // Output module +// std::cout<<" The size of BG tracks: trBgOutOfVertex= "<second; + +// std::cout<<"+++ ja="<push_back(*ij); - - // std::cout<<" New JPT energy "<<(*ij).et()<<" "<<(*ij).pt()<<" "<<(*ij).eta()<<" "<<(*ij).phi()<& fTracks, - edm::Handle >& extrapolations_h, - reco::TrackRefVector& trBgOutOfCalo) { - reco::TrackRefVector trBgOutOfVertex; +reco::TrackRefVector JetPlusTrackProducerAA::calculateBGtracksJet(reco::JPTJetCollection& fJets, std::vector & fTracks, + edm::Handle > & extrapolations_h, + reco::TrackRefVector& trBgOutOfCalo){ + + reco::TrackRefVector trBgOutOfVertex; + for (unsigned t = 0; t < fTracks.size(); ++t) { - int track_bg = 0; + int track_bg = 0; + // if(!(*fTracks[t]).quality(trackQuality_)) // { - // cout<<"BG, BAD trackQuality, ptBgV="<pt()<<" etaBgV = "<eta()<<" phiBgV = "<phi()< track="< track="<>>> Track inside jet at vertex, track_bg="<< track_bg <<" track="<>>> Track inside jet at vertex, track_bg="<< track_bg <<" track="<isValid().at(0)<isValid().at(0)<isValid().at(0) == 0 ) continue; - //in DF change in 4.2, all entries are valid. - nValid++; + //if( ixtrp->isValid().at(0) == 0 ) continue; + //in DF change in 4.2, all entries are valid. + nValid++; - reco::TrackRefVector::iterator it = find(trBgOutOfVertex.begin(), trBgOutOfVertex.end(), (*ixtrp).track()); + reco::TrackRefVector::iterator it = find(trBgOutOfVertex.begin(),trBgOutOfVertex.end(),(*ixtrp).track() ); - if (it != trBgOutOfVertex.end()) { - trBgOutOfCalo.push_back(*it); + if ( it != trBgOutOfVertex.end() ){ + trBgOutOfCalo.push_back (*it); + +// std::cout<<"+++trBgOutOfCalo, pt= "<track()->pt()<<" eta= "<track()->eta()<<" phi="<track()->phi() +// <<" Valid? "<isValid().at(0)<isValid().at(0)<definitions()).formula()).c_str()<definitions()).formula()).c_str()); + mFunc = new TFormula("function",((mParameters->definitions()).formula()).c_str()); - // Read parameters - if (debug_) { - std::cout << " Size of parameters as read by SimpleJetCorrectorParameters " << mParameters->size() << std::endl; - for (unsigned int i = 0; i < mParameters->size(); i++) { - const std::vector p = mParameters->record(i).parameters(); - for (std::vector::const_iterator j = p.begin(); j < p.end(); j++) { - std::cout << " Parameter number " << mParameters->record(i).xMin(0) << " " << mParameters->record(i).xMax(0) - << " " << (*j) << std::endl; - } - } - } // debug +// Read parameters + if (debug_) { + std::cout<<" Size of parameters as read by SimpleJetCorrectorParameters "<size()<size(); i++){ + const std::vector p = mParameters->record (i).parameters (); + for(std::vector::const_iterator j=p.begin(); jrecord (i).xMin(0)<<" "<record (i).xMax(0)<<" "<<(*j)< xx; - xx.push_back(eta); +// Define Eta bin for parametrization + std::vector xx; xx.push_back(eta); int band = mParameters->binIndex(xx); - if (band < 0) - return factor; + if(band < 0) return factor; - const std::vector p = mParameters->record(band).parameters(); + const std::vector p = mParameters->record (band).parameters (); - // Set parameters - for (unsigned int i = 0; i < p.size(); i++) { - mFunc->SetParameter(i, p[i]); + // Set parameters + for(unsigned int i=0; iSetParameter(i,p[i]); } if (debug_) { - cout << " Et and eta of jet " << et << " " << eta << " bin " << band << " " << p[1] << " " << p[2] << " " << p[3] - << " " << p[4] << " " << p[5] << endl; - } - - // double koef = 1. - p[2]*exp(p[3]*et)-p[4]*exp(p[5]*et); + cout<<" Et and eta of jet "<Eval(et); - // If et calojet less then some value - use correction on the boundary - - if (et < p[0]) - koef = 1. - mFunc->Eval(p[0]); +// If et calojet less then some value - use correction on the boundary + + if( et < p[0] ) koef = 1. - mFunc->Eval(p[0]); - // - if (koef <= 0.000001) { - if (debug_) - std::cout << "SimpleZSPJPTJetCorrector::Problem with ZSP corrections " << koef << std::endl; - koef = 1.; +// + if(koef <= 0.000001) + { + if (debug_) std::cout<<"SimpleZSPJPTJetCorrector::Problem with ZSP corrections "< xx; - xx.push_back(eta); +// Define Eta bin for parametrization + std::vector xx; xx.push_back(eta); int band = mParameters->binIndex(xx); - if (band < 0) - return factor; + if(band < 0) return factor; - const std::vector p = mParameters->record(band).parameters(); + const std::vector p = mParameters->record (band).parameters (); if (debug_) { - cout << " Et and eta of jet " << et << " " << eta << " bin " << band << std::endl; + cout<<" Et and eta of jet "<("PU"); - fixedPU = fConfig.getParameter("FixedPU"); - if (iPU >= 0 || fixedPU > 0) { - theFilesL1Offset = fConfig.getParameter >("tagNameOffset"); - for (vector::iterator it = theFilesL1Offset.begin(); it != theFilesL1Offset.end(); it++) { - std::string file = "CondFormats/JetMETObjects/data/" + (*it) + ".txt"; - edm::FileInPath f2(file); - mSimpleCorrectorOffset.push_back(new SimpleZSPJPTJetCorrector(f2.fullPath())); - } - } +ZSPJPTJetCorrector::ZSPJPTJetCorrector (const edm::ParameterSet& fConfig) { - theFilesZSP = fConfig.getParameter >("tagName"); - for (vector::iterator it = theFilesZSP.begin(); it != theFilesZSP.end(); it++) { - std::string file = "CondFormats/JetMETObjects/data/" + (*it) + ".txt"; - edm::FileInPath f1(file); - mSimpleCorrector.push_back(new SimpleZSPJPTJetCorrector(f1.fullPath())); - } - // cout<<" Size of correctors "<("PU"); + fixedPU = fConfig.getParameter("FixedPU"); + + if( iPU >= 0 || fixedPU > 0 ) { + theFilesL1Offset = fConfig.getParameter > ("tagNameOffset"); + for(vector::iterator it=theFilesL1Offset.begin(); it != theFilesL1Offset.end(); it++) { + std::string file="CondFormats/JetMETObjects/data/"+(*it)+".txt"; + edm::FileInPath f2(file); + mSimpleCorrectorOffset.push_back(new SimpleZSPJPTJetCorrector (f2.fullPath())); + } + } + + theFilesZSP = fConfig.getParameter > ("tagName"); + for(vector::iterator it=theFilesZSP.begin(); it != theFilesZSP.end(); it++) { + std::string file="CondFormats/JetMETObjects/data/"+(*it)+".txt"; + edm::FileInPath f1(file); + mSimpleCorrector.push_back(new SimpleZSPJPTJetCorrector (f1.fullPath())); + } +// cout<<" Size of correctors "< 0) { - // Look for the Lumi section - // LuminosityBlock lbID = iEvent.getLuminosityBlock(); - // cout<<" Not implemented yet "< 0) { +// Look for the Lumi section +// LuminosityBlock lbID = iEvent.getLuminosityBlock(); +// cout<<" Not implemented yet "<correctionPtEtaPhiE(fJet.p4().Pt(), fJet.p4().Eta(), fJet.p4().Phi(), fJet.p4().E()); + double a = mSimpleCorrector[nPU]->correctionPtEtaPhiE (fJet.p4().Pt(), fJet.p4().Eta(), fJet.p4().Phi(),fJet.p4().E()); - if (iPU >= 0) { - if (!mSimpleCorrectorOffset.empty()) { - b = mSimpleCorrectorOffset[nPU]->correctionPUEtEtaPhiP( - fJet.p4().Pt(), fJet.p4().Eta(), fJet.p4().Phi(), fJet.p4().E()); - } + if(iPU >= 0) { + if(!mSimpleCorrectorOffset.empty()) { + b = mSimpleCorrectorOffset[nPU]->correctionPUEtEtaPhiP (fJet.p4().Pt(), fJet.p4().Eta(), fJet.p4().Phi(),fJet.p4().E()); + } } - double c = a * b; - return c; + double c = a * b; + return c; } + diff --git a/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.h b/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.h index 988137462b3d7..eb0344ab49970 100644 --- a/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.h +++ b/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.h @@ -19,21 +19,21 @@ namespace edm { class SimpleZSPJPTJetCorrector; class ZSPJPTJetCorrector { -public: - ZSPJPTJetCorrector(const edm::ParameterSet& fParameters); - virtual ~ZSPJPTJetCorrector(); - /// apply correction using Event information - virtual double correction(const reco::Jet&, const edm::Event&, const edm::EventSetup&) const; + public: + ZSPJPTJetCorrector (const edm::ParameterSet& fParameters); + virtual ~ZSPJPTJetCorrector (); + /// apply correction using Event information + virtual double correction( const reco::Jet&, const edm::Event&, const edm::EventSetup& ) const; /// Set the number of pileups - virtual int setPU() const { return fixedPU; } + virtual int setPU() const {return fixedPU;} -private: - std::vector mSimpleCorrector; - std::vector mSimpleCorrectorOffset; - std::vector theFilesL1Offset; - std::vector theFilesZSP; - int iPU; - int fixedPU; + private: + std::vector mSimpleCorrector; + std::vector mSimpleCorrectorOffset; + std::vector theFilesL1Offset; + std::vector theFilesZSP; + int iPU; + int fixedPU; }; #endif From 1caafe3479f3865999e65061ec978e185786bdae Mon Sep 17 00:00:00 2001 From: Olga Kodolova Date: Tue, 9 Jun 2020 16:59:26 +0200 Subject: [PATCH 06/14] Cleaned Buildfile.xml from duplication --- RecoJets/JetPlusTracks/plugins/BuildFile.xml | 1 - 1 file changed, 1 deletion(-) diff --git a/RecoJets/JetPlusTracks/plugins/BuildFile.xml b/RecoJets/JetPlusTracks/plugins/BuildFile.xml index d27b7f845e85d..fa0d10b57dbf2 100644 --- a/RecoJets/JetPlusTracks/plugins/BuildFile.xml +++ b/RecoJets/JetPlusTracks/plugins/BuildFile.xml @@ -7,7 +7,6 @@ - From 3ebe83332746ad04424590e0ae04d2407bbfd0d9 Mon Sep 17 00:00:00 2001 From: Olga Kodolova Date: Wed, 10 Jun 2020 15:32:15 +0200 Subject: [PATCH 07/14] Make cleaning, i.e. change comaprison of collection size with 0 to empty() clean Buildfile.xml --- RecoJets/JetPlusTracks/plugins/BuildFile.xml | 22 ------------------- .../plugins/JetPlusTrackAddonSeedProducer.cc | 10 ++++----- .../plugins/JetPlusTrackAddonSeedProducer.h | 1 + .../plugins/JetPlusTrackCorrector.cc | 6 +++-- .../plugins/JetPlusTrackProducer.cc | 2 +- .../plugins/TrackFromPFProducer.cc | 2 +- .../python/JetPlusTrackCorrections_cff.py | 1 + 7 files changed, 13 insertions(+), 31 deletions(-) diff --git a/RecoJets/JetPlusTracks/plugins/BuildFile.xml b/RecoJets/JetPlusTracks/plugins/BuildFile.xml index fa0d10b57dbf2..05f892cd2eff8 100644 --- a/RecoJets/JetPlusTracks/plugins/BuildFile.xml +++ b/RecoJets/JetPlusTracks/plugins/BuildFile.xml @@ -13,35 +13,13 @@ - - - - - - - - - - - - - - - - - - - - - - diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc index 42ef4329e35bb..ace21d955746b 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc @@ -64,6 +64,7 @@ JetPlusTrackAddonSeedProducer::JetPlusTrackAddonSeedProducer(const edm::Paramete srcTrackJets = iConfig.getParameter("srcTrackJets"); srcPVs_ = iConfig.getParameter("srcPVs"); ptCUT = iConfig.getParameter("ptCUT"); + dRcone = iConfig.getParameter("dRcone"); usePAT = iConfig.getParameter("UsePAT"); produces("ak4CaloJetsJPTSeed"); @@ -109,7 +110,7 @@ JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::EventSetup auto pCaloOut = std::make_unique(); if (jetsTrackJets.isValid()) { - if(jetsTrackJets->size() > 0 ) { + if(!jetsTrackJets->empty() ) { // std::cout<<" AddonSeed::The size of trackjets "<size()<<" "<size()<size(); ++ijet) { const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet))); @@ -120,7 +121,7 @@ JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::EventSetup double dphi = fabs(jet->phi()-oldjet->phi()); if(dphi>4.*atan(1.)) dphi = 8.*atan(1.) - dphi; double dr = sqrt(dphi*dphi+deta*deta); - if(dr<0.4) iflag = 1; + if(dr ct; iEvent.getByToken(input_ctw_token_, ct); if(ct.isValid()) { - for(CaloTowerCollection::const_iterator it = ct->begin(); - it != ct->end(); it++) { + for(CaloTowerCollection::const_iterator it = ct->begin();it != ct->end(); it++) { double deta=(*jet).eta()-(*it).eta(); double dphi=(*jet).phi()-(*it).phi(); if(dphi > 4.*atan(1.) ) dphi = dphi-8.*atan(1.); @@ -189,7 +189,7 @@ JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::EventSetup eminhf += 0.5*(*it).energyInHF(); ncand++; } - } // tower collection is valid. + } } eefraction = (emineb+eminee)/caloen; hhfraction = (hadinhb+hadinhe+hadinhf+hadinho)/caloen; diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.h b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.h index 89372484cc6ba..0e668b0d4b433 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.h +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.h @@ -59,6 +59,7 @@ class JetPlusTrackAddonSeedProducer : public edm::stream::EDProducer<> { std::string alias; double ptCUT; + double dRcone; bool usePAT; edm::EDGetTokenT > input_jets_token_; edm::EDGetTokenT > input_trackjets_token_; diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc index e047764c2abbc..19a20824068be 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc @@ -426,10 +426,12 @@ bool JetPlusTrackCorrector::jtaUsingEventData( const reco::Jet& fJet, else { rebuildJta( fJet, jtV, trks.vertex_, excluded ); rebuildJta( fJet, jtV, relocate, excluded ); trks.vertex_ = relocate;} // std::cout<<" JetPlusTrackCorrector::trks.vertex_.empty() "< jetTracksAtCalo; diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc index 8c14058af5a09..e5ea873c932c1 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc @@ -134,7 +134,7 @@ JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) double scaleJPT = 1.; std::vector theJPTJets; if (jetsTrackJets.isValid()) { - if(jetsTrackJets->size() > 0 ) { + if(!jetsTrackJets->empty()) { for (unsigned ijet = 0; ijet < jetsTrackJets->size(); ++ijet) { const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet))); int icalo = -1; diff --git a/RecoJets/JetPlusTracks/plugins/TrackFromPFProducer.cc b/RecoJets/JetPlusTracks/plugins/TrackFromPFProducer.cc index 24954ce361c26..39da90bf5ce2e 100644 --- a/RecoJets/JetPlusTracks/plugins/TrackFromPFProducer.cc +++ b/RecoJets/JetPlusTracks/plugins/TrackFromPFProducer.cc @@ -38,7 +38,7 @@ void TrackFromPFProducer::produce(edm::Event& theEvent, const edm::EventSetup& s for(unsigned int i = 0, n = pfCandidates->size(); i < n; ++i) { const pat::PackedCandidate &pf = (*pfCandidates)[i]; if(pf.hasTrackDetails()){ - reco::Track mytrack = pf.pseudoTrack(); + const reco::Track &mytrack = pf.pseudoTrack(); // std::cout<<" Track "< Date: Wed, 10 Jun 2020 16:06:58 +0200 Subject: [PATCH 08/14] Applied patch https://cmssdt.cern.ch/SDT/code-checks/cms-sw-PR-30160/15988/code-format.patch e.g. curl https://cmssdt.cern.ch/SDT/code-checks/cms-sw-PR-30160/15988/code-format.patch | patch -p1 You can also run scram build code-format Provide some additional clean-up: introduce variable dRcone instead of 0.4 --- .../plugins/JetPlusTrackAddonSeedProducer.cc | 316 +-- .../plugins/JetPlusTrackAddonSeedProducer.h | 41 +- .../plugins/JetPlusTrackCorrector.cc | 2432 +++++++++-------- .../plugins/JetPlusTrackCorrector.h | 516 ++-- .../plugins/JetPlusTrackProducer.cc | 578 ++-- .../plugins/JetPlusTrackProducer.cc.orig | 393 +++ .../plugins/JetPlusTrackProducer.cc.rej | 389 +++ .../plugins/JetPlusTrackProducer.h | 46 +- .../plugins/JetPlusTrackProducer.h.orig | 70 + .../plugins/JetPlusTrackProducer.h.rej | 51 + .../plugins/JetPlusTrackProducerAA.cc | 644 +++-- .../plugins/JetPlusTrackProducerAA.h | 72 +- .../plugins/SimpleZSPJPTJetCorrector.cc | 133 +- .../plugins/SimpleZSPJPTJetCorrector.h | 30 +- .../plugins/TrackFromPFProducer.cc | 63 +- .../plugins/TrackFromPFProducer.h | 6 +- .../plugins/ZSPJPTJetCorrector.cc | 82 +- .../plugins/ZSPJPTJetCorrector.h | 26 +- 18 files changed, 3366 insertions(+), 2522 deletions(-) create mode 100644 RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc.orig create mode 100644 RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc.rej create mode 100644 RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.orig create mode 100644 RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.rej diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc index ace21d955746b..b1a4af1b48678 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc @@ -2,7 +2,7 @@ // // Package: JetPlusTracks // Class: JetPlusTrackProducer -// +// /**\class JetPlusTrackProducer JetPlusTrackProducer.cc JetPlusTrackProducer.cc Description: [one line class summary] @@ -16,7 +16,6 @@ // // - // system include files #include @@ -49,7 +48,6 @@ using namespace std; // constants, enums and typedefs // - // // static data member definitions // @@ -57,178 +55,182 @@ using namespace std; // // constructors and destructor // -JetPlusTrackAddonSeedProducer::JetPlusTrackAddonSeedProducer(const edm::ParameterSet& iConfig) -{ - //register your products - srcCaloJets = iConfig.getParameter("srcCaloJets"); - srcTrackJets = iConfig.getParameter("srcTrackJets"); - srcPVs_ = iConfig.getParameter("srcPVs"); - ptCUT = iConfig.getParameter("ptCUT"); - dRcone = iConfig.getParameter("dRcone"); - usePAT = iConfig.getParameter("UsePAT"); - - produces("ak4CaloJetsJPTSeed"); - - input_jets_token_ = consumes >(srcCaloJets); - input_trackjets_token_ = consumes >(srcTrackJets); - input_vertex_token_ = consumes(srcPVs_); - tokenPFCandidates_ = consumes(iConfig.getParameter("PFCandidates")); - input_ctw_token_ = consumes(iConfig.getParameter("towerMaker")); +JetPlusTrackAddonSeedProducer::JetPlusTrackAddonSeedProducer(const edm::ParameterSet& iConfig) { + //register your products + srcCaloJets = iConfig.getParameter("srcCaloJets"); + srcTrackJets = iConfig.getParameter("srcTrackJets"); + srcPVs_ = iConfig.getParameter("srcPVs"); + ptCUT = iConfig.getParameter("ptCUT"); + dRcone = iConfig.getParameter("dRcone"); + usePAT = iConfig.getParameter("UsePAT"); + + produces("ak4CaloJetsJPTSeed"); + + input_jets_token_ = consumes >(srcCaloJets); + input_trackjets_token_ = consumes >(srcTrackJets); + input_vertex_token_ = consumes(srcPVs_); + tokenPFCandidates_ = consumes(iConfig.getParameter("PFCandidates")); + input_ctw_token_ = consumes(iConfig.getParameter("towerMaker")); } - -JetPlusTrackAddonSeedProducer::~JetPlusTrackAddonSeedProducer() -{ - - // do anything here that needs to be done at desctruction time - // (e.g. close files, deallocate resources etc.) - +JetPlusTrackAddonSeedProducer::~JetPlusTrackAddonSeedProducer() { + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) } - // // member functions // // ------------ method called to produce the data ------------ -void -JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) -{ - using namespace edm; - - - // std::cout<<" RecoJets::JetPlusTrackAddonSeedProducer::produce "< > jets_h; - iEvent.getByToken (input_jets_token_, jets_h); + // get stuff from Event + edm::Handle > jets_h; + iEvent.getByToken(input_jets_token_, jets_h); - edm::Handle > jetsTrackJets; + edm::Handle > jetsTrackJets; iEvent.getByToken(input_trackjets_token_, jetsTrackJets); auto pCaloOut = std::make_unique(); - if (jetsTrackJets.isValid()) { - if(!jetsTrackJets->empty() ) { - // std::cout<<" AddonSeed::The size of trackjets "<size()<<" "<size()<empty()) { + // std::cout<<" AddonSeed::The size of trackjets "<size()<<" "<size()<size(); ++ijet) { - const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet))); - int iflag = 0; - for (unsigned i = 0; i < jets_h->size(); ++i) { + const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet))); + int iflag = 0; + for (unsigned i = 0; i < jets_h->size(); ++i) { const reco::CaloJet* oldjet = &(*(jets_h->refAt(i))); - double deta = fabs(jet->eta()-oldjet->eta()); - double dphi = fabs(jet->phi()-oldjet->phi()); - if(dphi>4.*atan(1.)) dphi = 8.*atan(1.) - dphi; - double dr = sqrt(dphi*dphi+deta*deta); - if(drpt()<<" "<eta()<< - // " "<phi()< pfCandidates; - iEvent.getByToken( tokenPFCandidates_, pfCandidates); - if(!pfCandidates.isValid()) { - // std::cout<<" No PFCandidate collection "<size(); i < n; ++i) { - const pat::PackedCandidate &pf = (*pfCandidates)[i]; - double deta=(*jet).eta()-pf.eta(); - double dphi=(*jet).phi()-pf.phi(); - - if(dphi > 4.*atan(1.) ) dphi = dphi-8.*atan(1.); - if(dphi < -1.*4.*atan(1.) ) dphi = dphi+8.*atan(1.); - double dr = sqrt(dphi*dphi+deta*deta); - if(dr>0.4) continue; - // jetconstit - caloen = caloen + pf.energy()*pf.caloFraction(); - hadinho += 0.; - if(fabs(pf.eta())<=1.4) hadinhb += pf.energy()*pf.caloFraction()*pf.hcalFraction(); - if(fabs(pf.eta())<3.&&(fabs(pf.eta())>3.)>1.4) hadinhe += pf.energy()*pf.caloFraction()*pf.hcalFraction(); - if(fabs(pf.eta())>=3.) hadinhf += pf.energy()*pf.caloFraction()*pf.hcalFraction(); - if(fabs(pf.eta())<=1.4) emineb += pf.energy()*pf.caloFraction()*(1.-pf.hcalFraction()); - if(fabs(pf.eta())<3.&&(fabs(pf.eta())>3.)>1.4) eminee += pf.energy()*pf.caloFraction()*(1.-pf.hcalFraction()); - if(fabs(pf.eta())>=3.) eminhf += pf.energy()*pf.caloFraction()*(1.-pf.hcalFraction()); - ncand++; - } // Calojet - } - } else { - // std::cout<<" RECO "< ct; - iEvent.getByToken(input_ctw_token_, ct); - if(ct.isValid()) { - for(CaloTowerCollection::const_iterator it = ct->begin();it != ct->end(); it++) { - double deta=(*jet).eta()-(*it).eta(); - double dphi=(*jet).phi()-(*it).phi(); - if(dphi > 4.*atan(1.) ) dphi = dphi-8.*atan(1.); - if(dphi < -1.*4.*atan(1.) ) dphi = dphi+8.*atan(1.); - double dr = sqrt(dphi*dphi+deta*deta); - if(dr>0.4) continue; - caloen = caloen + (*it).energy(); - hadinho += (*it).energyInHO(); - hadinhb += (*it).energyInHB(); - hadinhe += (*it).energyInHE(); - hadinhf += 0.5*(*it).energyInHF(); - emineb += (*it).energy()-(*it).energyInHB(); - eminee += (*it).energy()-(*it).energyInHE(); - eminhf += 0.5*(*it).energyInHF(); - ncand++; - } - } - } - eefraction = (emineb+eminee)/caloen; - hhfraction = (hadinhb+hadinhe+hadinhf+hadinho)/caloen; - - double trackp = sqrt(pow(jet->pt(),2)+pow(jet->pz(),2)); - // std::cout<<" Caloenergy "<jetArea()<px()/trackp, - caloen*jet->py()/trackp, - caloen*jet->pz()/trackp, - caloen); - reco::CaloJet::Specific calospe; - calospe.mTowersArea = -1*ncand; - calospe.mHadEnergyInHO=hadinho; - calospe.mHadEnergyInHB=hadinhb; - calospe.mHadEnergyInHE=hadinhe; - calospe.mHadEnergyInHF=hadinhf; - calospe.mEmEnergyInEB=emineb; - calospe.mEmEnergyInEE=eminee; - calospe.mEmEnergyInHF=eminhf; - calospe.mEnergyFractionEm=eefraction/caloen; - calospe.mEnergyFractionHadronic=hhfraction/caloen; - - reco::CaloJet mycalo(pcalo4,jet->primaryVertex()->position(),calospe); - mycalo.setJetArea(0.5024); - - //std::cout<<" AddonSeed::New Calojet "<jetArea()<push_back(mycalo); - - } // trackjets - } // jets - } // There is trackjet collection - - // std::cout<<" AddonSeed::size of collection "<size()<eta() - oldjet->eta()); + double dphi = fabs(jet->phi() - oldjet->phi()); + if (dphi > 4. * atan(1.)) + dphi = 8. * atan(1.) - dphi; + double dr = sqrt(dphi * dphi + deta * deta); + if (dr < dRcone) + iflag = 1; + } // Calojets + + if (iflag == 1) + continue; + // std::cout<<" AddonSeed::There is the additional trackjet seed "<pt()<<" "<eta()<< + // " "<phi()< pfCandidates; + iEvent.getByToken(tokenPFCandidates_, pfCandidates); + if (!pfCandidates.isValid()) { + // std::cout<<" No PFCandidate collection "<size(); i < n; ++i) { + const pat::PackedCandidate& pf = (*pfCandidates)[i]; + double deta = (*jet).eta() - pf.eta(); + double dphi = (*jet).phi() - pf.phi(); + + if (dphi > 4. * atan(1.)) + dphi = dphi - 8. * atan(1.); + if (dphi < -1. * 4. * atan(1.)) + dphi = dphi + 8. * atan(1.); + double dr = sqrt(dphi * dphi + deta * deta); + if (dr > dRcone) + continue; + // jetconstit + caloen = caloen + pf.energy() * pf.caloFraction(); + hadinho += 0.; + if (fabs(pf.eta()) <= 1.4) + hadinhb += pf.energy() * pf.caloFraction() * pf.hcalFraction(); + if (fabs(pf.eta()) < 3. && (fabs(pf.eta()) > 3.) > 1.4) + hadinhe += pf.energy() * pf.caloFraction() * pf.hcalFraction(); + if (fabs(pf.eta()) >= 3.) + hadinhf += pf.energy() * pf.caloFraction() * pf.hcalFraction(); + if (fabs(pf.eta()) <= 1.4) + emineb += pf.energy() * pf.caloFraction() * (1. - pf.hcalFraction()); + if (fabs(pf.eta()) < 3. && (fabs(pf.eta()) > 3.) > 1.4) + eminee += pf.energy() * pf.caloFraction() * (1. - pf.hcalFraction()); + if (fabs(pf.eta()) >= 3.) + eminhf += pf.energy() * pf.caloFraction() * (1. - pf.hcalFraction()); + ncand++; + } // Calojet + } + } else { + // std::cout<<" RECO "< ct; + iEvent.getByToken(input_ctw_token_, ct); + if (ct.isValid()) { + for (CaloTowerCollection::const_iterator it = ct->begin(); it != ct->end(); it++) { + double deta = (*jet).eta() - (*it).eta(); + double dphi = (*jet).phi() - (*it).phi(); + if (dphi > 4. * atan(1.)) + dphi = dphi - 8. * atan(1.); + if (dphi < -1. * 4. * atan(1.)) + dphi = dphi + 8. * atan(1.); + double dr = sqrt(dphi * dphi + deta * deta); + if (dr > dRcone) + continue; + caloen = caloen + (*it).energy(); + hadinho += (*it).energyInHO(); + hadinhb += (*it).energyInHB(); + hadinhe += (*it).energyInHE(); + hadinhf += 0.5 * (*it).energyInHF(); + emineb += (*it).energy() - (*it).energyInHB(); + eminee += (*it).energy() - (*it).energyInHE(); + eminhf += 0.5 * (*it).energyInHF(); + ncand++; + } + } + } + eefraction = (emineb + eminee) / caloen; + hhfraction = (hadinhb + hadinhe + hadinhf + hadinho) / caloen; + + double trackp = sqrt(pow(jet->pt(), 2) + pow(jet->pz(), 2)); + // std::cout<<" Caloenergy "<jetArea()<px() / trackp, caloen * jet->py() / trackp, caloen * jet->pz() / trackp, caloen); + reco::CaloJet::Specific calospe; + calospe.mTowersArea = -1 * ncand; + calospe.mHadEnergyInHO = hadinho; + calospe.mHadEnergyInHB = hadinhb; + calospe.mHadEnergyInHE = hadinhe; + calospe.mHadEnergyInHF = hadinhf; + calospe.mEmEnergyInEB = emineb; + calospe.mEmEnergyInEE = eminee; + calospe.mEmEnergyInHF = eminhf; + calospe.mEnergyFractionEm = eefraction / caloen; + calospe.mEnergyFractionHadronic = hhfraction / caloen; + + reco::CaloJet mycalo(pcalo4, jet->primaryVertex()->position(), calospe); + mycalo.setJetArea(3.14159 * dRcone * dRcone); + + //std::cout<<" AddonSeed::New Calojet "<jetArea()<push_back(mycalo); + + } // trackjets + } // jets + } // There is trackjet collection + + // std::cout<<" AddonSeed::size of collection "<size()< @@ -45,26 +44,24 @@ // class JetPlusTrackAddonSeedProducer : public edm::stream::EDProducer<> { - public: - explicit JetPlusTrackAddonSeedProducer(const edm::ParameterSet&); - ~JetPlusTrackAddonSeedProducer() override; - void produce(edm::Event&, const edm::EventSetup&) override; +public: + explicit JetPlusTrackAddonSeedProducer(const edm::ParameterSet&); + ~JetPlusTrackAddonSeedProducer() override; + void produce(edm::Event&, const edm::EventSetup&) override; - // ---------- private data members --------------------------- - private: - - edm::InputTag srcCaloJets; - edm::InputTag srcTrackJets; - edm::InputTag srcPVs_; - - std::string alias; - double ptCUT; - double dRcone; - bool usePAT; - edm::EDGetTokenT > input_jets_token_; - edm::EDGetTokenT > input_trackjets_token_; - edm::EDGetTokenT input_vertex_token_; - edm::EDGetTokenT > tokenPFCandidates_; - edm::EDGetTokenT input_ctw_token_; + // ---------- private data members --------------------------- +private: + edm::InputTag srcCaloJets; + edm::InputTag srcTrackJets; + edm::InputTag srcPVs_; + std::string alias; + double ptCUT; + double dRcone; + bool usePAT; + edm::EDGetTokenT > input_jets_token_; + edm::EDGetTokenT > input_trackjets_token_; + edm::EDGetTokenT input_vertex_token_; + edm::EDGetTokenT > tokenPFCandidates_; + edm::EDGetTokenT input_ctw_token_; }; diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc index 19a20824068be..feb5691794030 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc @@ -19,140 +19,141 @@ using namespace jpt; // ----------------------------------------------------------------------------- // -JetPlusTrackCorrector::JetPlusTrackCorrector( const edm::ParameterSet& pset, edm::ConsumesCollector&& iC ) - : verbose_( pset.getParameter("Verbose") ), - usereco_( pset.getParameter("UseReco") ), - vectorial_( pset.getParameter("VectorialCorrection") ), - vecResponse_( pset.getParameter("UseResponseInVecCorr") ), - useInConeTracks_( pset.getParameter("UseInConeTracks") ), - useOutOfConeTracks_( pset.getParameter("UseOutOfConeTracks") ), - useOutOfVertexTracks_( pset.getParameter("UseOutOfVertexTracks") ), - usePions_( pset.getParameter("UsePions") ), - useEff_( pset.getParameter("UseEfficiency") ), - useMuons_( pset.getParameter("UseMuons") ), - useElecs_( pset.getParameter("UseElectrons") ), - useTrackQuality_( pset.getParameter("UseTrackQuality") ), - jetTracksAtVertex_( pset.getParameter("JetTracksAssociationAtVertex") ), - jetTracksAtCalo_( pset.getParameter("JetTracksAssociationAtCaloFace") ), - jetSplitMerge_( pset.getParameter("JetSplitMerge") ), - srcPVs_(pset.getParameter("srcPVs") ), - ptErrorQuality_( pset.getParameter("PtErrorQuality") ), - dzVertexCut_( pset.getParameter("DzVertexCut") ), - muons_( pset.getParameter("Muons") ), - electrons_( pset.getParameter("Electrons") ), - electronIds_( pset.getParameter("ElectronIds") ), - patmuons_( pset.getParameter("PatMuons") ), - patelectrons_( pset.getParameter("PatElectrons") ), - trackQuality_( reco::TrackBase::qualityByName( pset.getParameter("TrackQuality") ) ), - response_( Map( pset.getParameter("ResponseMap"), verbose_ ) ), - efficiency_( Map( pset.getParameter("EfficiencyMap"), verbose_ ) ), - leakage_( Map( pset.getParameter("LeakageMap"), verbose_ ) ), - pionMass_(0.140), - muonMass_(0.105), - elecMass_(0.000511), - maxEta_( pset.getParameter("MaxJetEta") ) -{ - - if ( verbose_ ) { +JetPlusTrackCorrector::JetPlusTrackCorrector(const edm::ParameterSet& pset, edm::ConsumesCollector&& iC) + : verbose_(pset.getParameter("Verbose")), + usereco_(pset.getParameter("UseReco")), + vectorial_(pset.getParameter("VectorialCorrection")), + vecResponse_(pset.getParameter("UseResponseInVecCorr")), + useInConeTracks_(pset.getParameter("UseInConeTracks")), + useOutOfConeTracks_(pset.getParameter("UseOutOfConeTracks")), + useOutOfVertexTracks_(pset.getParameter("UseOutOfVertexTracks")), + usePions_(pset.getParameter("UsePions")), + useEff_(pset.getParameter("UseEfficiency")), + useMuons_(pset.getParameter("UseMuons")), + useElecs_(pset.getParameter("UseElectrons")), + useTrackQuality_(pset.getParameter("UseTrackQuality")), + jetTracksAtVertex_(pset.getParameter("JetTracksAssociationAtVertex")), + jetTracksAtCalo_(pset.getParameter("JetTracksAssociationAtCaloFace")), + jetSplitMerge_(pset.getParameter("JetSplitMerge")), + srcPVs_(pset.getParameter("srcPVs")), + ptErrorQuality_(pset.getParameter("PtErrorQuality")), + dzVertexCut_(pset.getParameter("DzVertexCut")), + muons_(pset.getParameter("Muons")), + electrons_(pset.getParameter("Electrons")), + electronIds_(pset.getParameter("ElectronIds")), + patmuons_(pset.getParameter("PatMuons")), + patelectrons_(pset.getParameter("PatElectrons")), + trackQuality_(reco::TrackBase::qualityByName(pset.getParameter("TrackQuality"))), + response_(Map(pset.getParameter("ResponseMap"), verbose_)), + efficiency_(Map(pset.getParameter("EfficiencyMap"), verbose_)), + leakage_(Map(pset.getParameter("LeakageMap"), verbose_)), + pionMass_(0.140), + muonMass_(0.105), + elecMass_(0.000511), + maxEta_(pset.getParameter("MaxJetEta")) { + if (verbose_) { std::stringstream ss; ss << "[JetPlusTrackCorrector::" << __func__ << "] Configuration for JPT corrector: " << std::endl << " Particles" << std::endl - << " UsePions : " << ( usePions_ ? "true" : "false" ) << std::endl - << " UseMuons : " << ( useMuons_ ? "true" : "false" ) << std::endl - << " UseElecs : " << ( useElecs_ ? "true" : "false" ) << std::endl - << " Corrections" << std::endl - << " UseInConeTracks : " << ( useInConeTracks_ ? "true" : "false" ) << std::endl - << " UseOutOfConeTracks : " << ( useOutOfConeTracks_ ? "true" : "false" ) << std::endl - << " UseOutOfVertexTracks : " << ( useOutOfVertexTracks_ ? "true" : "false" ) << std::endl + << " UsePions : " << (usePions_ ? "true" : "false") << std::endl + << " UseMuons : " << (useMuons_ ? "true" : "false") << std::endl + << " UseElecs : " << (useElecs_ ? "true" : "false") << std::endl + << " Corrections" << std::endl + << " UseInConeTracks : " << (useInConeTracks_ ? "true" : "false") << std::endl + << " UseOutOfConeTracks : " << (useOutOfConeTracks_ ? "true" : "false") << std::endl + << " UseOutOfVertexTracks : " << (useOutOfVertexTracks_ ? "true" : "false") << std::endl << " ResponseMap : " << pset.getParameter("ResponseMap") << std::endl << " Efficiency" << std::endl - << " UsePionEfficiency : " << ( useEff_ ? "true" : "false" ) << std::endl + << " UsePionEfficiency : " << (useEff_ ? "true" : "false") << std::endl << " EfficiencyMap : " << pset.getParameter("EfficiencyMap") << std::endl << " LeakageMap : " << pset.getParameter("LeakageMap") << std::endl << " Tracks" << std::endl << " JetTracksAtVertex : " << jetTracksAtVertex_ << std::endl << " JetTracksAtCalo : " << jetTracksAtCalo_ << std::endl << " JetSplitMerge : " << jetSplitMerge_ << std::endl - << " UseTrackQuality : " << ( useTrackQuality_ ? "true" : "false" ) << std::endl + << " UseTrackQuality : " << (useTrackQuality_ ? "true" : "false") << std::endl << " Collections" << std::endl << " Muons : " << muons_ << std::endl << " Electrons : " << electrons_ << std::endl << " Vectorial" << std::endl - << " UseTracksAndResponse : " << ( ( vectorial_ && vecResponse_ ) ? "true" : "false" ) << std::endl - << " UseTracksOnly : " << ( ( vectorial_ && !vecResponse_ ) ? "true" : "false" ); + << " UseTracksAndResponse : " << ((vectorial_ && vecResponse_) ? "true" : "false") << std::endl + << " UseTracksOnly : " << ((vectorial_ && !vecResponse_) ? "true" : "false"); edm::LogInfo("JetPlusTrackCorrector") << ss.str(); } - if ( !useInConeTracks_ || - !useOutOfConeTracks_ || - !useOutOfVertexTracks_ ) { + if (!useInConeTracks_ || !useOutOfConeTracks_ || !useOutOfVertexTracks_) { std::stringstream ss; ss << "[JetPlusTrackCorrector::" << __func__ << "]" << " You are using JPT algorithm in a non-standard way!" << std::endl - << " UseInConeTracks : " << ( useInConeTracks_ ? "true" : "false" ) << std::endl - << " UseOutOfConeTracks : " << ( useOutOfConeTracks_ ? "true" : "false" ) << std::endl - << " UseOutOfVertexTracks : " << ( useOutOfVertexTracks_ ? "true" : "false" ); + << " UseInConeTracks : " << (useInConeTracks_ ? "true" : "false") << std::endl + << " UseOutOfConeTracks : " << (useOutOfConeTracks_ ? "true" : "false") << std::endl + << " UseOutOfVertexTracks : " << (useOutOfVertexTracks_ ? "true" : "false"); edm::LogWarning("JetPlusTrackCorrector") << ss.str(); } - input_jetTracksAtVertex_token_ = iC.consumes(jetTracksAtVertex_); + input_jetTracksAtVertex_token_ = iC.consumes(jetTracksAtVertex_); input_jetTracksAtCalo_token_ = iC.consumes(jetTracksAtCalo_); input_pvCollection_token_ = iC.consumes(srcPVs_); - input_reco_muons_token_ = iC.consumes (muons_); + input_reco_muons_token_ = iC.consumes(muons_); input_reco_elecs_token_ = iC.consumes(electrons_); - input_reco_elec_ids_token_ = iC.consumes( electronIds_); + input_reco_elec_ids_token_ = iC.consumes(electronIds_); - input_pat_muons_token_ = iC.consumes (patmuons_); + input_pat_muons_token_ = iC.consumes(patmuons_); input_pat_elecs_token_ = iC.consumes(patelectrons_); - } // ----------------------------------------------------------------------------- // -JetPlusTrackCorrector::~JetPlusTrackCorrector() {;} +JetPlusTrackCorrector::~JetPlusTrackCorrector() { ; } // ----------------------------------------------------------------------------- // -double JetPlusTrackCorrector::correction( const reco::Jet& fJet, const reco::Jet& fJetcalo, - const edm::Event& event, - const edm::EventSetup& setup, - const reco::TrackRefVector& tracksinvert, - const reco::TrackRefVector& tracksincalo, - P4& corrected, - MatchedTracks &pions, - MatchedTracks &muons, - MatchedTracks &elecs - ) -{ +double JetPlusTrackCorrector::correction(const reco::Jet& fJet, + const reco::Jet& fJetcalo, + const edm::Event& event, + const edm::EventSetup& setup, + const reco::TrackRefVector& tracksinvert, + const reco::TrackRefVector& tracksincalo, + P4& corrected, + MatchedTracks& pions, + MatchedTracks& muons, + MatchedTracks& elecs) { double scale = 1.; corrected = fJet.p4(); - bool validMatches = matchTracks( fJetcalo, event, setup, tracksinvert, tracksincalo, pions, muons, elecs ); - if ( !validMatches ) { return 1.; } - if(usereco_) { - if ( usePions_ ) { corrected += pionCorrection( fJet.p4(), pions ); } - if ( useMuons_ ) { corrected += muonCorrection( fJet.p4(), muons ); } - if ( useElecs_ ) { corrected += elecCorrection( fJet.p4(), elecs ); } - } else { + bool validMatches = matchTracks(fJetcalo, event, setup, tracksinvert, tracksincalo, pions, muons, elecs); + if (!validMatches) { + return 1.; + } + if (usereco_) { + if (usePions_) { + corrected += pionCorrection(fJet.p4(), pions); + } + if (useMuons_) { + corrected += muonCorrection(fJet.p4(), muons); + } + if (useElecs_) { + corrected += elecCorrection(fJet.p4(), elecs); + } + } else { corrected += fJetcalo.p4(); - } - scale = checkScale( fJet.p4(), corrected ); -return scale; + } + scale = checkScale(fJet.p4(), corrected); + return scale; } - + // ----------------------------------------------------------------------------- // -double JetPlusTrackCorrector::correction( const reco::Jet& fJet, const reco::Jet& fJetcalo, - const edm::Event& event, - const edm::EventSetup& setup, - P4& corrected, - MatchedTracks &pions, - MatchedTracks &muons, - MatchedTracks &elecs, - bool &validMatches) -{ - -// std::cout<<" JetPlusTrackCorrector::correction "< 0. ? corrected.Et() / fJet.et() : 1. );// << std::endl + << " Scalar correction to Et : " << (fJet.et() > 0. ? corrected.Et() / fJet.et() : 1.); // << std::endl edm::LogVerbatim("JetPlusTrackCorrector") << ss.str(); } - /* + /* std::cout << " mScale= " << scale << " NewResponse " << corrected.energy() << " Jet energy " << fJet.energy() @@ -250,115 +247,104 @@ double JetPlusTrackCorrector::correction( const reco::Jet& fJet, const reco::Jet theSumEnergyWithoutEff < jetTracksAtVertex; - event.getByToken(input_jetTracksAtVertex_token_, jetTracksAtVertex ); - + event.getByToken(input_jetTracksAtVertex_token_, jetTracksAtVertex); + //std::cout<<"JetPlusTrackCorrector::jtaUsingEventData" < jetTracksAtCalo; - event.getByToken(input_jetTracksAtCalo_token_, jetTracksAtCalo ); + event.getByToken(input_jetTracksAtCalo_token_, jetTracksAtCalo); - if ( !jetTracksAtCalo.isValid() || jetTracksAtCalo.failedToGet() ) { - if ( verbose_ && edm::isDebugEnabled() ) { + if (!jetTracksAtCalo.isValid() || jetTracksAtCalo.failedToGet()) { + if (verbose_ && edm::isDebugEnabled()) { edm::LogWarning("JetPlusTrackCorrector") - << "[JetPlusTrackCorrector::" << __func__ << "]" - << " Invalid handle to reco::JetTracksAssociation::Container (for CaloFace)" - << " with InputTag (label:instance:process) \"" - << jetTracksAtCalo_.label() << ":" - << jetTracksAtCalo_.instance() << ":" - << jetTracksAtCalo_.process() << "\""; + << "[JetPlusTrackCorrector::" << __func__ << "]" + << " Invalid handle to reco::JetTracksAssociation::Container (for CaloFace)" + << " with InputTag (label:instance:process) \"" << jetTracksAtCalo_.label() << ":" + << jetTracksAtCalo_.instance() << ":" << jetTracksAtCalo_.process() << "\""; } - return false; + return false; } - + // Retrieve jet-tracks association for given jet - const reco::JetTracksAssociation::Container jtC = *( jetTracksAtCalo.product() ); - if ( jetSplitMerge_ < 0 ) { trks.caloFace_ = reco::JetTracksAssociation::getValue( jtC, fJet ); } - else { excludeJta( fJet, jtC, trks.caloFace_, excluded ); } - - // std::cout<<" JTA:Tracks in vertex "<& reco_muons ) const { - event.getByToken(input_reco_muons_token_, reco_muons ); - if ( !reco_muons.isValid() || reco_muons.failedToGet() ) { - edm::LogError("JetPlusTrackCorrector") - << "[JetPlusTrackCorrector::" << __func__ << "]" - << " Invalid handle to reco::Muon collection" - << " with InputTag (label:instance:process) \"" - << muons_.label() << ":" - << muons_.instance() << ":" - << muons_.process() << "\""; +bool JetPlusTrackCorrector::getMuons(const edm::Event& event, edm::Handle& reco_muons) const { + event.getByToken(input_reco_muons_token_, reco_muons); + if (!reco_muons.isValid() || reco_muons.failedToGet()) { + edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]" + << " Invalid handle to reco::Muon collection" + << " with InputTag (label:instance:process) \"" << muons_.label() << ":" + << muons_.instance() << ":" << muons_.process() << "\""; return false; } return true; } -bool JetPlusTrackCorrector::getMuons( const edm::Event& event, edm::Handle& reco_muons ) const { - event.getByToken(input_pat_muons_token_, reco_muons ); - if ( !reco_muons.isValid() || reco_muons.failedToGet() ) { - edm::LogError("JetPlusTrackCorrector") - << "[JetPlusTrackCorrector::" << __func__ << "]" - << " Invalid handle to reco::Muon collection" - << " with InputTag (label:instance:process) \"" - << muons_.label() << ":" - << muons_.instance() << ":" - << muons_.process() << "\""; +bool JetPlusTrackCorrector::getMuons(const edm::Event& event, edm::Handle& reco_muons) const { + event.getByToken(input_pat_muons_token_, reco_muons); + if (!reco_muons.isValid() || reco_muons.failedToGet()) { + edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]" + << " Invalid handle to reco::Muon collection" + << " with InputTag (label:instance:process) \"" << muons_.label() << ":" + << muons_.instance() << ":" << muons_.process() << "\""; return false; } return true; } - // ----------------------------------------------------------------------------- // -void JetPlusTrackCorrector::matchTracks( const JetTracks& jet_tracks, - const edm::Event& event, - MatchedTracks& pions, - MatchedTracks& muons, - MatchedTracks& elecs ) { - // Some init - pions.clear(); - muons.clear(); - elecs.clear(); +void JetPlusTrackCorrector::matchTracks(const JetTracks& jet_tracks, + const edm::Event& event, + MatchedTracks& pions, + MatchedTracks& muons, + MatchedTracks& elecs) { + // Some init + pions.clear(); + muons.clear(); + elecs.clear(); // Need vertex for track cleaning - vertex_=reco::Particle::Point(0,0,0); - edm::Handle pvCollection; - event.getByToken(input_pvCollection_token_, pvCollection); - if ( pvCollection.isValid() && !pvCollection->empty() ) vertex_=pvCollection->begin()->position(); + vertex_ = reco::Particle::Point(0, 0, 0); + edm::Handle pvCollection; + event.getByToken(input_pvCollection_token_, pvCollection); + if (pvCollection.isValid() && !pvCollection->empty()) + vertex_ = pvCollection->begin()->position(); // Get RECO muons edm::Handle reco_muons; edm::Handle pat_muons; bool found_reco_muons = true; bool found_pat_muons = true; - if ( useMuons_ ) {if(usereco_) {getMuons( event, reco_muons );} - else {getMuons( event, pat_muons ); - found_reco_muons = false;}} + if (useMuons_) { + if (usereco_) { + getMuons(event, reco_muons); + } else { + getMuons(event, pat_muons); + found_reco_muons = false; + } + } - // Get RECO electrons and their ids edm::Handle reco_elecs; edm::Handle pat_elecs; edm::Handle reco_elec_ids; bool found_reco_elecs = true; bool found_pat_elecs = true; - if ( useElecs_ ) { if(usereco_) {getElectrons( event, reco_elecs, reco_elec_ids );} - else {getElectrons(event, pat_elecs); - found_reco_elecs = false; }} + if (useElecs_) { + if (usereco_) { + getElectrons(event, reco_elecs, reco_elec_ids); + } else { + getElectrons(event, pat_elecs); + found_reco_elecs = false; + } + } - // std::cout<<" Found elec/muo "<quality(trackQuality_) && theSumPtForBetaOld <= 0.) + theSumPtForBeta += (**itrk).pt(); + // + // Track either belongs to PV or do not belong to any vertex - if ( useTrackQuality_ && (*itrk)->quality(trackQuality_) && theSumPtForBetaOld<=0. ) - theSumPtForBeta += (**itrk).pt(); -// -// Track either belongs to PV or do not belong to any vertex - - const reco::TrackBaseRef ttr1(*itrk); + const reco::TrackBaseRef ttr1(*itrk); - int numpv=0; + int numpv = 0; int itrack_belong = -1; - - for( reco::VertexCollection::const_iterator iv = pvCollection->begin(); iv != pvCollection->end(); iv++) { + + for (reco::VertexCollection::const_iterator iv = pvCollection->begin(); iv != pvCollection->end(); iv++) { numpv++; - std::vector::const_iterator rr = - find((*iv).tracks_begin(), - (*iv).tracks_end(), - ttr1); - if( rr != (*iv).tracks_end() ) { - itrack_belong++; - // std::cout<<" Numpv "< 1 && itrack_belong == 0 ) { - // std::cout<<" Drop track "<::const_iterator rr = find((*iv).tracks_begin(), (*iv).tracks_end(), ttr1); + if (rr != (*iv).tracks_end()) { + itrack_belong++; + // std::cout<<" Numpv "< 1 && itrack_belong == 0) { + // std::cout<<" Drop track "<& reco_elecs, - edm::Handle& reco_elec_ids ) const { - event.getByToken(input_reco_elecs_token_, reco_elecs ); - if ( !reco_elecs.isValid() || reco_elecs.failedToGet() ) { - edm::LogError("JetPlusTrackCorrector") - << "[JetPlusTrackCorrector::" << __func__ << "]" - << " Invalid handle to reco::GsfElectron collection" - << " with InputTag (label:instance:process) \"" - << electrons_.label() << ":" - << electrons_.instance() << ":" - << electrons_.process() << "\""; +bool JetPlusTrackCorrector::getElectrons(const edm::Event& event, + edm::Handle& reco_elecs, + edm::Handle& reco_elec_ids) const { + event.getByToken(input_reco_elecs_token_, reco_elecs); + if (!reco_elecs.isValid() || reco_elecs.failedToGet()) { + edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]" + << " Invalid handle to reco::GsfElectron collection" + << " with InputTag (label:instance:process) \"" << electrons_.label() << ":" + << electrons_.instance() << ":" << electrons_.process() << "\""; return false; } - event.getByToken(input_reco_elec_ids_token_, reco_elec_ids ); - if ( !reco_elec_ids.isValid() || reco_elec_ids.failedToGet() ) { - edm::LogError("JetPlusTrackCorrector") - << "[JetPlusTrackCorrector::" << __func__ << "]" - << " Invalid handle to reco::GsfElectron collection" - << " with InputTag (label:instance:process) \"" - << electronIds_.label() << ":" - << electronIds_.instance() << ":" - << electronIds_.process() << "\""; + event.getByToken(input_reco_elec_ids_token_, reco_elec_ids); + if (!reco_elec_ids.isValid() || reco_elec_ids.failedToGet()) { + edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]" + << " Invalid handle to reco::GsfElectron collection" + << " with InputTag (label:instance:process) \"" << electronIds_.label() + << ":" << electronIds_.instance() << ":" << electronIds_.process() << "\""; return false; } return true; -} - -bool JetPlusTrackCorrector::getElectrons( - const edm::Event& event, - edm::Handle& reco_elecs - ) const { - event.getByToken(input_pat_elecs_token_, reco_elecs ); - if ( !reco_elecs.isValid() || reco_elecs.failedToGet() ) { - edm::LogError("JetPlusTrackCorrector") - << "[JetPlusTrackCorrector::" << __func__ << "]" - << " Invalid handle to reco::GsfElectron collection" - << " with InputTag (label:instance:process) \"" - << electrons_.label() << ":" - << electrons_.instance() << ":" - << electrons_.process() << "\""; +} + +bool JetPlusTrackCorrector::getElectrons(const edm::Event& event, + edm::Handle& reco_elecs) const { + event.getByToken(input_pat_elecs_token_, reco_elecs); + if (!reco_elecs.isValid() || reco_elecs.failedToGet()) { + edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]" + << " Invalid handle to reco::GsfElectron collection" + << " with InputTag (label:instance:process) \"" << electrons_.label() << ":" + << electrons_.instance() << ":" << electrons_.process() << "\""; return false; } return true; } - - // ----------------------------------------------------------------------------- // -bool JetPlusTrackCorrector::failTrackQuality( TrackRefs::const_iterator& itrk ) const { -// if ( useTrackQuality_ && !(*itrk)->quality(trackQuality_) ) { return true; } -// else { return false; } - - bool retcode = false; +bool JetPlusTrackCorrector::failTrackQuality(TrackRefs::const_iterator& itrk) const { + // if ( useTrackQuality_ && !(*itrk)->quality(trackQuality_) ) { return true; } + // else { return false; } + + bool retcode = false; // std::cout<<"JetPlusTrackCorrector::failTrackQuality "<< (*itrk)->quality(trackQuality_)<quality(trackQuality_) ) { + if (useTrackQuality_ && !(*itrk)->quality(trackQuality_)) { // std::cout<<" Fail quality cut "<ptError()/(*itrk)->pt()) > ptErrorQuality_) { - // std::cout<<" Fail pterr "<<(*itrk)->pt()<<" "<<((*itrk)->ptError()/(*itrk)->pt())<<" "<< - // ptErrorQuality_<dz(vertex_)) > dzVertexCut_) { - //std::cout<<" Fail dz "<dz(vertex_))<<" "<ptError() / (*itrk)->pt()) > ptErrorQuality_) { + // std::cout<<" Fail pterr "<<(*itrk)->pt()<<" "<<((*itrk)->ptError()/(*itrk)->pt())<<" "<< + // ptErrorQuality_<dz(vertex_)) > dzVertexCut_) { + //std::cout<<" Fail dz "<dz(vertex_))<<" "<pt(), (*itrk)->eta(), (*itrk)->phi(), 0. ); -// tracks_present = true; + for (; itrk != jtrk; ++itrk) { + corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.); + // tracks_present = true; tracks_present_inin = true; } } - if ( !pions.inVertexOutOfCalo_.empty() ) { + if (!pions.inVertexOutOfCalo_.empty()) { TrackRefs::iterator itrk = pions.inVertexOutOfCalo_.begin(); TrackRefs::iterator jtrk = pions.inVertexOutOfCalo_.end(); - for ( ; itrk != jtrk; ++itrk ) { - corr += PtEtaPhiM( (*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0. ); -// tracks_present = true; + for (; itrk != jtrk; ++itrk) { + corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.); + // tracks_present = true; } } // Correct using muons in-cone at vertex - if ( !muons.inVertexInCalo_.empty() ) { + if (!muons.inVertexInCalo_.empty()) { TrackRefs::iterator itrk = muons.inVertexInCalo_.begin(); TrackRefs::iterator jtrk = muons.inVertexInCalo_.end(); - for ( ; itrk != jtrk; ++itrk ) { - corr += PtEtaPhiM( (*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0. ); -// tracks_present = true; + for (; itrk != jtrk; ++itrk) { + corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.); + // tracks_present = true; } } - if ( !muons.inVertexOutOfCalo_.empty() ) { + if (!muons.inVertexOutOfCalo_.empty()) { TrackRefs::iterator itrk = muons.inVertexOutOfCalo_.begin(); TrackRefs::iterator jtrk = muons.inVertexOutOfCalo_.end(); - for ( ; itrk != jtrk; ++itrk ) { - corr += PtEtaPhiM( (*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0. ); -// tracks_present = true; + for (; itrk != jtrk; ++itrk) { + corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.); + // tracks_present = true; } } // Correct using electrons in-cone at vertex - if ( !elecs.inVertexInCalo_.empty() ) { + if (!elecs.inVertexInCalo_.empty()) { TrackRefs::iterator itrk = elecs.inVertexInCalo_.begin(); TrackRefs::iterator jtrk = elecs.inVertexInCalo_.end(); - for ( ; itrk != jtrk; ++itrk ) { - corr += PtEtaPhiM( (*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0. ); -// tracks_present = true; + for (; itrk != jtrk; ++itrk) { + corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.); + // tracks_present = true; } } - - if ( !elecs.inVertexOutOfCalo_.empty() ) { + + if (!elecs.inVertexOutOfCalo_.empty()) { TrackRefs::iterator itrk = elecs.inVertexOutOfCalo_.begin(); TrackRefs::iterator jtrk = elecs.inVertexOutOfCalo_.end(); - for ( ; itrk != jtrk; ++itrk ) { - corr += PtEtaPhiM( (*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0. ); -// tracks_present = true; + for (; itrk != jtrk; ++itrk) { + corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.); + // tracks_present = true; } } - + // Adjust direction if in cone tracks are present - - if ( !tracks_present_inin ) { corr = corrected; } - else { - corr *= ( corr.P() > 0. ? corrected.P() / corr.P() : 1. ); - corr = P4( corr.px(), corr.py(), corr.pz(), corrected.energy() ); + + if (!tracks_present_inin) { + corr = corrected; + } else { + corr *= (corr.P() > 0. ? corrected.P() / corr.P() : 1.); + corr = P4(corr.px(), corr.py(), corr.pz(), corrected.energy()); } - + return corr; - } // ----------------------------------------------------------------------------- // -JetPlusTrackCorrector::P4 JetPlusTrackCorrector::calculateCorr( const P4& jet, - const TrackRefs& tracks, - jpt::Efficiency& eff, - bool in_cone_at_vertex, - bool in_cone_at_calo_face, - double mass, - bool is_pion, - double mip ) { - +JetPlusTrackCorrector::P4 JetPlusTrackCorrector::calculateCorr(const P4& jet, + const TrackRefs& tracks, + jpt::Efficiency& eff, + bool in_cone_at_vertex, + bool in_cone_at_calo_face, + double mass, + bool is_pion, + double mip) { // Correction to be applied to jet 4-momentum P4 correction; -/* + /* std::cout<<" >>>>> Jet "<pt() >= 50. ) { continue; } - + if (in_cone_at_calo_face && is_pion && (*itrk)->pt() >= 50.) { + continue; + } + // Inner track 4-momentum P4 inner; - if ( vectorial_ && vecResponse_ ) { - inner = PtEtaPhiM( (*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), mass ); - } else { - double energy = sqrt( (*itrk)->px() * (*itrk)->px() + - (*itrk)->py() * (*itrk)->py() + - (*itrk)->pz() * (*itrk)->pz() + - mass * mass ); - inner = ( jet.energy() > 0. ? energy / jet.energy() : 1. ) * jet; - } - + if (vectorial_ && vecResponse_) { + inner = PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), mass); + } else { + double energy = sqrt((*itrk)->px() * (*itrk)->px() + (*itrk)->py() * (*itrk)->py() + + (*itrk)->pz() * (*itrk)->pz() + mass * mass); + inner = (jet.energy() > 0. ? energy / jet.energy() : 1.) * jet; + } + // Add track momentum (if in-cone at vertex) - if ( in_cone_at_vertex ) { correction += inner; } - + if (in_cone_at_vertex) { + correction += inner; + } + // Find appropriate eta/pt bin for given track - double eta = fabs( (*itrk)->eta() ); - double pt = fabs( (*itrk)->pt() ); - uint32_t ieta = response_.etaBin( eta ); - uint32_t ipt = response_.ptBin( pt ); + double eta = fabs((*itrk)->eta()); + double pt = fabs((*itrk)->pt()); + uint32_t ieta = response_.etaBin(eta); + uint32_t ipt = response_.ptBin(pt); // Check bins (not for mips) - if ( is_pion && ( ieta == response_.nEtaBins() || ipt == response_.nPtBins() ) ) { continue; } - - // Outer track 4-momentum + if (is_pion && (ieta == response_.nEtaBins() || ipt == response_.nPtBins())) { + continue; + } + + // Outer track 4-momentum P4 outer; - if ( in_cone_at_calo_face ) { - if ( vectorial_ && vecResponse_ ) { - // Build 4-momentum from outer track (SHOULD USE IMPACT POINT?!) - double outer_pt = (*itrk)->pt(); - double outer_eta = (*itrk)->eta(); - double outer_phi = (*itrk)->phi(); - if ( (*itrk)->extra().isNonnull() ) { - outer_pt = (*itrk)->pt(); - outer_eta = (*itrk)->outerPosition().eta(); //@@ outerMomentum().eta() - outer_phi = (*itrk)->outerPosition().phi(); //@@ outerMomentum().phi() - } - outer = PtEtaPhiM( outer_pt, outer_eta, outer_phi, mass ); - // Check if mip or not - if ( !is_pion ) { outer *= ( outer.energy() > 0. ? mip / outer.energy() : 1. ); } //@@ Scale to mip energy - else { outer *= ( outer.energy() > 0. ? inner.energy() / outer.energy() : 1. ); } //@@ Scale to inner track energy - } else { - // Check if mip or not - if ( !is_pion ) { outer = ( jet.energy() > 0. ? mip / jet.energy() : 1. ) * jet; } //@@ Jet 4-mom scaled by mip energy - else { outer = inner; } //@@ Set to inner track 4-momentum - } - if ( is_pion ) { outer *= response_.value(ieta,ipt); } //@@ Scale by pion response - correction -= outer; //@@ Subtract - -// Calculate the sum of responses - theSumResp += response_.value(ieta,ipt); + if (in_cone_at_calo_face) { + if (vectorial_ && vecResponse_) { + // Build 4-momentum from outer track (SHOULD USE IMPACT POINT?!) + double outer_pt = (*itrk)->pt(); + double outer_eta = (*itrk)->eta(); + double outer_phi = (*itrk)->phi(); + if ((*itrk)->extra().isNonnull()) { + outer_pt = (*itrk)->pt(); + outer_eta = (*itrk)->outerPosition().eta(); //@@ outerMomentum().eta() + outer_phi = (*itrk)->outerPosition().phi(); //@@ outerMomentum().phi() + } + outer = PtEtaPhiM(outer_pt, outer_eta, outer_phi, mass); + // Check if mip or not + if (!is_pion) { + outer *= (outer.energy() > 0. ? mip / outer.energy() : 1.); + } //@@ Scale to mip energy + else { + outer *= (outer.energy() > 0. ? inner.energy() / outer.energy() : 1.); + } //@@ Scale to inner track energy + } else { + // Check if mip or not + if (!is_pion) { + outer = (jet.energy() > 0. ? mip / jet.energy() : 1.) * jet; + } //@@ Jet 4-mom scaled by mip energy + else { + outer = inner; + } //@@ Set to inner track 4-momentum + } + if (is_pion) { + outer *= response_.value(ieta, ipt); + } //@@ Scale by pion response + correction -= outer; //@@ Subtract + + // Calculate the sum of responses + theSumResp += response_.value(ieta, ipt); } - -// Calculate the sum of pt and energies - theSumPt += inner.pt(); - theSumEnergy += inner.energy(); - + + // Calculate the sum of pt and energies + theSumPt += inner.pt(); + theSumEnergy += inner.energy(); + // Record inner track energy for pion efficiency correction - if ( is_pion ) { eff.addE( ieta, ipt, inner.energy() ); } - + if (is_pion) { + eff.addE(ieta, ipt, inner.energy()); + } + // Debug - if ( verbose_ && edm::isDebugEnabled() ) { - std::stringstream temp; - temp << " Response[" << ieta << "," << ipt << "]"; - std::stringstream ss; - ss << "[JetPlusTrackCorrector::" << __func__ << "]" << std::endl - << " Track eta / pt : " << eta << " / " << pt << std::endl - << temp.str() << std::setw(21-temp.str().size()) << " : " - << response_.value(ieta,ipt) << std::endl - << " Track momentum added : " << inner.energy() << std::endl - << " Response subtracted : " << outer.energy() << std::endl - << " Energy correction : " << correction.energy(); - LogDebug("JetPlusTrackCorrector") << ss.str(); + if (verbose_ && edm::isDebugEnabled()) { + std::stringstream temp; + temp << " Response[" << ieta << "," << ipt << "]"; + std::stringstream ss; + ss << "[JetPlusTrackCorrector::" << __func__ << "]" << std::endl + << " Track eta / pt : " << eta << " / " << pt << std::endl + << temp.str() << std::setw(21 - temp.str().size()) << " : " << response_.value(ieta, ipt) << std::endl + << " Track momentum added : " << inner.energy() << std::endl + << " Response subtracted : " << outer.energy() << std::endl + << " Energy correction : " << correction.energy(); + LogDebug("JetPlusTrackCorrector") << ss.str(); } - - } // loop through tracks - } // ntracks != 0 - - if( in_cone_at_vertex ) { - - theResponseOfChargedWithEff += theSumResp; - theResponseOfChargedWithoutEff += theSumResp; - theSumPtWithEff += theSumPt; - theSumPtWithoutEff += theSumPt; - theSumEnergyWithEff += theSumEnergy; - theSumEnergyWithoutEff += theSumEnergy; - - } -/* + + } // loop through tracks + } // ntracks != 0 + + if (in_cone_at_vertex) { + theResponseOfChargedWithEff += theSumResp; + theResponseOfChargedWithoutEff += theSumResp; + theSumPtWithEff += theSumPt; + theSumPtWithoutEff += theSumPt; + theSumEnergyWithEff += theSumEnergy; + theSumEnergyWithoutEff += theSumEnergy; + } + /* std::cout<<" calculateCorr End::Corrections for jet "<< theResponseOfChargedWithEff <<" "<< theResponseOfChargedWithoutEff <<" "<< theSumPtWithEff <<" "<< @@ -1201,62 +1196,70 @@ JetPlusTrackCorrector::P4 JetPlusTrackCorrector::calculateCorr( const P4& jet, theSumEnergyWithoutEff < 0. ? corr / corr_p4.energy() : 1. ); //@@ p4 scaled up by mean energy for bin - } else { - corr_p4 = ( jet.energy() > 0. ? corr / jet.energy() : 1. ) * jet; - } - - // Apply correction - if ( ii == 0 ) { correction += corr_p4; theSumPt += corr_p4.pt(); theSumEnergy += corr_p4.energy();} //@@ Add out-of-cone - else if ( ii == 1 ) { correction -= corr_p4; theSumResp += corr_p4.energy();} //@@ Subtract in-cone - - } + if (!eff.nTrks(ieta, ipt)) { + continue; + } + for (uint16_t ii = 0; ii < 2; ++ii) { + // Check which correction should be applied + double corr = 0.; + if (ii == 0) { + corr = eff.outOfConeCorr(ieta, ipt); + } else if (ii == 1 && in_cone_at_calo_face) { + corr = eff.inConeCorr(ieta, ipt); + } else { + continue; + } + + // Calculate correction to be applied + P4 corr_p4; + if (vectorial_ && vecResponse_) { + double corr_eta = response_.binCenterEta(ieta); + double corr_phi = jet.phi(); //@@ jet phi! + double corr_pt = response_.binCenterPt(ipt); + corr_p4 = + PtEtaPhiM(corr_pt, corr_eta, corr_phi, pionMass_); //@@ E^2 = p^2 + m_pion^2, |p| calc'ed from pt bin + corr_p4 *= (corr_p4.energy() > 0. ? corr / corr_p4.energy() : 1.); //@@ p4 scaled up by mean energy for bin + } else { + corr_p4 = (jet.energy() > 0. ? corr / jet.energy() : 1.) * jet; + } + + // Apply correction + if (ii == 0) { + correction += corr_p4; + theSumPt += corr_p4.pt(); + theSumEnergy += corr_p4.energy(); + } //@@ Add out-of-cone + else if (ii == 1) { + correction -= corr_p4; + theSumResp += corr_p4.energy(); + } //@@ Subtract in-cone + } } } - theResponseOfChargedWithEff += theSumResp; - theSumPtWithEff += theSumPt; - theSumEnergyWithEff += theSumEnergy; -/* + theResponseOfChargedWithEff += theSumResp; + theSumPtWithEff += theSumPt; + theSumEnergyWithEff += theSumEnergy; + /* std::cout<<" Efficiency correction End::Corrections for jet "<< theResponseOfChargedWithEff <<" "<< theResponseOfChargedWithoutEff <<" "<< theSumPtWithEff <<" "<< @@ -1265,141 +1268,150 @@ JetPlusTrackCorrector::P4 JetPlusTrackCorrector::pionEfficiency( const P4& jet, theSumEnergyWithoutEff <& muons ) const { - - if ( muons->empty() ) { return false; } - - RecoMuons::const_iterator imuon = muons->begin(); - RecoMuons::const_iterator jmuon = muons->end(); - for ( ; imuon != jmuon; ++imuon ) { - - if ( imuon->innerTrack().isNull() || - !muon::isGoodMuon(*imuon,muon::TMLastStationTight) || - imuon->innerTrack()->pt() < 3.0 ) { continue; } - - if ( itrk->id() != imuon->innerTrack().id() ) { - edm::LogError("JetPlusTrackCorrector") - << "[JetPlusTrackCorrector::" << __func__ << "]" - << "Product id of the tracks associated to the jet " << itrk->id() - <<" is different from the product id of the inner track used for muons " << imuon->innerTrack().id() - << "!" << std::endl - << "Cannot compare tracks from different collection. Configuration Error!"; +bool JetPlusTrackCorrector::matchMuons(TrackRefs::const_iterator& itrk, const edm::Handle& muons) const { + if (muons->empty()) { + return false; + } + + RecoMuons::const_iterator imuon = muons->begin(); + RecoMuons::const_iterator jmuon = muons->end(); + for (; imuon != jmuon; ++imuon) { + if (imuon->innerTrack().isNull() || !muon::isGoodMuon(*imuon, muon::TMLastStationTight) || + imuon->innerTrack()->pt() < 3.0) { + continue; + } + + if (itrk->id() != imuon->innerTrack().id()) { + edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]" + << "Product id of the tracks associated to the jet " << itrk->id() + << " is different from the product id of the inner track used for muons " + << imuon->innerTrack().id() << "!" << std::endl + << "Cannot compare tracks from different collection. Configuration Error!"; return false; } - - if ( *itrk == imuon->innerTrack() ) return true; + + if (*itrk == imuon->innerTrack()) + return true; } - + return false; - } -bool JetPlusTrackCorrector::matchMuons( TrackRefs::const_iterator& itrk, - const edm::Handle& muons ) const { - - if ( muons->empty() ) { return false; } +bool JetPlusTrackCorrector::matchMuons(TrackRefs::const_iterator& itrk, + const edm::Handle& muons) const { + if (muons->empty()) { + return false; + } pat::MuonCollection::const_iterator imuon = muons->begin(); pat::MuonCollection::const_iterator jmuon = muons->end(); - for ( ; imuon != jmuon; ++imuon ) { - if(imuon->innerTrack().isNull() == 1 ) continue; + for (; imuon != jmuon; ++imuon) { + if (imuon->innerTrack().isNull() == 1) + continue; // std::cout<<"JetPlusTrackCorrector::matchMuons::Track "<<(**itrk).pt()<<" " - // <<(**itrk).eta()<<" "<<(**itrk).phi()<<" Muon "<< - // (*(imuon->innerTrack())).pt()<<" "<< (*(imuon->innerTrack())).eta()<<" "<< - // (*(imuon->innerTrack())).phi()<innerTrack())).pt())<0.1 && - fabs((**itrk).eta()-(*(imuon->innerTrack())).eta())<0.001 && - fabs((**itrk).phi()-(*(imuon->innerTrack())).phi())<0.001) { + // <<(**itrk).eta()<<" "<<(**itrk).phi()<<" Muon "<< + // (*(imuon->innerTrack())).pt()<<" "<< (*(imuon->innerTrack())).eta()<<" "<< + // (*(imuon->innerTrack())).phi()<innerTrack())).pt()) < 0.1 && + fabs((**itrk).eta() - (*(imuon->innerTrack())).eta()) < 0.001 && + fabs((**itrk).phi() - (*(imuon->innerTrack())).phi()) < 0.001) { // std::cout<<" Needed muon-track "<<(**itrk).pt()<<" "<< - // (**itrk).eta()<<" "<<(**itrk).phi()<& elecs, - const edm::Handle& elec_ids ) const { - - if ( elecs->empty() ) { return false; } - +bool JetPlusTrackCorrector::matchElectrons(TrackRefs::const_iterator& itrk, + const edm::Handle& elecs, + const edm::Handle& elec_ids) const { + if (elecs->empty()) { + return false; + } + double deltaR = 999.; double deltaRMIN = 999.; - + uint32_t electron_index = 0; - RecoElectrons::const_iterator ielec = elecs->begin(); - RecoElectrons::const_iterator jelec = elecs->end(); - for ( ; ielec != jelec; ++ielec ) { - - edm::Ref electron_ref( elecs, electron_index ); + RecoElectrons::const_iterator ielec = elecs->begin(); + RecoElectrons::const_iterator jelec = elecs->end(); + for (; ielec != jelec; ++ielec) { + edm::Ref electron_ref(elecs, electron_index); electron_index++; - - if ( (*elec_ids)[electron_ref] < 1.e-6 ) { continue; } //@@ Check for null value - + + if ((*elec_ids)[electron_ref] < 1.e-6) { + continue; + } //@@ Check for null value + // DR matching b/w electron and track - double deltaphi = fabs( ielec->phi() - (*itrk)->momentum().phi() ); - if ( deltaphi > 6.283185308 ) deltaphi -= 6.283185308; - if ( deltaphi > 3.141592654 ) deltaphi = 6.283185308 - deltaphi; - deltaR = abs( sqrt( pow( (ielec->eta() - (*itrk)->momentum().eta()), 2 ) + - pow( deltaphi , 2 ) ) ); - if ( deltaR < deltaRMIN ) { deltaRMIN = deltaR; } - + double deltaphi = fabs(ielec->phi() - (*itrk)->momentum().phi()); + if (deltaphi > 6.283185308) + deltaphi -= 6.283185308; + if (deltaphi > 3.141592654) + deltaphi = 6.283185308 - deltaphi; + deltaR = abs(sqrt(pow((ielec->eta() - (*itrk)->momentum().eta()), 2) + pow(deltaphi, 2))); + if (deltaR < deltaRMIN) { + deltaRMIN = deltaR; + } } - - if ( deltaRMIN < 0.02 ) return true; - else return false; - + + if (deltaRMIN < 0.02) + return true; + else + return false; } -bool JetPlusTrackCorrector::matchElectrons( TrackRefs::const_iterator& itrk, - const edm::Handle& elecs - ) const { - if ( elecs->empty() ) { return false; } - // std::cout<<"JetPlusTrackCorrector::matchElectrons "<& elecs) const { + if (elecs->empty()) { + return false; + } + // std::cout<<"JetPlusTrackCorrector::matchElectrons "<begin(); pat::ElectronCollection::const_iterator jelec = elecs->end(); - for ( ; ielec != jelec; ++ielec ) { - // std::cout<<"Electron "<eta()<<" "<phi()<<" Track "<<(*itrk)->momentum().eta()<<" "<< - // (*itrk)->momentum().phi()<<" PT "<pt()<<" "<<(*itrk)->pt()<phi() - (*itrk)->momentum().phi() ); - if ( deltaphi > 6.283185308 ) deltaphi -= 6.283185308; - if ( deltaphi > 3.141592654 ) deltaphi = 6.283185308 - deltaphi; - deltaR = abs( sqrt( pow( (ielec->eta() - (*itrk)->momentum().eta()), 2 ) + - pow( deltaphi , 2 ) ) ); - if ( deltaR < deltaRMIN ) { deltaRMIN = deltaR; } - } - // std::cout<<" matchElectrons:DeltaR "<eta()<<" "<phi()<<" Track "<<(*itrk)->momentum().eta()<<" "<< + // (*itrk)->momentum().phi()<<" PT "<pt()<<" "<<(*itrk)->pt()<phi() - (*itrk)->momentum().phi()); + if (deltaphi > 6.283185308) + deltaphi -= 6.283185308; + if (deltaphi > 3.141592654) + deltaphi = 6.283185308 - deltaphi; + deltaR = abs(sqrt(pow((ielec->eta() - (*itrk)->momentum().eta()), 2) + pow(deltaphi, 2))); + if (deltaR < deltaRMIN) { + deltaRMIN = deltaR; + } + } + // std::cout<<" matchElectrons:DeltaR "<::iterator JetBaseRefIterator; std::vector theJets = reco::JetTracksAssociation::allJets(jtV0); @@ -1407,292 +1419,297 @@ void JetPlusTrackCorrector::rebuildJta( const reco::Jet& fJet, TrackRefs tracks = tracksthis; tracksthis.clear(); -// std::cout<<" JetPlusTrackCorrector::rebuildJta:Size of initial vector "<4.*atan(1.))dfi = 8.*atan(1.)-dfi; - // double deta = fJet.eta() - (**it).eta(); - // double dR2check = sqrt(dfi*dfi+deta*deta); - - double scalethis = dR2this; - if(jetSplitMerge_ == 0) scalethis = 1.*jetEtIn; - if(jetSplitMerge_ == 2) scalethis = dR2this*jetEtIn; - tr++; - int flag = 1; - for(JetBaseRefIterator ii = theJets.begin(); ii != theJets.end(); ii++) - { - if(&(**ii) == &fJet ) {continue;} - double dR2 = deltaR2( (*ii)->eta(), (*ii)->phi(), trkEta, trkPhi ); - double scale = dR2; - if(jetSplitMerge_ == 0) scale = 1./(**ii).et(); - if(jetSplitMerge_ == 2) scale = dR2/(**ii).et(); - if(scale < scalethis) flag = 0; - - if(flag == 0) { - //std::cout<<" Track belong to another jet also "<et()<<" "<<(*ii)->eta()<<" "<< (*ii)->phi()<<" Track "<<(**it).eta()<<" "<<(**it).phi()<<" "<4.*atan(1.))dfi = 8.*atan(1.)-dfi; + // double deta = fJet.eta() - (**it).eta(); + // double dR2check = sqrt(dfi*dfi+deta*deta); + + double scalethis = dR2this; + if (jetSplitMerge_ == 0) + scalethis = 1. * jetEtIn; + if (jetSplitMerge_ == 2) + scalethis = dR2this * jetEtIn; + tr++; + int flag = 1; + for (JetBaseRefIterator ii = theJets.begin(); ii != theJets.end(); ii++) { + if (&(**ii) == &fJet) { + continue; + } + double dR2 = deltaR2((*ii)->eta(), (*ii)->phi(), trkEta, trkPhi); + double scale = dR2; + if (jetSplitMerge_ == 0) + scale = 1. / (**ii).et(); + if (jetSplitMerge_ == 2) + scale = dR2 / (**ii).et(); + if (scale < scalethis) + flag = 0; + + if (flag == 0) { + //std::cout<<" Track belong to another jet also "<et()<<" "<<(*ii)->eta()<<" "<< (*ii)->phi()<<" Track "<<(**it).eta()<<" "<<(**it).phi()<<" "< - - for( reco::TrackRefVector::iterator iBgtC = trBgOutOfCalo.begin(); iBgtC != trBgOutOfCalo.end(); iBgtC++) - { - // Temporary solution>>>>>> Remove tracks with pt>50 GeV - // if( (**iBgtC).pt() >= 50. ) continue; - //response_.value(ieta,ipt); - double eta = fabs( (**iBgtC).eta() ); - double pt = fabs( (**iBgtC).pt() ); - uint32_t ieta = response_.etaBin( eta ); - uint32_t ipt = response_.ptBin( pt ); - - if(fabs(fJet.eta() -(**iBgtC).eta()) > mConeSize) continue; +double JetPlusTrackCorrector::correctAA(const reco::Jet& fJet, + const reco::TrackRefVector& trBgOutOfVertex, + double& mConeSize, + const reco::TrackRefVector& pioninin, + const reco::TrackRefVector& pioninout, + double ja, + const reco::TrackRefVector& trBgOutOfCalo) const { + double mScale = 1.; + double NewResponse = fJet.energy(); + + //std::cout<<"---JetPlusTrackCorrector::correctAA, Jet initial: NewResponse="< -//=================================================================> + for (reco::TrackRefVector::iterator iBgtC = trBgOutOfCalo.begin(); iBgtC != trBgOutOfCalo.end(); iBgtC++) { + // Temporary solution>>>>>> Remove tracks with pt>50 GeV + // if( (**iBgtC).pt() >= 50. ) continue; + //response_.value(ieta,ipt); + double eta = fabs((**iBgtC).eta()); + double pt = fabs((**iBgtC).pt()); + uint32_t ieta = response_.etaBin(eta); + uint32_t ipt = response_.ptBin(pt); -//=================================================================> -// Look for in-out tracks - - double en = 0.; - double px = 0.; - double py = 0.; - double pz = 0.; - - for(reco::TrackRefVector::const_iterator it = pioninout.begin(); it != pioninout.end(); it++) { - -// std::cout<<" Track in out, size= "< + } // Response of BG tracks -//=> -// double SquareEtaRingWithoutJets = 4*(M_PI*mConeSize - mConeSize*mConeSize); - double SquareEtaRingWithoutJets = ja; - -// std::cout<<"---SquareEtaRingWithoutJets="< + //=================================================================> + // Look for in-out tracks - EnergyOfBackgroundCharged = M_PI*mConeSize*mConeSize*EnergyOfBackgroundCharged; - ResponseOfBackgroundCharged = M_PI*mConeSize*mConeSize*ResponseOfBackgroundCharged; -// NumberOfBackgroundCharged = M_PI*mConeSize*mConeSize*NumberOfBackgroundCharged; + double en = 0.; + double px = 0.; + double py = 0.; + double pz = 0.; + for (reco::TrackRefVector::const_iterator it = pioninout.begin(); it != pioninout.end(); it++) { + // std::cout<<" Track in out, size= "< eta(ieta) && ( ieta+1 == nEtaBins() || val < eta(ieta+1) ) ) { return ieta; } +uint32_t Map::etaBin(double val) const { + val = fabs(val); + for (uint32_t ieta = 0; ieta < nEtaBins() - 1; ++ieta) { //@@ "-1" is bug? + if (val > eta(ieta) && (ieta + 1 == nEtaBins() || val < eta(ieta + 1))) { + return ieta; + } } return nEtaBins(); } // ----------------------------------------------------------------------------- // -uint32_t Map::ptBin( double val ) const { - val = fabs( val ); - for ( uint32_t ipt = 0; ipt < nPtBins()-1; ++ipt ) { //@@ "-1" is bug? - if ( val > pt(ipt) && ( (ipt+1) == nPtBins() || val < pt(ipt+1) ) ) { return ipt; } +uint32_t Map::ptBin(double val) const { + val = fabs(val); + for (uint32_t ipt = 0; ipt < nPtBins() - 1; ++ipt) { //@@ "-1" is bug? + if (val > pt(ipt) && ((ipt + 1) == nPtBins() || val < pt(ipt + 1))) { + return ipt; + } } return nPtBins(); } // ----------------------------------------------------------------------------- // -double Map::value( uint32_t eta_bin, uint32_t pt_bin ) const { - if ( eta_bin < data_.size() && - pt_bin < ( data_.empty() ? 0 : data_[0].size() ) ) { return data_[eta_bin][pt_bin]; } - else { -// edm::LogWarning("JetPlusTrackCorrector") -// << "[jpt::Map::" << __func__ << "]" -// << " Trying to access element (" << eta_bin << "," << pt_bin << ")" -// << " of a vector with size (" << data_.size() << "," << ( data_.empty() ? 0 : data_[0].size() ) << ")" -// << "!"; - return 1.; +double Map::value(uint32_t eta_bin, uint32_t pt_bin) const { + if (eta_bin < data_.size() && pt_bin < (data_.empty() ? 0 : data_[0].size())) { + return data_[eta_bin][pt_bin]; + } else { + // edm::LogWarning("JetPlusTrackCorrector") + // << "[jpt::Map::" << __func__ << "]" + // << " Trying to access element (" << eta_bin << "," << pt_bin << ")" + // << " of a vector with size (" << data_.size() << "," << ( data_.empty() ? 0 : data_[0].size() ) << ")" + // << "!"; + return 1.; } } // ----------------------------------------------------------------------------- // -void Map::print( std::stringstream& ss ) const { - ss << " Number of bins in eta : " << data_.size() << std::endl - << " Number of bins in pt : " << ( data_.empty() ? 0 : data_[0].size() ) << std::endl; +void Map::print(std::stringstream& ss) const { + ss << " Number of bins in eta : " << data_.size() << std::endl + << " Number of bins in pt : " << (data_.empty() ? 0 : data_[0].size()) << std::endl; VVDouble::const_iterator ieta = data_.begin(); VVDouble::const_iterator jeta = data_.end(); - for ( ; ieta != jeta; ++ieta ) { + for (; ieta != jeta; ++ieta) { VDouble::const_iterator ipt = ieta->begin(); VDouble::const_iterator jpt = ieta->end(); - for ( ; ipt != jpt; ++ipt ) { - uint32_t eta_bin = static_cast( ieta - data_.begin() ); - uint32_t pt_bin = static_cast( ipt - ieta->begin() ); - ss << " EtaBinNumber: " << eta_bin - << " PtBinNumber: " << pt_bin - << " EtaValue: " << eta_[ eta_bin ] - << " PtValue: " << pt_[ pt_bin ] - << " Value: " << data_[eta_bin][pt_bin] - << std::endl; + for (; ipt != jpt; ++ipt) { + uint32_t eta_bin = static_cast(ieta - data_.begin()); + uint32_t pt_bin = static_cast(ipt - ieta->begin()); + ss << " EtaBinNumber: " << eta_bin << " PtBinNumber: " << pt_bin << " EtaValue: " << eta_[eta_bin] + << " PtValue: " << pt_[pt_bin] << " Value: " << data_[eta_bin][pt_bin] << std::endl; } } } // ----------------------------------------------------------------------------- // -MatchedTracks::MatchedTracks() - : inVertexInCalo_(), - outOfVertexInCalo_(), - inVertexOutOfCalo_() -{ - clear(); -} +MatchedTracks::MatchedTracks() : inVertexInCalo_(), outOfVertexInCalo_(), inVertexOutOfCalo_() { clear(); } // ----------------------------------------------------------------------------- // -MatchedTracks::~MatchedTracks() { - clear(); -} +MatchedTracks::~MatchedTracks() { clear(); } // ----------------------------------------------------------------------------- // @@ -1873,21 +1875,14 @@ void MatchedTracks::clear() { outOfVertexInCalo_.clear(); inVertexOutOfCalo_.clear(); } - + // ----------------------------------------------------------------------------- // -JetTracks::JetTracks() - : vertex_(), - caloFace_() -{ - clear(); -} +JetTracks::JetTracks() : vertex_(), caloFace_() { clear(); } // ----------------------------------------------------------------------------- // -JetTracks::~JetTracks() { - clear(); -} +JetTracks::~JetTracks() { clear(); } // ----------------------------------------------------------------------------- // @@ -1898,98 +1893,107 @@ void JetTracks::clear() { // ----------------------------------------------------------------------------- // -Efficiency::Efficiency( const jpt::Map& response, - const jpt::Map& efficiency, - const jpt::Map& leakage ) - : response_(response), - efficiency_(efficiency), - leakage_(leakage) -{ +Efficiency::Efficiency(const jpt::Map& response, const jpt::Map& efficiency, const jpt::Map& leakage) + : response_(response), efficiency_(efficiency), leakage_(leakage) { reset(); } // ----------------------------------------------------------------------------- // -double Efficiency::inConeCorr( uint32_t eta_bin, uint32_t pt_bin ) const { - if ( check(eta_bin,pt_bin,__func__) ) { - return ( outOfConeCorr( eta_bin, pt_bin ) * - leakage_.value( eta_bin, pt_bin ) * - response_.value( eta_bin, pt_bin ) ); - } else { return 0.; } +double Efficiency::inConeCorr(uint32_t eta_bin, uint32_t pt_bin) const { + if (check(eta_bin, pt_bin, __func__)) { + return (outOfConeCorr(eta_bin, pt_bin) * leakage_.value(eta_bin, pt_bin) * response_.value(eta_bin, pt_bin)); + } else { + return 0.; + } } // ----------------------------------------------------------------------------- // -double Efficiency::outOfConeCorr( uint32_t eta_bin, uint32_t pt_bin ) const { - if ( check(eta_bin,pt_bin,__func__) ) { - uint16_t ntrks = nTrks( eta_bin, pt_bin ); - double mean = meanE( eta_bin, pt_bin ); - double eff = ( 1. - efficiency_.value( eta_bin, pt_bin ) ) / efficiency_.value( eta_bin, pt_bin ); - if ( !ntrks ) { return 0.; } - return ( ntrks * eff * mean ); - } else { return 0.; } +double Efficiency::outOfConeCorr(uint32_t eta_bin, uint32_t pt_bin) const { + if (check(eta_bin, pt_bin, __func__)) { + uint16_t ntrks = nTrks(eta_bin, pt_bin); + double mean = meanE(eta_bin, pt_bin); + double eff = (1. - efficiency_.value(eta_bin, pt_bin)) / efficiency_.value(eta_bin, pt_bin); + if (!ntrks) { + return 0.; + } + return (ntrks * eff * mean); + } else { + return 0.; + } } // ----------------------------------------------------------------------------- // -uint16_t Efficiency::nTrks( uint32_t eta_bin, uint32_t pt_bin ) const { - if ( check(eta_bin,pt_bin,__func__) ) { - return data_[eta_bin][pt_bin].first; - } else { return 0; } +uint16_t Efficiency::nTrks(uint32_t eta_bin, uint32_t pt_bin) const { + if (check(eta_bin, pt_bin, __func__)) { + return data_[eta_bin][pt_bin].first; + } else { + return 0; + } } // ----------------------------------------------------------------------------- // -double Efficiency::sumE( uint32_t eta_bin, uint32_t pt_bin ) const { - if ( check(eta_bin,pt_bin,__func__) ) { - return data_[eta_bin][pt_bin].second; - } else { return 0.; } +double Efficiency::sumE(uint32_t eta_bin, uint32_t pt_bin) const { + if (check(eta_bin, pt_bin, __func__)) { + return data_[eta_bin][pt_bin].second; + } else { + return 0.; + } } // ----------------------------------------------------------------------------- // -double Efficiency::meanE( uint32_t eta_bin, uint32_t pt_bin ) const { - if ( check(eta_bin,pt_bin,__func__) ) { - Pair tmp = data_[eta_bin][pt_bin]; - if ( tmp.first ) { return tmp.second / tmp.first; } - else { return 0.; } - } else { return 0.; } +double Efficiency::meanE(uint32_t eta_bin, uint32_t pt_bin) const { + if (check(eta_bin, pt_bin, __func__)) { + Pair tmp = data_[eta_bin][pt_bin]; + if (tmp.first) { + return tmp.second / tmp.first; + } else { + return 0.; + } + } else { + return 0.; + } } // ----------------------------------------------------------------------------- // -void Efficiency::addE( uint32_t eta_bin, uint32_t pt_bin, double energy ) { - if ( check(eta_bin,pt_bin,__func__) ) { - data_[eta_bin][pt_bin].first++; +void Efficiency::addE(uint32_t eta_bin, uint32_t pt_bin, double energy) { + if (check(eta_bin, pt_bin, __func__)) { + data_[eta_bin][pt_bin].first++; data_[eta_bin][pt_bin].second += energy; - } + } } // ----------------------------------------------------------------------------- // -bool Efficiency::check( uint32_t eta_bin, uint32_t pt_bin, std::string method ) const { - if ( eta_bin < data_.size() && pt_bin < ( data_.empty() ? 0 : data_[0].size() ) ) { return true; } - else { -// edm::LogWarning("JetPlusTrackCorrector") -// << "[jpt::Efficiency::" << method << "]" -// << " Trying to access element (" << eta_bin << "," << pt_bin << ")" -// << " of a vector with size (" << data_.size() << "," << ( data_.empty() ? 0 : data_[0].size() ) << ")" -// << "!"; - return false; +bool Efficiency::check(uint32_t eta_bin, uint32_t pt_bin, std::string method) const { + if (eta_bin < data_.size() && pt_bin < (data_.empty() ? 0 : data_[0].size())) { + return true; + } else { + // edm::LogWarning("JetPlusTrackCorrector") + // << "[jpt::Efficiency::" << method << "]" + // << " Trying to access element (" << eta_bin << "," << pt_bin << ")" + // << " of a vector with size (" << data_.size() << "," << ( data_.empty() ? 0 : data_[0].size() ) << ")" + // << "!"; + return false; } } // ----------------------------------------------------------------------------- // -void Efficiency::reset() { +void Efficiency::reset() { data_.clear(); - data_.resize( response_.nEtaBins(), VPair( response_.nPtBins(), Pair(0,0.) ) ); + data_.resize(response_.nEtaBins(), VPair(response_.nPtBins(), Pair(0, 0.))); } // ----------------------------------------------------------------------------- // -void Efficiency::print() const { - if ( edm::isDebugEnabled() ) { +void Efficiency::print() const { + if (edm::isDebugEnabled()) { std::stringstream ss; ss << "[jpt::Efficiency::" << __func__ << "]" << " Contents of maps:" << std::endl; @@ -2000,5 +2004,5 @@ void Efficiency::print() const { ss << "Leakage map: " << std::endl; leakage_.print(ss); LogTrace("JetPlusTrackCorrector") << ss.str(); - } + } } diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.h b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.h index cbc7c103ede92..199df18e6b0bd 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.h +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.h @@ -33,100 +33,90 @@ namespace edm { class Event; class EventSetup; class ParameterSet; -} +} // namespace edm // -------------------------------------------------------- // -------------------- Helper classes -------------------- // -------------------------------------------------------- - namespace jpt { - + /// Container class for response & efficiency maps class Map { - public: - - Map( std::string, bool verbose = false ); + Map(std::string, bool verbose = false); Map(); ~Map(); - + uint32_t nEtaBins() const; uint32_t nPtBins() const; - - double eta( uint32_t ) const; - double pt( uint32_t ) const; - - uint32_t etaBin( double eta ) const; - uint32_t ptBin( double pt ) const; - - double value( uint32_t eta_bin, uint32_t pt_bin ) const; - - double binCenterEta( uint32_t ) const; - double binCenterPt( uint32_t ) const; - + + double eta(uint32_t) const; + double pt(uint32_t) const; + + uint32_t etaBin(double eta) const; + uint32_t ptBin(double pt) const; + + double value(uint32_t eta_bin, uint32_t pt_bin) const; + + double binCenterEta(uint32_t) const; + double binCenterPt(uint32_t) const; + void clear(); - void print( std::stringstream& ss ) const; + void print(std::stringstream& ss) const; private: - class Element { public: - Element() : ieta_(0), ipt_(0), eta_(0.), pt_(0.), val_(0.) {;} + Element() : ieta_(0), ipt_(0), eta_(0.), pt_(0.), val_(0.) { ; } uint32_t ieta_; uint32_t ipt_; double eta_; double pt_; double val_; }; - + typedef std::vector VDouble; typedef std::vector VVDouble; - + std::vector eta_; std::vector pt_; VVDouble data_; - }; inline uint32_t Map::nEtaBins() const { return eta_.size(); } inline uint32_t Map::nPtBins() const { return pt_.size(); } - - /// Generic container class - class Efficiency { + /// Generic container class + class Efficiency { public: + Efficiency(const jpt::Map& response, const jpt::Map& efficiency, const jpt::Map& leakage); + + typedef std::pair Pair; + + uint16_t nTrks(uint32_t eta_bin, uint32_t pt_bin) const; + + double inConeCorr(uint32_t eta_bin, uint32_t pt_bin) const; + double outOfConeCorr(uint32_t eta_bin, uint32_t pt_bin) const; - Efficiency( const jpt::Map& response, - const jpt::Map& efficiency, - const jpt::Map& leakage ); - - typedef std::pair Pair; - - uint16_t nTrks( uint32_t eta_bin, uint32_t pt_bin ) const; - - double inConeCorr( uint32_t eta_bin, uint32_t pt_bin ) const; - double outOfConeCorr( uint32_t eta_bin, uint32_t pt_bin ) const; - uint32_t nEtaBins() const; uint32_t nPtBins() const; uint32_t size() const; bool empty() const; - - void addE( uint32_t eta_bin, uint32_t pt_bin, double energy ); + + void addE(uint32_t eta_bin, uint32_t pt_bin, double energy); void reset(); - + void print() const; - + private: - Efficiency() = delete; - double sumE( uint32_t eta_bin, uint32_t pt_bin ) const; - double meanE( uint32_t eta_bin, uint32_t pt_bin ) const; + double sumE(uint32_t eta_bin, uint32_t pt_bin) const; + double meanE(uint32_t eta_bin, uint32_t pt_bin) const; - bool check( uint32_t eta_bin, uint32_t pt_bin, std::string name = "check" ) const; + bool check(uint32_t eta_bin, uint32_t pt_bin, std::string name = "check") const; typedef std::vector VPair; typedef std::vector VVPair; @@ -135,9 +125,8 @@ namespace jpt { const jpt::Map& response_; const jpt::Map& efficiency_; const jpt::Map& leakage_; - }; - + inline uint32_t Efficiency::nEtaBins() const { return response_.nEtaBins(); } inline uint32_t Efficiency::nPtBins() const { return response_.nPtBins(); } inline uint32_t Efficiency::size() const { return data_.size(); } @@ -161,19 +150,18 @@ namespace jpt { void clear(); reco::TrackRefVector inVertexInCalo_; reco::TrackRefVector outOfVertexInCalo_; - reco::TrackRefVector inVertexOutOfCalo_; + reco::TrackRefVector inVertexOutOfCalo_; }; - -//class Sum { -//public: -// Sum() { theResponseOfChargedWithEff = 0.; theResponseOfChargedFull = 0.;} -// void set( double a, double b) const {theResponseOfChargedWithEff=a;theResponseOfChargedFull=b;} -// double theResponseOfChargedWithEff; -// double theResponseOfChargedFull; -//}; -} + //class Sum { + //public: + // Sum() { theResponseOfChargedWithEff = 0.; theResponseOfChargedFull = 0.;} + // void set( double a, double b) const {theResponseOfChargedWithEff=a;theResponseOfChargedFull=b;} + // double theResponseOfChargedWithEff; + // double theResponseOfChargedFull; + //}; +} // namespace jpt // ------------------------------------------------------- // -------------------- JPT algorithm -------------------- @@ -183,120 +171,126 @@ namespace jpt { \brief Jet energy correction algorithm using tracks */ class JetPlusTrackCorrector { - // ---------- Public interface ---------- - - public: +public: /// Constructor - JetPlusTrackCorrector( const edm::ParameterSet& iPS, edm::ConsumesCollector&& iC ); + JetPlusTrackCorrector(const edm::ParameterSet& iPS, edm::ConsumesCollector&& iC); /// Destructor virtual ~JetPlusTrackCorrector(); // Typedefs for 4-momentum - typedef math::XYZTLorentzVector P4; + typedef math::XYZTLorentzVector P4; typedef math::PtEtaPhiELorentzVectorD PtEtaPhiE; typedef math::PtEtaPhiMLorentzVectorD PtEtaPhiM; - + /// Vectorial correction method (corrected 4-momentum passed by reference) - double correction( const reco::Jet&, const reco::Jet&, const edm::Event&, const edm::EventSetup&, P4&, - jpt::MatchedTracks &pions, - jpt::MatchedTracks &muons, - jpt::MatchedTracks &elecs, - bool &validMatches) ; - double correction( const reco::Jet&, const reco::Jet&, const edm::Event&, - const edm::EventSetup&, - const reco::TrackRefVector& tracksinvert, - const reco::TrackRefVector& tracksincalo, - P4&, - jpt::MatchedTracks &pions, - jpt::MatchedTracks &muons, - jpt::MatchedTracks &elecs - ) ; - + double correction(const reco::Jet&, + const reco::Jet&, + const edm::Event&, + const edm::EventSetup&, + P4&, + jpt::MatchedTracks& pions, + jpt::MatchedTracks& muons, + jpt::MatchedTracks& elecs, + bool& validMatches); + double correction(const reco::Jet&, + const reco::Jet&, + const edm::Event&, + const edm::EventSetup&, + const reco::TrackRefVector& tracksinvert, + const reco::TrackRefVector& tracksincalo, + P4&, + jpt::MatchedTracks& pions, + jpt::MatchedTracks& muons, + jpt::MatchedTracks& elecs); + /// Scalar correction method - double correction( const reco::Jet&, const reco::Jet&, const edm::Event&, const edm::EventSetup&, - jpt::MatchedTracks &pions, - jpt::MatchedTracks &muons, - jpt::MatchedTracks &elecs, - bool &validMatches) ; - + double correction(const reco::Jet&, + const reco::Jet&, + const edm::Event&, + const edm::EventSetup&, + jpt::MatchedTracks& pions, + jpt::MatchedTracks& muons, + jpt::MatchedTracks& elecs, + bool& validMatches); + /// Correction method (not used) - double correction( const reco::Jet& ) const; + double correction(const reco::Jet&) const; /// Correction method (not used) - double correction( const P4& ) const; + double correction(const P4&) const; /// For AA - correct in tracker - -// double correctAA( const reco::Jet&, const reco::TrackRefVector&, double&, const reco::TrackRefVector&,const reco::TrackRefVector&, double&) const; - double correctAA( const reco::Jet&, const reco::TrackRefVector&, double&, const reco::TrackRefVector&,const reco::TrackRefVector&, - double, - const reco::TrackRefVector&) const; - + // double correctAA( const reco::Jet&, const reco::TrackRefVector&, double&, const reco::TrackRefVector&,const reco::TrackRefVector&, double&) const; + double correctAA(const reco::Jet&, + const reco::TrackRefVector&, + double&, + const reco::TrackRefVector&, + const reco::TrackRefVector&, + double, + const reco::TrackRefVector&) const; + /// Returns true bool eventRequired() const; - + /// Returns value of configurable bool vectorialCorrection() const; - + // ---------- Extended interface ---------- /// Get responses/sumPT/SumEnergy with and without Efficiency correction - double getResponseOfChargedWithEff() {return theResponseOfChargedWithEff;} - double getResponseOfChargedWithoutEff() {return theResponseOfChargedWithoutEff;} - double getSumPtWithEff() {return theSumPtWithEff;} - double getSumPtWithoutEff() {return theSumPtWithoutEff;} - double getSumEnergyWithEff() {return theSumEnergyWithEff;} - double getSumEnergyWithoutEff() {return theSumEnergyWithoutEff;} - double getSumPtForBeta() {return theSumPtForBeta;} - + double getResponseOfChargedWithEff() { return theResponseOfChargedWithEff; } + double getResponseOfChargedWithoutEff() { return theResponseOfChargedWithoutEff; } + double getSumPtWithEff() { return theSumPtWithEff; } + double getSumPtWithoutEff() { return theSumPtWithoutEff; } + double getSumEnergyWithEff() { return theSumEnergyWithEff; } + double getSumEnergyWithoutEff() { return theSumEnergyWithoutEff; } + double getSumPtForBeta() { return theSumPtForBeta; } /// Can jet be JPT-corrected? - bool canCorrect( const reco::Jet& ) const; - - /// Matches tracks to different particle types - bool matchTracks( const reco::Jet&, - const edm::Event&, - const edm::EventSetup&, - jpt::MatchedTracks& pions, - jpt::MatchedTracks& muons, - jpt::MatchedTracks& elecs ) ; - - bool matchTracks( const reco::Jet&, - const edm::Event&, - const edm::EventSetup&, - const reco::TrackRefVector& tracksinvert, - const reco::TrackRefVector& tracksincalo, - jpt::MatchedTracks& pions, - jpt::MatchedTracks& muons, - jpt::MatchedTracks& elecs ) ; + bool canCorrect(const reco::Jet&) const; + + /// Matches tracks to different particle types + bool matchTracks(const reco::Jet&, + const edm::Event&, + const edm::EventSetup&, + jpt::MatchedTracks& pions, + jpt::MatchedTracks& muons, + jpt::MatchedTracks& elecs); + + bool matchTracks(const reco::Jet&, + const edm::Event&, + const edm::EventSetup&, + const reco::TrackRefVector& tracksinvert, + const reco::TrackRefVector& tracksincalo, + jpt::MatchedTracks& pions, + jpt::MatchedTracks& muons, + jpt::MatchedTracks& elecs); - /// Calculates corrections to be applied using pions - P4 pionCorrection( const P4& jet, const jpt::MatchedTracks& pions ) ; - + P4 pionCorrection(const P4& jet, const jpt::MatchedTracks& pions); + /// Calculates correction to be applied using muons - P4 muonCorrection( const P4& jet, const jpt::MatchedTracks& muons ) ; - + P4 muonCorrection(const P4& jet, const jpt::MatchedTracks& muons); + /// Calculates correction to be applied using electrons - P4 elecCorrection( const P4& jet, const jpt::MatchedTracks& elecs ) const; + P4 elecCorrection(const P4& jet, const jpt::MatchedTracks& elecs) const; /// Get reponses - -// double theResponseOfChargedWithEff; -// double theResponseOfChargedFull; -// double setResp(double a) const {return a;} -// double getChargedResponsesWithEff() { return theResponseOfChargedWithEff;} -// double getChargedResponsesFull() { return theResponseOfChargedFull;} - - // ---------- Protected interface ---------- - protected: + // double theResponseOfChargedWithEff; + // double theResponseOfChargedFull; + // double setResp(double a) const {return a;} + // double getChargedResponsesWithEff() { return theResponseOfChargedWithEff;} + // double getChargedResponsesFull() { return theResponseOfChargedFull;} + + // ---------- Protected interface ---------- +protected: // Some useful typedefs typedef reco::MuonCollection RecoMuons; typedef reco::GsfElectronCollection RecoElectrons; @@ -305,139 +299,106 @@ class JetPlusTrackCorrector { typedef reco::TrackRefVector TrackRefs; /// Associates tracks to jets (overriden in derived class) - virtual bool jetTrackAssociation( const reco::Jet&, - const edm::Event&, - const edm::EventSetup&, - jpt::JetTracks& ) const; - + virtual bool jetTrackAssociation(const reco::Jet&, const edm::Event&, const edm::EventSetup&, jpt::JetTracks&) const; + /// JTA using collections from event - bool jtaUsingEventData( const reco::Jet&, - const edm::Event&, - jpt::JetTracks& ) const; - + bool jtaUsingEventData(const reco::Jet&, const edm::Event&, jpt::JetTracks&) const; + /// Matches tracks to different particle types (overriden in derived class) - virtual void matchTracks( const jpt::JetTracks&, - const edm::Event&, - jpt::MatchedTracks& pions, - jpt::MatchedTracks& muons, - jpt::MatchedTracks& elecs ) ; + virtual void matchTracks(const jpt::JetTracks&, + const edm::Event&, + jpt::MatchedTracks& pions, + jpt::MatchedTracks& muons, + jpt::MatchedTracks& elecs); /// Calculates individual pion corrections - P4 pionCorrection( const P4& jet, - const TrackRefs& pions, - jpt::Efficiency&, - bool in_cone_at_vertex, - bool in_cone_at_calo_face ) ; + P4 pionCorrection( + const P4& jet, const TrackRefs& pions, jpt::Efficiency&, bool in_cone_at_vertex, bool in_cone_at_calo_face); /// Calculates individual muons corrections - P4 muonCorrection( const P4& jet, - const TrackRefs& muons, - bool in_cone_at_vertex, - bool in_cone_at_calo_face ) ; - + P4 muonCorrection(const P4& jet, const TrackRefs& muons, bool in_cone_at_vertex, bool in_cone_at_calo_face); + /// Calculates individual electron corrections - P4 elecCorrection( const P4& jet, - const TrackRefs& elecs, - bool in_cone_at_vertex, - bool in_cone_at_calo_face ) ; + P4 elecCorrection(const P4& jet, const TrackRefs& elecs, bool in_cone_at_vertex, bool in_cone_at_calo_face); /// Calculates vectorial correction using total track 3-momentum - P4 jetDirFromTracks( const P4& jet, - const jpt::MatchedTracks& pions, - const jpt::MatchedTracks& muons, - const jpt::MatchedTracks& elecs ) const; - + P4 jetDirFromTracks(const P4& jet, + const jpt::MatchedTracks& pions, + const jpt::MatchedTracks& muons, + const jpt::MatchedTracks& elecs) const; + /// Generic method to calculates 4-momentum correction to be applied - P4 calculateCorr( const P4& jet, - const TrackRefs&, - jpt::Efficiency&, - bool in_cone_at_vertex, - bool in_cone_at_calo_face, - double mass, - bool is_pion, - double mip ) ; - - /// Correction to be applied using tracking efficiency - P4 pionEfficiency( const P4& jet, - const jpt::Efficiency&, - bool in_cone_at_calo_face ) ; - + P4 calculateCorr(const P4& jet, + const TrackRefs&, + jpt::Efficiency&, + bool in_cone_at_vertex, + bool in_cone_at_calo_face, + double mass, + bool is_pion, + double mip); + + /// Correction to be applied using tracking efficiency + P4 pionEfficiency(const P4& jet, const jpt::Efficiency&, bool in_cone_at_calo_face); + /// Check corrected 4-momentum does not give negative scale - double checkScale( const P4& jet, P4& corrected ) const; - + double checkScale(const P4& jet, P4& corrected) const; + /// Get RECO muons - bool getMuons( const edm::Event&, edm::Handle& ) const; + bool getMuons(const edm::Event&, edm::Handle&) const; - bool getMuons( const edm::Event&, edm::Handle& ) const; + bool getMuons(const edm::Event&, edm::Handle&) const; /// Get RECO electrons - bool getElectrons( const edm::Event&, - edm::Handle&, - edm::Handle& ) const; + bool getElectrons(const edm::Event&, edm::Handle&, edm::Handle&) const; + + bool getElectrons(const edm::Event&, edm::Handle&) const; - bool getElectrons( const edm::Event&, - edm::Handle&) const; - /// Matches tracks to RECO muons - bool matchMuons( TrackRefs::const_iterator&, - const edm::Handle& ) const; - bool matchMuons( TrackRefs::const_iterator&, - const edm::Handle& ) const; - - + bool matchMuons(TrackRefs::const_iterator&, const edm::Handle&) const; + bool matchMuons(TrackRefs::const_iterator&, const edm::Handle&) const; + /// Matches tracks to RECO electrons - bool matchElectrons( TrackRefs::const_iterator&, - const edm::Handle&, - const edm::Handle& ) const; - bool matchElectrons( TrackRefs::const_iterator&, - const edm::Handle& - ) const; - + bool matchElectrons(TrackRefs::const_iterator&, + const edm::Handle&, + const edm::Handle&) const; + bool matchElectrons(TrackRefs::const_iterator&, const edm::Handle&) const; + /// Check on track quality - bool failTrackQuality( TrackRefs::const_iterator& ) const; + bool failTrackQuality(TrackRefs::const_iterator&) const; /// Find track in JetTracks collection - bool findTrack( const jpt::JetTracks&, - TrackRefs::const_iterator&, - TrackRefs::iterator& ) const; + bool findTrack(const jpt::JetTracks&, TrackRefs::const_iterator&, TrackRefs::iterator&) const; /// Find track in MatchedTracks collections - bool findTrack( const jpt::MatchedTracks& pions, - const jpt::MatchedTracks& muons, - const jpt::MatchedTracks& electrons, - TrackRefs::const_iterator& ) const; + bool findTrack(const jpt::MatchedTracks& pions, + const jpt::MatchedTracks& muons, + const jpt::MatchedTracks& electrons, + TrackRefs::const_iterator&) const; /// Determines if any tracks in cone at CaloFace - bool tracksInCalo( const jpt::MatchedTracks& pions, - const jpt::MatchedTracks& muons, - const jpt::MatchedTracks& elecs ) const; - - /// Rebuild jet-track association - void rebuildJta( const reco::Jet&, - const JetTracksAssociations&, - TrackRefs& included, - TrackRefs& excluded ) const; - - /// Exclude jet-track association - void excludeJta( const reco::Jet&, - const JetTracksAssociations&, - TrackRefs& included, - const TrackRefs& excluded ) const; - + bool tracksInCalo(const jpt::MatchedTracks& pions, + const jpt::MatchedTracks& muons, + const jpt::MatchedTracks& elecs) const; + + /// Rebuild jet-track association + void rebuildJta(const reco::Jet&, const JetTracksAssociations&, TrackRefs& included, TrackRefs& excluded) const; + + /// Exclude jet-track association + void excludeJta(const reco::Jet&, const JetTracksAssociations&, TrackRefs& included, const TrackRefs& excluded) const; + const jpt::Map& responseMap() const; const jpt::Map& efficiencyMap() const; const jpt::Map& leakageMap() const; - + /// Default constructor - JetPlusTrackCorrector() {;} + JetPlusTrackCorrector() { ; } // ---------- Protected member data ---------- - protected: - +protected: // Some general configuration bool verbose_; - bool usereco_; + bool usereco_; bool vectorial_; bool vecResponse_; bool useInConeTracks_; @@ -448,7 +409,7 @@ class JetPlusTrackCorrector { bool useMuons_; bool useElecs_; bool useTrackQuality_; - + // Jet-track association edm::InputTag jetTracksAtVertex_; edm::InputTag jetTracksAtCalo_; @@ -460,20 +421,20 @@ class JetPlusTrackCorrector { // Muons and electrons edm::InputTag muons_; - edm::InputTag electrons_; + edm::InputTag electrons_; edm::InputTag electronIds_; edm::InputTag patmuons_; edm::InputTag patelectrons_; - + // Filter tracks by quality reco::TrackBase::TrackQuality trackQuality_; - // Response and efficiency maps + // Response and efficiency maps const jpt::Map response_; const jpt::Map efficiency_; const jpt::Map leakage_; - // Mass + // Mass double pionMass_; double muonMass_; double elecMass_; @@ -487,64 +448,61 @@ class JetPlusTrackCorrector { float theSumEnergyWithEff; float theSumEnergyWithoutEff; float theSumPtForBeta; - jpt::Efficiency not_used{response_,efficiency_,leakage_}; + jpt::Efficiency not_used{response_, efficiency_, leakage_}; // ---------- Private data members ---------- - private: +private: edm::EDGetTokenT input_jetTracksAtVertex_token_; edm::EDGetTokenT input_jetTracksAtCalo_token_; edm::EDGetTokenT input_reco_muons_token_; edm::EDGetTokenT input_pvCollection_token_; - edm::EDGetTokenT input_reco_elecs_token_; + edm::EDGetTokenT input_reco_elecs_token_; edm::EDGetTokenT input_reco_elec_ids_token_; edm::EDGetTokenT input_pat_muons_token_; edm::EDGetTokenT input_pat_elecs_token_; - }; // ---------- Inline methods ---------- -inline double JetPlusTrackCorrector::correction( const reco::Jet& fJet, const reco::Jet& fJetcalo, - const edm::Event& event, - const edm::EventSetup& setup, - jpt::MatchedTracks &pions, - jpt::MatchedTracks &muons, - jpt::MatchedTracks &elecs, - bool &validMatches) { +inline double JetPlusTrackCorrector::correction(const reco::Jet& fJet, + const reco::Jet& fJetcalo, + const edm::Event& event, + const edm::EventSetup& setup, + jpt::MatchedTracks& pions, + jpt::MatchedTracks& muons, + jpt::MatchedTracks& elecs, + bool& validMatches) { P4 not_used_for_scalar_correction; - return correction( fJet, fJetcalo, event, setup, not_used_for_scalar_correction,pions,muons,elecs,validMatches ); + return correction(fJet, fJetcalo, event, setup, not_used_for_scalar_correction, pions, muons, elecs, validMatches); } inline bool JetPlusTrackCorrector::eventRequired() const { return true; } inline bool JetPlusTrackCorrector::vectorialCorrection() const { return vectorial_; } -inline bool JetPlusTrackCorrector::canCorrect( const reco::Jet& jet ) const { return ( fabs( jet.eta() ) <= maxEta_ ); } - -inline JetPlusTrackCorrector::P4 JetPlusTrackCorrector::pionCorrection( const P4& jet, - const TrackRefs& pions, - jpt::Efficiency& eff, - bool in_cone_at_vertex, - bool in_cone_at_calo_face ) { - return calculateCorr( jet, pions, eff, in_cone_at_vertex, in_cone_at_calo_face, pionMass_, true, -1. ); +inline bool JetPlusTrackCorrector::canCorrect(const reco::Jet& jet) const { return (fabs(jet.eta()) <= maxEta_); } + +inline JetPlusTrackCorrector::P4 JetPlusTrackCorrector::pionCorrection( + const P4& jet, const TrackRefs& pions, jpt::Efficiency& eff, bool in_cone_at_vertex, bool in_cone_at_calo_face) { + return calculateCorr(jet, pions, eff, in_cone_at_vertex, in_cone_at_calo_face, pionMass_, true, -1.); +} + +inline JetPlusTrackCorrector::P4 JetPlusTrackCorrector::muonCorrection(const P4& jet, + const TrackRefs& muons, + bool in_cone_at_vertex, + bool in_cone_at_calo_face) { + return calculateCorr(jet, muons, not_used, in_cone_at_vertex, in_cone_at_calo_face, muonMass_, false, 2.); +} + +inline JetPlusTrackCorrector::P4 JetPlusTrackCorrector::elecCorrection(const P4& jet, + const TrackRefs& elecs, + bool in_cone_at_vertex, + bool in_cone_at_calo_face) { + return calculateCorr(jet, elecs, not_used, in_cone_at_vertex, in_cone_at_calo_face, elecMass_, false, 0.); } -inline JetPlusTrackCorrector::P4 JetPlusTrackCorrector::muonCorrection( const P4& jet, - const TrackRefs& muons, - bool in_cone_at_vertex, - bool in_cone_at_calo_face ) { - return calculateCorr( jet, muons, not_used, in_cone_at_vertex, in_cone_at_calo_face, muonMass_, false, 2. ); -} - -inline JetPlusTrackCorrector::P4 JetPlusTrackCorrector::elecCorrection( const P4& jet, - const TrackRefs& elecs, - bool in_cone_at_vertex, - bool in_cone_at_calo_face ) { - return calculateCorr( jet, elecs, not_used, in_cone_at_vertex, in_cone_at_calo_face, elecMass_, false, 0. ); -} - -inline double JetPlusTrackCorrector::checkScale( const P4& jet, P4& corrected ) const { - if ( jet.energy() > 0. && ( corrected.energy() / jet.energy() ) < 0. ) { - corrected = jet; +inline double JetPlusTrackCorrector::checkScale(const P4& jet, P4& corrected) const { + if (jet.energy() > 0. && (corrected.energy() / jet.energy()) < 0.) { + corrected = jet; } return corrected.energy() / jet.energy(); } @@ -553,4 +511,4 @@ inline const jpt::Map& JetPlusTrackCorrector::responseMap() const { return respo inline const jpt::Map& JetPlusTrackCorrector::efficiencyMap() const { return efficiency_; } inline const jpt::Map& JetPlusTrackCorrector::leakageMap() const { return leakage_; } -#endif // RecoJets_JetPlusTracks_JetPlusTrackCorrector_h +#endif // RecoJets_JetPlusTracks_JetPlusTrackCorrector_h diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc index e5ea873c932c1..a1bd1ff2a44bb 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc @@ -2,7 +2,7 @@ // // Package: JetPlusTracks // Class: JetPlusTrackProducer -// +// /**\class JetPlusTrackProducer JetPlusTrackProducer.cc JetPlusTrackProducer.cc Description: [one line class summary] @@ -16,7 +16,6 @@ // // - // system include files #include @@ -50,7 +49,6 @@ using namespace jpt; // constants, enums and typedefs // - // // static data member definitions // @@ -58,212 +56,211 @@ using namespace jpt; // // constructors and destructor // -JetPlusTrackProducer::JetPlusTrackProducer(const edm::ParameterSet& iConfig) -{ - //register your products - src = iConfig.getParameter("src"); - srcTrackJets = iConfig.getParameter("srcTrackJets"); - alias = iConfig.getUntrackedParameter("alias"); - srcPVs_ = iConfig.getParameter("srcPVs"); - vectorial_ = iConfig.getParameter("VectorialCorrection"); - useZSP = iConfig.getParameter("UseZSP"); - ptCUT = iConfig.getParameter("ptCUT"); - - mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector()); - if(useZSP) mZSPalgo = new ZSPJPTJetCorrector(iConfig); - - produces().setBranchAlias(alias); - produces().setBranchAlias("ak4CaloJetsJPT"); - - input_jets_token_ = consumes >(src); - input_addjets_token_ = consumes >(iConfig.getParameter("srcAddCaloJets")); - input_trackjets_token_ = consumes >(srcTrackJets); - input_vertex_token_ = consumes(srcPVs_); - mExtrapolations = consumes > - (iConfig.getParameter ("extrapolations")); +JetPlusTrackProducer::JetPlusTrackProducer(const edm::ParameterSet& iConfig) { + //register your products + src = iConfig.getParameter("src"); + srcTrackJets = iConfig.getParameter("srcTrackJets"); + alias = iConfig.getUntrackedParameter("alias"); + srcPVs_ = iConfig.getParameter("srcPVs"); + vectorial_ = iConfig.getParameter("VectorialCorrection"); + useZSP = iConfig.getParameter("UseZSP"); + ptCUT = iConfig.getParameter("ptCUT"); + dRcone = iConfig.getParameter("dRcone"); + + mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector()); + if (useZSP) + mZSPalgo = new ZSPJPTJetCorrector(iConfig); + + produces().setBranchAlias(alias); + produces().setBranchAlias("ak4CaloJetsJPT"); + + input_jets_token_ = consumes >(src); + input_addjets_token_ = consumes >(iConfig.getParameter("srcAddCaloJets")); + input_trackjets_token_ = consumes >(srcTrackJets); + input_vertex_token_ = consumes(srcPVs_); + mExtrapolations = + consumes >(iConfig.getParameter("extrapolations")); } - -JetPlusTrackProducer::~JetPlusTrackProducer() -{ - - // do anything here that needs to be done at desctruction time - // (e.g. close files, deallocate resources etc.) - +JetPlusTrackProducer::~JetPlusTrackProducer() { + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) } - // // member functions // -bool sort_by_pt (reco::JPTJet a,reco::JPTJet b) { return (a.pt()>b.pt());} +bool sort_by_pt(reco::JPTJet a, reco::JPTJet b) { return (a.pt() > b.pt()); } // ------------ method called to produce the data ------------ -void -JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) -{ - using namespace edm; +void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + using namespace edm; -// std::cout<<" RecoJets::JetPlusTrackProducer::produce "< > jets_h; - iEvent.getByToken (input_jets_token_, jets_h); + // get stuff from Event + edm::Handle > jets_h; + iEvent.getByToken(input_jets_token_, jets_h); -//JetPlusTrackAddonSeed - edm::Handle > addjets_h; - iEvent.getByToken (input_addjets_token_, addjets_h); + //JetPlusTrackAddonSeed + edm::Handle > addjets_h; + iEvent.getByToken(input_addjets_token_, addjets_h); //std::cout<<" Additional Calojets "<size()< > jetsTrackJets; + edm::Handle > jetsTrackJets; iEvent.getByToken(input_trackjets_token_, jetsTrackJets); //std::cout<<" Additional Trackjets "<size()< > iExtrapolations; - iEvent.getByToken (mExtrapolations, iExtrapolations); + edm::Handle > iExtrapolations; + iEvent.getByToken(mExtrapolations, iExtrapolations); + + edm::RefProd pOut1RefProd = iEvent.getRefBeforePut(); + edm::Ref::key_type idxCaloJet = 0; - edm::RefProd pOut1RefProd = - iEvent.getRefBeforePut(); - edm::Ref::key_type idxCaloJet = 0; - auto pOut = std::make_unique(); auto pOut1 = std::make_unique(); - double scaleJPT = 1.; - std::vector theJPTJets; - if (jetsTrackJets.isValid()) { - if(!jetsTrackJets->empty()) { + double scaleJPT = 1.; + std::vector theJPTJets; + if (jetsTrackJets.isValid()) { + if (!jetsTrackJets->empty()) { for (unsigned ijet = 0; ijet < jetsTrackJets->size(); ++ijet) { - const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet))); - int icalo = -1; - if(addjets_h.isValid()) { + const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet))); + int icalo = -1; + if (addjets_h.isValid()) { for (unsigned i = 0; i < addjets_h->size(); ++i) { - const reco::CaloJet* oldjet = &(*(addjets_h->refAt(i))); - double deta = fabs(jet->eta()-oldjet->eta()); - double dphi = fabs(jet->phi()-oldjet->phi()); - if(dphi>4.*atan(1.)) dphi = 8.*atan(1.) - dphi; - double dr = sqrt(dphi*dphi+deta*deta); - if(dr<=0.4) {icalo=i;} - } // Calojets - } - if(icalo < 0) continue; - const reco::CaloJet* mycalo = &(*(addjets_h->refAt(icalo))); - // std::cout<<" Additional CaloJet "<pt()<<" "<eta()<< - // " "<phi()<refAt(i))); + double deta = fabs(jet->eta() - oldjet->eta()); + double dphi = fabs(jet->phi() - oldjet->phi()); + if (dphi > 4. * atan(1.)) + dphi = 8. * atan(1.) - dphi; + double dr = sqrt(dphi * dphi + deta * deta); + if (dr <= dRcone) { + icalo = i; + } + } // Calojets + } + if (icalo < 0) + continue; + const reco::CaloJet* mycalo = &(*(addjets_h->refAt(icalo))); + // std::cout<<" Additional CaloJet "<pt()<<" "<eta()<< + // " "<phi()< > tracksinjet = jet->tracks(); reco::TrackRefVector tracksincalo; reco::TrackRefVector tracksinvert; - for(std::vector >::iterator itrack = tracksinjet.begin(); - itrack != tracksinjet.end(); itrack++) { - for ( std::vector::const_iterator xtrpBegin = iExtrapolations->begin(), - xtrpEnd = iExtrapolations->end(), ixtrp = xtrpBegin; - ixtrp != xtrpEnd; ++ixtrp ) - { - if ( ixtrp->positions().empty() ) continue; - double mydphi =fabs(ixtrp->track()->phi()-(**itrack).phi()); - if(mydphi>4.*atan(1.)) mydphi = 8.*atan(1)-mydphi; - if(fabs(ixtrp->track()->pt()-(**itrack).pt()) > 0.001 || - fabs(ixtrp->track()->eta()-(**itrack).eta()) > 0.001 || mydphi > 0.001) continue; - tracksinvert.push_back(ixtrp->track()); - reco::TrackBase::Point const & point = ixtrp->positions().at(0); - - double dr = reco::deltaR( jet->eta(), jet->phi(), point.eta(), point.phi() ); - if(dr <= 0.4) { - /*std::cout<<" TrackINcalo "<track()); - } - } // Track extrapolations - } // tracks - - reco::TrackJet corrected = *jet; - math::XYZTLorentzVector p4; - jpt::MatchedTracks pions; - jpt::MatchedTracks muons; - jpt::MatchedTracks elecs; - - scaleJPT = mJPTalgo->correction( corrected, *mycalo, iEvent, iSetup, - tracksinvert, tracksincalo, p4, pions, muons, elecs); - // std::cout<<" JetPlusTrackProducer::AddSeedJet "<< (*mycalo).pt()<<" "<< (*mycalo).eta()<<" "<< - // (*mycalo).phi()<<" "<<(*mycalo).jetArea()<<" Corr "<< - // p4.pt()<<" "< ptCUT) { - reco::JPTJet::Specific jptspe; - jptspe.pionsInVertexInCalo = pions.inVertexInCalo_; - jptspe.pionsInVertexOutCalo = pions.inVertexOutOfCalo_; - jptspe.pionsOutVertexInCalo = pions.outOfVertexInCalo_; - jptspe.muonsInVertexInCalo = muons.inVertexInCalo_; - jptspe.muonsInVertexOutCalo = muons.inVertexOutOfCalo_; - jptspe.muonsOutVertexInCalo = muons.outOfVertexInCalo_; - jptspe.elecsInVertexInCalo = elecs.inVertexInCalo_; - jptspe.elecsInVertexOutCalo = elecs.inVertexOutOfCalo_; - jptspe.elecsOutVertexInCalo = elecs.outOfVertexInCalo_; - reco::CaloJetRef myjet(pOut1RefProd, idxCaloJet++); - jptspe.theCaloJetRef = edm::RefToBase(myjet); - jptspe.mZSPCor = 1.; - reco::JPTJet fJet(p4, jet->primaryVertex()->position(), jptspe, mycalo->getJetConstituents()); - pOut->push_back(fJet); - pOut1->push_back(*mycalo); - theJPTJets.push_back(fJet); - } - } // trackjets - } // jets - } // There is trackjet collection + for (std::vector >::iterator itrack = tracksinjet.begin(); itrack != tracksinjet.end(); + itrack++) { + for (std::vector::const_iterator xtrpBegin = iExtrapolations->begin(), + xtrpEnd = iExtrapolations->end(), + ixtrp = xtrpBegin; + ixtrp != xtrpEnd; + ++ixtrp) { + if (ixtrp->positions().empty()) + continue; + double mydphi = fabs(ixtrp->track()->phi() - (**itrack).phi()); + if (mydphi > 4. * atan(1.)) + mydphi = 8. * atan(1) - mydphi; + if (fabs(ixtrp->track()->pt() - (**itrack).pt()) > 0.001 || + fabs(ixtrp->track()->eta() - (**itrack).eta()) > 0.001 || mydphi > 0.001) + continue; + tracksinvert.push_back(ixtrp->track()); + reco::TrackBase::Point const& point = ixtrp->positions().at(0); + + double dr = reco::deltaR(jet->eta(), jet->phi(), point.eta(), point.phi()); + if (dr <= dRcone) { + /*std::cout<<" TrackINcalo "<track()); + } + } // Track extrapolations + } // tracks + + reco::TrackJet corrected = *jet; + math::XYZTLorentzVector p4; + jpt::MatchedTracks pions; + jpt::MatchedTracks muons; + jpt::MatchedTracks elecs; + + scaleJPT = mJPTalgo->correction( + corrected, *mycalo, iEvent, iSetup, tracksinvert, tracksincalo, p4, pions, muons, elecs); + // std::cout<<" JetPlusTrackProducer::AddSeedJet "<< (*mycalo).pt()<<" "<< (*mycalo).eta()<<" "<< + // (*mycalo).phi()<<" "<<(*mycalo).jetArea()<<" Corr "<< + // p4.pt()<<" "< ptCUT) { + reco::JPTJet::Specific jptspe; + jptspe.pionsInVertexInCalo = pions.inVertexInCalo_; + jptspe.pionsInVertexOutCalo = pions.inVertexOutOfCalo_; + jptspe.pionsOutVertexInCalo = pions.outOfVertexInCalo_; + jptspe.muonsInVertexInCalo = muons.inVertexInCalo_; + jptspe.muonsInVertexOutCalo = muons.inVertexOutOfCalo_; + jptspe.muonsOutVertexInCalo = muons.outOfVertexInCalo_; + jptspe.elecsInVertexInCalo = elecs.inVertexInCalo_; + jptspe.elecsInVertexOutCalo = elecs.inVertexOutOfCalo_; + jptspe.elecsOutVertexInCalo = elecs.outOfVertexInCalo_; + reco::CaloJetRef myjet(pOut1RefProd, idxCaloJet++); + jptspe.theCaloJetRef = edm::RefToBase(myjet); + jptspe.mZSPCor = 1.; + reco::JPTJet fJet(p4, jet->primaryVertex()->position(), jptspe, mycalo->getJetConstituents()); + pOut->push_back(fJet); + pOut1->push_back(*mycalo); + theJPTJets.push_back(fJet); + } + } // trackjets + } // jets + } // There is trackjet collection for (unsigned i = 0; i < jets_h->size(); ++i) { - - const reco::CaloJet* oldjet = &(*(jets_h->refAt(i))); - reco::CaloJet corrected = *oldjet; - -// ZSP corrections - - double factorZSP = 1.; - if(useZSP) factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup); - corrected.scaleEnergy (factorZSP); - -// JPT corrections - scaleJPT = 1.; - - math::XYZTLorentzVector p4; - - jpt::MatchedTracks pions; - jpt::MatchedTracks muons; - jpt::MatchedTracks elecs; - bool ok=false; - - if ( !vectorial_ ) { - - scaleJPT = mJPTalgo->correction ( corrected, *oldjet, iEvent, iSetup, pions, muons, elecs,ok ); - p4 = math::XYZTLorentzVector( corrected.px()*scaleJPT, - corrected.py()*scaleJPT, - corrected.pz()*scaleJPT, - corrected.energy()*scaleJPT ); - // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< (*oldjet).phi()<< - // " "<correction( corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs,ok ); - // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< - // (*oldjet).phi()<<" "<<(*oldjet).jetArea()<<" Corr "<< - // p4.pt()<<" "<refAt(i))); + reco::CaloJet corrected = *oldjet; + + // ZSP corrections + + double factorZSP = 1.; + if (useZSP) + factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup); + corrected.scaleEnergy(factorZSP); + + // JPT corrections + scaleJPT = 1.; + + math::XYZTLorentzVector p4; + + jpt::MatchedTracks pions; + jpt::MatchedTracks muons; + jpt::MatchedTracks elecs; + bool ok = false; + + if (!vectorial_) { + scaleJPT = mJPTalgo->correction(corrected, *oldjet, iEvent, iSetup, pions, muons, elecs, ok); + p4 = math::XYZTLorentzVector(corrected.px() * scaleJPT, + corrected.py() * scaleJPT, + corrected.pz() * scaleJPT, + corrected.energy() * scaleJPT); + // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< (*oldjet).phi()<< + // " "<correction(corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs, ok); + // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< + // (*oldjet).phi()<<" "<<(*oldjet).jetArea()<<" Corr "<< + // p4.pt()<<" "< myjet = (edm::RefToBase)jets_h->refAt(i); specific.theCaloJetRef = myjet; specific.mZSPCor = factorZSP; @@ -275,117 +272,126 @@ JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) specific.mSumEnergyOfChargedWithoutEff = (float)mJPTalgo->getSumEnergyWithoutEff(); specific.mChargedHadronEnergy = (float)mJPTalgo->getSumEnergyWithoutEff(); -// Fill Charged Jet shape parameters - double deR2Tr = 0.; - double deEta2Tr = 0.; - double dePhi2Tr = 0.; - double Zch = 0.; - double Pout2 = 0.; - double Pout = 0.; - double denominator_tracks = 0.; - int ntracks = 0; - - for( reco::TrackRefVector::const_iterator it = pions.inVertexInCalo_.begin(); it != pions.inVertexInCalo_.end(); it++) { - double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); - double deEta = (*it)->eta() - p4.eta(); - double dePhi = deltaPhi((*it)->phi(), p4.phi()); - if((**it).ptError()/(**it).pt() < 0.1) { - deR2Tr = deR2Tr + deR*deR*(*it)->pt(); - deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); - dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); - denominator_tracks = denominator_tracks + (*it)->pt(); - Zch = Zch + (*it)->pt(); - - Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); - ntracks++; - } - } - - for( reco::TrackRefVector::const_iterator it = muons.inVertexInCalo_.begin(); it != muons.inVertexInCalo_.end(); it++) { - double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); - double deEta = (*it)->eta() - p4.eta(); - double dePhi = deltaPhi((*it)->phi(), p4.phi()); - if((**it).ptError()/(**it).pt() < 0.1) { - deR2Tr = deR2Tr + deR*deR*(*it)->pt(); - deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); - dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); - denominator_tracks = denominator_tracks + (*it)->pt(); - Zch = Zch + (*it)->pt(); - - Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); - ntracks++; - } - } - for( reco::TrackRefVector::const_iterator it = elecs.inVertexInCalo_.begin(); it != elecs.inVertexInCalo_.end(); it++) { - double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); - double deEta = (*it)->eta() - p4.eta(); - double dePhi = deltaPhi((*it)->phi(), p4.phi()); - if((**it).ptError()/(**it).pt() < 0.1) { - deR2Tr = deR2Tr + deR*deR*(*it)->pt(); - deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); - dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); - denominator_tracks = denominator_tracks + (*it)->pt(); - Zch = Zch + (*it)->pt(); - - Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); - ntracks++; - } - } - for( reco::TrackRefVector::const_iterator it = pions.inVertexOutOfCalo_.begin(); it != pions.inVertexOutOfCalo_.end(); it++) { - Zch = Zch + (*it)->pt(); - } - for( reco::TrackRefVector::const_iterator it = muons.inVertexOutOfCalo_.begin(); it != muons.inVertexOutOfCalo_.end(); it++) { - Zch = Zch + (*it)->pt(); - } - for( reco::TrackRefVector::const_iterator it = elecs.inVertexOutOfCalo_.begin(); it != elecs.inVertexOutOfCalo_.end(); it++) { - Zch = Zch + (*it)->pt(); - } - - if(mJPTalgo->getSumPtForBeta()> 0.) Zch = Zch/mJPTalgo->getSumPtForBeta(); - -// std::cout<<" Zch "<< Zch<<" "<getSumPtForBeta()< 0) { - Pout = sqrt(fabs(Pout2))/ntracks; - } - if (denominator_tracks!=0){ - deR2Tr = deR2Tr/denominator_tracks; - deEta2Tr= deEta2Tr/denominator_tracks; - dePhi2Tr= dePhi2Tr/denominator_tracks; - } - - specific.R2momtr = deR2Tr; - specific.Eta2momtr = deEta2Tr; - specific.Phi2momtr = dePhi2Tr; - specific.Pout = Pout; - specific.Zch = Zch; - - -// std::cout<<" Moments for charged component "< pvCollection; - iEvent.getByToken(input_vertex_token_, pvCollection); - if ( pvCollection.isValid() && !pvCollection->empty() ) vertex_=pvCollection->begin()->position(); - - reco::JPTJet fJet(p4, vertex_, specific, corrected.getJetConstituents()); - - // fJet.printJet(); - -// Output module - if(fJet.pt()>ptCUT) pOut->push_back(fJet); + // Fill Charged Jet shape parameters + double deR2Tr = 0.; + double deEta2Tr = 0.; + double dePhi2Tr = 0.; + double Zch = 0.; + double Pout2 = 0.; + double Pout = 0.; + double denominator_tracks = 0.; + int ntracks = 0; + + for (reco::TrackRefVector::const_iterator it = pions.inVertexInCalo_.begin(); it != pions.inVertexInCalo_.end(); + it++) { + double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); + double deEta = (*it)->eta() - p4.eta(); + double dePhi = deltaPhi((*it)->phi(), p4.phi()); + if ((**it).ptError() / (**it).pt() < 0.1) { + deR2Tr = deR2Tr + deR * deR * (*it)->pt(); + deEta2Tr = deEta2Tr + deEta * deEta * (*it)->pt(); + dePhi2Tr = dePhi2Tr + dePhi * dePhi * (*it)->pt(); + denominator_tracks = denominator_tracks + (*it)->pt(); + Zch = Zch + (*it)->pt(); + + Pout2 = Pout2 + (**it).p() * (**it).p() - (Zch * p4.P()) * (Zch * p4.P()); + ntracks++; + } + } + + for (reco::TrackRefVector::const_iterator it = muons.inVertexInCalo_.begin(); it != muons.inVertexInCalo_.end(); + it++) { + double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); + double deEta = (*it)->eta() - p4.eta(); + double dePhi = deltaPhi((*it)->phi(), p4.phi()); + if ((**it).ptError() / (**it).pt() < 0.1) { + deR2Tr = deR2Tr + deR * deR * (*it)->pt(); + deEta2Tr = deEta2Tr + deEta * deEta * (*it)->pt(); + dePhi2Tr = dePhi2Tr + dePhi * dePhi * (*it)->pt(); + denominator_tracks = denominator_tracks + (*it)->pt(); + Zch = Zch + (*it)->pt(); + + Pout2 = Pout2 + (**it).p() * (**it).p() - (Zch * p4.P()) * (Zch * p4.P()); + ntracks++; + } + } + for (reco::TrackRefVector::const_iterator it = elecs.inVertexInCalo_.begin(); it != elecs.inVertexInCalo_.end(); + it++) { + double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); + double deEta = (*it)->eta() - p4.eta(); + double dePhi = deltaPhi((*it)->phi(), p4.phi()); + if ((**it).ptError() / (**it).pt() < 0.1) { + deR2Tr = deR2Tr + deR * deR * (*it)->pt(); + deEta2Tr = deEta2Tr + deEta * deEta * (*it)->pt(); + dePhi2Tr = dePhi2Tr + dePhi * dePhi * (*it)->pt(); + denominator_tracks = denominator_tracks + (*it)->pt(); + Zch = Zch + (*it)->pt(); + + Pout2 = Pout2 + (**it).p() * (**it).p() - (Zch * p4.P()) * (Zch * p4.P()); + ntracks++; + } + } + for (reco::TrackRefVector::const_iterator it = pions.inVertexOutOfCalo_.begin(); + it != pions.inVertexOutOfCalo_.end(); + it++) { + Zch = Zch + (*it)->pt(); + } + for (reco::TrackRefVector::const_iterator it = muons.inVertexOutOfCalo_.begin(); + it != muons.inVertexOutOfCalo_.end(); + it++) { + Zch = Zch + (*it)->pt(); + } + for (reco::TrackRefVector::const_iterator it = elecs.inVertexOutOfCalo_.begin(); + it != elecs.inVertexOutOfCalo_.end(); + it++) { + Zch = Zch + (*it)->pt(); + } + + if (mJPTalgo->getSumPtForBeta() > 0.) + Zch = Zch / mJPTalgo->getSumPtForBeta(); + + // std::cout<<" Zch "<< Zch<<" "<getSumPtForBeta()< 0) { + Pout = sqrt(fabs(Pout2)) / ntracks; + } + if (denominator_tracks != 0) { + deR2Tr = deR2Tr / denominator_tracks; + deEta2Tr = deEta2Tr / denominator_tracks; + dePhi2Tr = dePhi2Tr / denominator_tracks; + } + + specific.R2momtr = deR2Tr; + specific.Eta2momtr = deEta2Tr; + specific.Phi2momtr = dePhi2Tr; + specific.Pout = Pout; + specific.Zch = Zch; + + // std::cout<<" Moments for charged component "< pvCollection; + iEvent.getByToken(input_vertex_token_, pvCollection); + if (pvCollection.isValid() && !pvCollection->empty()) + vertex_ = pvCollection->begin()->position(); + + reco::JPTJet fJet(p4, vertex_, specific, corrected.getJetConstituents()); + + // fJet.printJet(); + + // Output module + if (fJet.pt() > ptCUT) + pOut->push_back(fJet); } - std::sort(pOut->begin(),pOut->end(),sort_by_pt); - //std::cout<<"Size of the additional jets "<size()<begin(), pOut->end(), sort_by_pt); + //std::cout<<"Size of the additional jets "<size()< + +// user include files + +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h" +#include "DataFormats/JetReco/interface/CaloJetCollection.h" +#include "DataFormats/JetReco/interface/CaloJet.h" +#include "DataFormats/JetReco/interface/JPTJetCollection.h" +#include "DataFormats/JetReco/interface/JPTJet.h" +#include "DataFormats/JetReco/interface/TrackJetCollection.h" +#include "DataFormats/JetReco/interface/TrackJet.h" +#include "DataFormats/TrackReco/interface/TrackFwd.h" +#include "DataFormats/TrackReco/interface/Track.h" +#include "DataFormats/JetReco/interface/Jet.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/Math/interface/deltaPhi.h" +#include "DataFormats/Math/interface/deltaR.h" + +#include + +using namespace std; +using namespace jpt; + +// +// constants, enums and typedefs +// + + +// +// static data member definitions +// + +// +// constructors and destructor +// +JetPlusTrackProducer::JetPlusTrackProducer(const edm::ParameterSet& iConfig) +{ + //register your products + src = iConfig.getParameter("src"); + srcTrackJets = iConfig.getParameter("srcTrackJets"); + alias = iConfig.getUntrackedParameter("alias"); + srcPVs_ = iConfig.getParameter("srcPVs"); + vectorial_ = iConfig.getParameter("VectorialCorrection"); + useZSP = iConfig.getParameter("UseZSP"); + ptCUT = iConfig.getParameter("ptCUT"); + dRcone = iConfig.getParameter("dRcone"); + + mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector()); + if(useZSP) mZSPalgo = new ZSPJPTJetCorrector(iConfig); + + produces().setBranchAlias(alias); + produces().setBranchAlias("ak4CaloJetsJPT"); + + input_jets_token_ = consumes >(src); + input_addjets_token_ = consumes >(iConfig.getParameter("srcAddCaloJets")); + input_trackjets_token_ = consumes >(srcTrackJets); + input_vertex_token_ = consumes(srcPVs_); + mExtrapolations = consumes > + (iConfig.getParameter ("extrapolations")); +} + + +JetPlusTrackProducer::~JetPlusTrackProducer() +{ + + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) + +} + + +// +// member functions +// +bool sort_by_pt (reco::JPTJet a,reco::JPTJet b) { return (a.pt()>b.pt());} + +// ------------ method called to produce the data ------------ +void +JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + using namespace edm; + +// std::cout<<" RecoJets::JetPlusTrackProducer::produce "< > jets_h; + iEvent.getByToken (input_jets_token_, jets_h); + +//JetPlusTrackAddonSeed + edm::Handle > addjets_h; + iEvent.getByToken (input_addjets_token_, addjets_h); + + //std::cout<<" Additional Calojets "<size()< > jetsTrackJets; + iEvent.getByToken(input_trackjets_token_, jetsTrackJets); + + //std::cout<<" Additional Trackjets "<size()< > iExtrapolations; + iEvent.getByToken (mExtrapolations, iExtrapolations); + + edm::RefProd pOut1RefProd = + iEvent.getRefBeforePut(); + edm::Ref::key_type idxCaloJet = 0; + + auto pOut = std::make_unique(); + auto pOut1 = std::make_unique(); + + double scaleJPT = 1.; + std::vector theJPTJets; + if (jetsTrackJets.isValid()) { + if(!jetsTrackJets->empty()) { + for (unsigned ijet = 0; ijet < jetsTrackJets->size(); ++ijet) { + const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet))); + int icalo = -1; + if(addjets_h.isValid()) { + for (unsigned i = 0; i < addjets_h->size(); ++i) { + const reco::CaloJet* oldjet = &(*(addjets_h->refAt(i))); + double deta = fabs(jet->eta()-oldjet->eta()); + double dphi = fabs(jet->phi()-oldjet->phi()); + if(dphi>4.*atan(1.)) dphi = 8.*atan(1.) - dphi; + double dr = sqrt(dphi*dphi+deta*deta); + if(dr<=dRcone) {icalo=i;} + } // Calojets + } + if(icalo < 0) continue; + const reco::CaloJet* mycalo = &(*(addjets_h->refAt(icalo))); + // std::cout<<" Additional CaloJet "<pt()<<" "<eta()<< + // " "<phi()< > tracksinjet = jet->tracks(); + reco::TrackRefVector tracksincalo; + reco::TrackRefVector tracksinvert; + for(std::vector >::iterator itrack = tracksinjet.begin(); + itrack != tracksinjet.end(); itrack++) { + for ( std::vector::const_iterator xtrpBegin = iExtrapolations->begin(), + xtrpEnd = iExtrapolations->end(), ixtrp = xtrpBegin; + ixtrp != xtrpEnd; ++ixtrp ) + { + if ( ixtrp->positions().empty() ) continue; + double mydphi =fabs(ixtrp->track()->phi()-(**itrack).phi()); + if(mydphi>4.*atan(1.)) mydphi = 8.*atan(1)-mydphi; + if(fabs(ixtrp->track()->pt()-(**itrack).pt()) > 0.001 || + fabs(ixtrp->track()->eta()-(**itrack).eta()) > 0.001 || mydphi > 0.001) continue; + tracksinvert.push_back(ixtrp->track()); + reco::TrackBase::Point const & point = ixtrp->positions().at(0); + + double dr = reco::deltaR( jet->eta(), jet->phi(), point.eta(), point.phi() ); + if(dr <= dRcone) { + /*std::cout<<" TrackINcalo "<track()); + } + } // Track extrapolations + } // tracks + + reco::TrackJet corrected = *jet; + math::XYZTLorentzVector p4; + jpt::MatchedTracks pions; + jpt::MatchedTracks muons; + jpt::MatchedTracks elecs; + + scaleJPT = mJPTalgo->correction( corrected, *mycalo, iEvent, iSetup, + tracksinvert, tracksincalo, p4, pions, muons, elecs); + // std::cout<<" JetPlusTrackProducer::AddSeedJet "<< (*mycalo).pt()<<" "<< (*mycalo).eta()<<" "<< + // (*mycalo).phi()<<" "<<(*mycalo).jetArea()<<" Corr "<< + // p4.pt()<<" "< ptCUT) { + reco::JPTJet::Specific jptspe; + jptspe.pionsInVertexInCalo = pions.inVertexInCalo_; + jptspe.pionsInVertexOutCalo = pions.inVertexOutOfCalo_; + jptspe.pionsOutVertexInCalo = pions.outOfVertexInCalo_; + jptspe.muonsInVertexInCalo = muons.inVertexInCalo_; + jptspe.muonsInVertexOutCalo = muons.inVertexOutOfCalo_; + jptspe.muonsOutVertexInCalo = muons.outOfVertexInCalo_; + jptspe.elecsInVertexInCalo = elecs.inVertexInCalo_; + jptspe.elecsInVertexOutCalo = elecs.inVertexOutOfCalo_; + jptspe.elecsOutVertexInCalo = elecs.outOfVertexInCalo_; + reco::CaloJetRef myjet(pOut1RefProd, idxCaloJet++); + jptspe.theCaloJetRef = edm::RefToBase(myjet); + jptspe.mZSPCor = 1.; + reco::JPTJet fJet(p4, jet->primaryVertex()->position(), jptspe, mycalo->getJetConstituents()); + pOut->push_back(fJet); + pOut1->push_back(*mycalo); + theJPTJets.push_back(fJet); + } + } // trackjets + } // jets + } // There is trackjet collection + + for (unsigned i = 0; i < jets_h->size(); ++i) { + + const reco::CaloJet* oldjet = &(*(jets_h->refAt(i))); + reco::CaloJet corrected = *oldjet; + +// ZSP corrections + + double factorZSP = 1.; + if(useZSP) factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup); + corrected.scaleEnergy (factorZSP); + +// JPT corrections + scaleJPT = 1.; + + math::XYZTLorentzVector p4; + + jpt::MatchedTracks pions; + jpt::MatchedTracks muons; + jpt::MatchedTracks elecs; + bool ok=false; + + if ( !vectorial_ ) { + + scaleJPT = mJPTalgo->correction ( corrected, *oldjet, iEvent, iSetup, pions, muons, elecs,ok ); + p4 = math::XYZTLorentzVector( corrected.px()*scaleJPT, + corrected.py()*scaleJPT, + corrected.pz()*scaleJPT, + corrected.energy()*scaleJPT ); + // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< (*oldjet).phi()<< + // " "<correction( corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs,ok ); + // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< + // (*oldjet).phi()<<" "<<(*oldjet).jetArea()<<" Corr "<< + // p4.pt()<<" "< myjet = (edm::RefToBase)jets_h->refAt(i); + specific.theCaloJetRef = myjet; + specific.mZSPCor = factorZSP; + specific.mResponseOfChargedWithEff = (float)mJPTalgo->getResponseOfChargedWithEff(); + specific.mResponseOfChargedWithoutEff = (float)mJPTalgo->getResponseOfChargedWithoutEff(); + specific.mSumPtOfChargedWithEff = (float)mJPTalgo->getSumPtWithEff(); + specific.mSumPtOfChargedWithoutEff = (float)mJPTalgo->getSumPtWithoutEff(); + specific.mSumEnergyOfChargedWithEff = (float)mJPTalgo->getSumEnergyWithEff(); + specific.mSumEnergyOfChargedWithoutEff = (float)mJPTalgo->getSumEnergyWithoutEff(); + specific.mChargedHadronEnergy = (float)mJPTalgo->getSumEnergyWithoutEff(); + +// Fill Charged Jet shape parameters + double deR2Tr = 0.; + double deEta2Tr = 0.; + double dePhi2Tr = 0.; + double Zch = 0.; + double Pout2 = 0.; + double Pout = 0.; + double denominator_tracks = 0.; + int ntracks = 0; + + for( reco::TrackRefVector::const_iterator it = pions.inVertexInCalo_.begin(); it != pions.inVertexInCalo_.end(); it++) { + double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); + double deEta = (*it)->eta() - p4.eta(); + double dePhi = deltaPhi((*it)->phi(), p4.phi()); + if((**it).ptError()/(**it).pt() < 0.1) { + deR2Tr = deR2Tr + deR*deR*(*it)->pt(); + deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); + dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); + denominator_tracks = denominator_tracks + (*it)->pt(); + Zch = Zch + (*it)->pt(); + + Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); + ntracks++; + } + } + + for( reco::TrackRefVector::const_iterator it = muons.inVertexInCalo_.begin(); it != muons.inVertexInCalo_.end(); it++) { + double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); + double deEta = (*it)->eta() - p4.eta(); + double dePhi = deltaPhi((*it)->phi(), p4.phi()); + if((**it).ptError()/(**it).pt() < 0.1) { + deR2Tr = deR2Tr + deR*deR*(*it)->pt(); + deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); + dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); + denominator_tracks = denominator_tracks + (*it)->pt(); + Zch = Zch + (*it)->pt(); + + Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); + ntracks++; + } + } + for( reco::TrackRefVector::const_iterator it = elecs.inVertexInCalo_.begin(); it != elecs.inVertexInCalo_.end(); it++) { + double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); + double deEta = (*it)->eta() - p4.eta(); + double dePhi = deltaPhi((*it)->phi(), p4.phi()); + if((**it).ptError()/(**it).pt() < 0.1) { + deR2Tr = deR2Tr + deR*deR*(*it)->pt(); + deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); + dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); + denominator_tracks = denominator_tracks + (*it)->pt(); + Zch = Zch + (*it)->pt(); + + Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); + ntracks++; + } + } + for( reco::TrackRefVector::const_iterator it = pions.inVertexOutOfCalo_.begin(); it != pions.inVertexOutOfCalo_.end(); it++) { + Zch = Zch + (*it)->pt(); + } + for( reco::TrackRefVector::const_iterator it = muons.inVertexOutOfCalo_.begin(); it != muons.inVertexOutOfCalo_.end(); it++) { + Zch = Zch + (*it)->pt(); + } + for( reco::TrackRefVector::const_iterator it = elecs.inVertexOutOfCalo_.begin(); it != elecs.inVertexOutOfCalo_.end(); it++) { + Zch = Zch + (*it)->pt(); + } + + if(mJPTalgo->getSumPtForBeta()> 0.) Zch = Zch/mJPTalgo->getSumPtForBeta(); + +// std::cout<<" Zch "<< Zch<<" "<getSumPtForBeta()< 0) { + Pout = sqrt(fabs(Pout2))/ntracks; + } + if (denominator_tracks!=0){ + deR2Tr = deR2Tr/denominator_tracks; + deEta2Tr= deEta2Tr/denominator_tracks; + dePhi2Tr= dePhi2Tr/denominator_tracks; + } + + specific.R2momtr = deR2Tr; + specific.Eta2momtr = deEta2Tr; + specific.Phi2momtr = dePhi2Tr; + specific.Pout = Pout; + specific.Zch = Zch; + + +// std::cout<<" Moments for charged component "< pvCollection; + iEvent.getByToken(input_vertex_token_, pvCollection); + if ( pvCollection.isValid() && !pvCollection->empty() ) vertex_=pvCollection->begin()->position(); + + reco::JPTJet fJet(p4, vertex_, specific, corrected.getJetConstituents()); + + // fJet.printJet(); + +// Output module + if(fJet.pt()>ptCUT) pOut->push_back(fJet); + } + + std::sort(pOut->begin(),pOut->end(),sort_by_pt); + //std::cout<<"Size of the additional jets "<size()<("src"); +- srcTrackJets = iConfig.getParameter("srcTrackJets"); +- alias = iConfig.getUntrackedParameter("alias"); +- srcPVs_ = iConfig.getParameter("srcPVs"); +- vectorial_ = iConfig.getParameter("VectorialCorrection"); +- useZSP = iConfig.getParameter("UseZSP"); +- ptCUT = iConfig.getParameter("ptCUT"); +- +- mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector()); +- if(useZSP) mZSPalgo = new ZSPJPTJetCorrector(iConfig); +- +- produces().setBranchAlias(alias); +- produces().setBranchAlias("ak4CaloJetsJPT"); +- +- input_jets_token_ = consumes >(src); +- input_addjets_token_ = consumes >(iConfig.getParameter("srcAddCaloJets")); +- input_trackjets_token_ = consumes >(srcTrackJets); +- input_vertex_token_ = consumes(srcPVs_); +- mExtrapolations = consumes > +- (iConfig.getParameter ("extrapolations")); ++JetPlusTrackProducer::JetPlusTrackProducer(const edm::ParameterSet& iConfig) { ++ //register your products ++ src = iConfig.getParameter("src"); ++ srcTrackJets = iConfig.getParameter("srcTrackJets"); ++ alias = iConfig.getUntrackedParameter("alias"); ++ srcPVs_ = iConfig.getParameter("srcPVs"); ++ vectorial_ = iConfig.getParameter("VectorialCorrection"); ++ useZSP = iConfig.getParameter("UseZSP"); ++ ptCUT = iConfig.getParameter("ptCUT"); ++ ++ mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector()); ++ if (useZSP) ++ mZSPalgo = new ZSPJPTJetCorrector(iConfig); ++ ++ produces().setBranchAlias(alias); ++ produces().setBranchAlias("ak4CaloJetsJPT"); ++ ++ input_jets_token_ = consumes >(src); ++ input_addjets_token_ = consumes >(iConfig.getParameter("srcAddCaloJets")); ++ input_trackjets_token_ = consumes >(srcTrackJets); ++ input_vertex_token_ = consumes(srcPVs_); ++ mExtrapolations = ++ consumes >(iConfig.getParameter("extrapolations")); + } + +- +-JetPlusTrackProducer::~JetPlusTrackProducer() +-{ +- +- // do anything here that needs to be done at desctruction time +- // (e.g. close files, deallocate resources etc.) +- ++JetPlusTrackProducer::~JetPlusTrackProducer() { ++ // do anything here that needs to be done at desctruction time ++ // (e.g. close files, deallocate resources etc.) + } + +- + // + // member functions + // +-bool sort_by_pt (reco::JPTJet a,reco::JPTJet b) { return (a.pt()>b.pt());} ++bool sort_by_pt(reco::JPTJet a, reco::JPTJet b) { return (a.pt() > b.pt()); } + + // ------------ method called to produce the data ------------ +-void +-JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) +-{ +- using namespace edm; ++void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { ++ using namespace edm; + +-// std::cout<<" RecoJets::JetPlusTrackProducer::produce "< > jets_h; +- iEvent.getByToken (input_jets_token_, jets_h); ++ // get stuff from Event ++ edm::Handle > jets_h; ++ iEvent.getByToken(input_jets_token_, jets_h); + +-//JetPlusTrackAddonSeed +- edm::Handle > addjets_h; +- iEvent.getByToken (input_addjets_token_, addjets_h); ++ //JetPlusTrackAddonSeed ++ edm::Handle > addjets_h; ++ iEvent.getByToken(input_addjets_token_, addjets_h); + + //std::cout<<" Additional Calojets "<size()< > jetsTrackJets; ++ edm::Handle > jetsTrackJets; + iEvent.getByToken(input_trackjets_token_, jetsTrackJets); + + //std::cout<<" Additional Trackjets "<size()< > iExtrapolations; +- iEvent.getByToken (mExtrapolations, iExtrapolations); ++ edm::Handle > iExtrapolations; ++ iEvent.getByToken(mExtrapolations, iExtrapolations); ++ ++ edm::RefProd pOut1RefProd = iEvent.getRefBeforePut(); ++ edm::Ref::key_type idxCaloJet = 0; + +- edm::RefProd pOut1RefProd = +- iEvent.getRefBeforePut(); +- edm::Ref::key_type idxCaloJet = 0; +- + auto pOut = std::make_unique(); + auto pOut1 = std::make_unique(); + +- double scaleJPT = 1.; +- std::vector theJPTJets; +- if (jetsTrackJets.isValid()) { +- if(!jetsTrackJets->empty()) { ++ double scaleJPT = 1.; ++ std::vector theJPTJets; ++ if (jetsTrackJets.isValid()) { ++ if (!jetsTrackJets->empty()) { + for (unsigned ijet = 0; ijet < jetsTrackJets->size(); ++ijet) { +- const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet))); +- int icalo = -1; +- if(addjets_h.isValid()) { ++ const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet))); ++ int icalo = -1; ++ if (addjets_h.isValid()) { + for (unsigned i = 0; i < addjets_h->size(); ++i) { +- const reco::CaloJet* oldjet = &(*(addjets_h->refAt(i))); +- double deta = fabs(jet->eta()-oldjet->eta()); +- double dphi = fabs(jet->phi()-oldjet->phi()); +- if(dphi>4.*atan(1.)) dphi = 8.*atan(1.) - dphi; +- double dr = sqrt(dphi*dphi+deta*deta); +- if(dr<=0.4) {icalo=i;} +- } // Calojets +- } +- if(icalo < 0) continue; +- const reco::CaloJet* mycalo = &(*(addjets_h->refAt(icalo))); +- // std::cout<<" Additional CaloJet "<pt()<<" "<eta()<< +- // " "<phi()<refAt(i))); ++ double deta = fabs(jet->eta() - oldjet->eta()); ++ double dphi = fabs(jet->phi() - oldjet->phi()); ++ if (dphi > 4. * atan(1.)) ++ dphi = 8. * atan(1.) - dphi; ++ double dr = sqrt(dphi * dphi + deta * deta); ++ if (dr <= 0.4) { ++ icalo = i; ++ } ++ } // Calojets ++ } ++ if (icalo < 0) ++ continue; ++ const reco::CaloJet* mycalo = &(*(addjets_h->refAt(icalo))); ++ // std::cout<<" Additional CaloJet "<pt()<<" "<eta()<< ++ // " "<phi()< > tracksinjet = jet->tracks(); + reco::TrackRefVector tracksincalo; + reco::TrackRefVector tracksinvert; +- for(std::vector >::iterator itrack = tracksinjet.begin(); +- itrack != tracksinjet.end(); itrack++) { +- for ( std::vector::const_iterator xtrpBegin = iExtrapolations->begin(), +- xtrpEnd = iExtrapolations->end(), ixtrp = xtrpBegin; +- ixtrp != xtrpEnd; ++ixtrp ) +- { +- if ( ixtrp->positions().empty() ) continue; +- double mydphi =fabs(ixtrp->track()->phi()-(**itrack).phi()); +- if(mydphi>4.*atan(1.)) mydphi = 8.*atan(1)-mydphi; +- if(fabs(ixtrp->track()->pt()-(**itrack).pt()) > 0.001 || +- fabs(ixtrp->track()->eta()-(**itrack).eta()) > 0.001 || mydphi > 0.001) continue; +- tracksinvert.push_back(ixtrp->track()); +- reco::TrackBase::Point const & point = ixtrp->positions().at(0); +- +- double dr = reco::deltaR( jet->eta(), jet->phi(), point.eta(), point.phi() ); +- if(dr <= 0.4) { +- /*std::cout<<" TrackINcalo "<track()); +- } +- } // Track extrapolations +- } // tracks +- +- reco::TrackJet corrected = *jet; +- math::XYZTLorentzVector p4; +- jpt::MatchedTracks pions; +- jpt::MatchedTracks muons; +- jpt::MatchedTracks elecs; +- +- scaleJPT = mJPTalgo->correction( corrected, *mycalo, iEvent, iSetup, +- tracksinvert, tracksincalo, p4, pions, muons, elecs); +- // std::cout<<" JetPlusTrackProducer::AddSeedJet "<< (*mycalo).pt()<<" "<< (*mycalo).eta()<<" "<< +- // (*mycalo).phi()<<" "<<(*mycalo).jetArea()<<" Corr "<< +- // p4.pt()<<" "< ptCUT) { +- reco::JPTJet::Specific jptspe; +- jptspe.pionsInVertexInCalo = pions.inVertexInCalo_; +- jptspe.pionsInVertexOutCalo = pions.inVertexOutOfCalo_; +- jptspe.pionsOutVertexInCalo = pions.outOfVertexInCalo_; +- jptspe.muonsInVertexInCalo = muons.inVertexInCalo_; +- jptspe.muonsInVertexOutCalo = muons.inVertexOutOfCalo_; +- jptspe.muonsOutVertexInCalo = muons.outOfVertexInCalo_; +- jptspe.elecsInVertexInCalo = elecs.inVertexInCalo_; +- jptspe.elecsInVertexOutCalo = elecs.inVertexOutOfCalo_; +- jptspe.elecsOutVertexInCalo = elecs.outOfVertexInCalo_; +- reco::CaloJetRef myjet(pOut1RefProd, idxCaloJet++); +- jptspe.theCaloJetRef = edm::RefToBase(myjet); +- jptspe.mZSPCor = 1.; +- reco::JPTJet fJet(p4, jet->primaryVertex()->position(), jptspe, mycalo->getJetConstituents()); +- pOut->push_back(fJet); +- pOut1->push_back(*mycalo); +- theJPTJets.push_back(fJet); +- } +- } // trackjets +- } // jets +- } // There is trackjet collection ++ for (std::vector >::iterator itrack = tracksinjet.begin(); itrack != tracksinjet.end(); ++ itrack++) { ++ for (std::vector::const_iterator xtrpBegin = iExtrapolations->begin(), ++ xtrpEnd = iExtrapolations->end(), ++ ixtrp = xtrpBegin; ++ ixtrp != xtrpEnd; ++ ++ixtrp) { ++ if (ixtrp->positions().empty()) ++ continue; ++ double mydphi = fabs(ixtrp->track()->phi() - (**itrack).phi()); ++ if (mydphi > 4. * atan(1.)) ++ mydphi = 8. * atan(1) - mydphi; ++ if (fabs(ixtrp->track()->pt() - (**itrack).pt()) > 0.001 || ++ fabs(ixtrp->track()->eta() - (**itrack).eta()) > 0.001 || mydphi > 0.001) ++ continue; ++ tracksinvert.push_back(ixtrp->track()); ++ reco::TrackBase::Point const& point = ixtrp->positions().at(0); ++ ++ double dr = reco::deltaR(jet->eta(), jet->phi(), point.eta(), point.phi()); ++ if (dr <= 0.4) { ++ /*std::cout<<" TrackINcalo "<track()); ++ } ++ } // Track extrapolations ++ } // tracks ++ ++ reco::TrackJet corrected = *jet; ++ math::XYZTLorentzVector p4; ++ jpt::MatchedTracks pions; ++ jpt::MatchedTracks muons; ++ jpt::MatchedTracks elecs; ++ ++ scaleJPT = mJPTalgo->correction( ++ corrected, *mycalo, iEvent, iSetup, tracksinvert, tracksincalo, p4, pions, muons, elecs); ++ // std::cout<<" JetPlusTrackProducer::AddSeedJet "<< (*mycalo).pt()<<" "<< (*mycalo).eta()<<" "<< ++ // (*mycalo).phi()<<" "<<(*mycalo).jetArea()<<" Corr "<< ++ // p4.pt()<<" "< ptCUT) { ++ reco::JPTJet::Specific jptspe; ++ jptspe.pionsInVertexInCalo = pions.inVertexInCalo_; ++ jptspe.pionsInVertexOutCalo = pions.inVertexOutOfCalo_; ++ jptspe.pionsOutVertexInCalo = pions.outOfVertexInCalo_; ++ jptspe.muonsInVertexInCalo = muons.inVertexInCalo_; ++ jptspe.muonsInVertexOutCalo = muons.inVertexOutOfCalo_; ++ jptspe.muonsOutVertexInCalo = muons.outOfVertexInCalo_; ++ jptspe.elecsInVertexInCalo = elecs.inVertexInCalo_; ++ jptspe.elecsInVertexOutCalo = elecs.inVertexOutOfCalo_; ++ jptspe.elecsOutVertexInCalo = elecs.outOfVertexInCalo_; ++ reco::CaloJetRef myjet(pOut1RefProd, idxCaloJet++); ++ jptspe.theCaloJetRef = edm::RefToBase(myjet); ++ jptspe.mZSPCor = 1.; ++ reco::JPTJet fJet(p4, jet->primaryVertex()->position(), jptspe, mycalo->getJetConstituents()); ++ pOut->push_back(fJet); ++ pOut1->push_back(*mycalo); ++ theJPTJets.push_back(fJet); ++ } ++ } // trackjets ++ } // jets ++ } // There is trackjet collection + + for (unsigned i = 0; i < jets_h->size(); ++i) { +- +- const reco::CaloJet* oldjet = &(*(jets_h->refAt(i))); +- reco::CaloJet corrected = *oldjet; +- +-// ZSP corrections +- +- double factorZSP = 1.; +- if(useZSP) factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup); +- corrected.scaleEnergy (factorZSP); +- +-// JPT corrections +- scaleJPT = 1.; +- +- math::XYZTLorentzVector p4; +- +- jpt::MatchedTracks pions; +- jpt::MatchedTracks muons; +- jpt::MatchedTracks elecs; +- bool ok=false; +- +- if ( !vectorial_ ) { +- +- scaleJPT = mJPTalgo->correction ( corrected, *oldjet, iEvent, iSetup, pions, muons, elecs,ok ); +- p4 = math::XYZTLorentzVector( corrected.px()*scaleJPT, +- corrected.py()*scaleJPT, +- corrected.pz()*scaleJPT, +- corrected.energy()*scaleJPT ); +- // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< (*oldjet).phi()<< +- // " "<correction( corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs,ok ); +- // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< +- // (*oldjet).phi()<<" "<<(*oldjet).jetArea()<<" Corr "<< +- // p4.pt()<<" "<refAt(i))); ++ reco::CaloJet corrected = *oldjet; ++ ++ // ZSP corrections ++ ++ double factorZSP = 1.; ++ if (useZSP) ++ factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup); ++ corrected.scaleEnergy(factorZSP); ++ ++ // JPT corrections ++ scaleJPT = 1.; ++ ++ math::XYZTLorentzVector p4; ++ ++ jpt::MatchedTracks pions; ++ jpt::MatchedTracks muons; ++ jpt::MatchedTracks elecs; ++ bool ok = false; ++ ++ if (!vectorial_) { ++ scaleJPT = mJPTalgo->correction(corrected, *oldjet, iEvent, iSetup, pions, muons, elecs, ok); ++ p4 = math::XYZTLorentzVector(corrected.px() * scaleJPT, ++ corrected.py() * scaleJPT, ++ corrected.pz() * scaleJPT, ++ corrected.energy() * scaleJPT); ++ // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< (*oldjet).phi()<< ++ // " "<correction(corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs, ok); ++ // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< ++ // (*oldjet).phi()<<" "<<(*oldjet).jetArea()<<" Corr "<< ++ // p4.pt()<<" "< myjet = (edm::RefToBase)jets_h->refAt(i); + specific.theCaloJetRef = myjet; + specific.mZSPCor = factorZSP; diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h index 11dadc66152fc..d226ccb3cc8af 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h @@ -2,7 +2,7 @@ // // Package: JetPlusTracks // Class: JetPlusTrackProducer -// +// /**\class JetPlusTrackProducer JetPlusTrackProducer.cc JetPlusTrackProducer.cc Description: [one line class summary] @@ -16,7 +16,6 @@ // // - // system include files #include @@ -42,28 +41,27 @@ // class JetPlusTrackProducer : public edm::stream::EDProducer<> { - public: - explicit JetPlusTrackProducer(const edm::ParameterSet&); - ~JetPlusTrackProducer() override; - void produce(edm::Event&, const edm::EventSetup&) override; +public: + explicit JetPlusTrackProducer(const edm::ParameterSet&); + ~JetPlusTrackProducer() override; + void produce(edm::Event&, const edm::EventSetup&) override; - // ---------- private data members --------------------------- - private: - - JetPlusTrackCorrector* mJPTalgo; - ZSPJPTJetCorrector* mZSPalgo; - edm::InputTag src; - edm::InputTag srcTrackJets; - edm::InputTag srcPVs_; - std::string alias; - bool vectorial_; - bool useZSP; - double ptCUT; + // ---------- private data members --------------------------- +private: + JetPlusTrackCorrector* mJPTalgo; + ZSPJPTJetCorrector* mZSPalgo; + edm::InputTag src; + edm::InputTag srcTrackJets; + edm::InputTag srcPVs_; + std::string alias; + bool vectorial_; + bool useZSP; + double ptCUT; + double dRcone; - edm::EDGetTokenT > input_jets_token_; - edm::EDGetTokenT > input_addjets_token_; - edm::EDGetTokenT > input_trackjets_token_; - edm::EDGetTokenT input_vertex_token_; - edm::EDGetTokenT > mExtrapolations; - + edm::EDGetTokenT > input_jets_token_; + edm::EDGetTokenT > input_addjets_token_; + edm::EDGetTokenT > input_trackjets_token_; + edm::EDGetTokenT input_vertex_token_; + edm::EDGetTokenT > mExtrapolations; }; diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.orig b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.orig new file mode 100644 index 0000000000000..4051671cd4e8e --- /dev/null +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.orig @@ -0,0 +1,70 @@ +// -*- C++ -*- +// +// Package: JetPlusTracks +// Class: JetPlusTrackProducer +// +/**\class JetPlusTrackProducer JetPlusTrackProducer.cc JetPlusTrackProducer.cc + + Description: [one line class summary] + + Implementation: + [Notes on implementation] +*/ +// +// Original Author: Olga Kodolova,40 R-A12,+41227671273, +// Created: Fri Feb 19 10:14:02 CET 2010 +// +// + + +// system include files +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "JetPlusTrackCorrector.h" +#include "ZSPJPTJetCorrector.h" + +#include "DataFormats/JetReco/interface/CaloJet.h" +#include "DataFormats/JetReco/interface/TrackJet.h" +#include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/JetReco/interface/TrackExtrapolation.h" + +#include + +// +// class declaration +// + +class JetPlusTrackProducer : public edm::stream::EDProducer<> { + public: + explicit JetPlusTrackProducer(const edm::ParameterSet&); + ~JetPlusTrackProducer() override; + void produce(edm::Event&, const edm::EventSetup&) override; + + // ---------- private data members --------------------------- + private: + + JetPlusTrackCorrector* mJPTalgo; + ZSPJPTJetCorrector* mZSPalgo; + edm::InputTag src; + edm::InputTag srcTrackJets; + edm::InputTag srcPVs_; + std::string alias; + bool vectorial_; + bool useZSP; + double ptCUT; + double dRcone; + + edm::EDGetTokenT > input_jets_token_; + edm::EDGetTokenT > input_addjets_token_; + edm::EDGetTokenT > input_trackjets_token_; + edm::EDGetTokenT input_vertex_token_; + edm::EDGetTokenT > mExtrapolations; + +}; diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.rej b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.rej new file mode 100644 index 0000000000000..36e2ac2f84e26 --- /dev/null +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.rej @@ -0,0 +1,51 @@ +--- RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h ++++ RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h +@@ -41,28 +40,26 @@ + // + + class JetPlusTrackProducer : public edm::stream::EDProducer<> { +- public: +- explicit JetPlusTrackProducer(const edm::ParameterSet&); +- ~JetPlusTrackProducer() override; +- void produce(edm::Event&, const edm::EventSetup&) override; ++public: ++ explicit JetPlusTrackProducer(const edm::ParameterSet&); ++ ~JetPlusTrackProducer() override; ++ void produce(edm::Event&, const edm::EventSetup&) override; + +- // ---------- private data members --------------------------- +- private: +- +- JetPlusTrackCorrector* mJPTalgo; +- ZSPJPTJetCorrector* mZSPalgo; +- edm::InputTag src; +- edm::InputTag srcTrackJets; +- edm::InputTag srcPVs_; +- std::string alias; +- bool vectorial_; +- bool useZSP; +- double ptCUT; ++ // ---------- private data members --------------------------- ++private: ++ JetPlusTrackCorrector* mJPTalgo; ++ ZSPJPTJetCorrector* mZSPalgo; ++ edm::InputTag src; ++ edm::InputTag srcTrackJets; ++ edm::InputTag srcPVs_; ++ std::string alias; ++ bool vectorial_; ++ bool useZSP; ++ double ptCUT; + +- edm::EDGetTokenT > input_jets_token_; +- edm::EDGetTokenT > input_addjets_token_; +- edm::EDGetTokenT > input_trackjets_token_; +- edm::EDGetTokenT input_vertex_token_; +- edm::EDGetTokenT > mExtrapolations; +- ++ edm::EDGetTokenT > input_jets_token_; ++ edm::EDGetTokenT > input_addjets_token_; ++ edm::EDGetTokenT > input_trackjets_token_; ++ edm::EDGetTokenT input_vertex_token_; ++ edm::EDGetTokenT > mExtrapolations; + }; diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc index cdd8f6c03dde1..50f1f5508fd8e 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc @@ -2,7 +2,7 @@ // // Package: JetPlusTrack // Class: JetPlusTrack -// +// /**\class JetPlusTrackProducer JetPlusTrackProducer.cc JetPlusTrackProducer.cc Description: [one line class summary] @@ -16,7 +16,6 @@ // // - // system include files #include @@ -68,7 +67,6 @@ using namespace jpt; // constants, enums and typedefs // - // // static data member definitions // @@ -76,140 +74,127 @@ using namespace jpt; // // constructors and destructor // -JetPlusTrackProducerAA::JetPlusTrackProducerAA(const edm::ParameterSet& iConfig) -{ - //register your products - src = iConfig.getParameter("src"); - alias = iConfig.getUntrackedParameter("alias"); - mTracks = iConfig.getParameter ("tracks"); - srcPVs_ = iConfig.getParameter("srcPVs"); - vectorial_ = iConfig.getParameter("VectorialCorrection"); - useZSP = iConfig.getParameter("UseZSP"); - std::string tq = iConfig.getParameter("TrackQuality"); - trackQuality_ = reco::TrackBase::qualityByName(tq); - mConeSize = iConfig.getParameter ("coneSize"); -//=> - mExtrapolations = iConfig.getParameter ("extrapolations"); -//=> - mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector()); - if(useZSP) mZSPalgo = new ZSPJPTJetCorrector(iConfig); - - produces().setBranchAlias(alias); - - input_jets_token_ = consumes >(src); - input_vertex_token_ = consumes(srcPVs_); - input_tracks_token_ = consumes(mTracks); - input_extrapolations_token_ = consumes >(mExtrapolations); +JetPlusTrackProducerAA::JetPlusTrackProducerAA(const edm::ParameterSet& iConfig) { + //register your products + src = iConfig.getParameter("src"); + alias = iConfig.getUntrackedParameter("alias"); + mTracks = iConfig.getParameter("tracks"); + srcPVs_ = iConfig.getParameter("srcPVs"); + vectorial_ = iConfig.getParameter("VectorialCorrection"); + useZSP = iConfig.getParameter("UseZSP"); + std::string tq = iConfig.getParameter("TrackQuality"); + trackQuality_ = reco::TrackBase::qualityByName(tq); + mConeSize = iConfig.getParameter("coneSize"); + //=> + mExtrapolations = iConfig.getParameter("extrapolations"); + //=> + mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector()); + if (useZSP) + mZSPalgo = new ZSPJPTJetCorrector(iConfig); + + produces().setBranchAlias(alias); + + input_jets_token_ = consumes >(src); + input_vertex_token_ = consumes(srcPVs_); + input_tracks_token_ = consumes(mTracks); + input_extrapolations_token_ = consumes >(mExtrapolations); } - -JetPlusTrackProducerAA::~JetPlusTrackProducerAA() -{ - - // do anything here that needs to be done at desctruction time - // (e.g. close files, deallocate resources etc.) - +JetPlusTrackProducerAA::~JetPlusTrackProducerAA() { + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) } - // // member functions // // ------------ method called to produce the data ------------ -void -JetPlusTrackProducerAA::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) -{ - using namespace edm; - - -// std::cout<<" RecoJets::JetPlusTrackProducerAA::produce "< > jets_h; - iEvent.getByToken (input_jets_token_, jets_h); - - edm::Handle tracks_h; - iEvent.getByToken (input_tracks_token_, tracks_h); - - std::vector fTracks; - fTracks.reserve (tracks_h->size()); +void JetPlusTrackProducerAA::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + using namespace edm; + + // std::cout<<" RecoJets::JetPlusTrackProducerAA::produce "< > jets_h; + iEvent.getByToken(input_jets_token_, jets_h); + + edm::Handle tracks_h; + iEvent.getByToken(input_tracks_token_, tracks_h); + + std::vector fTracks; + fTracks.reserve(tracks_h->size()); for (unsigned i = 0; i < tracks_h->size(); ++i) { - fTracks.push_back (reco::TrackRef (tracks_h, i)); - } + fTracks.push_back(reco::TrackRef(tracks_h, i)); + } -//=> - edm::Handle > extrapolations_h; + //=> + edm::Handle > extrapolations_h; iEvent.getByToken(input_extrapolations_token_, extrapolations_h); -// std::cout<<"JetPlusTrackProducerAA::produce, extrapolations_h="<size()< + // std::cout<<"JetPlusTrackProducerAA::produce, extrapolations_h="<size()< auto pOut = std::make_unique(); - + reco::JPTJetCollection tmpColl; for (unsigned i = 0; i < jets_h->size(); ++i) { + const reco::CaloJet* oldjet = &(*(jets_h->refAt(i))); - const reco::CaloJet* oldjet = &(*(jets_h->refAt(i))); - - reco::CaloJet corrected = *oldjet; - -// ZSP corrections - - double factorZSP = 1.; - if(useZSP) factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup); - -// std::cout << " UseZSP = "<correction ( corrected, *oldjet, iEvent, iSetup, pions, muons, elecs, ok ); - p4 = math::XYZTLorentzVector( corrected.px()*scaleJPT, - corrected.py()*scaleJPT, - corrected.pz()*scaleJPT, - corrected.energy()*scaleJPT ); - } else { - scaleJPT = mJPTalgo->correction( corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs, ok ); - } - - - - reco::JPTJet::Specific specific; - - if(ok) { -// std::cout<<" Size of Pion in-in "<et()<<" factorZSP "<correction(corrected, iEvent, iSetup); + + // std::cout << " UseZSP = "<correction(corrected, *oldjet, iEvent, iSetup, pions, muons, elecs, ok); + p4 = math::XYZTLorentzVector(corrected.px() * scaleJPT, + corrected.py() * scaleJPT, + corrected.pz() * scaleJPT, + corrected.energy() * scaleJPT); + } else { + scaleJPT = mJPTalgo->correction(corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs, ok); + } + + reco::JPTJet::Specific specific; + + if (ok) { + // std::cout<<" Size of Pion in-in "<et()<<" factorZSP "< myjet = (edm::RefToBase)jets_h->refAt(i); specific.theCaloJetRef = myjet; specific.mZSPCor = factorZSP; @@ -220,272 +205,269 @@ JetPlusTrackProducerAA::produce(edm::Event& iEvent, const edm::EventSetup& iSetu specific.mSumEnergyOfChargedWithEff = (float)mJPTalgo->getSumEnergyWithEff(); specific.mSumEnergyOfChargedWithoutEff = (float)mJPTalgo->getSumEnergyWithoutEff(); specific.mChargedHadronEnergy = (float)mJPTalgo->getSumEnergyWithoutEff(); -// Fill Charged Jet shape parameters - double deR2Tr = 0.; - double deEta2Tr = 0.; - double dePhi2Tr = 0.; - double Zch = 0.; - double Pout2 = 0.; - double Pout = 0.; - double denominator_tracks = 0.; - int ntracks = 0; - - for( reco::TrackRefVector::const_iterator it = pions.inVertexInCalo_.begin(); it != pions.inVertexInCalo_.end(); it++) { - double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); - double deEta = (*it)->eta() - p4.eta(); - double dePhi = deltaPhi((*it)->phi(), p4.phi()); - if((**it).ptError()/(**it).pt() < 0.1) { - deR2Tr = deR2Tr + deR*deR*(*it)->pt(); - deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); - dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); - denominator_tracks = denominator_tracks + (*it)->pt(); - Zch = Zch + (*it)->pt(); - - Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); - ntracks++; - } - } - for( reco::TrackRefVector::const_iterator it = muons.inVertexInCalo_.begin(); it != muons.inVertexInCalo_.end(); it++) { - double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); - double deEta = (*it)->eta() - p4.eta(); - double dePhi = deltaPhi((*it)->phi(), p4.phi()); - if((**it).ptError()/(**it).pt() < 0.1) { - deR2Tr = deR2Tr + deR*deR*(*it)->pt(); - deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); - dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); - denominator_tracks = denominator_tracks + (*it)->pt(); - Zch = Zch + (*it)->pt(); - - Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); - ntracks++; - } - } - for( reco::TrackRefVector::const_iterator it = elecs.inVertexInCalo_.begin(); it != elecs.inVertexInCalo_.end(); it++) { - double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); - double deEta = (*it)->eta() - p4.eta(); - double dePhi = deltaPhi((*it)->phi(), p4.phi()); - if((**it).ptError()/(**it).pt() < 0.1) { - deR2Tr = deR2Tr + deR*deR*(*it)->pt(); - deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); - dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); - denominator_tracks = denominator_tracks + (*it)->pt(); - Zch = Zch + (*it)->pt(); - - Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); - ntracks++; - } - } - for( reco::TrackRefVector::const_iterator it = pions.inVertexOutOfCalo_.begin(); it != pions.inVertexOutOfCalo_.end(); it++) { - Zch = Zch + (*it)->pt(); - } - for( reco::TrackRefVector::const_iterator it = muons.inVertexOutOfCalo_.begin(); it != muons.inVertexOutOfCalo_.end(); it++) { - Zch = Zch + (*it)->pt(); - } - for( reco::TrackRefVector::const_iterator it = elecs.inVertexOutOfCalo_.begin(); it != elecs.inVertexOutOfCalo_.end(); it++) { - Zch = Zch + (*it)->pt(); - } - - if(mJPTalgo->getSumPtForBeta()> 0.) Zch = Zch/mJPTalgo->getSumPtForBeta(); - - // std::cout<<" Zch "<< Zch<<" "<getSumPtForBeta()< 0) { - Pout = sqrt(fabs(Pout2))/ntracks; - } + // Fill Charged Jet shape parameters + double deR2Tr = 0.; + double deEta2Tr = 0.; + double dePhi2Tr = 0.; + double Zch = 0.; + double Pout2 = 0.; + double Pout = 0.; + double denominator_tracks = 0.; + int ntracks = 0; + + for (reco::TrackRefVector::const_iterator it = pions.inVertexInCalo_.begin(); it != pions.inVertexInCalo_.end(); + it++) { + double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); + double deEta = (*it)->eta() - p4.eta(); + double dePhi = deltaPhi((*it)->phi(), p4.phi()); + if ((**it).ptError() / (**it).pt() < 0.1) { + deR2Tr = deR2Tr + deR * deR * (*it)->pt(); + deEta2Tr = deEta2Tr + deEta * deEta * (*it)->pt(); + dePhi2Tr = dePhi2Tr + dePhi * dePhi * (*it)->pt(); + denominator_tracks = denominator_tracks + (*it)->pt(); + Zch = Zch + (*it)->pt(); + + Pout2 = Pout2 + (**it).p() * (**it).p() - (Zch * p4.P()) * (Zch * p4.P()); + ntracks++; + } + } + for (reco::TrackRefVector::const_iterator it = muons.inVertexInCalo_.begin(); it != muons.inVertexInCalo_.end(); + it++) { + double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); + double deEta = (*it)->eta() - p4.eta(); + double dePhi = deltaPhi((*it)->phi(), p4.phi()); + if ((**it).ptError() / (**it).pt() < 0.1) { + deR2Tr = deR2Tr + deR * deR * (*it)->pt(); + deEta2Tr = deEta2Tr + deEta * deEta * (*it)->pt(); + dePhi2Tr = dePhi2Tr + dePhi * dePhi * (*it)->pt(); + denominator_tracks = denominator_tracks + (*it)->pt(); + Zch = Zch + (*it)->pt(); + + Pout2 = Pout2 + (**it).p() * (**it).p() - (Zch * p4.P()) * (Zch * p4.P()); + ntracks++; + } + } + for (reco::TrackRefVector::const_iterator it = elecs.inVertexInCalo_.begin(); it != elecs.inVertexInCalo_.end(); + it++) { + double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); + double deEta = (*it)->eta() - p4.eta(); + double dePhi = deltaPhi((*it)->phi(), p4.phi()); + if ((**it).ptError() / (**it).pt() < 0.1) { + deR2Tr = deR2Tr + deR * deR * (*it)->pt(); + deEta2Tr = deEta2Tr + deEta * deEta * (*it)->pt(); + dePhi2Tr = dePhi2Tr + dePhi * dePhi * (*it)->pt(); + denominator_tracks = denominator_tracks + (*it)->pt(); + Zch = Zch + (*it)->pt(); + + Pout2 = Pout2 + (**it).p() * (**it).p() - (Zch * p4.P()) * (Zch * p4.P()); + ntracks++; + } + } + for (reco::TrackRefVector::const_iterator it = pions.inVertexOutOfCalo_.begin(); + it != pions.inVertexOutOfCalo_.end(); + it++) { + Zch = Zch + (*it)->pt(); + } + for (reco::TrackRefVector::const_iterator it = muons.inVertexOutOfCalo_.begin(); + it != muons.inVertexOutOfCalo_.end(); + it++) { + Zch = Zch + (*it)->pt(); + } + for (reco::TrackRefVector::const_iterator it = elecs.inVertexOutOfCalo_.begin(); + it != elecs.inVertexOutOfCalo_.end(); + it++) { + Zch = Zch + (*it)->pt(); + } + + if (mJPTalgo->getSumPtForBeta() > 0.) + Zch = Zch / mJPTalgo->getSumPtForBeta(); + + // std::cout<<" Zch "<< Zch<<" "<getSumPtForBeta()< 0) { + Pout = sqrt(fabs(Pout2)) / ntracks; + } + + if (denominator_tracks != 0) { + deR2Tr = deR2Tr / denominator_tracks; + deEta2Tr = deEta2Tr / denominator_tracks; + dePhi2Tr = dePhi2Tr / denominator_tracks; + } + specific.R2momtr = deR2Tr; + specific.Eta2momtr = deEta2Tr; + specific.Phi2momtr = dePhi2Tr; + specific.Pout = Pout; + specific.Zch = Zch; - if (denominator_tracks!=0){ - deR2Tr = deR2Tr/denominator_tracks; - deEta2Tr= deEta2Tr/denominator_tracks; - dePhi2Tr= dePhi2Tr/denominator_tracks; - } + // Create JPT jet - specific.R2momtr = deR2Tr; - specific.Eta2momtr = deEta2Tr; - specific.Phi2momtr = dePhi2Tr; - specific.Pout = Pout; - specific.Zch = Zch; + reco::Particle::Point vertex_ = reco::Jet::Point(0, 0, 0); -// Create JPT jet + // If we add primary vertex + edm::Handle pvCollection; + iEvent.getByToken(input_vertex_token_, pvCollection); + if (pvCollection.isValid() && !pvCollection->empty()) + vertex_ = pvCollection->begin()->position(); - reco::Particle::Point vertex_=reco::Jet::Point(0,0,0); - -// If we add primary vertex - edm::Handle pvCollection; - iEvent.getByToken(input_vertex_token_, pvCollection); - if ( pvCollection.isValid() && !pvCollection->empty() ) vertex_=pvCollection->begin()->position(); - - reco::JPTJet fJet(p4, vertex_, specific, corrected.getJetConstituents()); - // fJet.printJet(); + reco::JPTJet fJet(p4, vertex_, specific, corrected.getJetConstituents()); + // fJet.printJet(); -// Temporarily collection before correction for background - - tmpColl.push_back(fJet); + // Temporarily collection before correction for background + tmpColl.push_back(fJet); } -//=======================================================================================================> -// Correction for background + //=======================================================================================================> + // Correction for background reco::TrackRefVector trBgOutOfCalo; - reco::TrackRefVector trBgOutOfVertex = calculateBGtracksJet(tmpColl,fTracks,extrapolations_h,trBgOutOfCalo); - -//===> Area without Jets - std::map AreaNonJet; - - for(reco::JPTJetCollection::iterator ij1=tmpColl.begin(); ij1!=tmpColl.end(); ij1++) - { - int nj1 = 1; - for(reco::JPTJetCollection::iterator ij2=tmpColl.begin(); ij2!=tmpColl.end(); ij2++) - { - if(ij2 == ij1) continue; - if(fabs((*ij1).eta() - (*ij2).eta()) > 0.5 ) continue; - nj1++; + reco::TrackRefVector trBgOutOfVertex = calculateBGtracksJet(tmpColl, fTracks, extrapolations_h, trBgOutOfCalo); + + //===> Area without Jets + std::map AreaNonJet; + + for (reco::JPTJetCollection::iterator ij1 = tmpColl.begin(); ij1 != tmpColl.end(); ij1++) { + int nj1 = 1; + for (reco::JPTJetCollection::iterator ij2 = tmpColl.begin(); ij2 != tmpColl.end(); ij2++) { + if (ij2 == ij1) + continue; + if (fabs((*ij1).eta() - (*ij2).eta()) > 0.5) + continue; + nj1++; + } - } + AreaNonJet[ij1] = 4 * M_PI * mConeSize - nj1 * 4 * mConeSize * mConeSize; - AreaNonJet[ij1] = 4*M_PI*mConeSize - nj1*4*mConeSize*mConeSize; + // std::cout<<"+++AreaNonJet[ij1]="<second; - -// std::cout<<"+++ ja="<second; + + // std::cout<<"+++ ja="<push_back(*ij); - -// std::cout<<" New JPT energy "<<(*ij).et()<<" "<<(*ij).pt()<<" "<<(*ij).eta()<<" "<<(*ij).phi()<& fTracks, - edm::Handle > & extrapolations_h, - reco::TrackRefVector& trBgOutOfCalo){ - - +reco::TrackRefVector JetPlusTrackProducerAA::calculateBGtracksJet( + reco::JPTJetCollection& fJets, + std::vector& fTracks, + edm::Handle >& extrapolations_h, + reco::TrackRefVector& trBgOutOfCalo) { reco::TrackRefVector trBgOutOfVertex; - + for (unsigned t = 0; t < fTracks.size(); ++t) { + int track_bg = 0; - int track_bg = 0; - // if(!(*fTracks[t]).quality(trackQuality_)) // { - // cout<<"BG, BAD trackQuality, ptBgV="<pt()<<" etaBgV = "<eta()<<" phiBgV = "<phi()< track="< track="<>>> Track inside jet at vertex, track_bg="<< track_bg <<" track="<>>> Track inside jet at vertex, track_bg="<< track_bg <<" track="<isValid().at(0)<isValid().at(0) == 0 ) continue; - //in DF change in 4.2, all entries are valid. - nValid++; + //=====> Propagate BG tracks to calo + int nValid = 0; + for (std::vector::const_iterator xtrpBegin = extrapolations_h->begin(), + xtrpEnd = extrapolations_h->end(), + ixtrp = xtrpBegin; + ixtrp != xtrpEnd; + ++ixtrp) { + // std::cout<<"JetPlusTrackProducerAA::calculateBGtracksJet: initial track pt= "<track()->pt() + // <<" eta= "<track()->eta()<<" phi="<track()->phi() + // <<" Valid? "<isValid().at(0)<isValid().at(0) == 0 ) continue; + //in DF change in 4.2, all entries are valid. + nValid++; - if ( it != trBgOutOfVertex.end() ){ - trBgOutOfCalo.push_back (*it); + reco::TrackRefVector::iterator it = find(trBgOutOfVertex.begin(), trBgOutOfVertex.end(), (*ixtrp).track()); -// std::cout<<"+++trBgOutOfCalo, pt= "<track()->pt()<<" eta= "<track()->eta()<<" phi="<track()->phi() -// <<" Valid? "<isValid().at(0)<isValid().at(0)<definitions()).formula()).c_str()<definitions()).formula()).c_str()); + mFunc = new TFormula("function", ((mParameters->definitions()).formula()).c_str()); -// Read parameters - if (debug_) { - std::cout<<" Size of parameters as read by SimpleJetCorrectorParameters "<size()<size(); i++){ - const std::vector p = mParameters->record (i).parameters (); - for(std::vector::const_iterator j=p.begin(); jrecord (i).xMin(0)<<" "<record (i).xMax(0)<<" "<<(*j)<size() << std::endl; + for (unsigned int i = 0; i < mParameters->size(); i++) { + const std::vector p = mParameters->record(i).parameters(); + for (std::vector::const_iterator j = p.begin(); j < p.end(); j++) { + std::cout << " Parameter number " << mParameters->record(i).xMin(0) << " " << mParameters->record(i).xMax(0) + << " " << (*j) << std::endl; + } + } + } // debug } -SimpleZSPJPTJetCorrector::~SimpleZSPJPTJetCorrector () { -} +SimpleZSPJPTJetCorrector::~SimpleZSPJPTJetCorrector() {} -double SimpleZSPJPTJetCorrector::correctionPtEtaPhiE (double fPt, double fEta, double fPhi, double fE) const { - double costhetainv = cosh (fEta); - return correctionEtEtaPhiP (fE/costhetainv, fEta, fPhi, fPt*costhetainv); +double SimpleZSPJPTJetCorrector::correctionPtEtaPhiE(double fPt, double fEta, double fPhi, double fE) const { + double costhetainv = cosh(fEta); + return correctionEtEtaPhiP(fE / costhetainv, fEta, fPhi, fPt * costhetainv); } -double SimpleZSPJPTJetCorrector::correctionEtEtaPhiP (double fEt, double fEta, double fPhi, double fP) const { - - double et=fEt; - double eta=fabs (fEta); +double SimpleZSPJPTJetCorrector::correctionEtEtaPhiP(double fEt, double fEta, double fPhi, double fP) const { + double et = fEt; + double eta = fabs(fEta); double factor = 1.; -// Define Eta bin for parametrization - std::vector xx; xx.push_back(eta); + // Define Eta bin for parametrization + std::vector xx; + xx.push_back(eta); int band = mParameters->binIndex(xx); - if(band < 0) return factor; + if (band < 0) + return factor; - const std::vector p = mParameters->record (band).parameters (); + const std::vector p = mParameters->record(band).parameters(); - // Set parameters - for(unsigned int i=0; iSetParameter(i,p[i]); + // Set parameters + for (unsigned int i = 0; i < p.size(); i++) { + mFunc->SetParameter(i, p[i]); } if (debug_) { - cout<<" Et and eta of jet "<Eval(et); -// If et calojet less then some value - use correction on the boundary - - if( et < p[0] ) koef = 1. - mFunc->Eval(p[0]); + // If et calojet less then some value - use correction on the boundary -// - if(koef <= 0.000001) - { - if (debug_) std::cout<<"SimpleZSPJPTJetCorrector::Problem with ZSP corrections "<Eval(p[0]); + + // + if (koef <= 0.000001) { + if (debug_) + std::cout << "SimpleZSPJPTJetCorrector::Problem with ZSP corrections " << koef << std::endl; + koef = 1.; } - double etnew = et/koef; + double etnew = et / koef; - if (debug_) cout<<" The new energy found "< xx; xx.push_back(eta); + // Define Eta bin for parametrization + std::vector xx; + xx.push_back(eta); int band = mParameters->binIndex(xx); - if(band < 0) return factor; + if (band < 0) + return factor; - const std::vector p = mParameters->record (band).parameters (); + const std::vector p = mParameters->record(band).parameters(); if (debug_) { - cout<<" Et and eta of jet "<(iConfig.getParameter( "PFCandidates" )); - tokenPFCandidatesLostTracks_=consumes(iConfig.getParameter( "PFCandidatesLostTracks" )); - produces("tracksFromPF"); +TrackFromPFProducer::TrackFromPFProducer(const edm::ParameterSet& iConfig) { + tokenPFCandidates_ = consumes(iConfig.getParameter("PFCandidates")); + tokenPFCandidatesLostTracks_ = + consumes(iConfig.getParameter("PFCandidatesLostTracks")); + produces("tracksFromPF"); } - -void TrackFromPFProducer::produce(edm::Event& theEvent, const edm::EventSetup& setup) -{ +void TrackFromPFProducer::produce(edm::Event& theEvent, const edm::EventSetup& setup) { // // create empty output collections // auto outputTColl = std::make_unique(); - // std::cout<<" TrackFromPFProducer::produce "< pfCandidates; - theEvent.getByToken( tokenPFCandidates_, pfCandidates); - - for(unsigned int i = 0, n = pfCandidates->size(); i < n; ++i) { - const pat::PackedCandidate &pf = (*pfCandidates)[i]; - if(pf.hasTrackDetails()){ - const reco::Track &mytrack = pf.pseudoTrack(); - - // std::cout<<" Track "<push_back(mytrack); - } - //else { - // if(pf.charge()>0) std::cout< pfCandidates; + theEvent.getByToken(tokenPFCandidates_, pfCandidates); + + for (unsigned int i = 0, n = pfCandidates->size(); i < n; ++i) { + const pat::PackedCandidate& pf = (*pfCandidates)[i]; + if (pf.hasTrackDetails()) { + const reco::Track& mytrack = pf.pseudoTrack(); + + // std::cout<<" Track "<push_back(mytrack); } + //else { + // if(pf.charge()>0) std::cout< { public: - /// Constructor explicit TrackFromPFProducer(const edm::ParameterSet& iConfig); @@ -20,9 +19,8 @@ class TrackFromPFProducer : public edm::stream::EDProducer<> { void produce(edm::Event&, const edm::EventSetup&) override; private: - edm::EDGetTokenT > tokenPFCandidates_; - edm::EDGetTokenT > tokenPFCandidatesLostTracks_; - + edm::EDGetTokenT > tokenPFCandidates_; + edm::EDGetTokenT > tokenPFCandidatesLostTracks_; }; #endif diff --git a/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.cc b/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.cc index a8aa5a0d042c2..12b1b7edfc06a 100644 --- a/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.cc +++ b/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.cc @@ -15,52 +15,54 @@ using namespace std; +ZSPJPTJetCorrector::ZSPJPTJetCorrector(const edm::ParameterSet& fConfig) { + iPU = fConfig.getParameter("PU"); + fixedPU = fConfig.getParameter("FixedPU"); -ZSPJPTJetCorrector::ZSPJPTJetCorrector (const edm::ParameterSet& fConfig) { - - iPU = fConfig.getParameter("PU"); - fixedPU = fConfig.getParameter("FixedPU"); - - if( iPU >= 0 || fixedPU > 0 ) { - theFilesL1Offset = fConfig.getParameter > ("tagNameOffset"); - for(vector::iterator it=theFilesL1Offset.begin(); it != theFilesL1Offset.end(); it++) { - std::string file="CondFormats/JetMETObjects/data/"+(*it)+".txt"; - edm::FileInPath f2(file); - mSimpleCorrectorOffset.push_back(new SimpleZSPJPTJetCorrector (f2.fullPath())); - } - } + if (iPU >= 0 || fixedPU > 0) { + theFilesL1Offset = fConfig.getParameter >("tagNameOffset"); + for (vector::iterator it = theFilesL1Offset.begin(); it != theFilesL1Offset.end(); it++) { + std::string file = "CondFormats/JetMETObjects/data/" + (*it) + ".txt"; + edm::FileInPath f2(file); + mSimpleCorrectorOffset.push_back(new SimpleZSPJPTJetCorrector(f2.fullPath())); + } + } - theFilesZSP = fConfig.getParameter > ("tagName"); - for(vector::iterator it=theFilesZSP.begin(); it != theFilesZSP.end(); it++) { - std::string file="CondFormats/JetMETObjects/data/"+(*it)+".txt"; - edm::FileInPath f1(file); - mSimpleCorrector.push_back(new SimpleZSPJPTJetCorrector (f1.fullPath())); - } -// cout<<" Size of correctors "< >("tagName"); + for (vector::iterator it = theFilesZSP.begin(); it != theFilesZSP.end(); it++) { + std::string file = "CondFormats/JetMETObjects/data/" + (*it) + ".txt"; + edm::FileInPath f1(file); + mSimpleCorrector.push_back(new SimpleZSPJPTJetCorrector(f1.fullPath())); + } + // cout<<" Size of correctors "< 0) { -// Look for the Lumi section -// LuminosityBlock lbID = iEvent.getLuminosityBlock(); -// cout<<" Not implemented yet "< 0) { + // Look for the Lumi section + // LuminosityBlock lbID = iEvent.getLuminosityBlock(); + // cout<<" Not implemented yet "<correctionPtEtaPhiE (fJet.p4().Pt(), fJet.p4().Eta(), fJet.p4().Phi(),fJet.p4().E()); + double a = + mSimpleCorrector[nPU]->correctionPtEtaPhiE(fJet.p4().Pt(), fJet.p4().Eta(), fJet.p4().Phi(), fJet.p4().E()); - if(iPU >= 0) { - if(!mSimpleCorrectorOffset.empty()) { - b = mSimpleCorrectorOffset[nPU]->correctionPUEtEtaPhiP (fJet.p4().Pt(), fJet.p4().Eta(), fJet.p4().Phi(),fJet.p4().E()); - } + if (iPU >= 0) { + if (!mSimpleCorrectorOffset.empty()) { + b = mSimpleCorrectorOffset[nPU]->correctionPUEtEtaPhiP( + fJet.p4().Pt(), fJet.p4().Eta(), fJet.p4().Phi(), fJet.p4().E()); + } } - double c = a * b; - return c; + double c = a * b; + return c; } - diff --git a/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.h b/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.h index eb0344ab49970..988137462b3d7 100644 --- a/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.h +++ b/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.h @@ -19,21 +19,21 @@ namespace edm { class SimpleZSPJPTJetCorrector; class ZSPJPTJetCorrector { - public: - ZSPJPTJetCorrector (const edm::ParameterSet& fParameters); - virtual ~ZSPJPTJetCorrector (); - /// apply correction using Event information - virtual double correction( const reco::Jet&, const edm::Event&, const edm::EventSetup& ) const; +public: + ZSPJPTJetCorrector(const edm::ParameterSet& fParameters); + virtual ~ZSPJPTJetCorrector(); + /// apply correction using Event information + virtual double correction(const reco::Jet&, const edm::Event&, const edm::EventSetup&) const; /// Set the number of pileups - virtual int setPU() const {return fixedPU;} + virtual int setPU() const { return fixedPU; } - private: - std::vector mSimpleCorrector; - std::vector mSimpleCorrectorOffset; - std::vector theFilesL1Offset; - std::vector theFilesZSP; - int iPU; - int fixedPU; +private: + std::vector mSimpleCorrector; + std::vector mSimpleCorrectorOffset; + std::vector theFilesL1Offset; + std::vector theFilesZSP; + int iPU; + int fixedPU; }; #endif From d3fc790eb3ffe50e2cd9fbac7b38abb254333d0e Mon Sep 17 00:00:00 2001 From: Olga Kodolova Date: Thu, 11 Jun 2020 19:53:40 +0200 Subject: [PATCH 09/14] Add missed flag in configurator --- RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py index 760f734725ef6..1fd86b805eec5 100644 --- a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py +++ b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py @@ -42,7 +42,8 @@ UseZSP = cms.bool(False), srcPVs = cms.InputTag('offlinePrimaryVertices'), alias = cms.untracked.string('JetPlusTrackZSPCorJetAntiKt4'), - ptCUT = cms.double(15.) + ptCUT = cms.double(15.), + dRcone = cms.double(0.4) ) JetPlusTrackZSPCorJetAntiKt4.JetTracksAssociationAtVertex = cms.InputTag("ak4JetTracksAssociatorAtVertexJPT") From fa5a5cb093b70f2016915a45b206c6c522573ce4 Mon Sep 17 00:00:00 2001 From: Olga Kodolova Date: Sun, 14 Jun 2020 20:01:02 +0200 Subject: [PATCH 10/14] Remove *.orig *.rej --- .../plugins/JetPlusTrackProducer.cc.orig | 393 ------------------ .../plugins/JetPlusTrackProducer.cc.rej | 389 ----------------- .../plugins/JetPlusTrackProducer.h.orig | 70 ---- .../plugins/JetPlusTrackProducer.h.rej | 51 --- 4 files changed, 903 deletions(-) delete mode 100644 RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc.orig delete mode 100644 RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc.rej delete mode 100644 RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.orig delete mode 100644 RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.rej diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc.orig b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc.orig deleted file mode 100644 index 1b4258f0d79ba..0000000000000 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc.orig +++ /dev/null @@ -1,393 +0,0 @@ -// -*- C++ -*- -// -// Package: JetPlusTracks -// Class: JetPlusTrackProducer -// -/**\class JetPlusTrackProducer JetPlusTrackProducer.cc JetPlusTrackProducer.cc - - Description: [one line class summary] - - Implementation: - [Notes on implementation] -*/ -// -// Original Author: Olga Kodolova,40 R-A12,+41227671273, -// Created: Fri Feb 19 10:14:02 CET 2010 -// -// - - -// system include files -#include - -// user include files - -#include "FWCore/Framework/interface/MakerMacros.h" - -#include "FWCore/ParameterSet/interface/ParameterSet.h" - -#include "RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h" -#include "DataFormats/JetReco/interface/CaloJetCollection.h" -#include "DataFormats/JetReco/interface/CaloJet.h" -#include "DataFormats/JetReco/interface/JPTJetCollection.h" -#include "DataFormats/JetReco/interface/JPTJet.h" -#include "DataFormats/JetReco/interface/TrackJetCollection.h" -#include "DataFormats/JetReco/interface/TrackJet.h" -#include "DataFormats/TrackReco/interface/TrackFwd.h" -#include "DataFormats/TrackReco/interface/Track.h" -#include "DataFormats/JetReco/interface/Jet.h" -#include "DataFormats/VertexReco/interface/VertexFwd.h" -#include "DataFormats/VertexReco/interface/Vertex.h" -#include "DataFormats/Math/interface/deltaPhi.h" -#include "DataFormats/Math/interface/deltaR.h" - -#include - -using namespace std; -using namespace jpt; - -// -// constants, enums and typedefs -// - - -// -// static data member definitions -// - -// -// constructors and destructor -// -JetPlusTrackProducer::JetPlusTrackProducer(const edm::ParameterSet& iConfig) -{ - //register your products - src = iConfig.getParameter("src"); - srcTrackJets = iConfig.getParameter("srcTrackJets"); - alias = iConfig.getUntrackedParameter("alias"); - srcPVs_ = iConfig.getParameter("srcPVs"); - vectorial_ = iConfig.getParameter("VectorialCorrection"); - useZSP = iConfig.getParameter("UseZSP"); - ptCUT = iConfig.getParameter("ptCUT"); - dRcone = iConfig.getParameter("dRcone"); - - mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector()); - if(useZSP) mZSPalgo = new ZSPJPTJetCorrector(iConfig); - - produces().setBranchAlias(alias); - produces().setBranchAlias("ak4CaloJetsJPT"); - - input_jets_token_ = consumes >(src); - input_addjets_token_ = consumes >(iConfig.getParameter("srcAddCaloJets")); - input_trackjets_token_ = consumes >(srcTrackJets); - input_vertex_token_ = consumes(srcPVs_); - mExtrapolations = consumes > - (iConfig.getParameter ("extrapolations")); -} - - -JetPlusTrackProducer::~JetPlusTrackProducer() -{ - - // do anything here that needs to be done at desctruction time - // (e.g. close files, deallocate resources etc.) - -} - - -// -// member functions -// -bool sort_by_pt (reco::JPTJet a,reco::JPTJet b) { return (a.pt()>b.pt());} - -// ------------ method called to produce the data ------------ -void -JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) -{ - using namespace edm; - -// std::cout<<" RecoJets::JetPlusTrackProducer::produce "< > jets_h; - iEvent.getByToken (input_jets_token_, jets_h); - -//JetPlusTrackAddonSeed - edm::Handle > addjets_h; - iEvent.getByToken (input_addjets_token_, addjets_h); - - //std::cout<<" Additional Calojets "<size()< > jetsTrackJets; - iEvent.getByToken(input_trackjets_token_, jetsTrackJets); - - //std::cout<<" Additional Trackjets "<size()< > iExtrapolations; - iEvent.getByToken (mExtrapolations, iExtrapolations); - - edm::RefProd pOut1RefProd = - iEvent.getRefBeforePut(); - edm::Ref::key_type idxCaloJet = 0; - - auto pOut = std::make_unique(); - auto pOut1 = std::make_unique(); - - double scaleJPT = 1.; - std::vector theJPTJets; - if (jetsTrackJets.isValid()) { - if(!jetsTrackJets->empty()) { - for (unsigned ijet = 0; ijet < jetsTrackJets->size(); ++ijet) { - const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet))); - int icalo = -1; - if(addjets_h.isValid()) { - for (unsigned i = 0; i < addjets_h->size(); ++i) { - const reco::CaloJet* oldjet = &(*(addjets_h->refAt(i))); - double deta = fabs(jet->eta()-oldjet->eta()); - double dphi = fabs(jet->phi()-oldjet->phi()); - if(dphi>4.*atan(1.)) dphi = 8.*atan(1.) - dphi; - double dr = sqrt(dphi*dphi+deta*deta); - if(dr<=dRcone) {icalo=i;} - } // Calojets - } - if(icalo < 0) continue; - const reco::CaloJet* mycalo = &(*(addjets_h->refAt(icalo))); - // std::cout<<" Additional CaloJet "<pt()<<" "<eta()<< - // " "<phi()< > tracksinjet = jet->tracks(); - reco::TrackRefVector tracksincalo; - reco::TrackRefVector tracksinvert; - for(std::vector >::iterator itrack = tracksinjet.begin(); - itrack != tracksinjet.end(); itrack++) { - for ( std::vector::const_iterator xtrpBegin = iExtrapolations->begin(), - xtrpEnd = iExtrapolations->end(), ixtrp = xtrpBegin; - ixtrp != xtrpEnd; ++ixtrp ) - { - if ( ixtrp->positions().empty() ) continue; - double mydphi =fabs(ixtrp->track()->phi()-(**itrack).phi()); - if(mydphi>4.*atan(1.)) mydphi = 8.*atan(1)-mydphi; - if(fabs(ixtrp->track()->pt()-(**itrack).pt()) > 0.001 || - fabs(ixtrp->track()->eta()-(**itrack).eta()) > 0.001 || mydphi > 0.001) continue; - tracksinvert.push_back(ixtrp->track()); - reco::TrackBase::Point const & point = ixtrp->positions().at(0); - - double dr = reco::deltaR( jet->eta(), jet->phi(), point.eta(), point.phi() ); - if(dr <= dRcone) { - /*std::cout<<" TrackINcalo "<track()); - } - } // Track extrapolations - } // tracks - - reco::TrackJet corrected = *jet; - math::XYZTLorentzVector p4; - jpt::MatchedTracks pions; - jpt::MatchedTracks muons; - jpt::MatchedTracks elecs; - - scaleJPT = mJPTalgo->correction( corrected, *mycalo, iEvent, iSetup, - tracksinvert, tracksincalo, p4, pions, muons, elecs); - // std::cout<<" JetPlusTrackProducer::AddSeedJet "<< (*mycalo).pt()<<" "<< (*mycalo).eta()<<" "<< - // (*mycalo).phi()<<" "<<(*mycalo).jetArea()<<" Corr "<< - // p4.pt()<<" "< ptCUT) { - reco::JPTJet::Specific jptspe; - jptspe.pionsInVertexInCalo = pions.inVertexInCalo_; - jptspe.pionsInVertexOutCalo = pions.inVertexOutOfCalo_; - jptspe.pionsOutVertexInCalo = pions.outOfVertexInCalo_; - jptspe.muonsInVertexInCalo = muons.inVertexInCalo_; - jptspe.muonsInVertexOutCalo = muons.inVertexOutOfCalo_; - jptspe.muonsOutVertexInCalo = muons.outOfVertexInCalo_; - jptspe.elecsInVertexInCalo = elecs.inVertexInCalo_; - jptspe.elecsInVertexOutCalo = elecs.inVertexOutOfCalo_; - jptspe.elecsOutVertexInCalo = elecs.outOfVertexInCalo_; - reco::CaloJetRef myjet(pOut1RefProd, idxCaloJet++); - jptspe.theCaloJetRef = edm::RefToBase(myjet); - jptspe.mZSPCor = 1.; - reco::JPTJet fJet(p4, jet->primaryVertex()->position(), jptspe, mycalo->getJetConstituents()); - pOut->push_back(fJet); - pOut1->push_back(*mycalo); - theJPTJets.push_back(fJet); - } - } // trackjets - } // jets - } // There is trackjet collection - - for (unsigned i = 0; i < jets_h->size(); ++i) { - - const reco::CaloJet* oldjet = &(*(jets_h->refAt(i))); - reco::CaloJet corrected = *oldjet; - -// ZSP corrections - - double factorZSP = 1.; - if(useZSP) factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup); - corrected.scaleEnergy (factorZSP); - -// JPT corrections - scaleJPT = 1.; - - math::XYZTLorentzVector p4; - - jpt::MatchedTracks pions; - jpt::MatchedTracks muons; - jpt::MatchedTracks elecs; - bool ok=false; - - if ( !vectorial_ ) { - - scaleJPT = mJPTalgo->correction ( corrected, *oldjet, iEvent, iSetup, pions, muons, elecs,ok ); - p4 = math::XYZTLorentzVector( corrected.px()*scaleJPT, - corrected.py()*scaleJPT, - corrected.pz()*scaleJPT, - corrected.energy()*scaleJPT ); - // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< (*oldjet).phi()<< - // " "<correction( corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs,ok ); - // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< - // (*oldjet).phi()<<" "<<(*oldjet).jetArea()<<" Corr "<< - // p4.pt()<<" "< myjet = (edm::RefToBase)jets_h->refAt(i); - specific.theCaloJetRef = myjet; - specific.mZSPCor = factorZSP; - specific.mResponseOfChargedWithEff = (float)mJPTalgo->getResponseOfChargedWithEff(); - specific.mResponseOfChargedWithoutEff = (float)mJPTalgo->getResponseOfChargedWithoutEff(); - specific.mSumPtOfChargedWithEff = (float)mJPTalgo->getSumPtWithEff(); - specific.mSumPtOfChargedWithoutEff = (float)mJPTalgo->getSumPtWithoutEff(); - specific.mSumEnergyOfChargedWithEff = (float)mJPTalgo->getSumEnergyWithEff(); - specific.mSumEnergyOfChargedWithoutEff = (float)mJPTalgo->getSumEnergyWithoutEff(); - specific.mChargedHadronEnergy = (float)mJPTalgo->getSumEnergyWithoutEff(); - -// Fill Charged Jet shape parameters - double deR2Tr = 0.; - double deEta2Tr = 0.; - double dePhi2Tr = 0.; - double Zch = 0.; - double Pout2 = 0.; - double Pout = 0.; - double denominator_tracks = 0.; - int ntracks = 0; - - for( reco::TrackRefVector::const_iterator it = pions.inVertexInCalo_.begin(); it != pions.inVertexInCalo_.end(); it++) { - double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); - double deEta = (*it)->eta() - p4.eta(); - double dePhi = deltaPhi((*it)->phi(), p4.phi()); - if((**it).ptError()/(**it).pt() < 0.1) { - deR2Tr = deR2Tr + deR*deR*(*it)->pt(); - deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); - dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); - denominator_tracks = denominator_tracks + (*it)->pt(); - Zch = Zch + (*it)->pt(); - - Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); - ntracks++; - } - } - - for( reco::TrackRefVector::const_iterator it = muons.inVertexInCalo_.begin(); it != muons.inVertexInCalo_.end(); it++) { - double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); - double deEta = (*it)->eta() - p4.eta(); - double dePhi = deltaPhi((*it)->phi(), p4.phi()); - if((**it).ptError()/(**it).pt() < 0.1) { - deR2Tr = deR2Tr + deR*deR*(*it)->pt(); - deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); - dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); - denominator_tracks = denominator_tracks + (*it)->pt(); - Zch = Zch + (*it)->pt(); - - Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); - ntracks++; - } - } - for( reco::TrackRefVector::const_iterator it = elecs.inVertexInCalo_.begin(); it != elecs.inVertexInCalo_.end(); it++) { - double deR = deltaR((*it)->eta(), (*it)->phi(), p4.eta(), p4.phi()); - double deEta = (*it)->eta() - p4.eta(); - double dePhi = deltaPhi((*it)->phi(), p4.phi()); - if((**it).ptError()/(**it).pt() < 0.1) { - deR2Tr = deR2Tr + deR*deR*(*it)->pt(); - deEta2Tr = deEta2Tr + deEta*deEta*(*it)->pt(); - dePhi2Tr = dePhi2Tr + dePhi*dePhi*(*it)->pt(); - denominator_tracks = denominator_tracks + (*it)->pt(); - Zch = Zch + (*it)->pt(); - - Pout2 = Pout2 + (**it).p()*(**it).p() - (Zch*p4.P())*(Zch*p4.P()); - ntracks++; - } - } - for( reco::TrackRefVector::const_iterator it = pions.inVertexOutOfCalo_.begin(); it != pions.inVertexOutOfCalo_.end(); it++) { - Zch = Zch + (*it)->pt(); - } - for( reco::TrackRefVector::const_iterator it = muons.inVertexOutOfCalo_.begin(); it != muons.inVertexOutOfCalo_.end(); it++) { - Zch = Zch + (*it)->pt(); - } - for( reco::TrackRefVector::const_iterator it = elecs.inVertexOutOfCalo_.begin(); it != elecs.inVertexOutOfCalo_.end(); it++) { - Zch = Zch + (*it)->pt(); - } - - if(mJPTalgo->getSumPtForBeta()> 0.) Zch = Zch/mJPTalgo->getSumPtForBeta(); - -// std::cout<<" Zch "<< Zch<<" "<getSumPtForBeta()< 0) { - Pout = sqrt(fabs(Pout2))/ntracks; - } - if (denominator_tracks!=0){ - deR2Tr = deR2Tr/denominator_tracks; - deEta2Tr= deEta2Tr/denominator_tracks; - dePhi2Tr= dePhi2Tr/denominator_tracks; - } - - specific.R2momtr = deR2Tr; - specific.Eta2momtr = deEta2Tr; - specific.Phi2momtr = dePhi2Tr; - specific.Pout = Pout; - specific.Zch = Zch; - - -// std::cout<<" Moments for charged component "< pvCollection; - iEvent.getByToken(input_vertex_token_, pvCollection); - if ( pvCollection.isValid() && !pvCollection->empty() ) vertex_=pvCollection->begin()->position(); - - reco::JPTJet fJet(p4, vertex_, specific, corrected.getJetConstituents()); - - // fJet.printJet(); - -// Output module - if(fJet.pt()>ptCUT) pOut->push_back(fJet); - } - - std::sort(pOut->begin(),pOut->end(),sort_by_pt); - //std::cout<<"Size of the additional jets "<size()<("src"); -- srcTrackJets = iConfig.getParameter("srcTrackJets"); -- alias = iConfig.getUntrackedParameter("alias"); -- srcPVs_ = iConfig.getParameter("srcPVs"); -- vectorial_ = iConfig.getParameter("VectorialCorrection"); -- useZSP = iConfig.getParameter("UseZSP"); -- ptCUT = iConfig.getParameter("ptCUT"); -- -- mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector()); -- if(useZSP) mZSPalgo = new ZSPJPTJetCorrector(iConfig); -- -- produces().setBranchAlias(alias); -- produces().setBranchAlias("ak4CaloJetsJPT"); -- -- input_jets_token_ = consumes >(src); -- input_addjets_token_ = consumes >(iConfig.getParameter("srcAddCaloJets")); -- input_trackjets_token_ = consumes >(srcTrackJets); -- input_vertex_token_ = consumes(srcPVs_); -- mExtrapolations = consumes > -- (iConfig.getParameter ("extrapolations")); -+JetPlusTrackProducer::JetPlusTrackProducer(const edm::ParameterSet& iConfig) { -+ //register your products -+ src = iConfig.getParameter("src"); -+ srcTrackJets = iConfig.getParameter("srcTrackJets"); -+ alias = iConfig.getUntrackedParameter("alias"); -+ srcPVs_ = iConfig.getParameter("srcPVs"); -+ vectorial_ = iConfig.getParameter("VectorialCorrection"); -+ useZSP = iConfig.getParameter("UseZSP"); -+ ptCUT = iConfig.getParameter("ptCUT"); -+ -+ mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector()); -+ if (useZSP) -+ mZSPalgo = new ZSPJPTJetCorrector(iConfig); -+ -+ produces().setBranchAlias(alias); -+ produces().setBranchAlias("ak4CaloJetsJPT"); -+ -+ input_jets_token_ = consumes >(src); -+ input_addjets_token_ = consumes >(iConfig.getParameter("srcAddCaloJets")); -+ input_trackjets_token_ = consumes >(srcTrackJets); -+ input_vertex_token_ = consumes(srcPVs_); -+ mExtrapolations = -+ consumes >(iConfig.getParameter("extrapolations")); - } - -- --JetPlusTrackProducer::~JetPlusTrackProducer() --{ -- -- // do anything here that needs to be done at desctruction time -- // (e.g. close files, deallocate resources etc.) -- -+JetPlusTrackProducer::~JetPlusTrackProducer() { -+ // do anything here that needs to be done at desctruction time -+ // (e.g. close files, deallocate resources etc.) - } - -- - // - // member functions - // --bool sort_by_pt (reco::JPTJet a,reco::JPTJet b) { return (a.pt()>b.pt());} -+bool sort_by_pt(reco::JPTJet a, reco::JPTJet b) { return (a.pt() > b.pt()); } - - // ------------ method called to produce the data ------------ --void --JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) --{ -- using namespace edm; -+void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { -+ using namespace edm; - --// std::cout<<" RecoJets::JetPlusTrackProducer::produce "< > jets_h; -- iEvent.getByToken (input_jets_token_, jets_h); -+ // get stuff from Event -+ edm::Handle > jets_h; -+ iEvent.getByToken(input_jets_token_, jets_h); - --//JetPlusTrackAddonSeed -- edm::Handle > addjets_h; -- iEvent.getByToken (input_addjets_token_, addjets_h); -+ //JetPlusTrackAddonSeed -+ edm::Handle > addjets_h; -+ iEvent.getByToken(input_addjets_token_, addjets_h); - - //std::cout<<" Additional Calojets "<size()< > jetsTrackJets; -+ edm::Handle > jetsTrackJets; - iEvent.getByToken(input_trackjets_token_, jetsTrackJets); - - //std::cout<<" Additional Trackjets "<size()< > iExtrapolations; -- iEvent.getByToken (mExtrapolations, iExtrapolations); -+ edm::Handle > iExtrapolations; -+ iEvent.getByToken(mExtrapolations, iExtrapolations); -+ -+ edm::RefProd pOut1RefProd = iEvent.getRefBeforePut(); -+ edm::Ref::key_type idxCaloJet = 0; - -- edm::RefProd pOut1RefProd = -- iEvent.getRefBeforePut(); -- edm::Ref::key_type idxCaloJet = 0; -- - auto pOut = std::make_unique(); - auto pOut1 = std::make_unique(); - -- double scaleJPT = 1.; -- std::vector theJPTJets; -- if (jetsTrackJets.isValid()) { -- if(!jetsTrackJets->empty()) { -+ double scaleJPT = 1.; -+ std::vector theJPTJets; -+ if (jetsTrackJets.isValid()) { -+ if (!jetsTrackJets->empty()) { - for (unsigned ijet = 0; ijet < jetsTrackJets->size(); ++ijet) { -- const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet))); -- int icalo = -1; -- if(addjets_h.isValid()) { -+ const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet))); -+ int icalo = -1; -+ if (addjets_h.isValid()) { - for (unsigned i = 0; i < addjets_h->size(); ++i) { -- const reco::CaloJet* oldjet = &(*(addjets_h->refAt(i))); -- double deta = fabs(jet->eta()-oldjet->eta()); -- double dphi = fabs(jet->phi()-oldjet->phi()); -- if(dphi>4.*atan(1.)) dphi = 8.*atan(1.) - dphi; -- double dr = sqrt(dphi*dphi+deta*deta); -- if(dr<=0.4) {icalo=i;} -- } // Calojets -- } -- if(icalo < 0) continue; -- const reco::CaloJet* mycalo = &(*(addjets_h->refAt(icalo))); -- // std::cout<<" Additional CaloJet "<pt()<<" "<eta()<< -- // " "<phi()<refAt(i))); -+ double deta = fabs(jet->eta() - oldjet->eta()); -+ double dphi = fabs(jet->phi() - oldjet->phi()); -+ if (dphi > 4. * atan(1.)) -+ dphi = 8. * atan(1.) - dphi; -+ double dr = sqrt(dphi * dphi + deta * deta); -+ if (dr <= 0.4) { -+ icalo = i; -+ } -+ } // Calojets -+ } -+ if (icalo < 0) -+ continue; -+ const reco::CaloJet* mycalo = &(*(addjets_h->refAt(icalo))); -+ // std::cout<<" Additional CaloJet "<pt()<<" "<eta()<< -+ // " "<phi()< > tracksinjet = jet->tracks(); - reco::TrackRefVector tracksincalo; - reco::TrackRefVector tracksinvert; -- for(std::vector >::iterator itrack = tracksinjet.begin(); -- itrack != tracksinjet.end(); itrack++) { -- for ( std::vector::const_iterator xtrpBegin = iExtrapolations->begin(), -- xtrpEnd = iExtrapolations->end(), ixtrp = xtrpBegin; -- ixtrp != xtrpEnd; ++ixtrp ) -- { -- if ( ixtrp->positions().empty() ) continue; -- double mydphi =fabs(ixtrp->track()->phi()-(**itrack).phi()); -- if(mydphi>4.*atan(1.)) mydphi = 8.*atan(1)-mydphi; -- if(fabs(ixtrp->track()->pt()-(**itrack).pt()) > 0.001 || -- fabs(ixtrp->track()->eta()-(**itrack).eta()) > 0.001 || mydphi > 0.001) continue; -- tracksinvert.push_back(ixtrp->track()); -- reco::TrackBase::Point const & point = ixtrp->positions().at(0); -- -- double dr = reco::deltaR( jet->eta(), jet->phi(), point.eta(), point.phi() ); -- if(dr <= 0.4) { -- /*std::cout<<" TrackINcalo "<track()); -- } -- } // Track extrapolations -- } // tracks -- -- reco::TrackJet corrected = *jet; -- math::XYZTLorentzVector p4; -- jpt::MatchedTracks pions; -- jpt::MatchedTracks muons; -- jpt::MatchedTracks elecs; -- -- scaleJPT = mJPTalgo->correction( corrected, *mycalo, iEvent, iSetup, -- tracksinvert, tracksincalo, p4, pions, muons, elecs); -- // std::cout<<" JetPlusTrackProducer::AddSeedJet "<< (*mycalo).pt()<<" "<< (*mycalo).eta()<<" "<< -- // (*mycalo).phi()<<" "<<(*mycalo).jetArea()<<" Corr "<< -- // p4.pt()<<" "< ptCUT) { -- reco::JPTJet::Specific jptspe; -- jptspe.pionsInVertexInCalo = pions.inVertexInCalo_; -- jptspe.pionsInVertexOutCalo = pions.inVertexOutOfCalo_; -- jptspe.pionsOutVertexInCalo = pions.outOfVertexInCalo_; -- jptspe.muonsInVertexInCalo = muons.inVertexInCalo_; -- jptspe.muonsInVertexOutCalo = muons.inVertexOutOfCalo_; -- jptspe.muonsOutVertexInCalo = muons.outOfVertexInCalo_; -- jptspe.elecsInVertexInCalo = elecs.inVertexInCalo_; -- jptspe.elecsInVertexOutCalo = elecs.inVertexOutOfCalo_; -- jptspe.elecsOutVertexInCalo = elecs.outOfVertexInCalo_; -- reco::CaloJetRef myjet(pOut1RefProd, idxCaloJet++); -- jptspe.theCaloJetRef = edm::RefToBase(myjet); -- jptspe.mZSPCor = 1.; -- reco::JPTJet fJet(p4, jet->primaryVertex()->position(), jptspe, mycalo->getJetConstituents()); -- pOut->push_back(fJet); -- pOut1->push_back(*mycalo); -- theJPTJets.push_back(fJet); -- } -- } // trackjets -- } // jets -- } // There is trackjet collection -+ for (std::vector >::iterator itrack = tracksinjet.begin(); itrack != tracksinjet.end(); -+ itrack++) { -+ for (std::vector::const_iterator xtrpBegin = iExtrapolations->begin(), -+ xtrpEnd = iExtrapolations->end(), -+ ixtrp = xtrpBegin; -+ ixtrp != xtrpEnd; -+ ++ixtrp) { -+ if (ixtrp->positions().empty()) -+ continue; -+ double mydphi = fabs(ixtrp->track()->phi() - (**itrack).phi()); -+ if (mydphi > 4. * atan(1.)) -+ mydphi = 8. * atan(1) - mydphi; -+ if (fabs(ixtrp->track()->pt() - (**itrack).pt()) > 0.001 || -+ fabs(ixtrp->track()->eta() - (**itrack).eta()) > 0.001 || mydphi > 0.001) -+ continue; -+ tracksinvert.push_back(ixtrp->track()); -+ reco::TrackBase::Point const& point = ixtrp->positions().at(0); -+ -+ double dr = reco::deltaR(jet->eta(), jet->phi(), point.eta(), point.phi()); -+ if (dr <= 0.4) { -+ /*std::cout<<" TrackINcalo "<track()); -+ } -+ } // Track extrapolations -+ } // tracks -+ -+ reco::TrackJet corrected = *jet; -+ math::XYZTLorentzVector p4; -+ jpt::MatchedTracks pions; -+ jpt::MatchedTracks muons; -+ jpt::MatchedTracks elecs; -+ -+ scaleJPT = mJPTalgo->correction( -+ corrected, *mycalo, iEvent, iSetup, tracksinvert, tracksincalo, p4, pions, muons, elecs); -+ // std::cout<<" JetPlusTrackProducer::AddSeedJet "<< (*mycalo).pt()<<" "<< (*mycalo).eta()<<" "<< -+ // (*mycalo).phi()<<" "<<(*mycalo).jetArea()<<" Corr "<< -+ // p4.pt()<<" "< ptCUT) { -+ reco::JPTJet::Specific jptspe; -+ jptspe.pionsInVertexInCalo = pions.inVertexInCalo_; -+ jptspe.pionsInVertexOutCalo = pions.inVertexOutOfCalo_; -+ jptspe.pionsOutVertexInCalo = pions.outOfVertexInCalo_; -+ jptspe.muonsInVertexInCalo = muons.inVertexInCalo_; -+ jptspe.muonsInVertexOutCalo = muons.inVertexOutOfCalo_; -+ jptspe.muonsOutVertexInCalo = muons.outOfVertexInCalo_; -+ jptspe.elecsInVertexInCalo = elecs.inVertexInCalo_; -+ jptspe.elecsInVertexOutCalo = elecs.inVertexOutOfCalo_; -+ jptspe.elecsOutVertexInCalo = elecs.outOfVertexInCalo_; -+ reco::CaloJetRef myjet(pOut1RefProd, idxCaloJet++); -+ jptspe.theCaloJetRef = edm::RefToBase(myjet); -+ jptspe.mZSPCor = 1.; -+ reco::JPTJet fJet(p4, jet->primaryVertex()->position(), jptspe, mycalo->getJetConstituents()); -+ pOut->push_back(fJet); -+ pOut1->push_back(*mycalo); -+ theJPTJets.push_back(fJet); -+ } -+ } // trackjets -+ } // jets -+ } // There is trackjet collection - - for (unsigned i = 0; i < jets_h->size(); ++i) { -- -- const reco::CaloJet* oldjet = &(*(jets_h->refAt(i))); -- reco::CaloJet corrected = *oldjet; -- --// ZSP corrections -- -- double factorZSP = 1.; -- if(useZSP) factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup); -- corrected.scaleEnergy (factorZSP); -- --// JPT corrections -- scaleJPT = 1.; -- -- math::XYZTLorentzVector p4; -- -- jpt::MatchedTracks pions; -- jpt::MatchedTracks muons; -- jpt::MatchedTracks elecs; -- bool ok=false; -- -- if ( !vectorial_ ) { -- -- scaleJPT = mJPTalgo->correction ( corrected, *oldjet, iEvent, iSetup, pions, muons, elecs,ok ); -- p4 = math::XYZTLorentzVector( corrected.px()*scaleJPT, -- corrected.py()*scaleJPT, -- corrected.pz()*scaleJPT, -- corrected.energy()*scaleJPT ); -- // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< (*oldjet).phi()<< -- // " "<correction( corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs,ok ); -- // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< -- // (*oldjet).phi()<<" "<<(*oldjet).jetArea()<<" Corr "<< -- // p4.pt()<<" "<refAt(i))); -+ reco::CaloJet corrected = *oldjet; -+ -+ // ZSP corrections -+ -+ double factorZSP = 1.; -+ if (useZSP) -+ factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup); -+ corrected.scaleEnergy(factorZSP); -+ -+ // JPT corrections -+ scaleJPT = 1.; -+ -+ math::XYZTLorentzVector p4; -+ -+ jpt::MatchedTracks pions; -+ jpt::MatchedTracks muons; -+ jpt::MatchedTracks elecs; -+ bool ok = false; -+ -+ if (!vectorial_) { -+ scaleJPT = mJPTalgo->correction(corrected, *oldjet, iEvent, iSetup, pions, muons, elecs, ok); -+ p4 = math::XYZTLorentzVector(corrected.px() * scaleJPT, -+ corrected.py() * scaleJPT, -+ corrected.pz() * scaleJPT, -+ corrected.energy() * scaleJPT); -+ // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< (*oldjet).phi()<< -+ // " "<correction(corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs, ok); -+ // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< -+ // (*oldjet).phi()<<" "<<(*oldjet).jetArea()<<" Corr "<< -+ // p4.pt()<<" "< myjet = (edm::RefToBase)jets_h->refAt(i); - specific.theCaloJetRef = myjet; - specific.mZSPCor = factorZSP; diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.orig b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.orig deleted file mode 100644 index 4051671cd4e8e..0000000000000 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.orig +++ /dev/null @@ -1,70 +0,0 @@ -// -*- C++ -*- -// -// Package: JetPlusTracks -// Class: JetPlusTrackProducer -// -/**\class JetPlusTrackProducer JetPlusTrackProducer.cc JetPlusTrackProducer.cc - - Description: [one line class summary] - - Implementation: - [Notes on implementation] -*/ -// -// Original Author: Olga Kodolova,40 R-A12,+41227671273, -// Created: Fri Feb 19 10:14:02 CET 2010 -// -// - - -// system include files -#include - -// user include files -#include "FWCore/Framework/interface/Frameworkfwd.h" -#include "FWCore/Framework/interface/stream/EDProducer.h" -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" - -#include "JetPlusTrackCorrector.h" -#include "ZSPJPTJetCorrector.h" - -#include "DataFormats/JetReco/interface/CaloJet.h" -#include "DataFormats/JetReco/interface/TrackJet.h" -#include "DataFormats/VertexReco/interface/Vertex.h" -#include "DataFormats/JetReco/interface/TrackExtrapolation.h" - -#include - -// -// class declaration -// - -class JetPlusTrackProducer : public edm::stream::EDProducer<> { - public: - explicit JetPlusTrackProducer(const edm::ParameterSet&); - ~JetPlusTrackProducer() override; - void produce(edm::Event&, const edm::EventSetup&) override; - - // ---------- private data members --------------------------- - private: - - JetPlusTrackCorrector* mJPTalgo; - ZSPJPTJetCorrector* mZSPalgo; - edm::InputTag src; - edm::InputTag srcTrackJets; - edm::InputTag srcPVs_; - std::string alias; - bool vectorial_; - bool useZSP; - double ptCUT; - double dRcone; - - edm::EDGetTokenT > input_jets_token_; - edm::EDGetTokenT > input_addjets_token_; - edm::EDGetTokenT > input_trackjets_token_; - edm::EDGetTokenT input_vertex_token_; - edm::EDGetTokenT > mExtrapolations; - -}; diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.rej b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.rej deleted file mode 100644 index 36e2ac2f84e26..0000000000000 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h.rej +++ /dev/null @@ -1,51 +0,0 @@ ---- RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h -+++ RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h -@@ -41,28 +40,26 @@ - // - - class JetPlusTrackProducer : public edm::stream::EDProducer<> { -- public: -- explicit JetPlusTrackProducer(const edm::ParameterSet&); -- ~JetPlusTrackProducer() override; -- void produce(edm::Event&, const edm::EventSetup&) override; -+public: -+ explicit JetPlusTrackProducer(const edm::ParameterSet&); -+ ~JetPlusTrackProducer() override; -+ void produce(edm::Event&, const edm::EventSetup&) override; - -- // ---------- private data members --------------------------- -- private: -- -- JetPlusTrackCorrector* mJPTalgo; -- ZSPJPTJetCorrector* mZSPalgo; -- edm::InputTag src; -- edm::InputTag srcTrackJets; -- edm::InputTag srcPVs_; -- std::string alias; -- bool vectorial_; -- bool useZSP; -- double ptCUT; -+ // ---------- private data members --------------------------- -+private: -+ JetPlusTrackCorrector* mJPTalgo; -+ ZSPJPTJetCorrector* mZSPalgo; -+ edm::InputTag src; -+ edm::InputTag srcTrackJets; -+ edm::InputTag srcPVs_; -+ std::string alias; -+ bool vectorial_; -+ bool useZSP; -+ double ptCUT; - -- edm::EDGetTokenT > input_jets_token_; -- edm::EDGetTokenT > input_addjets_token_; -- edm::EDGetTokenT > input_trackjets_token_; -- edm::EDGetTokenT input_vertex_token_; -- edm::EDGetTokenT > mExtrapolations; -- -+ edm::EDGetTokenT > input_jets_token_; -+ edm::EDGetTokenT > input_addjets_token_; -+ edm::EDGetTokenT > input_trackjets_token_; -+ edm::EDGetTokenT input_vertex_token_; -+ edm::EDGetTokenT > mExtrapolations; - }; From 4139cd4a35c672393155e47c64c45e6d21301924 Mon Sep 17 00:00:00 2001 From: Olga Kodolova Date: Sun, 14 Jun 2020 20:03:05 +0200 Subject: [PATCH 11/14] Add deltaR method, change hardcoded cuts to configurable --- .../plugins/JetPlusTrackAddonSeedProducer.cc | 25 ++--------- .../plugins/JetPlusTrackCorrector.cc | 44 +++++++++---------- .../plugins/JetPlusTrackCorrector.h | 6 +++ .../python/JetPlusTrackCorrections_cfi.py | 6 ++- 4 files changed, 35 insertions(+), 46 deletions(-) diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc index b1a4af1b48678..27a4eb9db409e 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc @@ -85,9 +85,6 @@ JetPlusTrackAddonSeedProducer::~JetPlusTrackAddonSeedProducer() { // ------------ method called to produce the data ------------ void JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { using namespace edm; - - // std::cout<<" RecoJets::JetPlusTrackAddonSeedProducer::produce "< > jets_h; iEvent.getByToken(input_jets_token_, jets_h); @@ -99,25 +96,19 @@ void JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::Event if (jetsTrackJets.isValid()) { if (!jetsTrackJets->empty()) { - // std::cout<<" AddonSeed::The size of trackjets "<size()<<" "<size()<size(); ++ijet) { const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet))); int iflag = 0; for (unsigned i = 0; i < jets_h->size(); ++i) { const reco::CaloJet* oldjet = &(*(jets_h->refAt(i))); - double deta = fabs(jet->eta() - oldjet->eta()); - double dphi = fabs(jet->phi() - oldjet->phi()); - if (dphi > 4. * atan(1.)) - dphi = 8. * atan(1.) - dphi; - double dr = sqrt(dphi * dphi + deta * deta); + double dr = deltaR(jet->eta(),jet->phi(), + oldjet->eta(),oldjet->phi()); if (dr < dRcone) iflag = 1; } // Calojets if (iflag == 1) continue; - // std::cout<<" AddonSeed::There is the additional trackjet seed "<pt()<<" "<eta()<< - // " "<phi()< pfCandidates; iEvent.getByToken(tokenPFCandidates_, pfCandidates); if (!pfCandidates.isValid()) { - // std::cout<<" No PFCandidate collection "<size(); i < n; ++i) { @@ -168,7 +158,6 @@ void JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::Event } // Calojet } } else { - // std::cout<<" RECO "< ct; iEvent.getByToken(input_ctw_token_, ct); if (ct.isValid()) { @@ -198,7 +187,6 @@ void JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::Event hhfraction = (hadinhb + hadinhe + hadinhf + hadinho) / caloen; double trackp = sqrt(pow(jet->pt(), 2) + pow(jet->pz(), 2)); - // std::cout<<" Caloenergy "<jetArea()<primaryVertex()->position(), calospe); - mycalo.setJetArea(3.14159 * dRcone * dRcone); - - //std::cout<<" AddonSeed::New Calojet "<jetArea()<push_back(mycalo); } // trackjets } // jets } // There is trackjet collection - // std::cout<<" AddonSeed::size of collection "<size()< #include #include @@ -47,6 +49,10 @@ JetPlusTrackCorrector::JetPlusTrackCorrector(const edm::ParameterSet& pset, edm: response_(Map(pset.getParameter("ResponseMap"), verbose_)), efficiency_(Map(pset.getParameter("EfficiencyMap"), verbose_)), leakage_(Map(pset.getParameter("LeakageMap"), verbose_)), + muonPtmatch_(pset.getParameter("muonPtmatch")), + muonEtamatch_(pset.getParameter("muonEtamatch")), + muonPhimatch_(pset.getParameter("muonPhimatch")), + electronDRmatch_(pset.getParameter("electronDRmatch")), pionMass_(0.140), muonMass_(0.105), elecMass_(0.000511), @@ -1317,9 +1323,9 @@ bool JetPlusTrackCorrector::matchMuons(TrackRefs::const_iterator& itrk, // <<(**itrk).eta()<<" "<<(**itrk).phi()<<" Muon "<< // (*(imuon->innerTrack())).pt()<<" "<< (*(imuon->innerTrack())).eta()<<" "<< // (*(imuon->innerTrack())).phi()<innerTrack())).pt()) < 0.1 && - fabs((**itrk).eta() - (*(imuon->innerTrack())).eta()) < 0.001 && - fabs((**itrk).phi() - (*(imuon->innerTrack())).phi()) < 0.001) { + if (fabs((**itrk).pt() - (*(imuon->innerTrack())).pt()) < muonPtmatch_ && + fabs((**itrk).eta() - (*(imuon->innerTrack())).eta()) < muonEtamatch_ && + fabs((**itrk).phi() - (*(imuon->innerTrack())).phi()) < muonPhimatch_) { // std::cout<<" Needed muon-track "<<(**itrk).pt()<<" "<< // (**itrk).eta()<<" "<<(**itrk).phi()<phi() - (*itrk)->momentum().phi()); - if (deltaphi > 6.283185308) - deltaphi -= 6.283185308; - if (deltaphi > 3.141592654) - deltaphi = 6.283185308 - deltaphi; - deltaR = abs(sqrt(pow((ielec->eta() - (*itrk)->momentum().eta()), 2) + pow(deltaphi, 2))); - if (deltaR < deltaRMIN) { - deltaRMIN = deltaR; + + dR = deltaR(ielec->eta(),ielec->phi(),(*itrk)->momentum().eta(),(*itrk)->momentum().phi()); + if (dR < deltaRMIN) { + deltaRMIN = dR; } } - if (deltaRMIN < 0.02) + if (deltaRMIN < electronDRmatch_) return true; else return false; @@ -1376,25 +1378,21 @@ bool JetPlusTrackCorrector::matchElectrons(TrackRefs::const_iterator& itrk, return false; } // std::cout<<"JetPlusTrackCorrector::matchElectrons "<begin(); pat::ElectronCollection::const_iterator jelec = elecs->end(); for (; ielec != jelec; ++ielec) { // std::cout<<"Electron "<eta()<<" "<phi()<<" Track "<<(*itrk)->momentum().eta()<<" "<< // (*itrk)->momentum().phi()<<" PT "<pt()<<" "<<(*itrk)->pt()<phi() - (*itrk)->momentum().phi()); - if (deltaphi > 6.283185308) - deltaphi -= 6.283185308; - if (deltaphi > 3.141592654) - deltaphi = 6.283185308 - deltaphi; - deltaR = abs(sqrt(pow((ielec->eta() - (*itrk)->momentum().eta()), 2) + pow(deltaphi, 2))); - if (deltaR < deltaRMIN) { - deltaRMIN = deltaR; + dR = deltaR(ielec->eta(),ielec->phi(),(*itrk)->momentum().eta(),(*itrk)->momentum().phi()); + if (dR < deltaRMIN) { + deltaRMIN = dR; } + } // std::cout<<" matchElectrons:DeltaR "< Date: Mon, 15 Jun 2020 14:56:39 +0200 Subject: [PATCH 12/14] Changes proposed by code-format --- .../JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc | 3 +-- RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc | 5 ++--- RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc | 7 +++++-- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc index 27a4eb9db409e..bd103eb55d71a 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc @@ -101,8 +101,7 @@ void JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::Event int iflag = 0; for (unsigned i = 0; i < jets_h->size(); ++i) { const reco::CaloJet* oldjet = &(*(jets_h->refAt(i))); - double dr = deltaR(jet->eta(),jet->phi(), - oldjet->eta(),oldjet->phi()); + double dr = deltaR(jet->eta(), jet->phi(), oldjet->eta(), oldjet->phi()); if (dr < dRcone) iflag = 1; } // Calojets diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc index ccb34595354b6..b887b182a2614 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc @@ -1360,7 +1360,7 @@ bool JetPlusTrackCorrector::matchElectrons(TrackRefs::const_iterator& itrk, // DR matching b/w electron and track - dR = deltaR(ielec->eta(),ielec->phi(),(*itrk)->momentum().eta(),(*itrk)->momentum().phi()); + dR = deltaR(ielec->eta(), ielec->phi(), (*itrk)->momentum().eta(), (*itrk)->momentum().phi()); if (dR < deltaRMIN) { deltaRMIN = dR; } @@ -1385,11 +1385,10 @@ bool JetPlusTrackCorrector::matchElectrons(TrackRefs::const_iterator& itrk, for (; ielec != jelec; ++ielec) { // std::cout<<"Electron "<eta()<<" "<phi()<<" Track "<<(*itrk)->momentum().eta()<<" "<< // (*itrk)->momentum().phi()<<" PT "<pt()<<" "<<(*itrk)->pt()<eta(),ielec->phi(),(*itrk)->momentum().eta(),(*itrk)->momentum().phi()); + dR = deltaR(ielec->eta(), ielec->phi(), (*itrk)->momentum().eta(), (*itrk)->momentum().phi()); if (dR < deltaRMIN) { deltaRMIN = dR; } - } // std::cout<<" matchElectrons:DeltaR "<size()<<" "<size()<size(); ++i) { const reco::CaloJet* oldjet = &(*(jets_h->refAt(i))); reco::CaloJet corrected = *oldjet; @@ -237,11 +239,12 @@ void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iS corrected.py() * scaleJPT, corrected.pz() * scaleJPT, corrected.energy() * scaleJPT); - // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< (*oldjet).phi()<< + // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" " + // << (*oldjet).eta()<<" "<< (*oldjet).phi()<< // " "<correction(corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs, ok); - // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< + // std::cout<<" JetPlusTrackProducer::mainpart "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<< // (*oldjet).phi()<<" "<<(*oldjet).jetArea()<<" Corr "<< // p4.pt()<<" "< Date: Tue, 16 Jun 2020 10:59:30 +0200 Subject: [PATCH 13/14] Chnage to deltaR and deltaPhi --- .../plugins/JetPlusTrackAddonSeedProducer.cc | 17 ++--------------- .../plugins/JetPlusTrackProducer.cc | 11 ++--------- .../plugins/JetPlusTrackProducerAA.cc | 5 +---- 3 files changed, 5 insertions(+), 28 deletions(-) diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc index bd103eb55d71a..2c916fae06a36 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc @@ -128,14 +128,7 @@ void JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::Event } else { for (unsigned int i = 0, n = pfCandidates->size(); i < n; ++i) { const pat::PackedCandidate& pf = (*pfCandidates)[i]; - double deta = (*jet).eta() - pf.eta(); - double dphi = (*jet).phi() - pf.phi(); - - if (dphi > 4. * atan(1.)) - dphi = dphi - 8. * atan(1.); - if (dphi < -1. * 4. * atan(1.)) - dphi = dphi + 8. * atan(1.); - double dr = sqrt(dphi * dphi + deta * deta); + double dr = deltaR(jet->eta(), jet->phi(), pf.eta(), pf.phi()); if (dr > dRcone) continue; // jetconstit @@ -161,13 +154,7 @@ void JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::Event iEvent.getByToken(input_ctw_token_, ct); if (ct.isValid()) { for (CaloTowerCollection::const_iterator it = ct->begin(); it != ct->end(); it++) { - double deta = (*jet).eta() - (*it).eta(); - double dphi = (*jet).phi() - (*it).phi(); - if (dphi > 4. * atan(1.)) - dphi = dphi - 8. * atan(1.); - if (dphi < -1. * 4. * atan(1.)) - dphi = dphi + 8. * atan(1.); - double dr = sqrt(dphi * dphi + deta * deta); + double dr = deltaR(jet->eta(), jet->phi(), (*it).eta(), (*it).phi()); if (dr > dRcone) continue; caloen = caloen + (*it).energy(); diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc index 46ec8b1e4517b..2daa7ae162c66 100644 --- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc +++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc @@ -132,11 +132,7 @@ void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iS if (addjets_h.isValid()) { for (unsigned i = 0; i < addjets_h->size(); ++i) { const reco::CaloJet* oldjet = &(*(addjets_h->refAt(i))); - double deta = fabs(jet->eta() - oldjet->eta()); - double dphi = fabs(jet->phi() - oldjet->phi()); - if (dphi > 4. * atan(1.)) - dphi = 8. * atan(1.) - dphi; - double dr = sqrt(dphi * dphi + deta * deta); + double dr = reco::deltaR(jet->eta(), jet->phi(), oldjet->eta(), oldjet->phi()); if (dr <= dRcone) { icalo = i; } @@ -159,15 +155,12 @@ void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iS ++ixtrp) { if (ixtrp->positions().empty()) continue; - double mydphi = fabs(ixtrp->track()->phi() - (**itrack).phi()); - if (mydphi > 4. * atan(1.)) - mydphi = 8. * atan(1) - mydphi; + double mydphi = deltaPhi(ixtrp->track()->phi(),(**itrack).phi()); if (fabs(ixtrp->track()->pt() - (**itrack).pt()) > 0.001 || fabs(ixtrp->track()->eta() - (**itrack).eta()) > 0.001 || mydphi > 0.001) continue; tracksinvert.push_back(ixtrp->track()); reco::TrackBase::Point const& point = ixtrp->positions().at(0); - double dr = reco::deltaR(jet->eta(), jet->phi(), point.eta(), point.phi()); if (dr <= dRcone) { /*std::cout<<" TrackINcalo "<>>> Track inside jet at vertex, track_bg="<< track_bg <<" track="<size()<<" "<size()<size()<<" "<size()<size(); ++i) { const reco::CaloJet* oldjet = &(*(jets_h->refAt(i)));