Inheritance diagram for GenParticlePruner:

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

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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_

std::vector< size_t >	indices_

int	keepOrDropAll_

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

std::vector< std::string >	selection_

edm::EDGetTokenT < reco::GenParticleCollection >	srcToken_

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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 22 of file GenParticlePruner.cc.

Constructor & Destructor Documentation

GenParticlePruner::GenParticlePruner ( const edm::ParameterSet & cfg )

Definition at line 95 of file GenParticlePruner.cc.

                                                             :
   firstEvent_(true),
   srcToken_(consumes<GenParticleCollection>(cfg.getParameter<InputTag>("src"))), keepOrDropAll_(drop),
   selection_(cfg.getParameter<vector<string> >("select")) {
   using namespace ::helper;
   produces<GenParticleCollection>();
   produces<edm::Association<reco::GenParticleCollection> >();
 }

Member Function Documentation

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

private

Definition at line 104 of file GenParticlePruner.cc.

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

Referenced by produce().

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

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

private

Definition at line 110 of file GenParticlePruner.cc.

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

Referenced by produce().

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

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

private

Definition at line 275 of file GenParticlePruner.cc.

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

Referenced by produce().

                                                                  {
   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.size()>0)
           getDaughterKeys(daIndxs, daNewIndxs, daus);
       }
     }
   }
 }

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

private

Definition at line 296 of file GenParticlePruner.cc.

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

Referenced by produce().

                                                                  {
   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.size()>0)
           getMotherKeys(moIndxs, moNewIndxs, moms);
       }
     }
   }
 }

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

private

Definition at line 49 of file GenParticlePruner.cc.

References helper::SelectCode::all_, EnergyCorrector::c, edmPickEvents::command, edm::errors::Configuration, helper::SelectCode::daughtersDepth_, Exception, f, helper::SelectCode::keepOrDrop_, WDecay::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 GenParticlePruner::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

overrideprivatevirtual

Implements edm::stream::EDProducerBase.

Definition at line 154 of file GenParticlePruner.cc.

