#include <PhysicsTools/L1TriggerResultsConverter/plugins/L1TriggerResultsConverter.cc>

Inheritance diagram for L1TriggerResultsConverter:

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

	~L1TriggerResultsConverter () 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	beginRun (edm::Run const &, edm::EventSetup const &) override

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

Private Attributes
std::vector< unsigned int >	indices_

edm::ESGetToken < L1GtTriggerMask, L1GtTriggerMaskAlgoTrigRcd >	l1gtalgoMaskToken_

edm::ESGetToken < L1GtTriggerMenu, L1GtTriggerMenuRcd >	l1gtmenuToken_

edm::ESGetToken < L1TUtmTriggerMenu, L1TUtmTriggerMenuRcd >	l1utmTrigToken_

const bool	legacyL1_

std::vector< unsigned int >	mask_

std::vector< std::string >	names_

const bool	store_unprefireable_bit_

const edm::EDGetTokenT < GlobalAlgBlkBxCollection >	token_

const edm::EDGetTokenT < GlobalExtBlkBxCollection >	token_ext_

const edm::EDGetTokenT < L1GlobalTriggerReadoutRecord >	tokenLegacy_

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

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 50 of file L1TriggerResultsConverter.cc.

Constructor & Destructor Documentation

L1TriggerResultsConverter::L1TriggerResultsConverter ( const edm::ParameterSet & params )

explicit

Definition at line 78 of file L1TriggerResultsConverter.cc.

     : legacyL1_(params.getParameter<bool>("legacyL1")),
       store_unprefireable_bit_(!legacyL1_ ? params.getParameter<bool>("storeUnprefireableBit") : false),
       tokenLegacy_(legacyL1_ ? consumes<L1GlobalTriggerReadoutRecord>(params.getParameter<edm::InputTag>("src"))
                              : edm::EDGetTokenT<L1GlobalTriggerReadoutRecord>()),
       token_(!legacyL1_ ? consumes<GlobalAlgBlkBxCollection>(params.getParameter<edm::InputTag>("src"))
                         : edm::EDGetTokenT<GlobalAlgBlkBxCollection>()),
       token_ext_(store_unprefireable_bit_
                      ? consumes<GlobalExtBlkBxCollection>(params.getParameter<edm::InputTag>("src_ext"))
                      : edm::EDGetTokenT<GlobalExtBlkBxCollection>()),
       l1gtmenuToken_(esConsumes<edm::Transition::BeginRun>()),
       l1gtalgoMaskToken_(esConsumes<edm::Transition::BeginRun>()),
       l1utmTrigToken_(esConsumes<edm::Transition::BeginRun>()) {
   produces<edm::TriggerResults>();
 }

L1TriggerResultsConverter::~L1TriggerResultsConverter ( )

override

Definition at line 94 of file L1TriggerResultsConverter.cc.

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

Member Function Documentation

void L1TriggerResultsConverter::beginRun	(	edm::Run const &	,
		edm::EventSetup const &	setup
	)

overrideprivate

Definition at line 103 of file L1TriggerResultsConverter.cc.

References edm::EventSetup::getHandle(), indices_, l1gtalgoMaskToken_, l1gtmenuToken_, l1utmTrigToken_, legacyL1_, mask_, names_, and store_unprefireable_bit_.

                                                                                   {
   mask_.clear();
   names_.clear();
   indices_.clear();
   if (legacyL1_) {
     auto const& mapping = setup.getHandle(l1gtmenuToken_)->gtAlgorithmAliasMap();
     for (auto const& keyval : mapping) {
       names_.push_back(keyval.first);
       indices_.push_back(keyval.second.algoBitNumber());
     }
     mask_ = setup.getHandle(l1gtalgoMaskToken_)->gtTriggerMask();
   } else {
     auto const& mapping = setup.getHandle(l1utmTrigToken_)->getAlgorithmMap();
     for (auto const& keyval : mapping) {
       names_.push_back(keyval.first);
       indices_.push_back(keyval.second.getIndex());
     }
     if (store_unprefireable_bit_)
       names_.push_back("L1_UnprefireableEvent");
   }
 }

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

static

Definition at line 170 of file L1TriggerResultsConverter.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, and HLT_FULL_cff::InputTag.

                                                                                            {
   edm::ParameterSetDescription desc;
   desc.add<bool>("legacyL1")->setComment("is legacy L1");
   desc.add<edm::InputTag>("src")->setComment(
       "L1 input (L1GlobalTriggerReadoutRecord if legacy, GlobalAlgBlkBxCollection otherwise)");
   desc.add<bool>("storeUnprefireableBit", false)
       ->setComment("Activate storage of L1 unprefireable bit (needs L1 external decision input)");
   desc.add<edm::InputTag>("src_ext", edm::InputTag(""))
       ->setComment("L1 external decision input (GlobalExtBlkBxCollection, only supported if not legacy");
   descriptions.add("L1TriggerResultsConverter", desc);
 }

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

overrideprivate

Definition at line 127 of file L1TriggerResultsConverter.cc.

References edm::hlt::Fail, edm::Event::getByToken(), indices_, edm::HandleBase::isValid(), legacyL1_, LogDebug, mask_, GlobalExtBlk::maxExternalConditions, eostools::move(), names_, submitPVResolutionJobs::out, edm::hlt::Pass, edm::Event::put(), mps_fire::result, store_unprefireable_bit_, token_, token_ext_, and tokenLegacy_.

                                                                                      {
   using namespace edm;
   const std::vector<bool>* wordp = nullptr;
   bool unprefireable_bit = false;
   if (!legacyL1_) {
     edm::Handle<GlobalAlgBlkBxCollection> handleResults;
     iEvent.getByToken(token_, handleResults);
     wordp = &handleResults->at(0, 0).getAlgoDecisionFinal();
     if (store_unprefireable_bit_) {
       edm::Handle<GlobalExtBlkBxCollection> handleExtResults;
       iEvent.getByToken(token_ext_, handleExtResults);
       if (handleExtResults.isValid()) {
         if (handleExtResults->size() != 0) {
           unprefireable_bit = handleExtResults->at(0, 0).getExternalDecision(GlobalExtBlk::maxExternalConditions - 1);
         }
       } else {
         LogDebug("Unprefirable bit not found, always set to false");
       }
     }
   } else {
     // Legacy access
     edm::Handle<L1GlobalTriggerReadoutRecord> handleResults;
     iEvent.getByToken(tokenLegacy_, handleResults);
     wordp = &handleResults->decisionWord();
   }
   auto const& word = *wordp;
   HLTGlobalStatus l1bitsAsHLTStatus(names_.size());
   unsigned indices_size = indices_.size();
   for (size_t nidx = 0; nidx < indices_size; nidx++) {
     unsigned int index = indices_[nidx];
     bool result = word[index];
     if (!mask_.empty())
       result &= (mask_[index] != 0);
     l1bitsAsHLTStatus[nidx] = HLTPathStatus(result ? edm::hlt::Pass : edm::hlt::Fail);
   }
   if (store_unprefireable_bit_)
     l1bitsAsHLTStatus[indices_size] = HLTPathStatus(unprefireable_bit ? edm::hlt::Pass : edm::hlt::Fail);
   //mimic HLT trigger bits for L1
   auto out = std::make_unique<edm::TriggerResults>(l1bitsAsHLTStatus, names_);
   iEvent.put(std::move(out));
 }