JetSubstructurePacker Class Reference

#include <JetSubstructurePacker.h>

Inheritance diagram for JetSubstructurePacker:

Public Member Functions
	JetSubstructurePacker (const edm::ParameterSet &)
	~JetSubstructurePacker () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

Private Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
std::vector< std::string >	algoLabels_
std::vector< edm::InputTag >	algoTags_
std::vector< edm::EDGetTokenT< edm::View< pat::Jet > > >	algoTokens_
float	distMax_
bool	fixDaughters_
edm::EDGetTokenT< edm::View< pat::Jet > >	jetToken_
edm::EDGetTokenT< edm::Association< reco::PFCandidateCollection > >	pc2pf_
edm::EDGetTokenT< edm::Association< pat::PackedCandidateCollection > >	pf2pc_

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

Detailed Description

Definition at line 34 of file JetSubstructurePacker.h.

Constructor & Destructor Documentation

JetSubstructurePacker()

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

explicit

Definition at line 5 of file JetSubstructurePacker.cc.

    : distMax_(iConfig.getParameter<double>("distMax")),
      jetToken_(consumes<edm::View<pat::Jet>>(iConfig.getParameter<edm::InputTag>("jetSrc"))),
      algoLabels_(iConfig.getParameter<std::vector<std::string>>("algoLabels")),
      algoTags_(iConfig.getParameter<std::vector<edm::InputTag>>("algoTags")),
      fixDaughters_(iConfig.getParameter<bool>("fixDaughters")) {
  algoTokens_ =
      edm::vector_transform(algoTags_, [this](edm::InputTag const& tag) { return consumes<edm::View<pat::Jet>>(tag); });
  if (fixDaughters_) {
    pf2pc_ = consumes<edm::Association<pat::PackedCandidateCollection>>(
        iConfig.getParameter<edm::InputTag>("packedPFCandidates"));
    pc2pf_ = consumes<edm::Association<reco::PFCandidateCollection>>(
        iConfig.getParameter<edm::InputTag>("packedPFCandidates"));
  }
  //register products
  produces<std::vector<pat::Jet>>();
}

References algoTags_, algoTokens_, fixDaughters_, edm::ParameterSet::getParameter(), pc2pf_, pf2pc_, GlobalPosition_Frontier_DevDB_cff::tag, and edm::vector_transform().

~JetSubstructurePacker()

JetSubstructurePacker::~JetSubstructurePacker ( )

override

Definition at line 23 of file JetSubstructurePacker.cc.

{}

Member Function Documentation

produce()

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

overrideprivate

