ATLAS Offline Software
Loading...
Searching...
No Matches
CpmMonitorAlgorithm.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3*/
4
5#include "CpmMonitorAlgorithm.h"
6#include "TrigT1CaloUtils/CoordToHardware.h"
7#include "TrigT1CaloUtils/DataError.h"
8#include "TrigT1Interfaces/CPRoIDecoder.h"
9
10CpmMonitorAlgorithm::CpmMonitorAlgorithm( const std::string& name, ISvcLocator* pSvcLocator )
11 : AthMonitorAlgorithm(name,pSvcLocator),
12 m_phiScaleTT(32./M_PI)
13{
14}
15
16StatusCode CpmMonitorAlgorithm::initialize() {
17
18 ATH_MSG_DEBUG("CpmMonitorAlgorith::initialize");
19 ATH_MSG_DEBUG("Package Name "<< m_packageName);
20 // container names
21 ATH_MSG_DEBUG("m_xAODTriggerTowerContainerName"<< m_xAODTriggerTowerContainerName);
22 ATH_MSG_DEBUG("m_cpmTowerLocation"<< m_cpmTowerLocation);
23 ATH_MSG_DEBUG("m_cpmTowerLocationOverlap"<< m_cpmTowerLocationOverlap);
24
25 // steering parameters
26 ATH_MSG_DEBUG("m_crates"<<m_crates );
27 ATH_MSG_DEBUG("m_modules"<<m_modules );
28 ATH_MSG_DEBUG("m_maxSlices"<<m_maxSlices );
29 ATH_MSG_DEBUG("m_tobsPerCPM"<<m_tobsPerCPM );
30 ATH_MSG_DEBUG("m_isolBits"<<m_isolBits );
31 ATH_MSG_DEBUG("m_maxTobsPerCmx"<<m_maxTobsPerCmx );
32
33 // initialise all the containers that we need
34 ATH_CHECK(m_xAODTriggerTowerContainerName.initialize());
35 ATH_CHECK(m_cpmTowerLocation.initialize());
36 ATH_CHECK(m_cpmTowerLocationOverlap.initialize());
37 ATH_CHECK( m_cpmTobRoiLocation.initialize());
38 ATH_CHECK( m_cmxCpTobLocation.initialize());
39 ATH_CHECK( m_cmxCpHitsLocation.initialize());
40
41 ATH_CHECK(m_errorLocation.initialize());
42
43 return AthMonitorAlgorithm::initialize();
44}
45
46StatusCode CpmMonitorAlgorithm::fillHistograms( const EventContext& ctx ) const {
47
48 ATH_MSG_DEBUG("CpmMonitorAlgorithm::fillHistograms");
49
50 // Retrieve Trigger Towers from SG
51 SG::ReadHandle<xAOD::TriggerTowerContainer> triggerTowerTES(m_xAODTriggerTowerContainerName, ctx);
52
53 ATH_CHECK(triggerTowerTES.isValid());
54
55 // Retrieve Core CPM Towers from SG
56 SG::ReadHandle<xAOD::CPMTowerContainer> cpmTowerTES(m_cpmTowerLocation, ctx);
57 ATH_CHECK(cpmTowerTES.isValid());
58
59 // Retrieve Overlap CPM Towers from SG
60 SG::ReadHandle<xAOD::CPMTowerContainer> cpmTowerOverlapTES(m_cpmTowerLocationOverlap, ctx);
61 ATH_CHECK(cpmTowerOverlapTES.isValid());
62
63 //Retrieve CPM TOB RoIs from SG
64 SG::ReadHandle<xAOD::CPMTobRoIContainer> cpmTobRoiTES(m_cpmTobRoiLocation, ctx);
65 ATH_CHECK(cpmTobRoiTES.isValid());
66
67 //Retrieve CMX-CP TOBs from SG
68 SG::ReadHandle<xAOD::CMXCPTobContainer> cmxCpTobTES(m_cmxCpTobLocation, ctx);
69 ATH_CHECK(cmxCpTobTES.isValid());
70
71 //Retrieve CMX-CP Hits from SG
72 SG::ReadHandle<xAOD::CMXCPHitsContainer> cmxCpHitsTES(m_cmxCpHitsLocation, ctx);
73 ATH_CHECK(cmxCpHitsTES.isValid());
74
75 //
76 // array of monitored items
77 std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>> variables;
78
79 // Global plots
80 // Create a vector of towers we want to monitor
81 std::vector<MonitorTT> monTTs;
82 xAOD::TriggerTowerContainer::const_iterator ttIterator = (*triggerTowerTES).begin();
83 xAOD::TriggerTowerContainer::const_iterator ttIteratorEnd = (*triggerTowerTES).end();
84 for (; ttIterator != ttIteratorEnd; ++ttIterator) {
85 const int layer = (*ttIterator)->layer();
86 const xAOD::TriggerTower_v2* tt = *ttIterator;
87 const double eta = (*ttIterator)->eta();
88 if ( std::abs(eta) > 2.5) continue;
89
90 if (!tt->cpET()) continue;
91 //check if the TriggerTower is in EM or HAD layer
92 if (layer == 0) { //EM
93 const int em = int(tt->cpET());
94 if (em) {
95 MonitorTT monTT;
96 monTT.ttower=(*ttIterator);
97 monTT.phi_scaled=(*ttIterator)->phi()*m_phiScaleTT;
98 monTTs.push_back(monTT);
99 }
100 }
101 if (layer == 1) { //HAD
102 const int had = int(tt->cpET());
103 if (had) {
104 MonitorTT monTT;
105 monTT.ttower=(*ttIterator);
106 monTT.phi_scaled=(*ttIterator)->phi()*m_phiScaleTT;
107 monTTs.push_back(monTT);
108 }
109 }
110 } //ttIterator
111
112 // setup cutmasks to select the em and had TTs
113 auto mask_em_TT = Monitored::Collection("mask_em_TT", monTTs, []( const auto &tower ) {return ( tower.ttower->layer()==0); } ); variables.push_back( mask_em_TT );
114 auto mask_had_TT = Monitored::Collection("mask_had_TT", monTTs, []( const auto &tower ){return ( tower.ttower->layer()==1); } ); variables.push_back( mask_had_TT );
115
116 // the variables to monitor
117 auto etaTT = Monitored::Collection("etaTT", monTTs, []( const auto &tower ){return tower.ttower->eta();} ); variables.push_back( etaTT );
118 auto phiTT = Monitored::Collection("phiTT", monTTs, []( const auto &tower ){return tower.phi_scaled;} ); variables.push_back( phiTT );
119
120 // CPM Global maps
121
122 // Vectors for error overview bits;
123 std::vector<int> errorsCPM(m_crates * m_modules);
124 std::vector<int> errorsCMX(m_crates * 2); // L/R
125 //cpmTowerTES
126 std::vector<MonitorCpmTT> monCpmTTs_em;
127 std::vector<MonitorCpmTT> monCpmTTs_had;
128 // scalars to fill bitwise histograms directly
129 Monitored::Scalar<int> GLinkParityError = Monitored::Scalar<int>("GLinkParityError", 0);
130 Monitored::Scalar<int> cpmLoc = Monitored::Scalar<int>("cpmLoc", 0);
131 bool core=true;
132 ATH_CHECK(fillCpmTowerVectors(cpmTowerTES, monCpmTTs_em, monCpmTTs_had, errorsCPM, core, cpmLoc, GLinkParityError));
133 std::vector<MonitorCpmTT> monCpmOverlapTTs_em;
134 std::vector<MonitorCpmTT> monCpmOverlapTTs_had;
135 core=false;
136 ATH_CHECK(fillCpmTowerVectors(cpmTowerOverlapTES, monCpmOverlapTTs_em, monCpmOverlapTTs_had, errorsCPM, core, cpmLoc, GLinkParityError));
137
138 // add the CPM global variables to be monitored - exclude Overlap
139 auto etCpmTT_em = Monitored::Collection("etCpmTT_em", monCpmTTs_em, []( const auto &tt ){return tt.ttower->emEnergy();} ); variables.push_back( etCpmTT_em );
140 auto etaCpmTT_em = Monitored::Collection("etaCpmTT_em", monCpmTTs_em, []( const auto &tt ){return tt.ttower->eta();} ); variables.push_back( etaCpmTT_em );
141 auto phiCpmTT_em = Monitored::Collection("phiCpmTT_em", monCpmTTs_em, []( const auto &tt ){return tt.ttower->phi();} ); variables.push_back( phiCpmTT_em );
142 auto phiScaledCpmTT_em = Monitored::Collection("phiScaledCpmTT_em", monCpmTTs_em, []( const auto &tt ){return tt.phi_scaled;} );
143 variables.push_back( phiScaledCpmTT_em );
144 auto etCpmTT_had = Monitored::Collection("etCpmTT_had", monCpmTTs_had, []( const auto &tt ){return tt.ttower->hadEnergy();} ); variables.push_back( etCpmTT_had );
145 auto etaCpmTT_had = Monitored::Collection("etaCpmTT_had", monCpmTTs_had, []( const auto &tt ){return tt.ttower->eta();} ); variables.push_back( etaCpmTT_had );
146 auto phiCpmTT_had = Monitored::Collection("phiCpmTT_had", monCpmTTs_had, []( const auto &tt ){return tt.ttower->phi();} ); variables.push_back( phiCpmTT_had );
147 auto phiScaledCpmTT_had = Monitored::Collection("phiScaledCpmTT_had", monCpmTTs_had, []( const auto &tt ){return tt.phi_scaled;} );
148 variables.push_back( phiScaledCpmTT_had );
149
150 // errors and slices are filled for sum of Core and Overlap
151 std::vector<MonitorCpmTT> monCpmTTs_em_tot(monCpmTTs_em.begin(),monCpmTTs_em.end());
152 monCpmTTs_em_tot.insert(monCpmTTs_em_tot.end(), monCpmOverlapTTs_em.begin(),monCpmOverlapTTs_em.end());
153 std::vector<MonitorCpmTT> monCpmTTs_had_tot(monCpmTTs_had.begin(),monCpmTTs_had.end());
154 monCpmTTs_had_tot.insert(monCpmTTs_had_tot.end(), monCpmOverlapTTs_had.begin(),monCpmOverlapTTs_had.end());
155 // the variables
156 auto etaCpmTT_em_tot = Monitored::Collection("etaCpmTT_em_tot", monCpmTTs_em_tot, []( const auto &tt ){return tt.ttower->eta();} );
157 variables.push_back( etaCpmTT_em_tot) ;
158 auto phiScaledCpmTT_em_tot = Monitored::Collection("phiScaledCpmTT_em_tot", monCpmTTs_em_tot, []( const auto &tt ){return tt.phi_scaled;} );
159 variables.push_back( phiScaledCpmTT_em_tot );
160 auto etaCpmTT_had_tot = Monitored::Collection("etaCpmTT_had_tot", monCpmTTs_had_tot, []( const auto &tt ){return tt.ttower->eta();} );
161 variables.push_back( etaCpmTT_had_tot) ;
162 auto phiScaledCpmTT_had_tot = Monitored::Collection("phiScaledCpmTT_had_tot", monCpmTTs_had_tot, []( const auto &tt ){return tt.phi_scaled;} );
163 variables.push_back( phiScaledCpmTT_had_tot );
164
165
166 // the masks
167 auto parityErrorCpmTT_em = Monitored::Collection("parityErrorCpmTT_em", monCpmTTs_em_tot, []( const auto &tt ){return tt.emParityError;} );
168 variables.push_back( parityErrorCpmTT_em );
169 auto linkDownErrorCpmTT_em = Monitored::Collection("linkDownErrorCpmTT_em", monCpmTTs_em_tot, []( const auto &tt ){return tt.emLinkDownError;} );
170 variables.push_back( linkDownErrorCpmTT_em );
171 auto parityErrorCpmTT_had = Monitored::Collection("parityErrorCpmTT_had", monCpmTTs_had_tot, []( const auto &tt ){return tt.hadParityError;} );
172 variables.push_back( parityErrorCpmTT_had );
173 auto linkDownErrorCpmTT_had = Monitored::Collection("linkDownErrorCpmTT_had", monCpmTTs_had_tot, []( const auto &tt ){return tt.hadLinkDownError;} );
174 variables.push_back( linkDownErrorCpmTT_had );
175
176 // and the sum of the Core and Overlap for EM and HAD
177 std::vector<MonitorCpmTT> monCpmTTs_tot(monCpmTTs_em_tot.begin(),monCpmTTs_em_tot.end());
178 monCpmTTs_tot.insert(monCpmTTs_tot.end(), monCpmTTs_had_tot.begin(),monCpmTTs_had_tot.end());
179
180 auto peakCpmTT_tot = Monitored::Collection("peakCpmTT_tot", monCpmTTs_tot, []( const auto &tt ){return tt.ttower->peak();} );
181 variables.push_back( peakCpmTT_tot );
182 auto sliceCpmTT_tot = Monitored::Collection("sliceCpmTT_tot", monCpmTTs_tot, []( const auto &tt ){return tt.slice;} );
183 variables.push_back( sliceCpmTT_tot );
184
185 //=============================================
186 // CPM TOB RoIs
187 //=============================================
188
189 std::vector<MonitorTobRoI> monTobRoIsEner;
190 std::vector<MonitorTobRoI> monTobRoIsIsol;
191
192 const int vecSize = m_crates * m_modules * 2;
193 std::vector<int> tobCount(vecSize);
194 LVL1::CPRoIDecoder decoder;
195 xAOD::CPMTobRoIContainer::const_iterator crIterator = (*cpmTobRoiTES).begin();
196 xAOD::CPMTobRoIContainer::const_iterator crIteratorEnd = (*cpmTobRoiTES).end();
197 // fill thresholds and bits as scalars in the loop
198 auto thresholdsEm = Monitored::Scalar("bitsTobRoIsIsolEm", 0.);
199 auto thresholdWeightsEm = Monitored::Scalar<float>("bitsTobRoIsIsolEmWeight", 1.);
200 auto thresholdsTau = Monitored::Scalar("bitsTobRoIsIsolTau", 0.);
201 auto thresholdWeightsTau = Monitored::Scalar("bitsTobRoIsIsolTauWeight", 0.);
202 for (; crIterator != crIteratorEnd; ++crIterator) {
203 const int type = (*crIterator)->type(); // 0=EM, 1=Tau
204 const int energy = (*crIterator)->energy();
205 const int isolation = (*crIterator)->isolation();
206 const LVL1::CoordinateRange coord(decoder.coordinate((*crIterator)->roiWord()));
207 const double eta = coord.eta();
208 const double phi = coord.phi();
209 const double phiMod = phi * m_phiScaleTT - 0.5;
210 const double etaMod = eta - 0.05;
211 if (energy) {
212 MonitorTobRoI monTobRoI;
213 monTobRoI.tobroi=(*crIterator);
214 monTobRoI.etaMod=etaMod;
215 monTobRoI.phiMod=phiMod;
216 monTobRoIsEner.push_back(monTobRoI);
217 }
218 if (isolation) {
219 // fill isolation bits
220 std::vector<bool> isolbits=getIsolationBits(isolation, m_isolBits, 1);
221 for (int thr = 0; thr < m_isolBits; ++thr) {
222 if (isolbits[thr]){
223 if(type==0) {
224 thresholdsEm = thr;
225 thresholdWeightsEm = isolbits[thr];
226 fill(m_packageName, thresholdsEm, thresholdWeightsEm);
227 } else {
228 thresholdsTau = thr;
229 thresholdWeightsTau = isolbits[thr];
230 fill(m_packageName, thresholdsTau, thresholdWeightsTau);
231 }
232 }
233 }
234 //
235 MonitorTobRoI monTobRoI;
236 monTobRoI.tobroi=(*crIterator);
237 monTobRoI.etaMod=etaMod;
238 monTobRoI.phiMod=phiMod;
239 monTobRoIsIsol.push_back(monTobRoI);
240 }
241 const int crate = (*crIterator)->crate();
242 const int cpm = (*crIterator)->cpm();
243 ++tobCount[(crate * m_modules + cpm - 1) * 2 + type];
244 }
245 // Energy
246 auto etaTobRoIsEner = Monitored::Collection("etaTobRoIsEner", monTobRoIsEner, []( const auto &roi ){return roi.etaMod;} );
247 variables.push_back(etaTobRoIsEner);
248 auto phiTobRoIsEner = Monitored::Collection("phiTobRoIsEner", monTobRoIsEner, []( const auto &roi ){return roi.phiMod;} );
249 variables.push_back(phiTobRoIsEner);
250 auto energyTobRoIsEner = Monitored::Collection("energyTobRoIsEner", monTobRoIsEner, []( const auto &roi ){return roi.tobroi->energy();} );
251 variables.push_back(energyTobRoIsEner);
252 auto typeTobRoIsEner = Monitored::Collection("typeTobRoIsEner", monTobRoIsEner, []( const auto &roi ){return roi.tobroi->type();} );
253 variables.push_back(typeTobRoIsEner);
254
255 // setup cutmasks to select EM or Tau
256 auto mask_tobroi_ener_em = Monitored::Collection("mask_tobroi_ener_em", monTobRoIsEner, []( const auto &roi ) {return ( roi.tobroi->type()==0); } );
257 variables.push_back( mask_tobroi_ener_em );
258 auto mask_tobroi_ener_tau = Monitored::Collection("mask_tobroi_ener_tau", monTobRoIsEner, []( const auto &roi ){return ( roi.tobroi->type()==1); } );
259 variables.push_back( mask_tobroi_ener_tau );
260
261 // Isol
262 auto etaTobRoIsIsol = Monitored::Collection("etaTobRoIsIsol", monTobRoIsIsol, []( const auto &roi ){return roi.etaMod;} );
263 variables.push_back(etaTobRoIsIsol);
264 auto phiTobRoIsIsol = Monitored::Collection("phiTobRoIsIsol", monTobRoIsIsol, []( const auto &roi ){return roi.phiMod;} );
265 variables.push_back(phiTobRoIsIsol);
266 auto energyTobRoIsIsol = Monitored::Collection("energyTobRoIsIsol", monTobRoIsIsol, []( const auto &roi ){return roi.tobroi->isolation();} );
267 variables.push_back(energyTobRoIsIsol);
268
269 auto mask_tobroi_isol_em = Monitored::Collection("mask_tobroi_isol_em", monTobRoIsIsol, []( const auto &roi ) {return ( roi.tobroi->type()==0); } );
270 variables.push_back( mask_tobroi_isol_em );
271 auto mask_tobroi_isol_tau = Monitored::Collection("mask_tobroi_isol_tau", monTobRoIsIsol, []( const auto &roi ){return ( roi.tobroi->type()==1); } );
272 variables.push_back( mask_tobroi_isol_tau );
273
274
275 // count ToBs
276 std::vector<int> tobCountEm;
277 std::vector<int> tobCountTau;
278 for (int crate = 0; crate < m_crates; ++crate) {
279 for (int cpm = 1; cpm <= m_modules; ++cpm) {
280 for (int type = 0; type < 2; ++type) {
281 int val = tobCount[(crate * m_modules + cpm - 1) * 2 + type];
282 if (val) {
283 if (val > m_tobsPerCPM) val = m_tobsPerCPM + 1;
284 if (type == 0) {
285 tobCountEm.push_back(val);
286 } else {
287 tobCountTau.push_back(val);
288 }
289 }
290 }
291 }
292 }
293 auto tobEm = Monitored::Collection("tobPerCPMEm", tobCountEm, []( const auto &tob ){return tob;} ); variables.push_back( tobEm );
294 auto tobTau = Monitored::Collection("tobPerCPMTau", tobCountTau, []( const auto &tob ){return tob;} ); variables.push_back( tobTau );
295
296
297 //=============================================
298 // CMX-CP TOBs
299 //=============================================
300
301 std::vector<MonitorCmxCpTob> monCmxCpTobEnerLeft;
302 std::vector<MonitorCmxCpTob> monCmxCpTobEnerRight;
303 std::vector<MonitorCmxCpTob> monCmxCpTobError;
304 std::vector<MonitorCmxCpTob> monCmxCpTobIsolLeft;
305 std::vector<MonitorCmxCpTob> monCmxCpTobIsolRight;
306
307 tobCount.assign(vecSize, 0);
308 std::vector<int> cmxCount(m_crates * 2);
309 xAOD::CMXCPTobContainer::const_iterator cmxCpTobIter = (*cmxCpTobTES).begin();
310 xAOD::CMXCPTobContainer::const_iterator cmxCpTobIterEnd = (*cmxCpTobTES).end();
311 //
312 auto cmxCpmTobsIsolBitsLeft = Monitored::Scalar("cmxCpmTobsIsolBitsLeft", 0.);
313 auto cmxCpmTobsIsolBitsLeftW = Monitored::Scalar<float>("cmxCpmTobsIsolBitsLeftWeight", 1.);
314 auto cmxCpmTobsIsolBitsRight= Monitored::Scalar("cmxCpmTobsIsolBitsRight", 0.);
315 auto cmxCpmTobsIsolBitsRightW = Monitored::Scalar<float>("cmxCpmTobsIsolBitsRightWeight", 1.);
316 for (; cmxCpTobIter != cmxCpTobIterEnd; ++cmxCpTobIter) {
317 const uint8_t crate = (*cmxCpTobIter)->crate();
318 const uint8_t cpm = (*cmxCpTobIter)->cpm(); // 1-14
319 const uint8_t cmx = (*cmxCpTobIter)->cmx(); // 0=Left, 1=Right (Assumed in Sim to be Left Tau, Right EM)
320 const uint8_t chip = (*cmxCpTobIter)->chip(); // 4 bits
321 const uint8_t location = (*cmxCpTobIter)->location();// 2 bits
322 const uint8_t energy = (*cmxCpTobIter)->energy();
323 const uint8_t isolation = (*cmxCpTobIter)->isolation();
324 const uint32_t error = (*cmxCpTobIter)->error();
325 const uint8_t x = crate * m_modules + cpm - 1;
326 const uint8_t y = chip * 4 + location;
327 if (energy) {
328 MonitorCmxCpTob monCmxCpTob;
329 monCmxCpTob.tob=(*cmxCpTobIter);
330 monCmxCpTob.x=x;
331 monCmxCpTob.y=y;
332 if (cmx)
333 monCmxCpTobEnerRight.push_back(monCmxCpTob);
334 else
335 monCmxCpTobEnerLeft.push_back(monCmxCpTob);
336 }
337 if (isolation) {
338 MonitorCmxCpTob monCmxCpTob;
339 monCmxCpTob.tob=(*cmxCpTobIter);
340 monCmxCpTob.x=x;
341 monCmxCpTob.y=y;
342 if (cmx)
343 monCmxCpTobIsolRight.push_back(monCmxCpTob);
344 else
345 monCmxCpTobIsolLeft.push_back(monCmxCpTob);
346
347 int nBits=1; int offset = 0;
348 const int mask = (1 << nBits) - 1;
349 for (int thr = 0; thr < m_isolBits; ++thr) {
350 const int hit = (isolation >> (nBits*thr)) & mask;
351 if (hit) {
352 if(cmx) {
353 cmxCpmTobsIsolBitsRight=thr+offset;
354 cmxCpmTobsIsolBitsRightW=hit;
355 fill(m_packageName, cmxCpmTobsIsolBitsRight, cmxCpmTobsIsolBitsRightW);
356 } else {
357 cmxCpmTobsIsolBitsLeft=thr+offset;
358 cmxCpmTobsIsolBitsLeftW=hit;
359 fill(m_packageName, cmxCpmTobsIsolBitsLeft, cmxCpmTobsIsolBitsLeftW);
360 }
361 }
362 } // isol bits
363 } // isolation
364 if (error) {
365 MonitorCmxCpTob monCmxCpTob;
366 monCmxCpTob.tob=(*cmxCpTobIter);
367 monCmxCpTob.x=x;
368 monCmxCpTob.parityError=false;
369
370 const LVL1::DataError err(error);
371 if (err.get(LVL1::DataError::Overflow)) {
372 tobCount[x * 2 + cmx] = m_tobsPerCPM + 1;
373 }
374 const int ybase = cmx * 5;
375 monCmxCpTob.ybase=ybase;
376 bool parity = false;
377 if (err.get(LVL1::DataError::ParityMerge)) {
378 parity = true;
379 monCmxCpTob.parityError=true;
380 monCmxCpTob.ybaseError=ybase;
381 }
382 if (err.get(LVL1::DataError::ParityPhase0)) {
383 parity = true;
384 monCmxCpTob.parityError=true;
385 monCmxCpTob.ybaseError=ybase+1;
386 }
387 if (err.get(LVL1::DataError::ParityPhase1)) {
388 parity = true;
389 monCmxCpTob.parityError=true;
390 monCmxCpTob.ybaseError=ybase+2;
391 }
392 if (err.get(LVL1::DataError::ParityPhase2)) {
393 parity = true;
394 monCmxCpTob.parityError=true;
395 monCmxCpTob.ybaseError=ybase+3;
396 }
397 if (err.get(LVL1::DataError::ParityPhase3)) {
398 parity = true;
399 monCmxCpTob.parityError=true;
400 monCmxCpTob.ybaseError=ybase+4;
401 }
402 if (parity) errorsCMX[crate * 2 + cmx] |= (1 << TOBParity);
403
404 // and now push error structs
405 monCmxCpTobError.push_back(monCmxCpTob);
406 } // end of error
407 //
408 if (energy || isolation || error) {
409 ++tobCount[x * 2 + cmx];
410 ++cmxCount[crate * 2 + cmx];
411 }
412
413 //
414 auto cmxCpmTobsLeft = Monitored::Scalar("cmxCpmTobsLeft", 0.);
415 auto cmxCpmTobsRight = Monitored::Scalar("cmxCpmTobsRight", 0.);
416 auto cmxTobsCmxLeft = Monitored::Scalar("cmxTobsCmxLeft", 0.);
417 auto cmxTobsCmxRight = Monitored::Scalar("cmxTobsCmxRight", 0.);
418 for (int crate = 0; crate < m_crates; ++crate) {
419 for (int cpm = 1; cpm <= m_modules; ++cpm) {
420 for (int cmx = 0; cmx < 2; ++cmx) {
421 int val = tobCount[(crate * m_modules + cpm - 1) * 2 + cmx];
422 if (val) {
423 if (val > m_tobsPerCPM) val = m_tobsPerCPM + 1;
424 if (cmx == 0) {
425 cmxCpmTobsLeft=val;
426 fill(m_packageName, cmxCpmTobsLeft);
427 } else {
428 cmxCpmTobsRight=val;
429 fill(m_packageName, cmxCpmTobsRight);
430 }
431 }
432 }
433 }
434 for (int cmx = 0; cmx < 2; ++cmx) {
435 int val = cmxCount[crate * 2 + cmx];
436 if (val) {
437 if (val >= m_maxTobsPerCmx) val = m_maxTobsPerCmx - 1;
438 if (cmx == 0) {
439 cmxTobsCmxLeft=val;
440 fill(m_packageName, cmxTobsCmxLeft);
441 } else {
442 cmxTobsCmxRight=val;
443 fill(m_packageName, cmxTobsCmxRight);
444 }
445 }
446 }
447 }
448 } // CMX loop end
449
450 // now fill CMX-CP TOB monitor items
451 // Energy
452 auto cmxCpmTobsEnerLeft = Monitored::Collection("cmxCpmTobsEnerLeft", monCmxCpTobEnerLeft, []( const auto &tob ){return tob.tob->energy();} );
453 variables.push_back(cmxCpmTobsEnerLeft);
454 auto cmxCpmTobsEnerRight = Monitored::Collection("cmxCpmTobsEnerRight", monCmxCpTobEnerRight, []( const auto &tob ){return tob.tob->energy();} );
455 variables.push_back(cmxCpmTobsEnerRight);
456
457 auto cmxCpmTobsEnerXLeft = Monitored::Collection("cmxCpmTobsEnerXLeft", monCmxCpTobEnerLeft, []( const auto &tob ){return tob.x;} );
458 variables.push_back(cmxCpmTobsEnerXLeft);
459 auto cmxCpmTobsEnerYLeft = Monitored::Collection("cmxCpmTobsEnerYLeft", monCmxCpTobEnerLeft, []( const auto &tob ){return tob.y;} );
460 variables.push_back(cmxCpmTobsEnerYLeft);
461 auto cmxCpmTobsEnerXRight = Monitored::Collection("cmxCpmTobsEnerXRight", monCmxCpTobEnerRight, []( const auto &tob ){return tob.x;} );
462 variables.push_back(cmxCpmTobsEnerXRight);
463 auto cmxCpmTobsEnerYRight = Monitored::Collection("cmxCpmTobsEnerYRight", monCmxCpTobEnerRight, []( const auto &tob ){return tob.y;} );
464 variables.push_back(cmxCpmTobsEnerYRight);
465
466 // isolation
467 auto cmxCpmTobsIsolLeft = Monitored::Collection("cmxCpmTobsIsolLeft", monCmxCpTobIsolLeft, []( const auto &tob ){return tob.tob->isolation();} );
468 variables.push_back(cmxCpmTobsIsolLeft);
469 auto cmxCpmTobsIsolRight = Monitored::Collection("cmxCpmTobsIsolRight", monCmxCpTobIsolRight, []( const auto &tob ){return tob.tob->isolation();} );
470 variables.push_back(cmxCpmTobsIsolRight);
471
472 auto cmxCpmTobsIsolXLeft = Monitored::Collection("cmxCpmTobsIsolXLeft", monCmxCpTobIsolLeft, []( const auto &tob ){return tob.x;} );
473 variables.push_back(cmxCpmTobsIsolXLeft);
474 auto cmxCpmTobsIsolYLeft = Monitored::Collection("cmxCpmTobsIsolYLeft", monCmxCpTobIsolLeft, []( const auto &tob ){return tob.y;} );
475 variables.push_back(cmxCpmTobsIsolYLeft);
476 auto cmxCpmTobsIsolXRight = Monitored::Collection("cmxCpmTobsIsolXRight", monCmxCpTobIsolRight, []( const auto &tob ){return tob.x;} );
477 variables.push_back(cmxCpmTobsIsolXRight);
478 auto cmxCpmTobsIsolYRight = Monitored::Collection("cmxCpmTobsIsolYRight", monCmxCpTobIsolRight, []( const auto &tob ){return tob.y;} );
479 variables.push_back(cmxCpmTobsIsolYRight);
480
481 // errors
482 auto cmxCpmTobsErrorX = Monitored::Collection("cmxCpmTobsErrorX", monCmxCpTobError, []( const auto &tob ){return tob.x;} );
483 variables.push_back(cmxCpmTobsErrorX);
484 auto cmxCpmTobsErrorCmx = Monitored::Collection("cmxCpmTobsErrorCmx", monCmxCpTobError, []( const auto &tob ){return tob.tob->cmx();} );
485 variables.push_back(cmxCpmTobsErrorCmx);
486 auto cmxCpmTobsErrorYbase = Monitored::Collection("cmxCpmTobsErrorYbase", monCmxCpTobError, []( const auto &tob ){return tob.ybaseError;} );
487 variables.push_back(cmxCpmTobsErrorYbase);
488 // parity error mask
489 auto cmxCpmTobsErrorParity = Monitored::Collection("cmxCpmTobsErrorParity", monCmxCpTobError, []( const auto &tob ){return tob.parityError;} );
490 variables.push_back(cmxCpmTobsErrorParity);
491
492 //
493 //=============================================
494 // CMX-CP Hits
495 //=============================================
496
497 std::vector<MonitorCmxCpHits> monCmxCpHits;
498 std::vector<MonitorCmxCpHits> monCmxCpHitsLeft;
499 std::vector<MonitorCmxCpHits> monCmxCpHitsRight;
500
501 // scalars to fill bitwise histograms directly
502 Monitored::Scalar<int> cmxCpMapX = Monitored::Scalar<int>("cmxCpMapX", 0);
503 Monitored::Scalar<int> cmxCpMapY = Monitored::Scalar<int>("cmxCpMapY", 0);
504 Monitored::Scalar<int> cmxCpMapHit = Monitored::Scalar<int>("cmxCpMapHit", 0);
505 Monitored::Scalar<int> cmxCpCountsX = Monitored::Scalar<int>("cmxCpCountsX", 0);
506 Monitored::Scalar<int> cmxCpCountsY = Monitored::Scalar<int>("cmxCpCountsY", 0);
507 Monitored::Scalar<int> cmxCpCountsHit = Monitored::Scalar<int>("cmxCpCountsHit", 0);
508 //
509 Monitored::Scalar<int> cmxTopoTobsCpmRight = Monitored::Scalar<int>("cmxTopoTobsCpmRight", 0);
510 Monitored::Scalar<int> cmxTopoTobsCpmLeft = Monitored::Scalar<int>("cmxTopoTobsCpmLeft", 0);
511 //
512 Monitored::Scalar<int> cmxCpThresBinLeftX = Monitored::Scalar<int>("cmxCpThresBinLeftX", 0);
513 Monitored::Scalar<int> cmxCpThresBinLeftY = Monitored::Scalar<int>("cmxCpThresBinLeftY", 0);
514 Monitored::Scalar<int> cmxCpThresBinLeftHit = Monitored::Scalar<int>("cmxCpThresBinLeftHit", 0);
515 Monitored::Scalar<int> cmxCpThresBinRightX = Monitored::Scalar<int>("cmxCpThresBinRightX", 0);
516 Monitored::Scalar<int> cmxCpThresBinRightY = Monitored::Scalar<int>("cmxCpThresBinRightY", 0);
517 Monitored::Scalar<int> cmxCpThresBinRightHit = Monitored::Scalar<int>("cmxCpThresBinRightHit", 0);
518
519 cmxCount.assign(m_crates * 2, 0);
520 xAOD::CMXCPHitsContainer::const_iterator cmIterator = (*cmxCpHitsTES).begin();
521 xAOD::CMXCPHitsContainer::const_iterator cmIteratorEnd = (*cmxCpHitsTES).end();
522 for (; cmIterator != cmIteratorEnd; ++cmIterator) {
523 const uint32_t hits0 = (*cmIterator)->hits0();
524 const uint32_t hits1 = (*cmIterator)->hits1();
525 const uint8_t crate = (*cmIterator)->crate();
526 const uint8_t cmx = (*cmIterator)->cmx();
527 const uint8_t source = (*cmIterator)->sourceComponent();
528 const uint8_t slices = ((*cmIterator)->hitsVec0()).size();
529 const uint8_t crateCmx = crate * 2 + cmx;
530
531 //
532 MonitorCmxCpHits monCmxCpHit;
533 monCmxCpHit.hit=(*cmIterator);
534 monCmxCpHit.crateCmx=crateCmx;
535 monCmxCpHit.srcTopoCheckSum=false;
536 monCmxCpHit.crateSlices=crate * m_maxSlices + slices - 1;
537 if (source == xAOD::CMXCPHits::TOPO_CHECKSUM) {
538 monCmxCpHit.srcTopoCheckSum=true;
539 } else if (source == xAOD::CMXCPHits::TOPO_OCCUPANCY_MAP) {
540 if (hits0) {
541 const int nBits = 1;
542 const int offset = 1;
543 const int mask = (1 << nBits) - 1;
544 for (int thr = 0; thr < m_modules; ++thr) {
545 const int hit = (hits0 >> (nBits*thr)) & mask;
546 if (hit) {
547 cmxCpMapX=thr+offset;
548 cmxCpMapY=crateCmx;
549 cmxCpMapHit=hit;
550 fill(m_packageName,cmxCpMapX,cmxCpMapY,cmxCpMapHit);
551 }
552 }
553 }
554 } else if (source == xAOD::CMXCPHits::TOPO_OCCUPANCY_COUNTS) {
555
556 if (hits0) {
557 const int nBits = 3;
558 const int offset = 1;
559 const int mask = (1 << nBits) - 1;
560 for (int thr = 0; thr < (m_modules/2); ++thr) {
561 const int hit = (hits0 >> (nBits*thr)) & mask;
562 if (hit) {
563 cmxCpCountsX=thr+offset;
564 cmxCpCountsY=crateCmx;
565 cmxCpCountsHit=hit;
566 fill(m_packageName,cmxCpCountsX,cmxCpCountsY,cmxCpCountsHit);
567 }
568 }
569 }
570 for (int mod = 0; mod < m_modules / 2; ++mod) {
571 const int val = (hits0 >> (mod * 3)) & 0x7;
572 if (val) {
573 if (cmx) {
574 cmxTopoTobsCpmRight=val;
575 fill(m_packageName,cmxTopoTobsCpmRight);
576 } else {
577 cmxTopoTobsCpmLeft=val;
578 fill(m_packageName,cmxTopoTobsCpmLeft);
579 }
580 }
581 cmxCount[crate * 2 + cmx] += val;
582 } // hits0
583
584 if (hits1) {
585 const int nBits = 3;
586 const int offset = m_modules / 2 + 1;
587 const int mask = (1 << nBits) - 1;
588 for (int thr = 0; thr < (m_modules/2); ++thr) {
589 const int hit = (hits1 >> (nBits*thr)) & mask;
590 if (hit) {
591 cmxCpCountsX=thr+offset;
592 cmxCpCountsY=crateCmx;
593 cmxCpCountsHit=hit;
594 fill(m_packageName,cmxCpCountsX,cmxCpCountsY,cmxCpCountsHit);
595 }
596 }
597 for (int mod = 0; mod < m_modules / 2; ++mod) {
598 const int val = (hits1 >> (mod * 3)) & 0x7;
599 if (val) {
600 if (cmx) {
601 cmxTopoTobsCpmRight=val;
602 fill(m_packageName,cmxTopoTobsCpmRight);
603 } else {
604 cmxTopoTobsCpmLeft=val;
605 fill(m_packageName,cmxTopoTobsCpmLeft);
606 }
607 }
608 cmxCount[crate * 2 + cmx] += val;
609 }
610 } // hits1
611 } else {
612 int bin = 0;
613 if (source == xAOD::CMXCPHits::LOCAL) bin = crate;
614 else if (source == xAOD::CMXCPHits::REMOTE_0) bin = m_crates;
615 else if (source == xAOD::CMXCPHits::REMOTE_1) bin = m_crates + 1;
616 else if (source == xAOD::CMXCPHits::REMOTE_2) bin = m_crates + 2;
617 else if (source == xAOD::CMXCPHits::TOTAL) bin = m_crates + 3;
618 const int nThresh = m_thresholds / 2;
619 if (hits0) {
620 const int nBits = m_threshBits;
621 const int offset = 0;
622 const int mask = (1 << nBits) - 1;
623
624 for (int thr = 0; thr < nThresh; ++thr) {
625 const int hit = (hits0 >> (nBits*thr)) & mask;
626 if (hit) {
627 if (cmx) {
628 cmxCpThresBinRightX=bin;
629 cmxCpThresBinRightY=thr+offset;
630 cmxCpThresBinRightHit=hit;
631 fill(m_packageName,cmxCpThresBinRightX,cmxCpThresBinRightY,cmxCpThresBinRightHit);
632 } else {
633 cmxCpThresBinLeftX=bin;
634 cmxCpThresBinLeftY=thr+offset;
635 cmxCpThresBinLeftHit=hit;
636 fill(m_packageName,cmxCpThresBinLeftX,cmxCpThresBinLeftY,cmxCpThresBinLeftHit);
637 }
638 }
639 }
640 } // hits0
641
642 if (hits1) {
643 //
644 const int nBits = 3;
645 const int offset = nThresh;
646 const int mask = (1 << nBits) - 1;
647 for (int thr = 0; thr < nThresh; ++thr) {
648 const int hit = (hits1 >> (nBits*thr)) & mask;
649 if (hit) {
650 if (cmx) {
651 cmxCpThresBinRightX=bin;
652 cmxCpThresBinRightY=thr+offset;
653 cmxCpThresBinRightHit=hit;
654 fill(m_packageName,cmxCpThresBinRightX,cmxCpThresBinRightY,cmxCpThresBinRightHit);
655 } else {
656 cmxCpThresBinLeftX=bin;
657 cmxCpThresBinLeftY=thr+offset;
658 cmxCpThresBinLeftHit=hit;
659 fill(m_packageName,cmxCpThresBinLeftX,cmxCpThresBinLeftY,cmxCpThresBinLeftHit);
660 }
661 }
662 }
663 } // hits1
664
665 }
666
667 monCmxCpHits.push_back(monCmxCpHit);
668 if (cmx)
669 monCmxCpHitsRight.push_back(monCmxCpHit);
670 else
671 monCmxCpHitsLeft.push_back(monCmxCpHit);
672
673 } //CmxCpHitsCollection iterator
674 //
675 auto cmxCpmHitsPeak = Monitored::Collection("cmxCpHitsPeak", monCmxCpHits, []( const auto &hit ){return hit.hit->peak();} );
676 variables.push_back(cmxCpmHitsPeak);
677 auto cmxCpmHitsCrateSlices = Monitored::Collection("cmxCpHitsCrateSlices", monCmxCpHits, []( const auto &hit ){return hit.crateSlices;} );
678 variables.push_back(cmxCpmHitsCrateSlices);
679 auto cmxCpmHitsCrateCmx = Monitored::Collection("cmxCpHitsCrateCmx", monCmxCpHits, []( const auto &hit ){return hit.crateCmx;} );
680 variables.push_back(cmxCpmHitsCrateCmx);
681 // for masks
682 auto cmxCpmHitsHits0 = Monitored::Collection("cmxCpHitsHits0", monCmxCpHits, []( const auto &hit ){return hit.hit->hits0();} );
683 variables.push_back(cmxCpmHitsHits0);
684 auto cmxCpmHitsHits1 = Monitored::Collection("cmxCpHitsHits1", monCmxCpHits, []( const auto &hit ){return hit.hit->hits1();} );
685 variables.push_back(cmxCpmHitsHits1);
686 // mask for checksum plus hits0
687 auto cmxCpmHits0TopoCheckSum = Monitored::Collection("cmxCpHits0TopoCheckSum", monCmxCpHits, []( const auto &hit ){return (hit.hit->hits0() && hit.srcTopoCheckSum);} );
688 variables.push_back(cmxCpmHits0TopoCheckSum);
689
690 // CMX-CP Topo Tobs
691 Monitored::Scalar<int> cmxCpTopoTobsCmxLeft = Monitored::Scalar<int>("cmxCpTopoTobsCmxLeft", 0);
692 Monitored::Scalar<int> cmxCpTopoTobsCmxRight = Monitored::Scalar<int>("cmxCpTopoTobsCmxRight", 0);
693 for (int crate = 0; crate < m_crates; ++crate) {
694 for (int cmx = 0; cmx < 2; ++cmx) {
695 int val = cmxCount[crate * 2 + cmx];
696 if (val) {
697 if (val >= m_maxTobsPerCmx) val = m_maxTobsPerCmx - 1;
698 if (cmx == 0) {
699 cmxCpTopoTobsCmxLeft=val;
700 fill(m_packageName,cmxCpTopoTobsCmxLeft);
701 } else {
702 cmxCpTopoTobsCmxRight=val;
703 fill(m_packageName,cmxCpTopoTobsCmxRight);
704 }
705 }
706 }
707 }
708
709 // Update error summary plot
710 Monitored::Scalar<int> cpmErrorX = Monitored::Scalar<int>("cpmErrorX", 0);
711 Monitored::Scalar<int> cpmErrorY = Monitored::Scalar<int>("cpmErrorY", 0);
712 Monitored::Scalar<int> cpmErrorSummary = Monitored::Scalar<int>("cpmErrorSummary", 0);
713 Monitored::Scalar<int> cpmErrorSummary_Events = Monitored::Scalar<int>("cpmErrorSummary_Events", 0);
714 std::vector<int> crateErr(4);
715 for (int err = 0; err < NumberOfSummaryBins; ++err) {
716 int error = 0;
717 for (int loc = 0; loc < m_crates * m_modules; ++loc) {
718 if ((errorsCPM[loc] >> err) & 0x1) {
719 cpmErrorX=loc;
720 cpmErrorY=err;
721 fill(m_packageName,cpmErrorX,cpmErrorY);
722 error = 1;
723 crateErr[loc / m_modules] |= (1 << err);
724 }
725 if (loc < m_crates * 2) {
726 if ((errorsCMX[loc] >> err) & 0x1) {
727 cpmErrorX=loc+(m_crates*m_modules);
728 cpmErrorY=err;
729 fill(m_packageName,cpmErrorX,cpmErrorY);
730 error = 1;
731 crateErr[loc / 2] |= (1 << err);
732 }
733 }
734 }
735 if (error) {
736 cpmErrorSummary=err;
737 fill(m_packageName,cpmErrorSummary);
738 // event numbers
739 cpmErrorSummary_Events=err;
740 auto evtstr = Monitored::Scalar<std::string>("evtstr", std::to_string(ctx.eventID().event_number()));
741 fill(m_packageName,evtstr,cpmErrorSummary_Events);
742 }
743 } // NSummaryBins
744
745
746 // Save error vector for global summary
747
748 auto save = std::make_unique<std::vector<int>>(crateErr);
749 auto* result = SG::makeHandle(m_errorLocation, ctx).put(std::move(save));
750 if (!result) {
751 ATH_MSG_ERROR("Error recording CPM error vector in TES");
752 return StatusCode::FAILURE;
753 }
754
755 fill(m_packageName,variables);
756 variables.clear();
757 return StatusCode::SUCCESS;
758}
759
760
761std::vector<bool> CpmMonitorAlgorithm::getIsolationBits(int val, int nThresh, int nBits) const
762{
763 // return vector of threshold bits
764 //
765 std::vector<bool> nthres(nThresh, false);
766
767 if (val) {
768 const int mask = (1 << nBits) - 1;
769 for (int thr = 0; thr < nThresh; ++thr) {
770 const int hit = (val >> (nBits*thr)) & mask;
771 nthres[thr] = bool(hit);
772 }
773 } else {
774 ATH_MSG_WARNING("getIsolationBits: no input word supplied" );
775 }
776 return nthres;
777
778}
779
780StatusCode CpmMonitorAlgorithm::fillCpmTowerVectors(SG::ReadHandle<xAOD::CPMTowerContainer> &cpmTower,
781 std::vector<MonitorCpmTT> &monCpmTTs_em, std::vector<MonitorCpmTT> &monCpmTTs_had,
782 std::vector<int> &errorsCPM,
783 bool core,
784 Monitored::Scalar<int> &cpmLoc,
785 Monitored::Scalar<int> &GLinkParityError
786 ) const
787{
788 //
789 xAOD::CPMTowerContainer::const_iterator ctIterator = (*cpmTower).begin();
790 xAOD::CPMTowerContainer::const_iterator ctIteratorEnd = (*cpmTower).end();
791 for (; ctIterator != ctIteratorEnd; ++ctIterator) {
792 const xAOD::CPMTower* ct = *ctIterator;
793 const uint8_t em = ct->emEnergy();
794 const uint8_t had = ct->hadEnergy();
795 const double eta = ct->eta();
796 const double phi = ct->phi();
797 const LVL1::Coordinate coord(phi, eta);
798 LVL1::CoordToHardware converter;
799 const int crate = (core) ? converter.cpCrate(coord)
800 : converter.cpCrateOverlap(coord);
801 const int cpm = (core) ? converter.cpModule(coord)
802 : converter.cpModuleOverlap(coord);
803 const unsigned int loc = crate * m_modules + cpm - 1;
804 const int slices = (ct->emEnergyVec()).size();
805 const int slice = crate * m_maxSlices + slices - 1;
806 if (loc >= errorsCPM.size()) {
807 ATH_MSG_ERROR("Crate/module index out of range: " << loc << " >= "
808 << errorsCPM.size() << " crate " << crate
809 << " core " << core
810 << " eta " << eta << " phi " << phi <<
811 " cpm " << cpm << " slices " << slices <<
812 " max slices " << m_maxSlices << " m_modules " << m_modules <<
813 " slice " << slice);
814 }
815
816 // Errors
817 bool emParityError=false;
818 bool emLinkDownError=false;
819 uint32_t error = ct->emError();
820 if (error && loc < errorsCPM.size()) {
821 const LVL1::DataError emError(error);
822 if (emError.get(LVL1::DataError::Parity)) {
823 emParityError=true;
824 errorsCPM[loc] |= (1 << EMParity);
825 }
826 if (emError.get(LVL1::DataError::LinkDown)) {
827 emLinkDownError=true;
828 errorsCPM[loc] |= (1 << EMLink);
829 }
830 const int status = (error >> LVL1::DataError::GLinkParity) & 0xff;
831 if (status) {
832 cpmLoc=loc;
833 for (int bit = 0; bit < 8; ++bit) {
834 if ((status >> bit) & 0x1) {
835 GLinkParityError=bit;
836 fill(m_packageName, GLinkParityError, cpmLoc);
837 }
838 }
839 errorsCPM[loc] |= (1 << CPMStatus);
840 }
841 }
842
843 bool hadParityError=false;
844 bool hadLinkDownError=false;
845 error = ct->hadError();
846 if (error && loc < errorsCPM.size()) {
847 const LVL1::DataError hadError(error);
848 if (hadError.get(LVL1::DataError::Parity)) {
849 hadParityError=true;
850 errorsCPM[loc] |= (1 << HadParity);
851 }
852 if (hadError.get(LVL1::DataError::LinkDown)) {
853 hadLinkDownError=true;
854 errorsCPM[loc] |= (1 << HadLink);
855 }
856 }
857 // fill tower vector for plots
858 MonitorCpmTT monTT;
859 monTT.ttower=ct;
860 monTT.phi_scaled=ct->phi()*m_phiScaleTT;
861 monTT.slice=slice;
862 monTT.emParityError=emParityError;
863 monTT.emLinkDownError=emLinkDownError;
864 monTT.hadParityError=hadParityError;
865 monTT.hadLinkDownError=hadLinkDownError;
866 if (em) {
867 monCpmTTs_em.push_back(monTT);
868 }
869 if (had) {
870 monCpmTTs_had.push_back(monTT);
871 }
872
873 } // iterator
874
875
876 return StatusCode::SUCCESS;
877}
878
879
M_PI
#define M_PI
Definition ActiveFraction.h:11
eta
Scalar eta() const
pseudorapidity method
Definition AmgMatrixBasePlugin.h:83
phi
Scalar phi() const
phi method
Definition AmgMatrixBasePlugin.h:67
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
coord
double coord
Type of coordination system.
Definition JetVoronoiDiagramHelpers.h:45
y
#define y
x
#define x
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition AthMonitorAlgorithm.cxx:22
AthMonitorAlgorithm::AthMonitorAlgorithm
AthMonitorAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition AthMonitorAlgorithm.cxx:8
CpmMonitorAlgorithm::fillCpmTowerVectors
StatusCode fillCpmTowerVectors(SG::ReadHandle< xAOD::CPMTowerContainer > &cpmTower, std::vector< MonitorCpmTT > &monCpmTTs_em, std::vector< MonitorCpmTT > &monCpmTTs_had, std::vector< int > &errorsCPM, bool core, Monitored::Scalar< int > &cpmLoc, Monitored::Scalar< int > &GLinkParityError) const
Definition CpmMonitorAlgorithm.cxx:780
CpmMonitorAlgorithm::m_cpmTowerLocationOverlap
SG::ReadHandleKey< xAOD::CPMTowerContainer > m_cpmTowerLocationOverlap
Definition CpmMonitorAlgorithm.h:99
CpmMonitorAlgorithm::m_maxSlices
Gaudi::Property< int > m_maxSlices
Definition CpmMonitorAlgorithm.h:81
CpmMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition CpmMonitorAlgorithm.cxx:16
CpmMonitorAlgorithm::m_modules
Gaudi::Property< int > m_modules
Definition CpmMonitorAlgorithm.h:80
CpmMonitorAlgorithm::m_errorLocation
SG::WriteHandleKey< std::vector< int > > m_errorLocation
Definition CpmMonitorAlgorithm.h:89
CpmMonitorAlgorithm::m_threshBits
Gaudi::Property< int > m_threshBits
Definition CpmMonitorAlgorithm.h:84
CpmMonitorAlgorithm::m_crates
Gaudi::Property< int > m_crates
Definition CpmMonitorAlgorithm.h:79
CpmMonitorAlgorithm::m_cmxCpHitsLocation
SG::ReadHandleKey< xAOD::CMXCPHitsContainer > m_cmxCpHitsLocation
Definition CpmMonitorAlgorithm.h:102
CpmMonitorAlgorithm::m_cmxCpTobLocation
SG::ReadHandleKey< xAOD::CMXCPTobContainer > m_cmxCpTobLocation
Definition CpmMonitorAlgorithm.h:101
CpmMonitorAlgorithm::CpmMonitorAlgorithm
CpmMonitorAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Definition CpmMonitorAlgorithm.cxx:10
CpmMonitorAlgorithm::m_packageName
StringProperty m_packageName
Definition CpmMonitorAlgorithm.h:77
CpmMonitorAlgorithm::m_xAODTriggerTowerContainerName
SG::ReadHandleKey< xAOD::TriggerTowerContainer > m_xAODTriggerTowerContainerName
Definition CpmMonitorAlgorithm.h:97
CpmMonitorAlgorithm::m_maxTobsPerCmx
Gaudi::Property< int > m_maxTobsPerCmx
Definition CpmMonitorAlgorithm.h:86
CpmMonitorAlgorithm::m_thresholds
Gaudi::Property< int > m_thresholds
Definition CpmMonitorAlgorithm.h:85
CpmMonitorAlgorithm::getIsolationBits
std::vector< bool > getIsolationBits(int val, int nThresh, int nBits) const
Definition CpmMonitorAlgorithm.cxx:761
CpmMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const override
adds event to the monitoring histograms
Definition CpmMonitorAlgorithm.cxx:46
CpmMonitorAlgorithm::m_tobsPerCPM
Gaudi::Property< int > m_tobsPerCPM
Definition CpmMonitorAlgorithm.h:82
CpmMonitorAlgorithm::m_cpmTobRoiLocation
SG::ReadHandleKey< xAOD::CPMTobRoIContainer > m_cpmTobRoiLocation
Definition CpmMonitorAlgorithm.h:100
CpmMonitorAlgorithm::m_cpmTowerLocation
SG::ReadHandleKey< xAOD::CPMTowerContainer > m_cpmTowerLocation
Definition CpmMonitorAlgorithm.h:98
CpmMonitorAlgorithm::m_isolBits
Gaudi::Property< int > m_isolBits
Definition CpmMonitorAlgorithm.h:83
DataVector< xAOD::TriggerTower_v2 >::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:838
LVL1::CPRoIDecoder
A level 1 calorimeter trigger conversion service: returns the Coordinate represented by a RoI word.
Definition CPRoIDecoder.h:32
LVL1::CoordToHardware
returns the trigger hardware components associated with a given Coordinate
Definition CoordToHardware.h:37
LVL1::CoordToHardware::cpModuleOverlap
unsigned int cpModuleOverlap(const Coordinate &coord)
return ID of CP module for overlap coord
Definition CoordToHardware.cxx:213
LVL1::CoordToHardware::cpModule
unsigned int cpModule(const Coordinate &coord)
return ID of CP module.
Definition CoordToHardware.cxx:52
LVL1::CoordToHardware::cpCrateOverlap
unsigned int cpCrateOverlap(const Coordinate &coord)
returns crate ID covering that overlap coord.
Definition CoordToHardware.cxx:205
LVL1::CoordToHardware::cpCrate
unsigned int cpCrate(const Coordinate &coord)
returns crate ID covering that coord.
Definition CoordToHardware.cxx:39
LVL1::CoordinateRange
CoordinateRange class declaration.
Definition CoordinateRange.h:31
LVL1::DataError
Error data.
Definition DataError.h:27
LVL1::DataError::get
int get(ErrorBit bit) const
Return an error bit or data.
Definition DataError.cxx:48
Monitored::Scalar
Declare a monitored scalar variable.
Definition MonitoredScalar.h:34
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
xAOD::CMXCPHits_v1::TOPO_OCCUPANCY_MAP
@ TOPO_OCCUPANCY_MAP
Definition CMXCPHits_v1.h:30
xAOD::CMXCPHits_v1::REMOTE_1
@ REMOTE_1
Definition CMXCPHits_v1.h:29
xAOD::CMXCPHits_v1::TOTAL
@ TOTAL
Definition CMXCPHits_v1.h:29
xAOD::CMXCPHits_v1::TOPO_OCCUPANCY_COUNTS
@ TOPO_OCCUPANCY_COUNTS
Definition CMXCPHits_v1.h:30
xAOD::CMXCPHits_v1::LOCAL
@ LOCAL
Definition CMXCPHits_v1.h:29
xAOD::CMXCPHits_v1::REMOTE_0
@ REMOTE_0
Definition CMXCPHits_v1.h:29
xAOD::CMXCPHits_v1::REMOTE_2
@ REMOTE_2
Definition CMXCPHits_v1.h:29
xAOD::CMXCPHits_v1::TOPO_CHECKSUM
@ TOPO_CHECKSUM
Definition CMXCPHits_v1.h:30
xAOD::TriggerTower_v2
Description of TriggerTower_v2.
Definition TriggerTower_v2.h:49
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition MonitoredCollection.h:38
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition ReadCondHandle.h:270
xAOD::CPMTower
CPMTower_v2 CPMTower
Define the latest version of the CPMTower class.
Definition Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/CPMTower.h:16
type
GeneratePersELinkType_p1::type
ElementLink_p1< typename GenerateELinkIndexType_p1< typename LINK::index_type >::type > type
Definition ElementLink_p1.h:82
result
fill
void fill(H5::Group &out_file, size_t iterations)
Definition test-half-precision.cxx:64
Generated on for ATLAS Offline Software by doxygen 1.14.0