#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 ( const edm::ParameterSet & iConfig )

explicit

Definition at line 5 of file JetSubstructurePacker.cc.

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

     : 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>>();
 }

JetSubstructurePacker::~JetSubstructurePacker ( )

override

Definition at line 23 of file JetSubstructurePacker.cc.

23 {}

Member Function Documentation

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

overrideprivate

Definition at line 26 of file JetSubstructurePacker.cc.

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

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