#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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

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::EDGetTokenT< TrackingParticleCollection >	tpToken_

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

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 47 of file TrackingParticleSelectorByGen.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 131 of file TrackingParticleSelectorByGen.cc.

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

Member Function Documentation

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

static

Definition at line 329 of file TrackingParticleSelectorByGen.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and DEFINE_FWK_MODULE.

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

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

private

Definition at line 140 of file TrackingParticleSelectorByGen.cc.

References edm::RefVector< C, T, F >::begin(), reco::CompositeRefCandidateT< D >::daughterRefVector(), BPhysicsValidation_cfi::daughters, edm::RefVector< C, T, F >::end(), 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;
 }

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

private

Definition at line 146 of file TrackingParticleSelectorByGen.cc.

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

Referenced by produce().

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

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

private

Definition at line 194 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_, training_settings::idx, 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);
       }
     }
   }
 }

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

private

Definition at line 213 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_, training_settings::idx, 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);
       }
     }
   }
 }

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

private

Definition at line 81 of file TrackingParticleSelectorByGen.cc.

References helper::SelectCode::all_, EnergyCorrector::c, mps_check::command, edm::errors::Configuration, helper::SelectCode::daughtersDepth_, Exception, f, helper::SelectCode::kAll, helper::SelectCode::kDrop, helper::SelectCode::keepOrDrop_, helper::SelectCode::kFirst, helper::SelectCode::kKeep, helper::SelectCode::kNone, helper::SelectCode::mothersDepth_, gen::n, 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 == "*";
 }

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

overrideprivate

Definition at line 232 of file TrackingParticleSelectorByGen.cc.

References helper::SelectCode::all_, edm::errors::Configuration, TkAlMuonSelectors_cfi::cut, drop, Exception, firstEvent_, flagDaughters(), flagMothers(), flags_, edm::Event::get(), gpToken_, mps_fire::i, keep, helper::SelectCode::keepOrDrop_, keepOrDropAll_, WDecay::kNone, eostools::move(), gen::n, MillePedeFileConverter_cfg::out, AlCaHLTBitMon_ParallelJobs::p, parse(), edm::Event::put(), recursiveFlagDaughters(), recursiveFlagMothers(), cuy::rep, PdgEntryReplacer::replace(), triggerObjects_cff::sel, select_, selection_, and tpToken_.

                                                                                          {
   using namespace edm;
 
   if (firstEvent_) {
     PdgEntryReplacer rep(iSetup);
     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 = rep.replace(cut);
         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));
 }

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

private

Definition at line 152 of file TrackingParticleSelectorByGen.cc.

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

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

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

private

Definition at line 173 of file TrackingParticleSelectorByGen.cc.

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

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