References reco::CompositeRefCandidateT< D >::addDaughter(), reco::CompositeRefCandidateT< D >::addMother(), helper::SelectCode::all_, edm::errors::Configuration, counter, GOODCOLL_filter_cfg::cut, reco::CompositeRefCandidateT< D >::daughterRefVector(), drop, Exception, edm::helper::Filler< Map >::fill(), firstEvent_, flagDaughters(), flagMothers(), flags_, relval_steps::gen(), GenParticle::GenParticle, edm::Event::getByToken(), getDaughterKeys(), getMotherKeys(), edm::Event::getRefBeforePut(), i, cmsHarvester::index, indices_, edm::helper::Filler< Map >::insert(), j, keep, helper::SelectCode::keepOrDrop_, keepOrDropAll_, WDecay::kNone, reco::CompositeRefCandidateT< D >::motherRefVector(), gen::n, dbtoconf::out, AlCaHLTBitMon_ParallelJobs::p, parse(), edm::Event::put(), recursiveFlagDaughters(), recursiveFlagMothers(), cuy::rep, PdgEntryReplacer::replace(), EgammaValidation_Wenu_cff::sel, select_, selection_, python.multivaluedict::sort(), alcazmumu_cfi::src, srcToken_, and reco::GenParticle::statusFlags().

                                                                 {
   if (firstEvent_) {
     PdgEntryReplacer rep(es);
     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;
   }
 
   using namespace ::helper;
   Handle<GenParticleCollection> src;
   evt.getByToken(srcToken_, src);
   const size_t n = src->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 = (*src)[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, *src, keepOrDrop, allIndicesDa); break;
     case SelectCode::kFirst :
       flagDaughters(p, keepOrDrop); break;
     case SelectCode::kNone:
       ;
     };
     switch(code.mothersDepth_) {
     case SelectCode::kAll :
       recursiveFlagMothers(i, *src, keepOrDrop, allIndicesMo); break;
     case SelectCode::kFirst :
       flagMothers(p, keepOrDrop); break;
     case SelectCode::kNone:
       ;
     };
       }
     }
   }
   indices_.clear();
   int counter = 0;
   for(size_t i = 0; i < n; ++i) {
     if(flags_[i] == keep) {
       indices_.push_back(i);
       flags_[i] = counter++;
     } else
     {
       flags_[i]=-1; //set to invalid ref    
     }
   }
 
   auto_ptr<GenParticleCollection> out(new GenParticleCollection);
   GenParticleRefProd outRef = evt.getRefBeforePut<GenParticleCollection>();
   out->reserve(counter);
   
   for(vector<size_t>::const_iterator i = indices_.begin(); i != indices_.end(); ++i) {
     size_t index = *i;
     const GenParticle & gen = (*src)[index];
     const LeafCandidate & part = gen;
     out->push_back(GenParticle(part));
     GenParticle & newGen = out->back();
     //fill status flags
     newGen.statusFlags() = gen.statusFlags();
     // The "daIndxs" and "moIndxs" keep a list of the keys for the mother/daughter
     // parentage/descendency. In some cases, a circular referencing is encountered,
     // which would result in an infinite loop. The list is checked to
     // avoid this.
     vector<size_t> daIndxs, daNewIndxs;
     getDaughterKeys(daIndxs, daNewIndxs, gen.daughterRefVector());
     std::sort(daNewIndxs.begin(),daNewIndxs.end());
     for(size_t i=0; i<daNewIndxs.size(); ++i)
       newGen.addDaughter( GenParticleRef(outRef, daNewIndxs[i]) );
 
     vector<size_t> moIndxs, moNewIndxs;
     getMotherKeys(moIndxs, moNewIndxs, gen.motherRefVector());
     std::sort(moNewIndxs.begin(),moNewIndxs.end());
     for(size_t i=0; i<moNewIndxs.size(); ++i)
       newGen.addMother( GenParticleRef(outRef, moNewIndxs[i]) );
   }
 
 
     edm::OrphanHandle<reco::GenParticleCollection> oh = evt.put(out);
     std::auto_ptr<edm::Association<reco::GenParticleCollection> > orig2new(new edm::Association<reco::GenParticleCollection>(oh   ));
     edm::Association<reco::GenParticleCollection>::Filler orig2newFiller(*orig2new);
     orig2newFiller.insert(src, flags_.begin(), flags_.end());
     orig2newFiller.fill();
     evt.put(orig2new);
    
 
 }

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

private

Definition at line 116 of file GenParticlePruner.cc.

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

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 GenParticlePruner::recursiveFlagMothers	(	size_t	index,
		const reco::GenParticleCollection &	src,
		int	keepOrDrop,
		std::vector< size_t > &	allIndices
	)

private

Definition at line 135 of file GenParticlePruner.cc.

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

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

Member Data Documentation

bool GenParticlePruner::firstEvent_

private

Definition at line 27 of file GenParticlePruner.cc.

Referenced by produce().

std::vector<int> GenParticlePruner::flags_

private

Definition at line 32 of file GenParticlePruner.cc.

Referenced by flagDaughters(), flagMothers(), getDaughterKeys(), getMotherKeys(), produce(), recursiveFlagDaughters(), and recursiveFlagMothers().

std::vector<size_t> GenParticlePruner::indices_

private

Definition at line 33 of file GenParticlePruner.cc.

Referenced by produce().

int GenParticlePruner::keepOrDropAll_

private

Definition at line 29 of file GenParticlePruner.cc.

Referenced by produce().

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

private

Definition at line 31 of file GenParticlePruner.cc.

Referenced by produce().

std::vector<std::string> GenParticlePruner::selection_

private

Definition at line 30 of file GenParticlePruner.cc.

Referenced by produce().

edm::EDGetTokenT<reco::GenParticleCollection> GenParticlePruner::srcToken_

private

Definition at line 28 of file GenParticlePruner.cc.

Referenced by produce().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation