Inheritance diagram for PATTauIDEmbedder:

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

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

	~PATTauIDEmbedder () 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 std::pair< edm::InputTag, std::vector< NameWPIdx > >	IDContainerData

typedef std::pair< std::string, edm::InputTag >	NameTag

typedef std::pair< std::string, int >	NameWPIdx

Private Attributes
size_t	nNewPlainTauIds_

size_t	nNewTauIds_

std::vector< edm::EDGetTokenT< reco::TauDiscriminatorContainer > >	patTauIDContainerTokens_

std::vector< edm::EDGetTokenT< pat::PATTauDiscriminator > >	patTauIDTokens_

edm::EDGetTokenT< pat::TauCollection >	src_

std::vector< std::vector< NameWPIdx > >	tauIDSrcContainers_

std::vector< NameTag >	tauIDSrcs_

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

Definition at line 11 of file PATTauIDEmbedder.cc.

Member Typedef Documentation

◆ IDContainerData

typedef std::pair<edm::InputTag, std::vector<NameWPIdx> > PATTauIDEmbedder::IDContainerData

private

Definition at line 24 of file PATTauIDEmbedder.cc.

◆ NameTag

typedef std::pair<std::string, edm::InputTag> PATTauIDEmbedder::NameTag

private

Definition at line 21 of file PATTauIDEmbedder.cc.

◆ NameWPIdx

typedef std::pair<std::string, int> PATTauIDEmbedder::NameWPIdx

private

Definition at line 22 of file PATTauIDEmbedder.cc.

Constructor & Destructor Documentation

◆ PATTauIDEmbedder()

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

explicit

Definition at line 33 of file PATTauIDEmbedder.cc.

