JetPlusTrackProducerAA Class Reference

#include <JetPlusTrackProducerAA.cc>

Inheritance diagram for JetPlusTrackProducerAA:

Public Member Functions
reco::TrackRefVector	calculateBGtracksJet (reco::JPTJetCollection &, std::vector< reco::TrackRef > &, edm::Handle< std::vector< reco::TrackExtrapolation > > &, reco::TrackRefVector &)
	JetPlusTrackProducerAA (const edm::ParameterSet &)
void	produce (edm::Event &, const edm::EventSetup &) override
	~JetPlusTrackProducerAA () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Private Attributes
std::string	alias
edm::EDGetTokenT< std::vector< reco::TrackExtrapolation > >	input_extrapolations_token_
edm::EDGetTokenT< edm::View< reco::CaloJet > >	input_jets_token_
edm::EDGetTokenT< reco::TrackCollection >	input_tracks_token_
edm::EDGetTokenT< reco::VertexCollection >	input_vertex_token_
double	mConeSize
edm::InputTag	mExtrapolations
JetPlusTrackCorrector *	mJPTalgo
edm::InputTag	mTracks
ZSPJPTJetCorrector *	mZSPalgo
edm::InputTag	src
edm::InputTag	srcPVs_
reco::TrackBase::TrackQuality	trackQuality_
bool	useZSP
bool	vectorial_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 55 of file JetPlusTrackProducerAA.h.

Constructor & Destructor Documentation

JetPlusTrackProducerAA()

JetPlusTrackProducerAA::JetPlusTrackProducerAA ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 76 of file JetPlusTrackProducerAA.cc.

References SiStripOfflineCRack_cfg::alias, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), reco::TrackBase::qualityByName(), TrackRefitter_38T_cff::src, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                             {
  //register your products
  src = iConfig.getParameter<edm::InputTag>("src");
  alias = iConfig.getUntrackedParameter<string>("alias");
  mTracks = iConfig.getParameter<edm::InputTag>("tracks");
  srcPVs_ = iConfig.getParameter<edm::InputTag>("srcPVs");
  vectorial_ = iConfig.getParameter<bool>("VectorialCorrection");
  useZSP = iConfig.getParameter<bool>("UseZSP");
  std::string tq = iConfig.getParameter<std::string>("TrackQuality");
  trackQuality_ = reco::TrackBase::qualityByName(tq);
  mConeSize = iConfig.getParameter<double>("coneSize");
  //=>
  mExtrapolations = iConfig.getParameter<edm::InputTag>("extrapolations");
  //=>
  mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector());
  if (useZSP)
    mZSPalgo = new ZSPJPTJetCorrector(iConfig);

  produces<reco::JPTJetCollection>().setBranchAlias(alias);

  input_jets_token_ = consumes<edm::View<reco::CaloJet> >(src);
  input_vertex_token_ = consumes<reco::VertexCollection>(srcPVs_);
  input_tracks_token_ = consumes<reco::TrackCollection>(mTracks);
  input_extrapolations_token_ = consumes<std::vector<reco::TrackExtrapolation> >(mExtrapolations);
}

~JetPlusTrackProducerAA()

JetPlusTrackProducerAA::~JetPlusTrackProducerAA ( )

override

Definition at line 102 of file JetPlusTrackProducerAA.cc.

                                                {
  // do anything here that needs to be done at desctruction time
  // (e.g. close files, deallocate resources etc.)
}

Member Function Documentation

calculateBGtracksJet()

reco::TrackRefVector JetPlusTrackProducerAA::calculateBGtracksJet	(	reco::JPTJetCollection &	fJets,
		std::vector< reco::TrackRef > &	fTracks,
		edm::Handle< std::vector< reco::TrackExtrapolation > > &	extrapolations_h,
		reco::TrackRefVector &	trBgOutOfCalo
	)

Definition at line 352 of file JetPlusTrackProducerAA.cc.

