#include <SimGeneral/TrackingParticleSelectorByGen/plugins/TrackingParticleSelectorByGen.cc>

Inheritance diagram for TrackingParticleSelectorByGen:

Public Member Functions
	TrackingParticleSelectorByGen (const edm::ParameterSet &)

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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
void	flagDaughters (const reco::GenParticle &, int)

void	flagMothers (const reco::GenParticle &, int)

void	getDaughterKeys (std::vector< size_t > &, std::vector< size_t > &, const reco::GenParticleRefVector &) const

void	getMotherKeys (std::vector< size_t > &, std::vector< size_t > &, const reco::GenParticleRefVector &) const

void	parse (const std::string &selection, helper::SelectCode &code, std::string &cut) const

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

void	recursiveFlagDaughters (size_t, const reco::GenParticleCollection &, int, std::vector< size_t > &)

void	recursiveFlagMothers (size_t, const reco::GenParticleCollection &, int, std::vector< size_t > &)

Private Attributes
bool	firstEvent_

std::vector< int >	flags_

edm::EDGetTokenT< reco::GenParticleCollection >	gpToken_

int	keepOrDropAll_

std::vector< std::pair< StringCutObjectSelector< reco::GenParticle >, helper::SelectCode > >	select_

std::vector< std::string >	selection_

edm::ESGetToken< HepPDT::ParticleDataTable, edm::DefaultRecord >	tableToken_

edm::EDGetTokenT< TrackingParticleCollection >	tpToken_

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 49 of file TrackingParticleSelectorByGen.cc.

Constructor & Destructor Documentation

◆ TrackingParticleSelectorByGen()

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

explicit

Definition at line 134 of file TrackingParticleSelectorByGen.cc.

     : tpToken_(consumes<TrackingParticleCollection>(iConfig.getParameter<edm::InputTag>("trackingParticles"))),
       gpToken_(consumes<reco::GenParticleCollection>(iConfig.getParameter<edm::InputTag>("genParticles"))),
       tableToken_(esConsumes()),
       firstEvent_(true),
       keepOrDropAll_(drop),
       selection_(iConfig.getParameter<vector<string>>("select")) {
   produces<TrackingParticleCollection>();
 }

Member Function Documentation

◆ fillDescriptions()

void TrackingParticleSelectorByGen::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 333 of file TrackingParticleSelectorByGen.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and HLT_2022v14_cff::InputTag.

                                                                                                {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("trackingParticles", edm::InputTag("mix", "MergedTrackTruth"));
   desc.add<edm::InputTag>("genParticles", edm::InputTag("genParticles"));
   desc.add<vector<string>>("select");
 
   descriptions.add("tpSelectorByGenDefault", desc);
 }

◆ flagDaughters()

void TrackingParticleSelectorByGen::flagDaughters	(	const reco::GenParticle &	gen,
		int	keepOrDrop
	)

private

Definition at line 144 of file TrackingParticleSelectorByGen.cc.

References BPhysicsValidation_cfi::daughters, flags_, and mps_fire::i.

Referenced by produce().

                                                                                             {
   const GenParticleRefVector &daughters = gen.daughterRefVector();
   for (GenParticleRefVector::const_iterator i = daughters.begin(); i != daughters.end(); ++i)
     flags_[i->key()] = keepOrDrop;
 }

◆ flagMothers()

void TrackingParticleSelectorByGen::flagMothers	(	const reco::GenParticle &	gen,
		int	keepOrDrop
	)

private

Definition at line 150 of file TrackingParticleSelectorByGen.cc.

References edm::RefVector< C, T, F >::begin(), edm::RefVector< C, T, F >::end(), flags_, and mps_fire::i.

Referenced by produce().

                                                                                           {
   const GenParticleRefVector &mothers = gen.motherRefVector();
   for (GenParticleRefVector::const_iterator i = mothers.begin(); i != mothers.end(); ++i)
     flags_[i->key()] = keepOrDrop;
 }

◆ getDaughterKeys()

void TrackingParticleSelectorByGen::getDaughterKeys	(	std::vector< size_t > &	daIndxs,
		std::vector< size_t > &	daNewIndxs,
		const reco::GenParticleRefVector &	daughters
	)		const

private

Definition at line 198 of file TrackingParticleSelectorByGen.cc.

References BPhysicsValidation_cfi::daughters, edm::RefVector< C, T, F >::empty(), spr::find(), flags_, heavyIonCSV_trainingSettings::idx, dqmiolumiharvest::j, and edm::Ref< C, T, F >::key().

                                                                                                  {
   for (GenParticleRefVector::const_iterator j = daughters.begin(); j != daughters.end(); ++j) {
     GenParticleRef dau = *j;
     if (find(daIndxs.begin(), daIndxs.end(), dau.key()) == daIndxs.end()) {
       daIndxs.push_back(dau.key());
       int idx = flags_[dau.key()];
       if (idx > 0) {
         daNewIndxs.push_back(idx);
       } else {
         const GenParticleRefVector &daus = dau->daughterRefVector();
         if (!daus.empty())
           getDaughterKeys(daIndxs, daNewIndxs, daus);
       }
     }
   }
 }

