Produces reco::GenParticle from SimTracks. More...

Inheritance diagram for pat::PATGenCandsFromSimTracksProducer:

Classes
struct	GlobalContext
	Global context for all recursive methods. More...

struct	LessById

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

	~PATGenCandsFromSimTracksProducer () override

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

Private Types
typedef StringCutObjectSelector< reco::GenParticle >	StrFilter

Private Member Functions
const SimTrack *	findGeantMother (const SimTrack &tk, const GlobalContext &g) const
	Find the mother of a given GEANT track (or NULL if it can't be found). More...

edm::Ref< reco::GenParticleCollection >	findRef (const SimTrack &tk, GlobalContext &g) const

edm::Ref< reco::GenParticleCollection >	generatorRef_ (const SimTrack &tk, const GlobalContext &g) const
	Used by findRef if the track is a PYTHIA particle. More...

reco::GenParticle	makeGenParticle_ (const SimTrack &tk, const edm::Ref< reco::GenParticleCollection > &mother, const GlobalContext &g) const
	Make a GenParticle for this SimTrack, with a given mother. More...

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

Private Attributes
const StrFilter	filter_

bool	firstEvent_

edm::EDGetTokenT< std::vector< int > >	genBarcodesToken_

edm::EDGetTokenT< reco::GenParticleCollection >	genParticlesToken_
	Collection of GenParticles I need to make refs to. It must also have its associated vector<int> of barcodes, aligned with them. More...

bool	makeMotherLink_
	If true, I'll try to make a link from the GEANT particle to a GenParticle. More...

std::set< int >	motherPdgIds_

std::vector< PdtEntry >	motherPdts_

std::set< int >	pdgIds_

std::vector< PdtEntry >	pdts_

int	setStatus_

edm::EDGetTokenT< edm::SimTrackContainer >	simTracksToken_

edm::EDGetTokenT< edm::SimVertexContainer >	simVertexToken_

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

bool	writeAncestors_
	If true, I'll save GenParticles corresponding to the ancestors of this GEANT particle. Common ancestors are only written once. More...

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

Produces reco::GenParticle from SimTracks.

The PATGenCandsFromSimTracksProducer produces GenParticles from SimTracks, so they can be used for MC matching.

Author: Jordan Tucker (original module), Giovanni Petrucciani (PAT integration)

Version

Id: PATGenCandsFromSimTracksProducer.cc,v 1.8 2010/10/20 23:09:25 wmtan Exp

Definition at line 31 of file PATGenCandsFromSimTracksProducer.cc.

Member Typedef Documentation

◆ StrFilter

typedef StringCutObjectSelector<reco::GenParticle> pat::PATGenCandsFromSimTracksProducer::StrFilter

private

Definition at line 48 of file PATGenCandsFromSimTracksProducer.cc.

Constructor & Destructor Documentation

◆ PATGenCandsFromSimTracksProducer()

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

explicit

Definition at line 124 of file PATGenCandsFromSimTracksProducer.cc.

     : firstEvent_(true),
       simTracksToken_(consumes<SimTrackContainer>(cfg.getParameter<InputTag>("src"))),   // source sim tracks
       simVertexToken_(consumes<SimVertexContainer>(cfg.getParameter<InputTag>("src"))),  // source sim  vertices
       setStatus_(cfg.getParameter<int32_t>("setStatus")),  // set status of GenParticle to this code
       filter_(cfg.existsAs<string>("filter") ? cfg.getParameter<string>("filter") : std::string("1 == 1")),
       makeMotherLink_(cfg.existsAs<bool>("makeMotherLink") ? cfg.getParameter<bool>("makeMotherLink") : false),
       writeAncestors_(cfg.existsAs<bool>("writeAncestors") ? cfg.getParameter<bool>("writeAncestors") : false),
       genParticlesToken_(mayConsume<GenParticleCollection>(cfg.getParameter<InputTag>("genParticles"))),
       genBarcodesToken_(mayConsume<std::vector<int> >(cfg.getParameter<InputTag>("genParticles"))),
       tableToken_(esConsumes()) {
   // Possibly allow a list of particle types
   if (cfg.exists("particleTypes")) {
     pdts_ = cfg.getParameter<vector<PdtEntry> >("particleTypes");
   }
   if (cfg.exists("motherTypes")) {
     motherPdts_ = cfg.getParameter<vector<PdtEntry> >("motherTypes");
   }
  
   if (writeAncestors_ && !makeMotherLink_) {
     edm::LogWarning("Configuration")
         << "PATGenCandsFromSimTracksProducer: "
         << "you have set 'writeAncestors' to 'true' and 'makeMotherLink' to false;"
         << "GEANT particles with generator level (e.g.PYHIA) mothers won't have mother links.\n";
   }
   produces<GenParticleCollection>();
 }

References looper::cfg, makeMotherLink_, motherPdts_, pdts_, and writeAncestors_.

◆ ~PATGenCandsFromSimTracksProducer()

pat::PATGenCandsFromSimTracksProducer::~PATGenCandsFromSimTracksProducer ( )

inlineoverride

Definition at line 34 of file PATGenCandsFromSimTracksProducer.cc.

34 {}

Member Function Documentation

◆ findGeantMother()

const SimTrack * PATGenCandsFromSimTracksProducer::findGeantMother	(	const SimTrack &	tk,
		const GlobalContext &	g
	)		const

private

Find the mother of a given GEANT track (or NULL if it can't be found).

Definition at line 152 of file PATGenCandsFromSimTracksProducer.cc.

                                                                                                                   {
   assert(tk.genpartIndex() == -1);  // MUST NOT be called with a PYTHIA track
   if (!tk.noVertex()) {
     const SimVertex &vtx = g.simvtxs[tk.vertIndex()];
     if (!vtx.noParent()) {
       unsigned int idx = vtx.parentIndex();
       SimTrackContainer::const_iterator it = std::lower_bound(g.simtks.begin(), g.simtks.end(), idx, LessById());
       if ((it != g.simtks.end()) && (it->trackId() == idx)) {
         return &*it;
       }
     }
   }
   return nullptr;
 }

References cms::cuda::assert(), g, SimTrack::genpartIndex(), heavyIonCSV_trainingSettings::idx, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, SimTrack::noVertex(), SimTrack::vertIndex(), and extraflags_cff::vtx.

Referenced by findRef(), and produce().

◆ findRef()

edm::Ref< reco::GenParticleCollection > PATGenCandsFromSimTracksProducer::findRef	(	const SimTrack &	tk,
		GlobalContext &	g
	)		const

private

Find the GenParticle reference for a given GEANT or PYTHIA track.

if the track corresponds to a PYTHIA particle, return a ref to that particle
otherwise, if this simtrack has no mother simtrack, return a null ref
otherwise, if writeAncestors is true, make a GenParticle for it and return a ref to it
otherwise, if writeAncestors is false, return the ref to the GEANT mother of this track

Definition at line 167 of file PATGenCandsFromSimTracksProducer.cc.

                                                                                                         {
   if (tk.genpartIndex() != -1)
     return makeMotherLink_ ? generatorRef_(tk, g) : edm::Ref<reco::GenParticleCollection>();
   const SimTrack *simMother = findGeantMother(tk, g);
  
   edm::Ref<reco::GenParticleCollection> motherRef;
   if (simMother != nullptr)
     motherRef = findRef(*simMother, g);
  
   if (writeAncestors_) {
     // If writing ancestors, I need to serialize myself, and then to return a ref to me
     // But first check if I've already been serialized
     std::map<unsigned int, int>::const_iterator it = g.simTksProcessed.find(tk.trackId());
     if (it != g.simTksProcessed.end()) {
       // just return a ref to it
       assert(it->second > 0);
       return edm::Ref<reco::GenParticleCollection>(g.refprod, (it->second) - 1);
     } else {
       // make genParticle, save, update the map, and return ref to myself
       reco::GenParticle p = makeGenParticle_(tk, motherRef, g);
       g.output.push_back(p);
       g.simTksProcessed[tk.trackId()] = g.output.size();
       return edm::Ref<reco::GenParticleCollection>(g.refprod, g.output.size() - 1);
     }
   } else {
     // Otherwise, I just return a ref to my mum
     return motherRef;
   }
 }

References cms::cuda::assert(), findGeantMother(), g, generatorRef_(), SimTrack::genpartIndex(), makeGenParticle_(), makeMotherLink_, AlCaHLTBitMon_ParallelJobs::p, CoreSimTrack::trackId(), and writeAncestors_.

Referenced by produce().

◆ generatorRef_()

edm::Ref< reco::GenParticleCollection > PATGenCandsFromSimTracksProducer::generatorRef_	(	const SimTrack &	tk,
		const GlobalContext &	g
	)		const

private

Used by findRef if the track is a PYTHIA particle.

Definition at line 198 of file PATGenCandsFromSimTracksProducer.cc.

                                                                                                                     {
   assert(st.genpartIndex() != -1);
   // Note that st.genpartIndex() is the barcode, not the index within GenParticleCollection, so I have to search the particle
   std::vector<int>::const_iterator it;
   if (g.barcodesAreSorted) {
     it = std::lower_bound(g.genBarcodes->begin(), g.genBarcodes->end(), st.genpartIndex());
   } else {
     it = std::find(g.genBarcodes->begin(), g.genBarcodes->end(), st.genpartIndex());
   }
  
   // Check that I found something
   // I need to check '*it == st.genpartIndex()' because lower_bound just finds the right spot for an item in a sorted list, not the item
   if ((it != g.genBarcodes->end()) && (*it == st.genpartIndex())) {
     return reco::GenParticleRef(g.gens, it - g.genBarcodes->begin());
   } else {
     return reco::GenParticleRef();
   }
 }

References cms::cuda::assert(), spr::find(), g, SimTrack::genpartIndex(), and pfDeepBoostedJetPreprocessParams_cfi::lower_bound.

Referenced by findRef().

◆ makeGenParticle_()

reco::GenParticle PATGenCandsFromSimTracksProducer::makeGenParticle_	(	const SimTrack &	tk,
		const edm::Ref< reco::GenParticleCollection > &	mother,
		const GlobalContext &	g
	)		const

private

Make a GenParticle for this SimTrack, with a given mother.

Definition at line 218 of file PATGenCandsFromSimTracksProducer.cc.

                                                                                                        {
   // Make up a GenParticleCandidate from the GEANT track info.
   int charge = static_cast<int>(tk.charge());
   const Particle::LorentzVector &p4 = tk.momentum();
   Particle::Point vtx;  // = (0,0,0) by default
   if (!tk.noVertex())
     vtx = g.simvtxs[tk.vertIndex()].position();
   GenParticle gp(charge, p4, vtx, tk.type(), setStatus_, true);
   if (mother.isNonnull())
     gp.addMother(mother);
   return gp;
 }

References CoreSimTrack::charge(), ALCARECOTkAlJpsiMuMu_cff::charge, g, runTauDisplay::gp, edm::Ref< C, T, F >::isNonnull(), CoreSimTrack::momentum(), SimTrack::noVertex(), p4, setStatus_, CoreSimTrack::type(), SimTrack::vertIndex(), and extraflags_cff::vtx.

Referenced by findRef(), and produce().

◆ produce()

void PATGenCandsFromSimTracksProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 232 of file PATGenCandsFromSimTracksProducer.cc.

                                                                                      {
   if (firstEvent_) {
     auto const &pdt = iSetup.getData(tableToken_);
     if (!pdts_.empty()) {
       pdgIds_.clear();
       for (vector<PdtEntry>::iterator itp = pdts_.begin(), edp = pdts_.end(); itp != edp; ++itp) {
         itp->setup(pdt);  // decode string->pdgId and vice-versa
         pdgIds_.insert(std::abs(itp->pdgId()));
       }
       pdts_.clear();
     }
     if (!motherPdts_.empty()) {
       motherPdgIds_.clear();
       for (vector<PdtEntry>::iterator itp = motherPdts_.begin(), edp = motherPdts_.end(); itp != edp; ++itp) {
         itp->setup(pdt);  // decode string->pdgId and vice-versa
         motherPdgIds_.insert(std::abs(itp->pdgId()));
       }
       motherPdts_.clear();
     }
     firstEvent_ = false;
   }
  
   // Simulated tracks (i.e. GEANT particles).
   Handle<SimTrackContainer> simtracks;
   event.getByToken(simTracksToken_, simtracks);
  
   // Need to check that SimTrackContainer is sorted; otherwise, copy and sort :-(
   std::unique_ptr<SimTrackContainer> simtracksTmp;
   const SimTrackContainer *simtracksSorted = &*simtracks;
   if (makeMotherLink_ || writeAncestors_) {
     if (!__gnu_cxx::is_sorted(simtracks->begin(), simtracks->end(), LessById())) {
       simtracksTmp = std::make_unique<SimTrackContainer>(*simtracks);
       std::sort(simtracksTmp->begin(), simtracksTmp->end(), LessById());
       simtracksSorted = &*simtracksTmp;
     }
   }
  
   // Get the associated vertices
   Handle<SimVertexContainer> simvertices;
   event.getByToken(simVertexToken_, simvertices);
  
   // Get the GenParticles and barcodes, if needed to set mother links
   Handle<GenParticleCollection> gens;
   Handle<std::vector<int> > genBarcodes;
   bool barcodesAreSorted = true;
   if (makeMotherLink_) {
     event.getByToken(genParticlesToken_, gens);
     event.getByToken(genBarcodesToken_, genBarcodes);
     if (gens->size() != genBarcodes->size())
       throw cms::Exception("Corrupt data") << "Barcodes not of the same size as GenParticles!\n";
     barcodesAreSorted = __gnu_cxx::is_sorted(genBarcodes->begin(), genBarcodes->end());
   }
  
   // make the output collection
   auto cands = std::make_unique<GenParticleCollection>();
   edm::RefProd<GenParticleCollection> refprod = event.getRefBeforePut<GenParticleCollection>();
  
   GlobalContext globals(*simtracksSorted, *simvertices, gens, genBarcodes, barcodesAreSorted, *cands, refprod);
  
   for (SimTrackContainer::const_iterator isimtrk = simtracks->begin(); isimtrk != simtracks->end(); ++isimtrk) {
     // Skip PYTHIA tracks.
     if (isimtrk->genpartIndex() != -1)
       continue;
  
     // Maybe apply the PdgId filter
     if (!pdgIds_.empty()) {  // if we have a filter on pdg ids
       if (pdgIds_.find(std::abs(isimtrk->type())) == pdgIds_.end())
         continue;
     }
  
     GenParticle genp = makeGenParticle_(*isimtrk, Ref<GenParticleCollection>(), globals);
  
     // Maybe apply filter on the particle
     if (!(filter_(genp)))
       continue;
  
     if (!motherPdgIds_.empty()) {
       const SimTrack *motherSimTk = findGeantMother(*isimtrk, globals);
       if (motherSimTk == nullptr)
         continue;
       if (motherPdgIds_.find(std::abs(motherSimTk->type())) == motherPdgIds_.end())
         continue;
     }
  
     if (makeMotherLink_ || writeAncestors_) {
       Ref<GenParticleCollection> motherRef;
       const SimTrack *mother = findGeantMother(*isimtrk, globals);
       if (mother != nullptr)
         motherRef = findRef(*mother, globals);
       if (motherRef.isNonnull())
         genp.addMother(motherRef);
     }
  
     cands->push_back(genp);
   }
  
   // Write to the Event, and get back a handle (which can be useful for debugging)
   edm::OrphanHandle<reco::GenParticleCollection> orphans = event.put(std::move(cands));
  
 #ifdef DEBUG_PATGenCandsFromSimTracksProducer
   std::cout << "Produced a list of " << orphans->size() << " genParticles." << std::endl;
   for (GenParticleCollection::const_iterator it = orphans->begin(), ed = orphans->end(); it != ed; ++it) {
     std::cout << "    ";
     std::cout << "GenParticle #" << (it - orphans->begin()) << ": pdgId " << it->pdgId() << ", pt = " << it->pt()
               << ", eta = " << it->eta() << ", phi = " << it->phi() << ", rho = " << it->vertex().Rho()
               << ", z = " << it->vertex().Z() << std::endl;
     edm::Ref<GenParticleCollection> mom = it->motherRef();
     size_t depth = 2;
     while (mom.isNonnull()) {
       if (mom.id() == orphans.id()) {
         // I need to re-make the ref because they are not working until this module returns.
         mom = edm::Ref<GenParticleCollection>(orphans, mom.key());
       }
       for (size_t i = 0; i < depth; ++i)
         std::cout << "    ";
       std::cout << "GenParticleRef [" << mom.id() << "/" << mom.key() << "]: pdgId " << mom->pdgId()
                 << ", status = " << mom->status() << ", pt = " << mom->pt() << ", eta = " << mom->eta()
                 << ", phi = " << mom->phi() << ", rho = " << mom->vertex().Rho() << ", z = " << mom->vertex().Z()
                 << std::endl;
       if (mom.id() != orphans.id())
         break;
       if ((mom->motherRef().id() == mom.id()) && (mom->motherRef().key() == mom.key())) {
         throw cms::Exception("Corrupt Data") << "A particle is it's own mother.\n";
       }
       mom = mom->motherRef();
       depth++;
     }
   }
   std::cout << std::endl;
 #endif
 }