User will overwrite this function. Histogram booking is no longer done in C++. This function is called in execute once the filters are all passed.
49 {
50 using namespace Monitored;
51
52
53 SG::ReadHandle<xAOD::EventInfo> thisEvent(
GetEventInfo(ctx));
55
57 return StatusCode::SUCCESS;
58
59
60 if (
m_trigDecTool->ExperimentalAndExpertMethods().isHLTTruncated()){
62 return StatusCode::SUCCESS;
63 }
64
65
66 SG::ReadHandle<xAOD::CaloClusterContainer> hltCluster_readHandle(
m_HLT_cont_key, ctx);
67 if (! hltCluster_readHandle.isValid() ) {
69 return StatusCode::FAILURE;
70 }
71
72
73 SG::ReadHandle<xAOD::CaloClusterContainer> offCluster_readHandle(
m_OFF_cont_key, ctx);
74 if (! offCluster_readHandle.isValid() ) {
76 return StatusCode::FAILURE;
77 }
78
79
80 int bcid = ctx.eventID().bunch_crossing_id();
81 auto HLT_bc = Monitored::Scalar<int>("HLT_bc",-1);
82
84 if (!bcidHdl.isValid()) {
85 ATH_MSG_ERROR(
"Unable to retrieve BunchCrossing conditions object" );
86 return StatusCode::FAILURE;
87 }
88 const BunchCrossingCondData* bcData=*bcidHdl;
89
92
93
95
96
97 std::vector<clus_kin> vec_hlt_clusters;
99
100
101 if (accepted_hlt_clusters.size()>0){
102 for (const auto* hlt_cluster : accepted_hlt_clusters) {
103 auto hlt_clus_et = hlt_cluster->et();
105
106 bool HLT_type_match = false;
107
109 if (hlt_cluster->clusterSize() ==
m_HLT_types[n]) { HLT_type_match =
true;
break; }
110 }
111
112 if (!
m_HLT_types.empty() && !HLT_type_match)
continue;
113 vec_hlt_clusters.push_back({hlt_clus_et*0.001, hlt_cluster->eta(), hlt_cluster->phi(), hlt_cluster});
114 }
115 }
116 else{
117 for (const auto hlt_cluster : *hltCluster_readHandle) {
118 auto hlt_clus_et = hlt_cluster->et();
120
121 bool HLT_type_match = false;
122
124 if (hlt_cluster->clusterSize() ==
m_HLT_types[n]) { HLT_type_match =
true;
break; }
125 }
126
127 if (!
m_HLT_types.empty() && !HLT_type_match)
continue;
128 vec_hlt_clusters.push_back({hlt_clus_et*0.001, hlt_cluster->eta(), hlt_cluster->phi(), hlt_cluster});
129 }
130 }
131
132
133 float off_clus_eta = 0;
134 float off_clus_phi = 0;
135 float off_clus_et = 0;
136 std::vector<clus_kin> vec_off_clusters;
137 for (const auto off_cluster : *offCluster_readHandle) {
139 off_clus_et = off_cluster->et();
140 off_clus_eta = off_cluster->eta();
141 off_clus_phi = off_cluster->phi();
142 }
143 else{
144 off_clus_et = off_cluster->rawE()/std::cosh(std::abs(off_cluster->rawEta()));
145 off_clus_eta = off_cluster->rawEta();
146 off_clus_phi = off_cluster->rawPhi();
147 }
149
150 bool OFF_type_match = false;
151
153 if (off_cluster->clusterSize() ==
m_OFF_types[n]) { OFF_type_match =
true;
break; }
154 }
155
156 if (!
m_OFF_types.empty() && !OFF_type_match)
continue;
157 vec_off_clusters.push_back({off_clus_et*0.001, off_clus_eta, off_clus_phi, off_cluster});
158 }
159
160
162
164
165 unsigned int n_hlt_clusters = 0;
166 unsigned int n_hlt_barrel_high_et_clusters = 0;
167 unsigned int n_hlt_clusters_no_match = 0;
168 unsigned int n_hlt_clusters_with_match = 0;
169
170
171 auto HLT_num = Monitored::Scalar<int>("HLT_num",0);
175 auto HLT_type =
Monitored::Collection(
"HLT_type", vec_hlt_clusters, [](
const clus_kin& clus) {
return clus.
parent->clusterSize(); } );
176
178 static const SG::ConstAccessor<int> nCellsAcc("nCells");
179 return nCellsAcc.withDefault(*clus.
parent, 0);
180 });
182
183
184 std::vector<char> vec_hlt_barrel_high_et, vec_hlt_no_off_match, vec_hlt_with_off_match;
188
189 auto HLT_barrel_high_et_num = Monitored::Scalar<int>("HLT_barrel_high_et_num",0);
190 auto HLT_no_OFF_match_num = Monitored::Scalar<int>("HLT_no_OFF_match_num",0);
191 auto HLT_with_OFF_match_num = Monitored::Scalar<int>("HLT_with_OFF_match_num",0);
192
193
194 std::vector<float> vec_hlt_vs_off_minimum_delta_r, vec_hlt_vs_off_delta_eta, vec_hlt_vs_off_delta_phi, vec_hlt_vs_off_delta_time, vec_hlt_vs_off_resolution, vec_off_match_et;
195
196 auto HLT_matched_fraction = Monitored::Scalar<float>("HLT_matched_fraction", 0.0);
197 auto HLT_vs_OFF_minimum_delta_r =
Monitored::Collection(
"HLT_vs_OFF_minimum_delta_r", vec_hlt_vs_off_minimum_delta_r);
200 auto HLT_vs_OFF_delta_time =
Monitored::Collection(
"HLT_vs_OFF_delta_time", vec_hlt_vs_off_delta_time);
201 auto HLT_vs_OFF_resolution =
Monitored::Collection(
"HLT_vs_OFF_resolution", vec_hlt_vs_off_resolution);
203
204 const clus_kin *off_match = nullptr;
205
206
207
208 for (const auto& hlt_cluster : vec_hlt_clusters) {
209
210 ++n_hlt_clusters;
211
212
213 if (hlt_cluster.et > (
m_HLT_high_et * 0.001) && std::abs(hlt_cluster.eta) < 2.5) {
214 ++n_hlt_barrel_high_et_clusters;
215 vec_hlt_barrel_high_et.push_back(1);
216 }
217 else vec_hlt_barrel_high_et.push_back(0);
218
219
220
221 float min_delta_r = 999999.9;
222
223 for (const auto& off_cluster : vec_off_clusters) {
225
226 if (delta_r < min_delta_r) {
227
228 min_delta_r = delta_r;
229 off_match = &off_cluster;
230 }
231
232 }
233
234 vec_hlt_vs_off_minimum_delta_r.push_back(min_delta_r);
235
236
238
239 ++n_hlt_clusters_no_match;
240
241 vec_off_match_et.push_back(0.);
242
243 vec_hlt_vs_off_resolution.push_back(0.);
244 vec_hlt_vs_off_delta_eta.push_back(0.);
245 vec_hlt_vs_off_delta_phi.push_back(0.);
246 vec_hlt_vs_off_delta_time.push_back(0.);
247
248 vec_hlt_no_off_match.push_back(1);
249 vec_hlt_with_off_match.push_back(0);
250 }
251
252
253 else {
254
255 ++n_hlt_clusters_with_match;
256
257 vec_off_match_et.push_back(off_match->
et);
258
259 vec_hlt_vs_off_resolution.push_back(((off_match->
et - hlt_cluster.et) / off_match->
et) * 100);
260 vec_hlt_vs_off_delta_eta.push_back(off_match->
eta - hlt_cluster.eta);
262 vec_hlt_vs_off_delta_time.push_back(off_match->
parent->time() - hlt_cluster.parent->time());
263
264 vec_hlt_no_off_match.push_back(0);
265 vec_hlt_with_off_match.push_back(1);
266 }
267
268 }
269
270 HLT_num = n_hlt_clusters;
271 HLT_barrel_high_et_num = n_hlt_barrel_high_et_clusters;
272 HLT_no_OFF_match_num = n_hlt_clusters_no_match;
273 HLT_with_OFF_match_num = n_hlt_clusters_with_match;
274 if (n_hlt_clusters>0) {
275 HLT_matched_fraction = static_cast<float>(n_hlt_clusters_with_match) / n_hlt_clusters;
276 }
277
279
281
282 unsigned int n_off_clusters = 0;
283 unsigned int n_off_clusters_no_match = 0;
284 unsigned int n_off_clusters_with_match = 0;
285
286
287 std::vector<float> vec_off_et, vec_off_eta, vec_off_phi, vec_off_time;
288 std::vector<int> vec_off_type;
289
290 auto OFF_num = Monitored::Scalar<int>("OFF_num",0);
295 auto OFF_type =
Monitored::Collection(
"OFF_type", vec_off_clusters, [](
const clus_kin& clus) {
return clus.
parent->clusterSize(); } );
296
297
298 std::vector<char> vec_off_no_hlt_match, vec_off_with_hlt_match;
301
302 auto OFF_no_HLT_match_num = Monitored::Scalar<int>("OFF_no_HLT_match_num",0);
303 auto OFF_with_HLT_match_num = Monitored::Scalar<int>("OFF_with_HLT_match_num",0);
304
305
306 std::vector<float> vec_off_vs_hlt_minimum_delta_r, vec_off_vs_hlt_delta_eta, vec_off_vs_hlt_delta_phi, vec_off_vs_hlt_delta_time, vec_off_vs_hlt_resolution, vec_hlt_match_et;
307
308 auto OFF_matched_fraction = Monitored::Scalar<float>("OFF_matched_fraction", 0.0);
309 auto OFF_vs_HLT_minimum_delta_r =
Monitored::Collection(
"OFF_vs_HLT_minimum_delta_r", vec_off_vs_hlt_minimum_delta_r);
312 auto OFF_vs_HLT_delta_time =
Monitored::Collection(
"OFF_vs_HLT_delta_time", vec_off_vs_hlt_delta_time);
313 auto OFF_vs_HLT_resolution =
Monitored::Collection(
"OFF_vs_HLT_resolution", vec_off_vs_hlt_resolution);
315
316 const clus_kin *hlt_match = nullptr;
317
318
319
320 for (const auto& off_cluster: vec_off_clusters) {
321
322 ++n_off_clusters;
323
324
325
326 float min_delta_r = 999999.9;
327
328 for (const auto& hlt_cluster : vec_hlt_clusters) {
329
331
332 if (delta_r < min_delta_r) {
333
334 min_delta_r = delta_r;
335 hlt_match = &hlt_cluster;
336 }
337
338 }
339
340 vec_off_vs_hlt_minimum_delta_r.push_back(min_delta_r);
341
342
344
345 ++n_off_clusters_no_match;
346
347 vec_hlt_match_et.push_back(0.);
348
349 vec_off_vs_hlt_resolution.push_back(0.);
350 vec_off_vs_hlt_delta_eta.push_back(0.);
351 vec_off_vs_hlt_delta_phi.push_back(0.);
352 vec_off_vs_hlt_delta_time.push_back(0.);
353
354 vec_off_no_hlt_match.push_back(1);
355 vec_off_with_hlt_match.push_back(0);
356 }
357
358 else {
359
360 ++n_off_clusters_with_match;
361
362 vec_hlt_match_et.push_back(hlt_match->
et);
363
364 vec_off_vs_hlt_resolution.push_back(((off_cluster.et - hlt_match->
et) / off_cluster.et) * 100);
365 vec_off_vs_hlt_delta_eta.push_back(off_cluster.eta - hlt_match->
eta);
367 vec_off_vs_hlt_delta_time.push_back(off_cluster.parent->time() - hlt_match->
parent->time());
368
369 vec_off_no_hlt_match.push_back(0);
370 vec_off_with_hlt_match.push_back(1);
371 }
372
373 }
374
375
376 OFF_num = n_off_clusters;
377 OFF_no_HLT_match_num = n_off_clusters_no_match;
378 OFF_with_HLT_match_num = n_off_clusters_with_match;
379 if (n_off_clusters>0) {
380 OFF_matched_fraction = static_cast<float>(n_off_clusters_with_match) / n_off_clusters;
381 }
383
385 if(accepted_hlt_clusters.size()>0){
387
389
390 HLT_num, HLT_et, HLT_eta, HLT_phi, HLT_time, HLT_type, HLT_size, HLT_barrel_high_et_num, HLT_bc,
391
392
393 HLT_barrel_high_et, HLT_no_OFF_match, HLT_with_OFF_match,
394
395
396 OFF_num, OFF_et, OFF_eta, OFF_phi, OFF_time, OFF_type,
397
398
399 OFF_no_HLT_match, OFF_with_HLT_match,
400
401
402 HLT_matched_fraction, HLT_no_OFF_match_num, HLT_vs_OFF_minimum_delta_r, HLT_with_OFF_match_num,
403 OFF_match_et, HLT_vs_OFF_resolution, HLT_vs_OFF_delta_eta, HLT_vs_OFF_delta_phi, HLT_vs_OFF_delta_time,
404
405
406 OFF_matched_fraction, OFF_no_HLT_match_num, OFF_vs_HLT_minimum_delta_r, OFF_with_HLT_match_num,
407 HLT_match_et, OFF_vs_HLT_resolution, OFF_vs_HLT_delta_eta, OFF_vs_HLT_delta_phi, OFF_vs_HLT_delta_time
408 );
409
410 }
414
415 HLT_num, HLT_et, HLT_eta, HLT_phi, HLT_time, HLT_type, HLT_size, HLT_barrel_high_et_num, HLT_bc,
416
417
418 HLT_barrel_high_et, HLT_no_OFF_match, HLT_with_OFF_match,
419
420
421 OFF_num, OFF_et, OFF_eta, OFF_phi, OFF_time, OFF_type,
422
423
424 OFF_no_HLT_match, OFF_with_HLT_match,
425
426
427 HLT_matched_fraction, HLT_no_OFF_match_num, HLT_vs_OFF_minimum_delta_r, HLT_with_OFF_match_num,
428 OFF_match_et, HLT_vs_OFF_resolution, HLT_vs_OFF_delta_eta, HLT_vs_OFF_delta_phi, HLT_vs_OFF_delta_time,
429
430
431 OFF_matched_fraction, OFF_no_HLT_match_num, OFF_vs_HLT_minimum_delta_r, OFF_with_HLT_match_num,
432 HLT_match_et, OFF_vs_HLT_resolution, OFF_vs_HLT_delta_eta, OFF_vs_HLT_delta_phi, OFF_vs_HLT_delta_time
433 );
434 }
435 }
436 else {
439
440 HLT_num, HLT_et, HLT_eta, HLT_phi, HLT_time, HLT_type, HLT_size, HLT_barrel_high_et_num, HLT_bc,
441
442
443 HLT_barrel_high_et, HLT_no_OFF_match, HLT_with_OFF_match,
444
445
446 OFF_num, OFF_et, OFF_eta, OFF_phi, OFF_time, OFF_type,
447
448
449 OFF_no_HLT_match, OFF_with_HLT_match,
450
451
452 HLT_matched_fraction, HLT_no_OFF_match_num, HLT_vs_OFF_minimum_delta_r, HLT_with_OFF_match_num,
453 OFF_match_et, HLT_vs_OFF_resolution, HLT_vs_OFF_delta_eta, HLT_vs_OFF_delta_phi, HLT_vs_OFF_delta_time,
454
455
456 OFF_matched_fraction, OFF_no_HLT_match_num, OFF_vs_HLT_minimum_delta_r, OFF_with_HLT_match_num,
457 HLT_match_et, OFF_vs_HLT_resolution, OFF_vs_HLT_delta_eta, OFF_vs_HLT_delta_phi, OFF_vs_HLT_delta_time
458 );
459
460 }
461 return StatusCode::SUCCESS;
462}
#define ATH_CHECK
Evaluate an expression and check for errors.
const ToolHandle< Trig::TrigDecisionTool > & getTrigDecisionTool() const
Get the trigger decision tool member.
SG::ReadHandle< xAOD::EventInfo > GetEventInfo(const EventContext &) const
Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)
int distanceFromFront(const bcid_type bcid, const BunchDistanceType type=NanoSec) const
The distance of the specific bunch crossing from the front of the train.
@ BunchCrossings
Distance in units of 25 nanoseconds.
SG::ReadCondHandleKey< BunchCrossingCondData > m_bunchCrossingKey
virtual float calculateDeltaR(float max_deltar, float eta_1, float phi_1, float eta_2, float phi_2) const
std::vector< const xAOD::CaloCluster * > ifStepPassed(const std::string &chain) const
@ LAr
The LAr calorimeter.
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > &&variables) const
Fills a vector of variables to a group by reference.
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
setEventNumber setTimeStamp bcid
1.14.0