Definition at line 26 of file JetSubstructurePacker.cc.

                                                                          {
  auto outputs = std::make_unique<std::vector<pat::Jet>>();
 
  edm::Handle<edm::View<pat::Jet>> jetHandle;
  std::vector<edm::Handle<edm::View<pat::Jet>>> algoHandles;
 
  edm::Handle<edm::Association<pat::PackedCandidateCollection>> pf2pc;
  edm::Handle<edm::Association<reco::PFCandidateCollection>> pc2pf;
  if (fixDaughters_) {
    iEvent.getByToken(pf2pc_, pf2pc);
    iEvent.getByToken(pc2pf_, pc2pf);
  }
 
  iEvent.getByToken(jetToken_, jetHandle);
  algoHandles.resize(algoTags_.size());
  for (size_t i = 0; i < algoTags_.size(); ++i) {
    iEvent.getByToken(algoTokens_[i], algoHandles[i]);
  }
 
  // Loop over the input jets that will be modified.
  for (auto const& ijet : *jetHandle) {
    // Copy the jet.
    outputs->push_back(ijet);
    // Loop over the substructure collections
    unsigned int index = 0;
 
    for (auto const& ialgoHandle : algoHandles) {
      std::vector<edm::Ptr<pat::Jet>> nextSubjets;
      float dRMin = distMax_;
      for (auto const& jjet : *ialgoHandle) {
        if (reco::deltaR(ijet, jjet) < dRMin) {
          for (auto const& userfloatstr : jjet.userFloatNames()) {
            outputs->back().addUserFloat(userfloatstr, jjet.userFloat(userfloatstr));
          }
          for (auto const& userintstr : jjet.userIntNames()) {
            outputs->back().addUserInt(userintstr, jjet.userInt(userintstr));
          }
          for (auto const& usercandstr : jjet.userCandNames()) {
            outputs->back().addUserCand(usercandstr, jjet.userCand(usercandstr));
          }
          for (size_t ida = 0; ida < jjet.numberOfDaughters(); ++ida) {
            reco::CandidatePtr candPtr = jjet.daughterPtr(ida);
            nextSubjets.push_back(edm::Ptr<pat::Jet>(candPtr));
          }
          break;
        }
      }
      outputs->back().addSubjets(nextSubjets, algoLabels_[index]);
      ++index;
    }
 
    // fix daughters
    if (fixDaughters_) {
      std::vector<reco::CandidatePtr> daughtersInSubjets;
      std::vector<reco::CandidatePtr> daughtersNew;
      const std::vector<reco::CandidatePtr>& jdausPF = outputs->back().daughterPtrVector();
      std::vector<reco::CandidatePtr> jdaus;
      jdaus.reserve(jdausPF.size());
      // Convert the daughters to packed candidates. This is easier than ref-navigating through PUPPI or CHS to particleFlow.
      for (auto const& jdau : jdausPF) {
        jdaus.push_back(edm::refToPtr((*pf2pc)[jdau]));
      }
 
      for (const edm::Ptr<pat::Jet>& subjet : outputs->back().subjets()) {
        const std::vector<reco::CandidatePtr>& sjdaus = subjet->daughterPtrVector();
        // check that the subjet does not contain any extra constituents not contained in the jet
        bool skipSubjet = false;
        for (const reco::CandidatePtr& dau : sjdaus) {
          if (std::find(jdaus.begin(), jdaus.end(), dau) == jdaus.end()) {
            skipSubjet = true;
            break;
          }
        }
        if (skipSubjet)
          continue;
 
        daughtersInSubjets.insert(daughtersInSubjets.end(), sjdaus.begin(), sjdaus.end());
        daughtersNew.push_back(reco::CandidatePtr(subjet));
      }
      for (const reco::CandidatePtr& dau : jdaus) {
        if (std::find(daughtersInSubjets.begin(), daughtersInSubjets.end(), dau) == daughtersInSubjets.end()) {
          daughtersNew.push_back(dau);
        }
      }
      outputs->back().clearDaughters();
      for (const auto& dau : daughtersNew)
        outputs->back().addDaughter(dau);
    }
  }
 
  iEvent.put(std::move(outputs));
}

References algoLabels_, algoTags_, algoTokens_, reco::deltaR(), distMax_, HLT_2018_cff::dRMin, spr::find(), fixDaughters_, mps_fire::i, iEvent, jetToken_, eostools::move(), PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, pc2pf_, pf2pc_, and edm::refToPtr().

Member Data Documentation

algoLabels_

std::vector<std::string> JetSubstructurePacker::algoLabels_

private

Definition at line 47 of file JetSubstructurePacker.h.

Referenced by produce().

algoTags_

std::vector<edm::InputTag> JetSubstructurePacker::algoTags_

private

Definition at line 48 of file JetSubstructurePacker.h.

Referenced by JetSubstructurePacker(), and produce().

algoTokens_

std::vector<edm::EDGetTokenT<edm::View<pat::Jet> > > JetSubstructurePacker::algoTokens_

private

Definition at line 49 of file JetSubstructurePacker.h.

Referenced by JetSubstructurePacker(), and produce().

distMax_

float JetSubstructurePacker::distMax_

private

Definition at line 45 of file JetSubstructurePacker.h.

Referenced by produce().

fixDaughters_

bool JetSubstructurePacker::fixDaughters_

private

Definition at line 50 of file JetSubstructurePacker.h.

Referenced by JetSubstructurePacker(), and produce().

jetToken_

edm::EDGetTokenT<edm::View<pat::Jet> > JetSubstructurePacker::jetToken_

private

Definition at line 46 of file JetSubstructurePacker.h.

Referenced by produce().

pc2pf_

edm::EDGetTokenT<edm::Association<reco::PFCandidateCollection> > JetSubstructurePacker::pc2pf_

private

Definition at line 52 of file JetSubstructurePacker.h.

Referenced by JetSubstructurePacker(), and produce().

pf2pc_

edm::EDGetTokenT<edm::Association<pat::PackedCandidateCollection> > JetSubstructurePacker::pf2pc_

private

Definition at line 51 of file JetSubstructurePacker.h.

Referenced by JetSubstructurePacker(), and produce().