References edm::RefVector< C, T, F >::begin(), SiPixelRawToDigiRegional_cfi::deltaPhi, edm::RefVector< C, T, F >::end(), spr::find(), dqmiolumiharvest::j, metsig::jet, reco::btau::jetEta, reco::btau::jetPhi, edm::RefVector< C, T, F >::push_back(), submitPVValidationJobs::t, HLT_2022v12_cff::track, reco::btau::trackEta, and reco::btau::trackPhi.

                                       {
  reco::TrackRefVector trBgOutOfVertex;

  for (unsigned t = 0; t < fTracks.size(); ++t) {
    int track_bg = 0;

    const reco::Track* track = &*(fTracks[t]);
    double trackEta = track->eta();
    double trackPhi = track->phi();

    //loop on jets
    for (unsigned j = 0; j < fJets.size(); ++j) {
      const reco::Jet* jet = &(fJets[j]);
      double jetEta = jet->eta();
      double jetPhi = jet->phi();

      if (fabs(jetEta - trackEta) < mConeSize) {
        double dphiTrackJet = deltaPhi(trackPhi, jetPhi);
        if (dphiTrackJet < mConeSize) {
          track_bg = 1;
        }
      }
    }  //jets

    if (track_bg == 0) {
      trBgOutOfVertex.push_back(fTracks[t]);
    }

  }  //tracks

  //=====> Propagate BG tracks to calo
  int nValid = 0;
  for (std::vector<reco::TrackExtrapolation>::const_iterator xtrpBegin = extrapolations_h->begin(),
                                                             xtrpEnd = extrapolations_h->end(),
                                                             ixtrp = xtrpBegin;
       ixtrp != xtrpEnd;
       ++ixtrp) {
    nValid++;

    reco::TrackRefVector::iterator it = find(trBgOutOfVertex.begin(), trBgOutOfVertex.end(), (*ixtrp).track());

    if (it != trBgOutOfVertex.end()) {
      trBgOutOfCalo.push_back(*it);
    }
  }

  return trBgOutOfVertex;
}

produce()

void JetPlusTrackProducerAA::produce ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

override

Definition at line 112 of file JetPlusTrackProducerAA.cc.

References edm::RefVector< C, T, F >::begin(), SiPixelRawToDigiRegional_cfi::deltaPhi, PbPb_ZMuSkimMuonDPG_cff::deltaR, singleTopDQM_cfi::elecs, edm::RefVector< C, T, F >::end(), reco::LeafCandidate::energy(), dqmMemoryStats::float, reco::Jet::getJetConstituents(), mps_fire::i, iEvent, jpt::MatchedTracks::inVertexInCalo_, jpt::MatchedTracks::inVertexOutOfCalo_, M_PI, eostools::move(), PDWG_BPHSkim_cff::muons, ntracks, convertSQLiteXML::ok, jpt::MatchedTracks::outOfVertexInCalo_, heavyFlavorDQMFirstStep_cff::pvCollection, reco::LeafCandidate::px(), reco::LeafCandidate::py(), reco::LeafCandidate::pz(), reco::Jet::scaleEnergy(), edm::second(), timingPdfMaker::specific, and mathSSE::sqrt().

                                                                                  {
  using namespace edm;

  // get stuff from Event
  edm::Handle<edm::View<reco::CaloJet> > jets_h;
  iEvent.getByToken(input_jets_token_, jets_h);

  edm::Handle<reco::TrackCollection> tracks_h;
  iEvent.getByToken(input_tracks_token_, tracks_h);

  std::vector<reco::TrackRef> fTracks;
  fTracks.reserve(tracks_h->size());
  for (unsigned i = 0; i < tracks_h->size(); ++i) {
    fTracks.push_back(reco::TrackRef(tracks_h, i));
  }

  edm::Handle<std::vector<reco::TrackExtrapolation> > extrapolations_h;
  iEvent.getByToken(input_extrapolations_token_, extrapolations_h);

  auto pOut = std::make_unique<reco::JPTJetCollection>();

  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);

    corrected.scaleEnergy(factorZSP);

    // JPT corrections

    double scaleJPT = 1.;

    math::XYZTLorentzVector p4;

    // Construct JPTJet constituent
    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);
    } 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
    edm::RefToBase<reco::Jet> myjet = (edm::RefToBase<reco::Jet>)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();

    if (ntracks > 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;

    // Create JPT jet

    reco::Particle::Point vertex_ = reco::Jet::Point(0, 0, 0);

    // If we add primary vertex
    edm::Handle<reco::VertexCollection> 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

    tmpColl.push_back(fJet);
  }

  //=======================================================================================================>
  // Correction for background

  reco::TrackRefVector trBgOutOfCalo;
  reco::TrackRefVector trBgOutOfVertex = calculateBGtracksJet(tmpColl, fTracks, extrapolations_h, trBgOutOfCalo);

  //===> Area without Jets
  std::map<reco::JPTJetCollection::iterator, double> 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;
  }

  //===>

  for (reco::JPTJetCollection::iterator ij = tmpColl.begin(); ij != tmpColl.end(); ij++) {
    // Correct JPTjet for background tracks

    const reco::TrackRefVector pioninin = (*ij).getPionsInVertexInCalo();
    const reco::TrackRefVector pioninout = (*ij).getPionsInVertexOutCalo();

    double ja = (AreaNonJet.find(ij))->second;

    double factorPU = mJPTalgo->correctAA(*ij, trBgOutOfVertex, mConeSize, pioninin, pioninout, ja, trBgOutOfCalo);

    (*ij).scaleEnergy(factorPU);

    // Output module
    pOut->push_back(*ij);
  }

  iEvent.put(std::move(pOut));
}

