HadronAndPartonSelector Class Reference

Selects hadrons and partons from a collection of GenParticles. More...

#include <PhysicsTools/JetMCAlgos/plugins/HadronAndPartonSelector.cc>

Inheritance diagram for HadronAndPartonSelector:

Public Member Functions
	HadronAndPartonSelector (const edm::ParameterSet &)
	~HadronAndPartonSelector () 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

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

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

Private Attributes
bool	fullChainPhysPartons_
const edm::EDGetTokenT< reco::GenParticleCollection >	particlesToken_
std::string	partonMode_
PartonSelectorPtr	partonSelector_
bool	partonSelectorSet_
const edm::EDGetTokenT< GenEventInfoProduct >	srcToken_

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

Selects hadrons and partons from a collection of GenParticles.

This producer selects hadrons, partons, and leptons from a collection of GenParticles and stores vectors of EDM references to these particles in the event. The following hadrons are selected:

• b hadrons that do not have other b hadrons as daughters
• c hadrons that do not have other c hadrons as daughters

Older Fortran Monte Carlo generators (Pythia6 and Herwig6) follow the HEPEVT [1] particle status code convention while newer C++ Monte Carlo generators (Pythia8, Herwig++, and Sherpa) follow the HepMC [2] particle status code convention. However, both conventions give considerable freedom in defining the status codes of intermediate particle states. Hence, the parton selection is generator-dependent and is described in each of the parton selectors separately.

Using the provenance information of the GenEventInfoProduct, the producer attempts to automatically determine what generator was used to hadronize events and based on that information decides what parton selection mode to use. It is also possible to enforce any of the supported parton selection modes.

The selected hadrons and partons are finally used by the JetFlavourClustering producer to determine the jet flavour.

The following leptons are selected:

• status==1 electrons and muons
• status==2 taus

[1] http://cepa.fnal.gov/psm/stdhep/ [2] http://lcgapp.cern.ch/project/simu/HepMC/

Definition at line 77 of file HadronAndPartonSelector.cc.

Constructor & Destructor Documentation

HadronAndPartonSelector()

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

explicit

Definition at line 104 of file HadronAndPartonSelector.cc.

References partonSelector_, and partonSelectorSet_.

    :

      srcToken_(mayConsume<GenEventInfoProduct>(iConfig.getParameter<edm::InputTag>("src"))),
      particlesToken_(consumes<reco::GenParticleCollection>(iConfig.getParameter<edm::InputTag>("particles"))),
      partonMode_(iConfig.getParameter<std::string>("partonMode")),
      fullChainPhysPartons_(iConfig.getParameter<bool>("fullChainPhysPartons"))

{
  //register your products
  produces<reco::GenParticleRefVector>("bHadrons");
  produces<reco::GenParticleRefVector>("cHadrons");
  produces<reco::GenParticleRefVector>("algorithmicPartons");
  produces<reco::GenParticleRefVector>("physicsPartons");
  produces<reco::GenParticleRefVector>("leptons");

  partonSelectorSet_ = false;
  partonSelector_ = nullptr;
}

~HadronAndPartonSelector()

HadronAndPartonSelector::~HadronAndPartonSelector ( )

override

Definition at line 124 of file HadronAndPartonSelector.cc.

                                                  {
  // do anything here that needs to be done at desctruction time
  // (e.g. close files, deallocate resources etc.)
}

Member Function Documentation

fillDescriptions()

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

static

Definition at line 266 of file HadronAndPartonSelector.cc.

References edm::ConfigurationDescriptions::addDefault(), and submitPVResolutionJobs::desc.

                                                                                         {
  //The following says we do not know what parameters are allowed so do no validation
  // Please change this to state exactly what you do use, even if it is no parameters
  edm::ParameterSetDescription desc;
  desc.setUnknown();
  descriptions.addDefault(desc);
}

produce()

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

overrideprivate

Definition at line 134 of file HadronAndPartonSelector.cc.

