152 std::map<std::string, std::vector<PathAndFlags> >::const_iterator it =
map_.find(filter);
153 return (it ==
map_.end() ?
empty_ : it->second);
161 std::map<std::string, std::vector<PathAndFlags> >
map_;
162 const std::vector<PathAndFlags>
empty_ = {};
177 : nameProcess_(iConfig.getParameter<std::
string>(
"processName")),
178 autoProcessName_(nameProcess_ ==
"*"),
179 onlyStandAlone_(iConfig.getParameter<bool>(
"onlyStandAlone")),
183 tagL1GlobalTriggerObjectMaps_(
"l1L1GtObjectMap"),
185 tagL1ExtraNoIsoEG_(),
192 autoProcessNameL1ExtraMu_(
false),
193 autoProcessNameL1ExtraNoIsoEG_(
false),
194 autoProcessNameL1ExtraIsoEG_(
false),
195 autoProcessNameL1ExtraCenJet_(
false),
196 autoProcessNameL1ExtraForJet_(
false),
197 autoProcessNameL1ExtraTauJet_(
false),
198 autoProcessNameL1ExtraETM_(
false),
199 autoProcessNameL1ExtraHTM_(
false),
202 hltPrescaleProvider_(iConfig, consumesCollector(), *this),
203 hltConfigInit_(
false),
205 tagTriggerResults_(
"TriggerResults"),
206 tagTriggerEvent_(
"hltTriggerSummaryAOD"),
208 labelHltPrescaleTable_(),
209 hltPrescaleTableRun_(),
210 hltPrescaleTableLumi_(),
211 addPathModuleLabels_(
false),
212 packPathNames_(iConfig.existsAs<bool>(
"packTriggerPathNames") ? iConfig.getParameter<bool>(
"packTriggerPathNames")
214 packLabels_(iConfig.existsAs<bool>(
"packTriggerLabels") ? iConfig.getParameter<bool>(
"packTriggerLabels") :
true),
215 packPrescales_(iConfig.existsAs<bool>(
"packTriggerPrescales") ? iConfig.getParameter<bool>(
"packTriggerPrescales")
219 if (
iConfig.exists(
"addL1Algos"))
220 addL1Algos_ =
iConfig.getParameter<
bool>(
"addL1Algos");
221 if (
iConfig.exists(
"l1GlobalTriggerObjectMaps"))
222 tagL1GlobalTriggerObjectMaps_ =
iConfig.getParameter<
InputTag>(
"l1GlobalTriggerObjectMaps");
223 l1GlobalTriggerObjectMapsToken_ = mayConsume<L1GlobalTriggerObjectMaps>(tagL1GlobalTriggerObjectMaps_);
224 if (
iConfig.exists(
"l1ExtraMu")) {
226 if (tagL1ExtraMu_.process() ==
"*") {
227 if (autoProcessName_)
228 autoProcessNameL1ExtraMu_ =
true;
230 tagL1ExtraMu_ =
InputTag(tagL1ExtraMu_.label(), tagL1ExtraMu_.instance(), nameProcess_);
235 if (
iConfig.exists(
"l1ExtraNoIsoEG")) {
237 if (tagL1ExtraNoIsoEG_.process() ==
"*") {
238 if (autoProcessName_)
239 autoProcessNameL1ExtraNoIsoEG_ =
true;
241 tagL1ExtraNoIsoEG_ =
InputTag(tagL1ExtraNoIsoEG_.label(), tagL1ExtraNoIsoEG_.instance(), nameProcess_);
246 if (
iConfig.exists(
"l1ExtraIsoEG")) {
248 if (tagL1ExtraIsoEG_.process() ==
"*") {
249 if (autoProcessName_)
250 autoProcessNameL1ExtraIsoEG_ =
true;
252 tagL1ExtraIsoEG_ =
InputTag(tagL1ExtraIsoEG_.label(), tagL1ExtraIsoEG_.instance(), nameProcess_);
257 if (
iConfig.exists(
"l1ExtraCenJet")) {
259 if (tagL1ExtraCenJet_.process() ==
"*") {
260 if (autoProcessName_)
261 autoProcessNameL1ExtraCenJet_ =
true;
263 tagL1ExtraCenJet_ =
InputTag(tagL1ExtraCenJet_.label(), tagL1ExtraCenJet_.instance(), nameProcess_);
268 if (
iConfig.exists(
"l1ExtraForJet")) {
270 if (tagL1ExtraForJet_.process() ==
"*") {
271 if (autoProcessName_)
272 autoProcessNameL1ExtraForJet_ =
true;
274 tagL1ExtraForJet_ =
InputTag(tagL1ExtraForJet_.label(), tagL1ExtraForJet_.instance(), nameProcess_);
279 if (
iConfig.exists(
"l1ExtraTauJet")) {
281 if (tagL1ExtraTauJet_.process() ==
"*") {
282 if (autoProcessName_)
283 autoProcessNameL1ExtraTauJet_ =
true;
285 tagL1ExtraTauJet_ =
InputTag(tagL1ExtraTauJet_.label(), tagL1ExtraTauJet_.instance(), nameProcess_);
290 if (
iConfig.exists(
"l1ExtraETM")) {
292 if (tagL1ExtraETM_.process() ==
"*") {
293 if (autoProcessName_)
294 autoProcessNameL1ExtraETM_ =
true;
296 tagL1ExtraETM_ =
InputTag(tagL1ExtraETM_.label(), tagL1ExtraETM_.instance(), nameProcess_);
301 if (
iConfig.exists(
"l1ExtraHTM")) {
303 if (tagL1ExtraHTM_.process() ==
"*") {
304 if (autoProcessName_)
305 autoProcessNameL1ExtraHTM_ =
true;
307 tagL1ExtraHTM_ =
InputTag(tagL1ExtraHTM_.label(), tagL1ExtraHTM_.instance(), nameProcess_);
312 if (
iConfig.exists(
"mainBxOnly"))
313 mainBxOnly_ =
iConfig.getParameter<
bool>(
"mainBxOnly");
314 if (
iConfig.exists(
"saveL1Refs"))
315 saveL1Refs_ =
iConfig.getParameter<
bool>(
"saveL1Refs");
318 if (
iConfig.exists(
"triggerResults"))
320 triggerResultsGetter_ =
322 tagTriggerResults_.instance(),
323 autoProcessName_ ?
std::string(
"") : nameProcess_)),
325 if (
iConfig.exists(
"triggerEvent"))
329 if (
iConfig.exists(
"hltPrescaleLabel"))
330 hltPrescaleLabel_ =
iConfig.getParameter<std::string>(
"hltPrescaleLabel");
331 if (
iConfig.exists(
"hltPrescaleTable")) {
332 labelHltPrescaleTable_ =
iConfig.getParameter<std::string>(
"hltPrescaleTable");
337 hltPrescaleTableEventGetter_ =
340 if (
iConfig.exists(
"addPathModuleLabels"))
341 addPathModuleLabels_ =
iConfig.getParameter<
bool>(
"addPathModuleLabels");
342 exludeCollections_.clear();
343 if (
iConfig.exists(
"exludeCollections"))
344 exludeCollections_ =
iConfig.getParameter<std::vector<std::string> >(
"exludeCollections");
347 if (
iConfig.exists(
"l1ExtraMu"))
348 l1ExtraMuGetter_(bd);
349 if (
iConfig.exists(
"l1ExtraNoIsoEG"))
350 l1ExtraNoIsoEGGetter_(bd);
351 if (
iConfig.exists(
"l1ExtraIsoEG"))
352 l1ExtraIsoEGGetter_(bd);
353 if (
iConfig.exists(
"l1ExtraCenJet"))
354 l1ExtraCenJetGetter_(bd);
355 if (
iConfig.exists(
"l1ExtraForJet"))
356 l1ExtraForJetGetter_(bd);
357 if (
iConfig.exists(
"l1ExtraTauJet"))
358 l1ExtraTauJetGetter_(bd);
359 if (
iConfig.exists(
"l1ExtraETM"))
360 l1ExtraETMGetter_(bd);
361 if (
iConfig.exists(
"l1ExtraHTM"))
362 l1ExtraHTMGetter_(bd);
363 if (not(this->autoProcessName_ and bd.
processName() == this->moduleDescription().processName())) {
364 triggerResultsGetter_(bd);
366 triggerEventGetter_(bd);
367 if (
iConfig.exists(
"hltPrescaleTable")) {
368 hltPrescaleTableRunGetter_(bd);
369 hltPrescaleTableLumiGetter_(bd);
370 hltPrescaleTableEventGetter_(bd);
374 if (!onlyStandAlone_) {
375 produces<TriggerAlgorithmCollection>();
376 produces<TriggerConditionCollection>();
377 produces<TriggerPathCollection>();
378 produces<TriggerFilterCollection>();
379 produces<TriggerObjectCollection>();
381 if (packPrescales_) {
382 produces<PackedTriggerPrescales>();
383 produces<PackedTriggerPrescales>(
"l1max");
384 produces<PackedTriggerPrescales>(
"l1min");
386 produces<TriggerObjectStandAloneCollection>();
415 <<
"' not produced according to process history of input data\n"
416 <<
"No trigger information produced";
419 LogInfo(
"autoProcessName") <<
"HLT process name' " <<
nameProcess_ <<
"' used for PAT trigger information";
426 <<
"' differs from HLT process name '" <<
nameProcess_ <<
"'";
432 <<
"' differs from HLT process name '" <<
nameProcess_ <<
"'";
455 LogError(
"hltConfig") <<
"HLT config extraction error with process name '" <<
nameProcess_ <<
"'";
456 }
else if (hltConfig.size() <= 0) {
457 LogError(
"hltConfig") <<
"HLT config size error";
473 if (handleHltPrescaleTable.
isValid()) {
475 handleHltPrescaleTable->set(), handleHltPrescaleTable->labels(), handleHltPrescaleTable->table());
495 if (handleHltPrescaleTable.
isValid()) {
497 handleHltPrescaleTable->set(), handleHltPrescaleTable->labels(), handleHltPrescaleTable->table());
508 auto triggerObjects = std::make_unique<TriggerObjectCollection>();
509 auto triggerObjectsStandAlone = std::make_unique<TriggerObjectStandAloneCollection>();
510 std::unique_ptr<PackedTriggerPrescales> packedPrescales, packedPrescalesL1min, packedPrescalesL1max;
522 if (!handleTriggerResults.
isValid()) {
524 <<
"' not in event\n"
525 <<
"No HLT information produced";
527 }
else if (!handleTriggerEvent.
isValid()) {
529 <<
"' not in event\n"
530 <<
"No HLT information produced";
546 if (handleHltPrescaleTable.
isValid()) {
548 handleHltPrescaleTable->set(), handleHltPrescaleTable->labels(), handleHltPrescaleTable->table());
552 if (hltPrescaleTable.size() == 0) {
556 <<
"Using default from event setup";
562 LogDebug(
"hltPrescaleTable") <<
"HLT prescale table found in event setup";
564 LogWarning(
"hltPrescaleSet") <<
"HLTPrescaleTable from event setup has error";
568 unsigned set(hltPrescaleTable.set());
569 if (hltPrescaleTable.size() > 0) {
571 bool foundPrescaleLabel(
false);
572 for (
unsigned iLabel = 0; iLabel < hltPrescaleTable.labels().size(); ++iLabel) {
575 foundPrescaleLabel =
true;
579 if (!foundPrescaleLabel) {
586 LogError(
"hltPrescaleTable") <<
"No HLT prescale table found\n"
587 <<
"Using default empty table with all prescales 1";
591 const unsigned sizePaths(hltConfig.
size());
592 const unsigned sizeFilters(handleTriggerEvent->sizeFilters());
593 const unsigned sizeObjects(handleTriggerEvent->sizeObjects());
595 std::map<std::string, int> moduleStates;
598 auto triggerPaths = std::make_unique<TriggerPathCollection>();
600 const std::vector<std::string>& pathNames = hltConfig.
triggerNames();
601 for (
size_t indexPath = 0; indexPath < sizePaths; ++indexPath) {
602 const std::string& namePath = pathNames.at(indexPath);
603 unsigned indexLastFilterPathModules(handleTriggerResults->index(indexPath) + 1);
604 const unsigned sizeModulesPath(hltConfig.
size(indexPath));
606 if (sizeModulesPath != 0) {
607 while (indexLastFilterPathModules > 0) {
608 --indexLastFilterPathModules;
609 const std::string& labelLastFilterPathModules(hltConfig.
moduleLabel(indexPath, indexLastFilterPathModules));
610 unsigned indexLastFilterFilters =
612 if (indexLastFilterFilters < sizeFilters) {
613 if (hltConfig.
moduleType(labelLastFilterPathModules) ==
"HLTBool")
619 indexLastFilterPathModules = 0;
624 handleTriggerResults->wasrun(indexPath),
625 handleTriggerResults->accept(indexPath),
626 handleTriggerResults->error(indexPath),
627 indexLastFilterPathModules,
631 assert(indexLastFilterPathModules < sizeModulesPath || sizeModulesPath == 0);
632 std::map<unsigned, std::string> indicesModules;
633 for (
size_t iM = 0; iM < sizeModulesPath; ++iM) {
634 const std::string& nameModule(hltConfig.
moduleLabel(indexPath, iM));
636 triggerPath.addModule(nameModule);
638 const unsigned indexFilter(handleTriggerEvent->filterIndex(
InputTag(nameModule,
"",
nameProcess_)));
639 if (indexFilter < sizeFilters) {
640 triggerPath.addFilterIndex(indexFilter);
642 const unsigned slotModule(hltConfig.
moduleIndex(indexPath, nameModule));
643 indicesModules.insert(std::pair<unsigned, std::string>(slotModule, nameModule));
647 for (L1SeedCollection::const_iterator iSeed = l1Seeds.begin(); iSeed != l1Seeds.end(); ++iSeed) {
648 triggerPath.addL1Seed(*iSeed);
653 for (std::map<unsigned, std::string>::const_iterator iM = indicesModules.begin(); iM != indicesModules.end();
655 if (iM->first < indexLastFilterPathModules) {
656 moduleStates[iM->second] = 1;
657 }
else if (iM->first == indexLastFilterPathModules) {
658 moduleStates[iM->second] = handleTriggerResults->accept(indexPath);
659 }
else if (moduleStates.find(iM->second) == moduleStates.end()) {
660 moduleStates[iM->second] = -1;
671 std::multimap<trigger::size_type, int> objectTypes;
672 std::multimap<trigger::size_type, std::string> filterLabels;
674 for (
size_t iF = 0; iF < sizeFilters; ++iF) {
675 const std::string nameFilter(handleTriggerEvent->filterLabel(iF));
678 assert(types.size() == keys.size());
679 for (
size_t iK = 0; iK < keys.size(); ++iK) {
680 filterLabels.insert(std::pair<trigger::size_type, std::string>(keys[iK], nameFilter));
681 objectTypes.insert(std::pair<trigger::size_type, int>(keys[iK], types[iK]));
688 triggerObjectsStandAlone->reserve(sizeObjects);
690 const trigger::Keys& collectionKeys(handleTriggerEvent->collectionKeys());
691 std::map<trigger::size_type, trigger::size_type> newObjectKeys;
692 for (
size_t iO = 0, iC = 0, nC = handleTriggerEvent->sizeCollections(); iO < sizeObjects && iC < nC; ++iO) {
697 while (iO >= collectionKeys[iC])
699 triggerObject.
setCollection(handleTriggerEvent->collectionTagEncoded(iC));
701 typedef std::multimap<trigger::size_type, int>::const_iterator it_type;
702 for (std::pair<it_type, it_type> trange = objectTypes.equal_range(iO); trange.first != trange.second;
704 triggerObject.addTriggerObjectType(trange.first->second);
710 bool excluded(
false);
721 typedef std::multimap<trigger::size_type, std::string>::const_iterator it_fl;
722 for (std::pair<it_fl, it_fl> frange = filterLabels.equal_range(iO); frange.first != frange.second;
725 const std::vector<ModuleLabelToPathAndFlags::PathAndFlags>&
paths =
727 for (std::vector<ModuleLabelToPathAndFlags::PathAndFlags>::const_iterator iP = paths.begin(); iP != paths.end();
729 bool pathFired = handleTriggerResults->wasrun(iP->pathIndex) && handleTriggerResults->accept(iP->pathIndex);
730 triggerObjectStandAlone.
addPathName(iP->pathName, pathFired && iP->lastFilter, pathFired && iP->l3Filter);
734 triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
736 triggerObjects->push_back(triggerObject);
743 auto triggerFilters = std::make_unique<TriggerFilterCollection>();
744 triggerFilters->reserve(sizeFilters);
745 for (
size_t iF = 0; iF < sizeFilters; ++iF) {
746 const std::string nameFilter(handleTriggerEvent->filterTag(iF).label());
751 const std::string typeFilter(hltConfig.
moduleType(nameFilter));
752 triggerFilter.
setType(typeFilter);
755 for (
size_t iK = 0; iK < keys.size(); ++iK) {
757 if (newObjectKeys.find(keys.at(iK)) != newObjectKeys.end()) {
758 if (newObjectKeys[keys.at(iK)] == sizeObjects)
763 LogWarning(
"triggerObjectKey") <<
"TriggerFilter '" << nameFilter
764 <<
"' requests non-existing TriggerObject key " << keys.at(iK) <<
"\n"
765 <<
"Skipping object assignment";
769 std::map<std::string, int>::iterator iS(moduleStates.find(nameFilter));
770 if (iS != moduleStates.end()) {
771 if (!triggerFilter.
setStatus(iS->second)) {
778 triggerFilters->push_back(triggerFilter);
785 packedPrescales = std::make_unique<PackedTriggerPrescales>(handleTriggerResults);
786 packedPrescalesL1min = std::make_unique<PackedTriggerPrescales>(handleTriggerResults);
787 packedPrescalesL1max = std::make_unique<PackedTriggerPrescales>(handleTriggerResults);
790 for (
unsigned int i = 0,
n = names.size();
i <
n; ++
i) {
793 if (pvdet.first.empty()) {
794 packedPrescalesL1max->addPrescaledTrigger(
i, 1);
795 packedPrescalesL1min->addPrescaledTrigger(
i, 1);
797 int pmin = -1, pmax = -1;
798 for (
const auto&
p : pvdet.first) {
800 if (
p.second > 0 && (pmin == -1 || pmin >
p.second))
803 packedPrescalesL1max->addPrescaledTrigger(
i, pmax);
804 packedPrescalesL1min->addPrescaledTrigger(
i, pmin);
807 packedPrescales->addPrescaledTrigger(
i, pvdet.second);
821 std::map<L1GtObject, std::vector<unsigned> > l1ObjectTypeMap;
825 if (handleL1ExtraMu.
isValid()) {
826 std::vector<unsigned> muKeys;
827 for (
size_t l1Mu = 0; l1Mu < handleL1ExtraMu->size(); ++l1Mu) {
828 if (
mainBxOnly_ && handleL1ExtraMu->at(l1Mu).bx() != 0)
835 const reco::LeafCandidate leafCandidate(*(handleL1ExtraMu->at(l1Mu).reco::LeafCandidate::clone()));
841 triggerObjects->push_back(triggerObject);
843 triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
844 if (handleL1ExtraMu->at(l1Mu).bx() == 0)
845 muKeys.push_back(triggerObjectsStandAlone->size() - 1);
847 l1ObjectTypeMap.insert(std::make_pair(
Mu, muKeys));
855 if (handleL1ExtraNoIsoEG.
isValid()) {
856 std::vector<unsigned> noIsoEGKeys;
857 for (
size_t l1NoIsoEG = 0; l1NoIsoEG < handleL1ExtraNoIsoEG->size(); ++l1NoIsoEG) {
858 if (
mainBxOnly_ && handleL1ExtraNoIsoEG->at(l1NoIsoEG).bx() != 0)
865 const reco::LeafCandidate leafCandidate(*(handleL1ExtraNoIsoEG->at(l1NoIsoEG).reco::LeafCandidate::clone()));
871 triggerObjects->push_back(triggerObject);
873 triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
874 if (handleL1ExtraNoIsoEG->at(l1NoIsoEG).bx() == 0)
875 noIsoEGKeys.push_back(triggerObjectsStandAlone->size() - 1);
877 l1ObjectTypeMap.insert(std::make_pair(
NoIsoEG, noIsoEGKeys));
879 LogError(
"l1ExtraValid") <<
"l1extra::L1EmParticleCollection product with InputTag '"
885 if (handleL1ExtraIsoEG.
isValid()) {
886 std::vector<unsigned> isoEGKeys;
887 for (
size_t l1IsoEG = 0; l1IsoEG < handleL1ExtraIsoEG->size(); ++l1IsoEG) {
888 if (
mainBxOnly_ && handleL1ExtraIsoEG->at(l1IsoEG).bx() != 0)
895 const reco::LeafCandidate leafCandidate(*(handleL1ExtraIsoEG->at(l1IsoEG).reco::LeafCandidate::clone()));
901 triggerObjects->push_back(triggerObject);
903 triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
904 if (handleL1ExtraIsoEG->at(l1IsoEG).bx() == 0)
905 isoEGKeys.push_back(triggerObjectsStandAlone->size() - 1);
907 l1ObjectTypeMap.insert(std::make_pair(
IsoEG, isoEGKeys));
915 if (handleL1ExtraCenJet.
isValid()) {
916 std::vector<unsigned> cenJetKeys;
917 for (
size_t l1CenJet = 0; l1CenJet < handleL1ExtraCenJet->size(); ++l1CenJet) {
918 if (
mainBxOnly_ && handleL1ExtraCenJet->at(l1CenJet).bx() != 0)
925 const reco::LeafCandidate leafCandidate(*(handleL1ExtraCenJet->at(l1CenJet).reco::LeafCandidate::clone()));
931 triggerObjects->push_back(triggerObject);
933 triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
934 if (handleL1ExtraCenJet->at(l1CenJet).bx() == 0)
935 cenJetKeys.push_back(triggerObjectsStandAlone->size() - 1);
937 l1ObjectTypeMap.insert(std::make_pair(
CenJet, cenJetKeys));
939 LogError(
"l1ExtraValid") <<
"l1extra::L1JetParticleCollection product with InputTag '"
945 if (handleL1ExtraForJet.
isValid()) {
946 std::vector<unsigned> forJetKeys;
947 for (
size_t l1ForJet = 0; l1ForJet < handleL1ExtraForJet->size(); ++l1ForJet) {
948 if (
mainBxOnly_ && handleL1ExtraForJet->at(l1ForJet).bx() != 0)
955 const reco::LeafCandidate leafCandidate(*(handleL1ExtraForJet->at(l1ForJet).reco::LeafCandidate::clone()));
961 triggerObjects->push_back(triggerObject);
963 triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
964 if (handleL1ExtraForJet->at(l1ForJet).bx() == 0)
965 forJetKeys.push_back(triggerObjectsStandAlone->size() - 1);
967 l1ObjectTypeMap.insert(std::make_pair(
ForJet, forJetKeys));
969 LogError(
"l1ExtraValid") <<
"l1extra::L1JetParticleCollection product with InputTag '"
975 if (handleL1ExtraTauJet.
isValid()) {
976 std::vector<unsigned> tauJetKeys;
977 for (
size_t l1TauJet = 0; l1TauJet < handleL1ExtraTauJet->size(); ++l1TauJet) {
978 if (
mainBxOnly_ && handleL1ExtraTauJet->at(l1TauJet).bx() != 0)
985 const reco::LeafCandidate leafCandidate(*(handleL1ExtraTauJet->at(l1TauJet).reco::LeafCandidate::clone()));
991 triggerObjects->push_back(triggerObject);
993 triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
994 if (handleL1ExtraTauJet->at(l1TauJet).bx() == 0)
995 tauJetKeys.push_back(triggerObjectsStandAlone->size() - 1);
997 l1ObjectTypeMap.insert(std::make_pair(
TauJet, tauJetKeys));
999 LogError(
"l1ExtraValid") <<
"l1extra::L1JetParticleCollection product with InputTag '"
1005 if (handleL1ExtraETM.
isValid()) {
1006 std::vector<unsigned> etmKeys;
1007 for (
size_t l1ETM = 0; l1ETM < handleL1ExtraETM->size(); ++l1ETM) {
1008 if (
mainBxOnly_ && handleL1ExtraETM->at(l1ETM).bx() != 0)
1015 const reco::LeafCandidate leafCandidate(*(handleL1ExtraETM->at(l1ETM).reco::LeafCandidate::clone()));
1021 triggerObjects->push_back(triggerObject);
1023 triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
1024 if (handleL1ExtraETM->at(l1ETM).bx() == 0)
1025 etmKeys.push_back(triggerObjectsStandAlone->size() - 1);
1027 l1ObjectTypeMap.insert(std::make_pair(
ETM, etmKeys));
1029 LogError(
"l1ExtraValid") <<
"l1extra::L1EtMissParticleCollection product with InputTag '"
1035 if (handleL1ExtraHTM.
isValid()) {
1036 std::vector<unsigned> htmKeys;
1037 for (
size_t l1HTM = 0; l1HTM < handleL1ExtraHTM->size(); ++l1HTM) {
1038 if (
mainBxOnly_ && handleL1ExtraHTM->at(l1HTM).bx() != 0)
1045 const reco::LeafCandidate leafCandidate(*(handleL1ExtraHTM->at(l1HTM).reco::LeafCandidate::clone()));
1051 triggerObjects->push_back(triggerObject);
1053 triggerObjectsStandAlone->push_back(triggerObjectStandAlone);
1054 if (handleL1ExtraHTM->at(l1HTM).bx() == 0)
1055 htmKeys.push_back(triggerObjectsStandAlone->size() - 1);
1057 l1ObjectTypeMap.insert(std::make_pair(
HTM, htmKeys));
1059 LogError(
"l1ExtraValid") <<
"l1extra::L1EtMissParticleCollection product with InputTag '"
1069 auto triggerAlgos = std::make_unique<TriggerAlgorithmCollection>();
1073 std::map<L1GtObject, trigger::TriggerObjectType> mapObjectTypes;
1085 auto const& l1GtAlgorithms = handleL1GtTriggerMenu->gtAlgorithmMap();
1086 auto const& l1GtTechTriggers = handleL1GtTriggerMenu->gtTechnicalTriggerMap();
1087 auto const& l1GtConditionsVector = handleL1GtTriggerMenu->gtConditionMap();
1090 for (
size_t iCv = 0; iCv < l1GtConditionsVector.size(); ++iCv) {
1091 l1GtConditions.insert(l1GtConditionsVector.at(iCv).begin(), l1GtConditionsVector.at(iCv).end());
1093 triggerAlgos->reserve(l1GtAlgorithms.size() + l1GtTechTriggers.size());
1096 if (!handleL1GlobalTriggerObjectMaps.
isValid()) {
1097 LogError(
"l1ObjectMap") <<
"L1GlobalTriggerObjectMaps product with InputTag '"
1099 <<
"No L1 objects and GTL results available for physics algorithms";
1101 handleL1GlobalTriggerObjectMaps->consistencyCheck();
1104 handleL1GlobalTriggerObjectMaps->namesParameterSetID()));
1106 LogError(
"l1ObjectMap") <<
"ParameterSet registry not available\n"
1107 <<
"Skipping conditions for all L1 physics algorithm names in this run";
1111 LogInfo(
"l1ObjectMap") <<
"ParameterSet registry not available\n"
1112 <<
"Skipping conditions for all L1 physics algorithm names in this event";
1116 for (
CItAlgo iAlgo = l1GtAlgorithms.begin(); iAlgo != l1GtAlgorithms.end(); ++iAlgo) {
1117 const std::string& algoName(iAlgo->second.algoName());
1119 LogError(
"l1Algo") <<
"L1 physics algorithm '" << algoName <<
"' has bit number "
1120 << iAlgo->second.algoBitNumber()
1128 LogError(
"l1Algo") <<
"L1 physics algorithm '" << algoName <<
"' not found in the L1 menu\n"
1133 LogError(
"l1Algo") <<
"L1 physics algorithm '" << algoName
1134 <<
"' does not have category 'AlgorithmTrigger' from 'L1GtUtils'\n"
1138 bool decisionBeforeMask;
1139 bool decisionAfterMask;
1142 int error(l1GtUtils.
l1Results(iEvent, algoName, decisionBeforeMask, decisionAfterMask, prescale, mask));
1144 LogError(
"l1Algo") <<
"L1 physics algorithm '" << algoName <<
"' decision has error code " <<
error
1145 <<
" from 'L1GtUtils'\n"
1150 iAlgo->second.algoAlias(),
1159 if (!handleL1GlobalTriggerObjectMaps.
isValid()) {
1160 triggerAlgos->push_back(triggerAlgo);
1163 if (!handleL1GlobalTriggerObjectMaps->algorithmExists(bit)) {
1164 LogError(
"l1ObjectMap") <<
"L1 physics algorithm '" << algoName
1165 <<
"' is missing in L1GlobalTriggerObjectMaps\n"
1166 <<
"Skipping conditions and GTL result";
1167 triggerAlgos->push_back(triggerAlgo);
1170 bool algorithmResult = handleL1GlobalTriggerObjectMaps->algorithmResult(bit);
1172 if ((algorithmResult != decisionBeforeMask) &&
1173 (decisionBeforeMask ==
true)) {
1174 LogInfo(
"l1ObjectMap") <<
"L1 physics algorithm '" << algoName <<
"' with different decisions in\n"
1175 <<
"L1GlobalTriggerObjectMaps (GTL result) : " << algorithmResult <<
"\n"
1176 <<
"L1GlobalTriggerReadoutRecord (decision before mask): " << decisionBeforeMask;
1181 handleL1GlobalTriggerObjectMaps->getConditionsInAlgorithm(bit);
1183 triggerAlgos->push_back(triggerAlgo);
1188 LogError(
"l1ObjectMap") <<
"L1 physics algorithm name '" << algoName
1189 <<
"' not available in ParameterSet registry\n"
1190 <<
"Skipping conditions for this algorithm in this run";
1192 LogInfo(
"l1ObjectMap") <<
"L1 physics algorithm name '" << algoName
1193 <<
"' not available in ParameterSet registry\n"
1194 <<
"Skipping conditions for this algorithm in this event";
1196 triggerAlgos->push_back(triggerAlgo);
1199 std::vector<std::string> conditionNames(
l1PSet_->
getParameter<std::vector<std::string> >(algoName));
1201 for (
unsigned iT = 0; iT < conditionNames.size(); ++iT) {
1202 size_t key(triggerConditions->size());
1203 for (
size_t iC = 0; iC < triggerConditions->size(); ++iC) {
1204 if (conditionNames.at(iT) == triggerConditions->at(iC).name()) {
1209 if (
key == triggerConditions->size()) {
1211 LogError(
"l1CondMap") <<
"More condition names from ParameterSet registry than the "
1212 << conditions.
nConditions() <<
" conditions in L1GlobalTriggerObjectMaps\n"
1213 <<
"Skipping condition " << conditionNames.at(iT) <<
" in algorithm " << algoName;
1217 if (l1GtConditions.find(triggerCond.name()) != l1GtConditions.end()) {
1218 triggerCond.
setCategory(l1GtConditions[triggerCond.name()]->condCategory());
1219 triggerCond.setType(l1GtConditions[triggerCond.name()]->condType());
1220 const std::vector<L1GtObject> l1ObjectTypes(l1GtConditions[triggerCond.name()]->objectType());
1221 for (
size_t iType = 0; iType < l1ObjectTypes.size(); ++iType) {
1222 triggerCond.addTriggerObjectType(mapObjectTypes[l1ObjectTypes.at(iType)]);
1226 handleL1GlobalTriggerObjectMaps->getCombinationsInCondition(bit, iT);
1227 for (
size_t iVV = 0; iVV < combinations.
nCombinations(); ++iVV) {
1230 if (iV >= l1ObjectTypes.size()) {
1231 LogError(
"l1CondMap") <<
"Index " << iV <<
" in combinations vector overshoots size "
1232 << l1ObjectTypes.size() <<
" of types vector in conditions map\n"
1233 <<
"Skipping object key in condition " << triggerCond.name();
1234 }
else if (l1ObjectTypeMap.find(l1ObjectTypes.at(iV)) != l1ObjectTypeMap.end()) {
1235 if (objectIndex >= l1ObjectTypeMap[l1ObjectTypes.at(iV)].size()) {
1237 <<
"Index " << objectIndex <<
" in combination overshoots number "
1238 << l1ObjectTypeMap[l1ObjectTypes.at(iV)].size() <<
"of according trigger objects\n"
1239 <<
"Skipping object key in condition " << triggerCond.name();
1241 const unsigned objectKey(l1ObjectTypeMap[l1ObjectTypes.at(iV)].at(objectIndex));
1242 triggerCond.addObjectKey(objectKey);
1244 triggerObjectsStandAlone->at(objectKey).addAlgorithmName(
1245 triggerAlgo.
name(), (triggerAlgo.
decision() && triggerCond.wasAccept()));
1246 triggerObjectsStandAlone->at(objectKey).addConditionName(triggerCond.name());
1251 LogWarning(
"l1CondMap") <<
"L1 conditions '" << triggerCond.name() <<
"' not found in the L1 menu\n"
1252 <<
"Remains incomplete";
1254 triggerConditions->push_back(triggerCond);
1258 triggerAlgos->push_back(triggerAlgo);
1261 for (
CItAlgo iAlgo = l1GtTechTriggers.begin(); iAlgo != l1GtTechTriggers.end(); ++iAlgo) {
1262 const std::string& algoName(iAlgo->second.algoName());
1264 LogError(
"l1Algo") <<
"L1 technical trigger '" << algoName <<
"' has bit number "
1265 << iAlgo->second.algoBitNumber()
1273 LogError(
"l1Algo") <<
"L1 technical trigger '" << algoName <<
"' not found in the L1 menu\n"
1278 LogError(
"l1Algo") <<
"L1 technical trigger '" << algoName
1279 <<
"' does not have category 'TechnicalTrigger' from 'L1GtUtils'\n"
1283 bool decisionBeforeMask;
1284 bool decisionAfterMask;
1287 int error(l1GtUtils.
l1Results(iEvent, algoName, decisionBeforeMask, decisionAfterMask, prescale, mask));
1289 LogError(
"l1Algo") <<
"L1 technical trigger '" << algoName <<
"' decision has error code " <<
error
1290 <<
" from 'L1GtUtils'\n"
1295 iAlgo->second.algoAlias(),
1303 triggerAlgos->push_back(triggerAlgo);
1319 obj.packPathNames(names);
1321 obj.packFilterLabels(iEvent, *handleTriggerResults);
1332 const std::vector<std::string>& pathNames = hltConfig.
triggerNames();
1333 unsigned int sizePaths = pathNames.size();
1334 for (
unsigned int indexPath = 0; indexPath < sizePaths; ++indexPath) {
1335 const std::string& namePath = pathNames[indexPath];
1337 const std::vector<std::string>& nameModules = hltConfig.
moduleLabels(indexPath);
1338 unsigned int sizeModulesPath = nameModules.size();
1339 bool lastFilter =
true;
1340 unsigned int iM = sizeModulesPath;
1342 const std::string& nameFilter = nameModules[--iM];
1345 if (hltConfig.
moduleType(nameFilter) ==
"HLTBool")
1348 insert(nameFilter, namePath, indexPath, lastFilter, saveTags);
unsigned int set() const
low-level const accessors for data members
unsigned int size() const
number of trigger paths in trigger table
collection_type::const_iterator const_iterator
const std::vector< PathAndFlags > empty_
bool getByLabel(std::string const &label, Handle< PROD > &result) const
unsigned char getObjectIndex(unsigned combination, unsigned object) const
std::vector< L1Seed > L1SeedCollection
Collection of L1Seed.
bool saveTags(const std::string &module) const
Is module an L3 filter (ie, tracked saveTags=true)
Analysis-level L1 trigger algorithm class.
void beginLuminosityBlock(const edm::LuminosityBlock &iLuminosityBlock, const edm::EventSetup &iSetup) override
OrphanHandle< PROD > put(std::unique_ptr< PROD > product)
Put a new product.
edm::InputTag tagL1ExtraForJet_
const std::string moduleType(const std::string &module) const
C++ class name of module.
bool autoProcessNameL1ExtraHTM_
bool autoProcessNameL1ExtraIsoEG_
edm::EDGetTokenT< L1GlobalTriggerObjectMaps > l1GlobalTriggerObjectMapsToken_
edm::InputTag tagTriggerEvent_
PATTriggerProducer(const edm::ParameterSet &iConfig)
static const char category[]
bool setStatus(int status)
static PFTauRenderPlugin instance
bool getByToken(EDGetToken token, Handle< PROD > &result) const
enum start value shifted to 81 so as to avoid clashes with PDG codes
bool autoProcessNameL1ExtraTauJet_
#define DEFINE_FWK_MODULE(type)
edm::InputTag tagTriggerResults_
const bool l1AlgoTechTrigBitNumber(const std::string &nameAlgoTechTrig, TriggerCategory &trigCategory, int &bitNumber) const
static const unsigned int NumberTechnicalTriggers
const std::vector< std::string > & triggerNames() const
names of trigger paths
The single EDProduct containing the HLT Prescale Table.
void setGtlResult(bool gtlResult)
Set L1 algorithm GTL result.
unsigned short nObjectsPerCombination() const
bool exists(std::string const ¶meterName) const
checks if a parameter exists
void insert(const std::string &filter, const std::string &path, unsigned int pathIndex, bool lastFilter, bool l3Filter)
const std::string moduleEDMType(const std::string &module) const
C++ base class name of module.
std::pair< std::vector< std::pair< std::string, TL1 > >, THLT > prescaleValuesInDetail(const edm::Event &iEvent, const edm::EventSetup &iSetup, const std::string &trigger)
void beginRun(const edm::Run &iRun, const edm::EventSetup &iSetup) override
PathAndFlags(const std::string &name, unsigned int index, bool last, bool l3)
edm::InputTag tagL1ExtraETM_
std::string const & processName() const
void addTriggerObjectType(trigger::TriggerObjectType triggerObjectType)
Add a new trigger object type identifier.
std::string hltPrescaleLabel_
Log< level::Error, false > LogError
void addObjectKey(unsigned objectKey)
Add a new trigger object collection index.
bool getByLabel(std::string const &label, Handle< PROD > &result) const
const std::map< std::string, std::vector< unsigned int > > & prescaleTable() const
Analysis-level trigger object class.
edm::GetterOfProducts< trigger::HLTPrescaleTable > hltPrescaleTableLumiGetter_
edm::GetterOfProducts< l1extra::L1JetParticleCollection > l1ExtraForJetGetter_
const std::string names[nVars_]
bool autoProcessNameL1ExtraMu_
void addFilterLabel(const std::string &filterLabel)
Adds a new HLT filter label.
bool autoProcessNameL1ExtraCenJet_
const std::string & moduleLabel(unsigned int trigger, unsigned int module) const
edm::TriggerNames const & triggerNames(edm::TriggerResults const &triggerResults) const override
const std::vector< std::string > & saveTagsModules(unsigned int trigger) const
Single trigger physics object (e.g., an isolated muon)
bool getConfigurationForProcess(std::string const &name, ProcessConfiguration &config) const
void addPathName(const std::string &pathName, bool pathLastFilterAccepted=true, bool pathL3FilterAccepted=true)
Adds a new HLT path name.
const std::vector< PathAndFlags > & operator[](const std::string &filter) const
bool addPathModuleLabels_
Analysis-level HLTrigger filter class.
std::vector< std::string > exludeCollections_
edm::GetterOfProducts< l1extra::L1EmParticleCollection > l1ExtraNoIsoEGGetter_
edm::GetterOfProducts< trigger::HLTPrescaleTable > hltPrescaleTableEventGetter_
Produces the full or stand-alone PAT trigger information collections.
std::map< std::string, std::vector< PathAndFlags > > map_
ParameterSetID const & parameterSetID() const
unsigned int moduleIndex(unsigned int trigger, const std::string &module) const
slot position of module on trigger path (0 to size-1)
edm::InputTag tagL1ExtraIsoEG_
void setCollection(const std::string &collName)
Methods.
Analysis-level L1 trigger condition class.
Analysis-level HLTrigger path class.
static const unsigned int NumberPhysTriggersExtended
const std::vector< std::string > & labels() const
edm::GetterOfProducts< l1extra::L1EtMissParticleCollection > l1ExtraHTMGetter_
trigger::HLTPrescaleTable hltPrescaleTableLumi_
const std::string & name() const
Get L1 algorithm name.
bool hasCollection(const std::string &collName) const override
Checks, if a certain label of original collection is assigned (method overrides)
edm::GetterOfProducts< l1extra::L1JetParticleCollection > l1ExtraTauJetGetter_
tuple key
prepare the HTCondor submission files and eventually submit them
edm::GetterOfProducts< l1extra::L1JetParticleCollection > l1ExtraCenJetGetter_
edm::GetterOfProducts< l1extra::L1EtMissParticleCollection > l1ExtraETMGetter_
ProcessHistory const & processHistory() const
const int l1Results(const edm::Event &iEvent, const std::string &nameAlgoTechTrig, bool &decisionBeforeMask, bool &decisionAfterMask, int &prescaleFactor, int &triggerMask) const
static const unsigned int NumberPhysTriggers
edm::GetterOfProducts< l1extra::L1EmParticleCollection > l1ExtraIsoEGGetter_
void setSaveTags(bool saveTags)
Set the L3 status.
void setLogicalExpression(const std::string &expression)
Set L1 algorithm logical expression.
edm::GetterOfProducts< trigger::TriggerEvent > triggerEventGetter_
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
unsigned nConditions() const
int prescaleSet(const edm::Event &iEvent, const edm::EventSetup &iSetup)
edm::GetterOfProducts< l1extra::L1MuonParticleCollection > l1ExtraMuGetter_
const std::vector< std::string > & moduleLabels(unsigned int trigger) const
label(s) of module(s) on a trigger path
const std::vector< std::vector< std::pair< bool, std::string > > > & hltL1GTSeeds() const
edm::InputTag tagL1GlobalTriggerObjectMaps_
Log< level::Info, false > LogInfo
edm::InputTag tagL1ExtraMu_
ModuleLabelToPathAndFlags moduleLabelToPathAndFlags_
ProcessHistory const & processHistory() const override
void setCategory(L1GtConditionCategory category)
Set the condition category.
unsigned nCombinations() const
void init(const HLTConfigProvider &)
const edm::ESGetToken< L1GtTriggerMenu, L1GtTriggerMenuRcd > handleL1GtTriggerMenuToken_
~PATTriggerProducer() override
std::vector< size_type > Keys
void produce(edm::Event &iEvent, const edm::EventSetup &iSetup) override
T getParameter(std::string const &) const
bool autoProcessNameL1ExtraForJet_
const std::vector< std::string > & prescaleLabels() const
low-level data member access
HLTConfigProvider const & hltConfigProvider() const
void addConditionKey(unsigned conditionKey)
Add a new trigger condition collection index.
tuple config
parse the configuration file
void setType(const std::string &type)
Set the filter module type.
edm::InputTag tagL1ExtraTauJet_
math::PtEtaPhiMLorentzVector PolarLorentzVector
Lorentz vector.
unsigned int prescaleSize() const
trigger::HLTPrescaleTable hltPrescaleTableRun_
bool getConditionResult(unsigned condition) const
bool autoProcessNameL1ExtraETM_
bool autoProcessNameL1ExtraNoIsoEG_
ESHandle< T > getHandle(const ESGetToken< T, R > &iToken) const
Log< level::Warning, false > LogWarning
void addTriggerObjectType(trigger::TriggerObjectType triggerObjectType)
Add a new trigger object type identifier.
T prescaleValue(unsigned int set, const std::string &trigger) const
HLT prescale value in specific prescale set for a specific trigger path.
static std::string const triggerPaths
L1GtUtils const & l1GtUtils() const
const std::map< std::string, std::vector< unsigned int > > & table() const
edm::InputTag tagL1ExtraNoIsoEG_
bool init(const edm::Run &iRun, const edm::EventSetup &iSetup, const std::string &processName, bool &changed)
edm::InputTag tagL1ExtraCenJet_
edm::GetterOfProducts< edm::TriggerResults > triggerResultsGetter_
HLTPrescaleProvider hltPrescaleProvider_
edm::GetterOfProducts< trigger::HLTPrescaleTable > hltPrescaleTableRunGetter_
Analysis-level trigger object class (stand-alone)
edm::InputTag tagL1ExtraHTM_
edm::ParameterSet * l1PSet_
std::string labelHltPrescaleTable_