Member Data Documentation

alias

std::string JetPlusTrackProducerAA::alias

private

Definition at line 72 of file JetPlusTrackProducerAA.h.

input_extrapolations_token_

edm::EDGetTokenT<std::vector<reco::TrackExtrapolation> > JetPlusTrackProducerAA::input_extrapolations_token_

private

Definition at line 86 of file JetPlusTrackProducerAA.h.

input_jets_token_

edm::EDGetTokenT<edm::View<reco::CaloJet> > JetPlusTrackProducerAA::input_jets_token_

private

Definition at line 83 of file JetPlusTrackProducerAA.h.

input_tracks_token_

edm::EDGetTokenT<reco::TrackCollection> JetPlusTrackProducerAA::input_tracks_token_

private

Definition at line 85 of file JetPlusTrackProducerAA.h.

input_vertex_token_

edm::EDGetTokenT<reco::VertexCollection> JetPlusTrackProducerAA::input_vertex_token_

private

Definition at line 84 of file JetPlusTrackProducerAA.h.

mConeSize

double JetPlusTrackProducerAA::mConeSize

private

Definition at line 76 of file JetPlusTrackProducerAA.h.

mExtrapolations

edm::InputTag JetPlusTrackProducerAA::mExtrapolations

private

Definition at line 80 of file JetPlusTrackProducerAA.h.

mJPTalgo

JetPlusTrackCorrector* JetPlusTrackProducerAA::mJPTalgo

private

Definition at line 68 of file JetPlusTrackProducerAA.h.

mTracks

edm::InputTag JetPlusTrackProducerAA::mTracks

private

Definition at line 75 of file JetPlusTrackProducerAA.h.

mZSPalgo

ZSPJPTJetCorrector* JetPlusTrackProducerAA::mZSPalgo

private

Definition at line 69 of file JetPlusTrackProducerAA.h.

src

edm::InputTag JetPlusTrackProducerAA::src

private

Definition at line 70 of file JetPlusTrackProducerAA.h.

srcPVs_

edm::InputTag JetPlusTrackProducerAA::srcPVs_

private

Definition at line 71 of file JetPlusTrackProducerAA.h.

trackQuality_

reco::TrackBase::TrackQuality JetPlusTrackProducerAA::trackQuality_

private

Definition at line 77 of file JetPlusTrackProducerAA.h.

useZSP

bool JetPlusTrackProducerAA::useZSP

private

Definition at line 74 of file JetPlusTrackProducerAA.h.

vectorial_

bool JetPlusTrackProducerAA::vectorial_

private

Definition at line 73 of file JetPlusTrackProducerAA.h.