References AK4GenJetFlavourInfos_cfi::bHadrons, AK4GenJetFlavourInfos_cfi::cHadrons, Exception, fullChainPhysPartons_, CandMCTagUtils::hasBottom(), CandMCTagUtils::hasCharm(), mps_fire::i, edm::HandleBase::id(), iEvent, reco::isElectron(), reco::isMuon(), CandMCTagUtils::isParton(), reco::isTau(), edm::HandleBase::isValid(), HLT_2022v14_cff::leptons, edm::moduleName(), EcalCalibMonitorClient_cfi::moduleName, eostools::move(), edm::parameterSet(), ecalTrigSettings_cff::particles, particlesToken_, partonMode_, dqmAnalyzer_cff::partons, partonSelector_, partonSelectorSet_, srcToken_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                   {
  // determine hadronizer type (done only once per job)
  if (partonMode_ == "Auto") {
    edm::Handle<GenEventInfoProduct> genEvtInfoProduct;
    iEvent.getByToken(srcToken_, genEvtInfoProduct);

    std::string moduleName = "";
    if (genEvtInfoProduct.isValid()) {
      const edm::StableProvenance& prov = iEvent.getStableProvenance(genEvtInfoProduct.id());
      moduleName = edm::moduleName(prov, iEvent.processHistory());
      if (moduleName == "ExternalGeneratorFilter") {
        moduleName = edm::parameterSet(prov, iEvent.processHistory()).getParameter<std::string>("@external_type");
        edm::LogInfo("SpecialModule") << "GEN events are produced by ExternalGeneratorFilter, "
                                      << "which is a wrapper of the original module: " << moduleName;
      }
    }

    if (moduleName.find("Pythia6") != std::string::npos)
      partonMode_ = "Pythia6";
    else if (moduleName.find("Pythia8") != std::string::npos)
      partonMode_ = "Pythia8";
    else if (moduleName.find("ThePEG") != std::string::npos)
      partonMode_ = "Herwig++";
    else if (moduleName.find("Herwig7") != std::string::npos)
      partonMode_ = "Herwig++";
    else if (moduleName.find("Sherpa") != std::string::npos)
      partonMode_ = "Sherpa";
    else
      partonMode_ = "Undefined";
  }

  // set the parton selection mode (done only once per job)
  if (!partonSelectorSet_) {
    if (partonMode_ == "Undefined")
      edm::LogWarning("UndefinedPartonMode")
          << "Could not automatically determine the hadronizer type and set the correct parton selection mode. "
             "Parton-based jet flavour will not be defined.";
    else if (partonMode_ == "Pythia6") {
      partonSelector_ = PartonSelectorPtr(new Pythia6PartonSelector());
      edm::LogInfo("PartonModeDefined") << "Using Pythia6 parton selection mode.";
    } else if (partonMode_ == "Pythia8") {
      partonSelector_ = PartonSelectorPtr(new Pythia8PartonSelector());
      edm::LogInfo("PartonModeDefined") << "Using Pythia8 parton selection mode.";
    } else if (partonMode_ == "Herwig++") {
      partonSelector_ = PartonSelectorPtr(new HerwigppPartonSelector());
      edm::LogInfo("PartonModeDefined") << "Using Herwig++ parton selection mode.";
    } else if (partonMode_ == "Sherpa") {
      partonSelector_ = PartonSelectorPtr(new SherpaPartonSelector());
      edm::LogInfo("PartonModeDefined") << "Using Sherpa parton selection mode.";
    } else
      throw cms::Exception("InvalidPartonMode") << "Parton selection mode is invalid: " << partonMode_
                                                << ", use Auto | Pythia6 | Pythia8 | Herwig++ | Sherpa" << std::endl;

    partonSelectorSet_ = true;
  }

  edm::Handle<reco::GenParticleCollection> particles;
  iEvent.getByToken(particlesToken_, particles);

  auto bHadrons = std::make_unique<reco::GenParticleRefVector>();
  auto cHadrons = std::make_unique<reco::GenParticleRefVector>();
  auto partons = std::make_unique<reco::GenParticleRefVector>();
  auto physicsPartons = std::make_unique<reco::GenParticleRefVector>();
  auto leptons = std::make_unique<reco::GenParticleRefVector>();

  // loop over particles and select b and c hadrons and leptons
  for (reco::GenParticleCollection::const_iterator it = particles->begin(); it != particles->end(); ++it) {
    // if b hadron
    if (CandMCTagUtils::hasBottom(*it)) {
      // check if any of the daughters is also a b hadron
      bool hasbHadronDaughter = false;
      for (size_t i = 0; i < it->numberOfDaughters(); ++i) {
        if (CandMCTagUtils::hasBottom(*(it->daughter(i)))) {
          hasbHadronDaughter = true;
          break;
        }
      }
      if (hasbHadronDaughter)
        continue;  // skip excited b hadrons that have other b hadrons as daughters

      bHadrons->push_back(reco::GenParticleRef(particles, it - particles->begin()));
    }

    // if c hadron
    if (CandMCTagUtils::hasCharm(*it)) {
      // check if any of the daughters is also a c hadron
      bool hascHadronDaughter = false;
      for (size_t i = 0; i < it->numberOfDaughters(); ++i) {
        if (CandMCTagUtils::hasCharm(*(it->daughter(i)))) {
          hascHadronDaughter = true;
          break;
        }
      }
      if (hascHadronDaughter)
        continue;  // skip excited c hadrons that have other c hadrons as daughters

      cHadrons->push_back(reco::GenParticleRef(particles, it - particles->begin()));
    }

    // status==1 electrons and muons
    if ((reco::isElectron(*it) || reco::isMuon(*it)) && it->status() == 1)
      leptons->push_back(reco::GenParticleRef(particles, it - particles->begin()));

    // status==2 taus
    if (reco::isTau(*it) && it->status() == 2)
      leptons->push_back(reco::GenParticleRef(particles, it - particles->begin()));
  }

  // select algorithmic partons
  if (partonMode_ != "Undefined") {
    partonSelector_->run(particles, partons);
  }

  // select physics partons
  for (reco::GenParticleCollection::const_iterator it = particles->begin(); it != particles->end(); ++it) {
    if (!fullChainPhysPartons_) {
      if (!(it->status() == 3 || ((partonMode_ == "Pythia8") && (it->status() == 23))))
        continue;
    }
    if (!CandMCTagUtils::isParton(*it))
      continue;  // skip particle if not a parton
    physicsPartons->push_back(reco::GenParticleRef(particles, it - particles->begin()));
  }

  iEvent.put(std::move(bHadrons), "bHadrons");
  iEvent.put(std::move(cHadrons), "cHadrons");
  iEvent.put(std::move(partons), "algorithmicPartons");
  iEvent.put(std::move(physicsPartons), "physicsPartons");
  iEvent.put(std::move(leptons), "leptons");
}

Member Data Documentation

fullChainPhysPartons_

bool HadronAndPartonSelector::fullChainPhysPartons_

private

Definition at line 92 of file HadronAndPartonSelector.cc.

Referenced by produce().

particlesToken_

const edm::EDGetTokenT<reco::GenParticleCollection> HadronAndPartonSelector::particlesToken_

private

Definition at line 89 of file HadronAndPartonSelector.cc.

Referenced by produce().

partonMode_

std::string HadronAndPartonSelector::partonMode_

private

Definition at line 91 of file HadronAndPartonSelector.cc.

Referenced by produce().

partonSelector_

PartonSelectorPtr HadronAndPartonSelector::partonSelector_

private

Definition at line 94 of file HadronAndPartonSelector.cc.

Referenced by HadronAndPartonSelector(), and produce().

partonSelectorSet_

bool HadronAndPartonSelector::partonSelectorSet_

private

Definition at line 93 of file HadronAndPartonSelector.cc.

Referenced by HadronAndPartonSelector(), and produce().

srcToken_

const edm::EDGetTokenT<GenEventInfoProduct> HadronAndPartonSelector::srcToken_

private

Definition at line 88 of file HadronAndPartonSelector.cc.

Referenced by produce().