References looper::cfg, generateEDF::cont, dqmdumpme::first, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNamesForType(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, Skims_PA_cff::name, names, nNewPlainTauIds_, nNewTauIds_, patTauIDContainerTokens_, patTauIDTokens_, src_, makeGlobalPositionRcd_cfg::tag, tauIDSrcContainers_, tauIDSrcs_, and edm::vector_transform().

                                                              {
   src_ = consumes<pat::TauCollection>(cfg.getParameter<edm::InputTag>("src"));
   // read the different tau ID names
   edm::ParameterSet idps = cfg.getParameter<edm::ParameterSet>("tauIDSources");
   std::vector<std::string> names = idps.getParameterNamesForType<edm::ParameterSet>();
   std::map<std::string, IDContainerData> idContainerMap;
   for (auto const& name : names) {
     edm::ParameterSet idp = idps.getParameter<edm::ParameterSet>(name);
     int wpidx = idp.getParameter<int>("workingPointIndex");
     edm::InputTag tag = idp.getParameter<edm::InputTag>("inputTag");
     if (wpidx == -99) {
       tauIDSrcs_.push_back(NameTag(name, tag));
     } else {
       std::map<std::string, IDContainerData>::iterator it;
       it = idContainerMap.insert({tag.label() + tag.instance(), {tag, std::vector<NameWPIdx>()}}).first;
       it->second.second.push_back(NameWPIdx(name, wpidx));
     }
   }
   // but in any case at least once
   if (tauIDSrcs_.empty() && idContainerMap.empty())
     throw cms::Exception("Configuration") << "PATTauProducer: id addTauID is true, you must specify:\n"
                                           << "\tPSet tauIDSources = { \n"
                                           << "\t\tInputTag <someName> = <someTag>   // as many as you want \n "
                                           << "\t}\n";
   for (auto const& mapEntry : idContainerMap) {
     tauIDSrcContainers_.push_back(mapEntry.second.second);
     patTauIDContainerTokens_.push_back(mayConsume<reco::TauDiscriminatorContainer>(mapEntry.second.first));
   }
   patTauIDTokens_ = edm::vector_transform(
       tauIDSrcs_, [this](NameTag const& tag) { return mayConsume<pat::PATTauDiscriminator>(tag.second); });
   nNewPlainTauIds_ = tauIDSrcs_.size();
   nNewTauIds_ = nNewPlainTauIds_;
   for (auto const& cont : tauIDSrcContainers_) {
     nNewTauIds_ += cont.size();
   }
 
   produces<std::vector<pat::Tau> >();
 }

◆ ~PATTauIDEmbedder()

PATTauIDEmbedder::~PATTauIDEmbedder ( )

inlineoverride

Definition at line 14 of file PATTauIDEmbedder.cc.

14 {};

Member Function Documentation

◆ produce()

void PATTauIDEmbedder::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

override

Definition at line 72 of file PATTauIDEmbedder.cc.

References edm::Event::get(), edm::Event::getByToken(), mps_fire::i, dqmiolumiharvest::j, eostools::move(), nNewPlainTauIds_, nNewTauIds_, patTauIDContainerTokens_, patTauIDTokens_, edm::Event::put(), PDWG_TauSkim_cff::rawValues, edm::second(), pat::Tau::setTauIDs(), src_, tauIDSrcContainers_, tauIDSrcs_, and PDWG_TauSkim_cff::workingPoints.

                                                                      {
   edm::Handle<pat::TauCollection> inputTaus;
   evt.getByToken(src_, inputTaus);
 
   auto outputTaus = std::make_unique<std::vector<pat::Tau> >();
   outputTaus->reserve(inputTaus->size());
 
   int tau_idx = 0;
   for (pat::TauCollection::const_iterator inputTau = inputTaus->begin(); inputTau != inputTaus->end();
        ++inputTau, ++tau_idx) {
     pat::Tau outputTau(*inputTau);
     pat::TauRef inputTauRef(inputTaus, tau_idx);
     size_t nTauIds = inputTau->tauIDs().size();
     std::vector<pat::Tau::IdPair> tauIds(nTauIds + nNewTauIds_);
 
     // copy IDs that are already stored in PAT taus
     for (size_t i = 0; i < nTauIds; ++i) {
       tauIds[i] = inputTau->tauIDs().at(i);
     }
 
     // store IDs that were produced in PATTauDiscriminator format
     edm::Handle<pat::PATTauDiscriminator> tauDiscr;
     for (size_t i = 0; i < nNewPlainTauIds_; ++i) {
       evt.getByToken(patTauIDTokens_[i], tauDiscr);
       tauIds[nTauIds + i].first = tauIDSrcs_[i].first;
       tauIds[nTauIds + i].second = (*tauDiscr)[inputTauRef];
     }
 
     // store IDs that were produced in PATTauDiscriminatorContainer format
     size_t nEmbeddedIDs = nTauIds + nNewPlainTauIds_;
     for (size_t i = 0; i < tauIDSrcContainers_.size(); ++i) {
       auto const& tauDiscrCont = evt.get(patTauIDContainerTokens_[i]);
       for (size_t j = 0; j < tauIDSrcContainers_[i].size(); ++j) {
         tauIds[nEmbeddedIDs + j].first = tauIDSrcContainers_[i][j].first;
         int wpIdx = tauIDSrcContainers_[i][j].second;
         if (wpIdx < 0) {
           if (tauDiscrCont[inputTauRef].rawValues.size() == 1)
             //Only 0th component filled with default value if prediscriminor in PatTauDiscriminator failed.
             tauIds[nEmbeddedIDs + j].second = tauDiscrCont[inputTauRef].rawValues.at(0);
           else
             //uses negative indices to access rawValues. In most cases only one rawValue at WPIdx=-1 exists.
             tauIds[nEmbeddedIDs + j].second = tauDiscrCont[inputTauRef].rawValues.at(-1 - wpIdx);
         } else {
           if (tauDiscrCont[inputTauRef].workingPoints.empty())
             //WP vector not filled if prediscriminor in PatTauDiscriminator failed. Set PAT output to false in this case
             tauIds[nEmbeddedIDs + j].second = 0.0;
           else
             tauIds[nEmbeddedIDs + j].second = tauDiscrCont[inputTauRef].workingPoints.at(wpIdx);
         }
       }
       nEmbeddedIDs += tauIDSrcContainers_[i].size();
     }
 
     outputTau.setTauIDs(tauIds);
     outputTaus->push_back(outputTau);
   }
 
   evt.put(std::move(outputTaus));
 }