|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
#include "DQMOffline/Lumi/interface/TriggerTools.h"
#include "FWCore/Utilities/interface/RegexMatch.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/Math/interface/deltaR.h"
#include <algorithm>
//--------------------------------------------------------------------------------------------------
void TriggerTools::initPathNames(const std::vector<std::string>& triggerNames) {
/*
init HLT path every run (e.g. versions can change)
*/
edm::LogVerbatim("TriggerTools") << "TriggerTools::initPathNames initHLT";
for (auto& iRec : records) {
iRec.hltPathName = "";
iRec.hltPathIndex = (unsigned int)-1;
const std::string pattern = iRec.hltPattern;
if (edm::is_glob(pattern)) { // handle pattern with wildcards (*,?)
std::vector<std::vector<std::string>::const_iterator> matches = edm::regexMatch(triggerNames, pattern);
if (matches.empty()) {
edm::LogWarning("ZCounting") << "requested pattern [" << pattern << "] does not match any HLT paths";
} else {
for (auto const& match : matches) {
iRec.hltPathName = *match;
}
}
} else { // take full HLT path name given
iRec.hltPathName = pattern;
}
}
}
//--------------------------------------------------------------------------------------------------
void TriggerTools::initHLTObjects(const HLTConfigProvider& hltConfigProvider_) {
/*
execture each run to initialize the last filter of each trigger corresponding to the corresponding object that has fired the trigger
*/
edm::LogVerbatim("TriggerTools") << "TriggerTools::initHLTObjects initHLTObjects";
const std::vector<std::string>& triggerNames(hltConfigProvider_.triggerNames());
initPathNames(triggerNames);
for (auto& iRec : records) {
std::vector<std::string> hltFiltersWithTags_;
for (auto const& iPathName : triggerNames) {
if (iPathName != iRec.hltPathName) {
continue;
}
edm::LogVerbatim("TriggerTools") << "TriggerTools::initHLTObjects trigger name: " << iPathName;
iRec.hltPathIndex = hltConfigProvider_.triggerIndex(iPathName);
auto const& moduleLabels(hltConfigProvider_.moduleLabels(iRec.hltPathIndex));
for (int idx = moduleLabels.size() - 1; idx >= 0; --idx) {
auto const& moduleLabel(moduleLabels.at(idx));
auto const& moduleEDMType(hltConfigProvider_.moduleEDMType(moduleLabel));
if (moduleEDMType != "EDFilter") {
continue;
}
auto const& moduleType(hltConfigProvider_.moduleType(moduleLabel));
if ((moduleType == "HLTTriggerTypeFilter") or (moduleType == "HLTBool") or (moduleType == "HLTPrescaler")) {
continue;
}
if (!hltConfigProvider_.saveTags(moduleLabel)) {
continue;
}
edm::LogVerbatim("TriggerTools") << "TriggerTools::initHLTObjects new hlt object name: " << moduleLabel;
iRec.hltObjName = moduleLabel;
break;
}
break;
}
if (iRec.hltPathIndex == (unsigned int)-1) {
edm::LogWarning("TriggerTools") << "TriggerTools::initHLTObjects hltPathIndex has not been found for: "
<< iRec.hltPattern << std::endl;
continue;
}
}
}
//--------------------------------------------------------------------------------------------------
void TriggerTools::readEvent(const edm::Event& iEvent) {
/*
execture each event to load trigger objects
*/
LogDebug("TriggerTools") << "TriggerTools::readEvent";
iEvent.getByToken(fHLTTag_token, hTrgRes);
if (!hTrgRes.isValid()) {
edm::LogWarning("TriggerTools") << "TriggerTools::readEvent No valid trigger result product found";
}
iEvent.getByToken(fHLTObjTag_token, hTrgEvt);
if (!hTrgEvt.isValid()) {
edm::LogWarning("TriggerTools") << "TriggerTools::readEvent No valid trigger event product found";
}
triggerBits.reset();
for (unsigned int i = 0; i < records.size(); i++) {
if (records.at(i).hltPathIndex == (unsigned int)-1) {
LogDebug("TriggerTools") << "TriggerTools::readEvent hltPathIndex has not been set" << std::endl;
continue;
}
if (hTrgRes->accept(records.at(i).hltPathIndex)) {
triggerBits[i] = true;
}
}
LogDebug("TriggerTools") << "TriggerTools::readEvent bitset = " << triggerBits[1] << triggerBits[0];
}
//--------------------------------------------------------------------------------------------------
bool TriggerTools::pass() const {
/*
check if the event passed any of the initialized triggers
*/
return triggerBits != 0;
}
//--------------------------------------------------------------------------------------------------
bool TriggerTools::passObj(const double eta, const double phi) const {
/*
check if the object is matched to any trigger of the initialized triggers, and that this trigger is passed
*/
for (unsigned int i = 0; i < records.size(); i++) {
const std::string& filterName = records.at(i).hltObjName;
edm::InputTag filterTag(filterName, "", "HLT");
// filterIndex must be less than the size of trgEvent or you get a CMSException: _M_range_check
if (hTrgEvt->filterIndex(filterTag) < hTrgEvt->sizeFilters()) {
const trigger::TriggerObjectCollection& toc(hTrgEvt->getObjects());
const trigger::Keys& keys(hTrgEvt->filterKeys(hTrgEvt->filterIndex(filterTag)));
for (unsigned int hlto = 0; hlto < keys.size(); hlto++) {
trigger::size_type hltf = keys[hlto];
const trigger::TriggerObject& tobj(toc[hltf]);
if (reco::deltaR2(eta, phi, tobj.eta(), tobj.phi()) < DRMAX) {
return true;
}
}
}
}
return false;
}
|