◆ getMotherKeys()

void TrackingParticleSelectorByGen::getMotherKeys	(	std::vector< size_t > &	moIndxs,
		std::vector< size_t > &	moNewIndxs,
		const reco::GenParticleRefVector &	mothers
	)		const

private

Definition at line 217 of file TrackingParticleSelectorByGen.cc.

References edm::RefVector< C, T, F >::begin(), edm::RefVector< C, T, F >::empty(), edm::RefVector< C, T, F >::end(), spr::find(), flags_, heavyIonCSV_trainingSettings::idx, dqmiolumiharvest::j, and edm::Ref< C, T, F >::key().

                                                                                              {
   for (GenParticleRefVector::const_iterator j = mothers.begin(); j != mothers.end(); ++j) {
     GenParticleRef mom = *j;
     if (find(moIndxs.begin(), moIndxs.end(), mom.key()) == moIndxs.end()) {
       moIndxs.push_back(mom.key());
       int idx = flags_[mom.key()];
       if (idx >= 0) {
         moNewIndxs.push_back(idx);
       } else {
         const GenParticleRefVector &moms = mom->motherRefVector();
         if (!moms.empty())
           getMotherKeys(moIndxs, moNewIndxs, moms);
       }
     }
   }
 }

◆ parse()

void TrackingParticleSelectorByGen::parse	(	const std::string &	selection,
		helper::SelectCode &	code,
		std::string &	cut
	)		const

private

Definition at line 84 of file TrackingParticleSelectorByGen.cc.

References helper::SelectCode::all_, c, mps_check::command, edm::errors::Configuration, PA_MinBiasSkim_cff::cut, helper::SelectCode::daughtersDepth_, Exception, f, helper::SelectCode::keepOrDrop_, WDecay::kNone, helper::SelectCode::mothersDepth_, dqmiodumpmetadata::n, corrVsCorr::selection, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by produce().

                                                                 {
   using namespace ::helper;
   size_t f = selection.find_first_not_of(' ');
   size_t n = selection.size();
   string command;
   char c;
   for (; (c = selection[f]) != ' ' && f < n; ++f) {
     command.push_back(c);
   }
   if (command[0] == '+') {
     command.erase(0, 1);
     if (command[0] == '+') {
       command.erase(0, 1);
       code.mothersDepth_ = SelectCode::kAll;
     } else {
       code.mothersDepth_ = SelectCode::kFirst;
     }
   } else
     code.mothersDepth_ = SelectCode::kNone;
 
   if (command[command.size() - 1] == '+') {
     command.erase(command.size() - 1);
     if (command[command.size() - 1] == '+') {
       command.erase(command.size() - 1);
       code.daughtersDepth_ = SelectCode::kAll;
     } else {
       code.daughtersDepth_ = SelectCode::kFirst;
     }
   } else
     code.daughtersDepth_ = SelectCode::kNone;
 
   if (command == "keep")
     code.keepOrDrop_ = SelectCode::kKeep;
   else if (command == "drop")
     code.keepOrDrop_ = SelectCode::kDrop;
   else {
     throw Exception(errors::Configuration) << "invalid selection command: " << command << "\n" << endl;
   }
   for (; f < n; ++f) {
     if (selection[f] != ' ')
       break;
   }
   cut = string(selection, f);
   if (cut[0] == '*')
     cut = string(cut, 0, cut.find_first_of(' '));
   code.all_ = cut == "*";
 }

◆ produce()

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

overrideprivate

Definition at line 236 of file TrackingParticleSelectorByGen.cc.

References edm::errors::Configuration, PA_MinBiasSkim_cff::cut, drop, Exception, firstEvent_, flagDaughters(), flagMothers(), flags_, edm::EventSetup::getData(), gpToken_, mps_fire::i, iEvent, isSelected(), dqmiolumiharvest::j, keep, keepOrDropAll_, WDecay::kNone, eostools::move(), dqmiodumpmetadata::n, MillePedeFileConverter_cfg::out, AlCaHLTBitMon_ParallelJobs::p, parse(), pdgEntryReplace(), recursiveFlagDaughters(), recursiveFlagMothers(), EgammaValidation_Wenu_cff::sel, select_, selection_, tableToken_, cmsswSequenceInfo::tp, and tpToken_.

                                                                                          {
   using namespace edm;
 
   if (firstEvent_) {
     auto const &pdt = iSetup.getData(tableToken_);
     for (vector<string>::const_iterator i = selection_.begin(); i != selection_.end(); ++i) {
       string cut;
       ::helper::SelectCode code;
       parse(*i, code, cut);
       if (code.all_) {
         if (i != selection_.begin())
           throw Exception(errors::Configuration)
               << "selections \"keep *\" and \"drop *\" can be used only as first options. Here used in position # "
               << (i - selection_.begin()) + 1 << "\n"
               << endl;
         switch (code.keepOrDrop_) {
           case ::helper::SelectCode::kDrop:
             keepOrDropAll_ = drop;
             break;
           case ::helper::SelectCode::kKeep:
             keepOrDropAll_ = keep;
         };
       } else {
         cut = pdgEntryReplace(cut, pdt);
         select_.push_back(make_pair(StringCutObjectSelector<GenParticle>(cut), code));
       }
     }
     firstEvent_ = false;
   }
 
   const auto &tps = iEvent.get(tpToken_);
 
   const auto &gps = iEvent.get(gpToken_);
 
   using namespace ::helper;
   const size_t n = gps.size();
   flags_.clear();
   flags_.resize(n, keepOrDropAll_);
   for (size_t j = 0; j < select_.size(); ++j) {
     const pair<StringCutObjectSelector<GenParticle>, SelectCode> &sel = select_[j];
     SelectCode code = sel.second;
     const StringCutObjectSelector<GenParticle> &cut = sel.first;
     for (size_t i = 0; i < n; ++i) {
       const GenParticle &p = gps[i];
       if (cut(p)) {
         int keepOrDrop = keep;
         switch (code.keepOrDrop_) {
           case SelectCode::kKeep:
             keepOrDrop = keep;
             break;
           case SelectCode::kDrop:
             keepOrDrop = drop;
         };
         flags_[i] = keepOrDrop;
         std::vector<size_t> allIndicesDa;
         std::vector<size_t> allIndicesMo;
         switch (code.daughtersDepth_) {
           case SelectCode::kAll:
             recursiveFlagDaughters(i, gps, keepOrDrop, allIndicesDa);
             break;
           case SelectCode::kFirst:
             flagDaughters(p, keepOrDrop);
             break;
           case SelectCode::kNone:;
         };
         switch (code.mothersDepth_) {
           case SelectCode::kAll:
             recursiveFlagMothers(i, gps, keepOrDrop, allIndicesMo);
             break;
           case SelectCode::kFirst:
             flagMothers(p, keepOrDrop);
             break;
           case SelectCode::kNone:;
         };
       }
     }
   }
 
   auto out = std::make_unique<TrackingParticleCollection>();
   out->reserve(n);
 
   for (auto &&tp : tps) {
     auto &associatedGenParticles = tp.genParticles();
 
     bool isSelected = false;
     for (auto &&assocGen : associatedGenParticles) {
       if (flags_[assocGen.index()] == keep)
         isSelected = true;
     }
 
     if (isSelected) {
       out->emplace_back(tp);
     }
   }
   iEvent.put(std::move(out));
 }

◆ recursiveFlagDaughters()

void TrackingParticleSelectorByGen::recursiveFlagDaughters	(	size_t	index,
		const reco::GenParticleCollection &	src,
		int	keepOrDrop,
		std::vector< size_t > &	allIndices
	)

private

Definition at line 156 of file TrackingParticleSelectorByGen.cc.

References BPhysicsValidation_cfi::daughters, spr::find(), flags_, mps_fire::i, and TrackRefitter_38T_cff::src.

Referenced by produce().

                                                                                           {
   GenParticleRefVector daughters = src[index].daughterRefVector();
   // avoid infinite recursion if the daughters are set to "this" particle.
   size_t cachedIndex = index;
   for (GenParticleRefVector::const_iterator i = daughters.begin(); i != daughters.end(); ++i) {
     index = i->key();
     // To also avoid infinite recursion if a "loop" is found in the daughter list,
     // check to make sure the index hasn't already been added.
     if (find(allIndices.begin(), allIndices.end(), index) == allIndices.end()) {
       allIndices.push_back(index);
       if (cachedIndex != index) {
         flags_[index] = keepOrDrop;
         recursiveFlagDaughters(index, src, keepOrDrop, allIndices);
       }
     }
   }
 }

◆ recursiveFlagMothers()

void TrackingParticleSelectorByGen::recursiveFlagMothers	(	size_t	index,
		const reco::GenParticleCollection &	src,
		int	keepOrDrop,
		std::vector< size_t > &	allIndices
	)

private

Definition at line 177 of file TrackingParticleSelectorByGen.cc.

References edm::RefVector< C, T, F >::begin(), edm::RefVector< C, T, F >::end(), spr::find(), flags_, mps_fire::i, and TrackRefitter_38T_cff::src.

Referenced by produce().

                                                                                         {
   GenParticleRefVector mothers = src[index].motherRefVector();
   // avoid infinite recursion if the mothers are set to "this" particle.
   size_t cachedIndex = index;
   for (GenParticleRefVector::const_iterator i = mothers.begin(); i != mothers.end(); ++i) {
     index = i->key();
     // To also avoid infinite recursion if a "loop" is found in the daughter list,
     // check to make sure the index hasn't already been added.
     if (find(allIndices.begin(), allIndices.end(), index) == allIndices.end()) {
       allIndices.push_back(index);
       if (cachedIndex != index) {
         flags_[index] = keepOrDrop;
         recursiveFlagMothers(index, src, keepOrDrop, allIndices);
       }
     }
   }
 }