ATLAS Offline Software
LArCablingChecker.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 #include "LArRawEvent/LArDigit.h"
10 #include <algorithm>
11 #include <sstream>
12 #include <iomanip>
13 
14 LArCablingChecker::LArCablingChecker(const std::string& name, ISvcLocator* pSvcLocator)
15  : AthAlgorithm(name, pSvcLocator),
16  //m_chan(0),
17  m_onlineHelper(0),
18  m_emId(0),
19  m_errorcellsThisEvent(0),
20  m_errorCounterThisEvent(0),
21  m_errorcellsPreviousEvent(0),
22  m_errorCounterPreviousEvent(0),
23  m_numberOfEventsWithThisErrorState(0),
24  m_channelHashMax(0)
25 {
26  m_count = 0;
27  declareProperty("DigitKey", m_key = "");
28  declareProperty("FileName", m_outFileName = "CablingSummary.txt");
29  //declareProperty("Pattern", m_vPattern);
30  declareProperty("ADCThreshold", m_ADCThreshold = 1250);
31  declareProperty("DACHighGainThreshold", m_DACHighGainThreshold = 100);
32  declareProperty("DACMediumGainThreshold", m_DACMediumGainThreshold = 1000);
33  declareProperty("DACLowGainThreshold", m_DACLowGainThreshold = 10000);
34  declareProperty("PrintAllCellsAndEvents", m_PrintAllCellsAndEvents = false);
35  declareProperty("PrintDisconnectedCells", m_PrintDisconnectedCells = true);
36  declareProperty("PrintEventSummary", m_printEventSummary = false);
37  declareProperty("UseBadChannelTool", m_useBadChannelTool = true);
38 }
39 
41  //empty
42 }
43 
45  ATH_CHECK( detStore()->retrieve(m_onlineHelper, "LArOnlineID") );
48 
49  if (m_useBadChannelTool) {
50  ATH_CHECK( m_BCKey.initialize() );
51  }
52 
53  m_outfile.open(m_outFileName.c_str(), std::ios::out);
54  if (!m_outfile.is_open()) {
55  ATH_MSG_ERROR ( "Unable to open output file with name " << m_outFileName );
56  return StatusCode::FAILURE;
57  }
58 
59  const CaloCell_ID* idHelper = nullptr;
60  ATH_CHECK( detStore()->retrieve (idHelper, "CaloCell_ID") );
61  m_emId=idHelper->em_idHelper();
62 
64 
67  // Phony "previous" event so that the first event has something to compare to.
68  m_errorcellsThisEvent = new std::vector<bool>(m_channelHashMax);
71 
72  ATH_MSG_DEBUG ( "======== LArCablingChecker initialize successfully ========" );
73  return StatusCode::SUCCESS;
74 }
75 
77  const EventContext& ctx = Gaudi::Hive::currentContext();
78  unsigned eventNb = ctx.eventID().event_number();
79 
80  ATH_MSG_INFO ( "======== executing event "<< eventNb << " ========" );
81  //m_outfile << "Checking Event " << eventNb << "..." << std::endl;
82 
83  //log << MSG::INFO << "Retrieving LArDigitContainer. Key= " << m_key << std::endl;
84  const LArDigitContainer* larDigitCont = nullptr;
85  ATH_CHECK( evtStore()->retrieve(larDigitCont, m_key) );
86 
87  //const LArCalibParams* calibParams;
88  const LArCalibParams* calibParams = nullptr;
89  ATH_CHECK( detStore()->retrieve(calibParams,"LArCalibParams") );
90 
92  const LArBadChannelCont *bcCont {*readHandle};
93  if(!bcCont) {
94  ATH_MSG_ERROR( "Do not have Bad chan container " << m_BCKey.key() );
95  return StatusCode::FAILURE;
96  }
97 
99  const LArOnOffIdMapping* cabling=*cablingHdl;
100  if(!cabling) {
101  ATH_MSG_ERROR( "Do not have cabling object LArOnOffIdMapping" );
102  return StatusCode::FAILURE;
103  }
104 
106  const LArCalibLineMapping *clCont {*clHdl};
107  if(!clCont) {
108  ATH_MSG_ERROR( "Do not have calib line mapping !!!" );
109  return StatusCode::FAILURE;
110  }
111 
112 
113  // Using vectors like this works because the hashes seem to be guaranteed to be collision-free.
114  delete m_errorcellsPreviousEvent; // OK to delete 0, Stroustrup 6.2.6
116  m_errorcellsThisEvent = new std::vector<bool>(m_channelHashMax); // All elements initialized to false, Stroustrup 16.3.4
117 
120 
121  int cellsCounter = 0;
122 
123  int inconsistencyCounter = 0;
124  int disconnectedCounter = 0;
125  int badChannelCounter = 0;
126 
127  bool signalPresent;
128  bool pulsed;
129  bool badChannel;
130  bool disconnected;
131 
132  // Put errors in ErrorList, to print if needed.
133  std::ostringstream ErrorList;
134 
135  // Loop on all cells (digits).
136  for (const LArDigit* digit : *larDigitCont) {
137  cellsCounter++;
138 
139  ErrorList.clear();
140 
141  // Get FEB info.
142  const HWIdentifier online_id = digit->hardwareID();
143  const HWIdentifier febid = m_onlineHelper->feb_Id(online_id);
144 
145  int chNb = m_onlineHelper->channel(online_id);
146 
147  // Check if channel is connected.
148  if (!cabling->isOnlineConnected(online_id)) {
149  disconnected = true;
150  disconnectedCounter++;
151  } else
152  disconnected = false;
153 
154  Identifier offline_id;
155 
156  // Get offline id.
157  bool noOffline_id = false;
158  try {
159  offline_id = cabling->cnvToIdentifier(online_id);
160  }
161  catch (const LArID_Exception&) {
162  noOffline_id = true;
163  }
164 
165  // Find out if signal over theshold is present.
166  // Set signalPresent.
167  const int max = *max_element(digit->samples().begin(), digit->samples().end());
168  if (max >= m_ADCThreshold)
169  signalPresent = true;
170  else
171  signalPresent = false;
172 
173  // Loop on calibchannels to see which, if any, that pulsed the cell.
174  // Set pulsed and DACvalue, and fill PulserList.
175  pulsed = false;
176  int DACvalue = -1;
177  std::ostringstream PulserList;
178  const std::vector<HWIdentifier>& calibChannelIDs=clCont->calibSlotLine(online_id);
179 
180  for (HWIdentifier hwid : calibChannelIDs) {
181  //m_outfile << hwid.get_compact() << " ";
182  bool isPulsed=calibParams->isPulsed(eventNb, hwid);
183  if (isPulsed) {
184  int DACvalue_temp = calibParams->DAC(eventNb, hwid);
185  if (DACvalue_temp > DACvalue)
186  DACvalue = DACvalue_temp;
187  pulsed = true;
188  const int slot = m_onlineHelper->slot(hwid);
189  const int line = m_onlineHelper->channel(hwid);
190  PulserList << std::hex << hwid.get_compact() << std::dec << " " << slot << " " << line << " ";
191  }
192  }
193  //m_outfile << std::endl;
194 
195  CaloGain::CaloGain gain = digit->gain();
196  bool DACOverThreshold;
197  switch (gain) {
198  case CaloGain::LARLOWGAIN :
199  DACOverThreshold = DACvalue >= m_DACLowGainThreshold;
200  break;
202  DACOverThreshold = DACvalue >= m_DACMediumGainThreshold;
203  break;
204  case CaloGain::LARHIGHGAIN :
205  DACOverThreshold = DACvalue >= m_DACHighGainThreshold;
206  break;
207  default:
208  DACOverThreshold = DACvalue >= m_DACHighGainThreshold;
209  }
210 
211  // Find out if we have a bad cell.
212  if (m_useBadChannelTool && !noOffline_id) {
213  if (bcCont->offlineStatus(offline_id).good()) {
214  badChannel = false;
215  } else {
216  badChannel = true;
217  badChannelCounter++;
218  }
219  } else {
220  badChannel = false;
221  }
222 
223  // Analyze and report.
224 
225  bool inconsistency = (signalPresent != pulsed) && DACOverThreshold;
226  if (inconsistency)
227  inconsistencyCounter++;
228 
229  bool errorInCell = inconsistency || badChannel;
230  if (errorInCell)
232 
233  std::ostringstream CellData;
234  CellData << "0x" << std::hex << std::setw(8) << febid.get_compact() << std::dec
235  << std::setw(5) << m_onlineHelper->feedthrough(febid)
236  << std::setw(5) << m_onlineHelper->slot(febid)
237  << std::setw(5) << chNb;
238 
239  CellData << std::setw(5);
240  if (noOffline_id)
241  CellData << "-";
242  else
243  CellData << m_emId->sampling(offline_id);
244 
245  CellData << std::setw(5);
246  if (noOffline_id)
247  CellData << "-";
248  else
249  CellData << m_emId->eta(offline_id);
250 
251  CellData << std::setw(5);
252  if (noOffline_id)
253  CellData << "-";
254  else
255  CellData << m_emId->phi(offline_id);
256 
257  CellData << std::setw(7) << max;
258  if (DACvalue >= 0) // Above have set DACvalue=-1 if got no DAC value.
259  CellData << std::setw(7) << DACvalue;
260  else
261  CellData << std::setw(7) << "-";
262 
263  if (disconnected) {
265  ErrorList << " D ";
266  ErrorList << CellData.str() << std::endl;
267  }
268  }
269  else {
270  // Set relevant bit in m_errorcellsThisEvent if error in this cell.
271  if (errorInCell)
272  (*m_errorcellsThisEvent)[m_onlineHelper->channel_Hash(online_id)] = true;
273 
274  if (errorInCell || m_PrintAllCellsAndEvents) {
275  if (inconsistency)
276  ErrorList << "I";
277  else
278  ErrorList << " ";
279  if (pulsed)
280  ErrorList << "P";
281  else
282  ErrorList << " ";
283  if (signalPresent)
284  ErrorList << "S";
285  else
286  ErrorList << " ";
287  if (badChannel)
288  ErrorList << "B ";
289  else
290  ErrorList << " ";
291 
292  ErrorList << CellData.str();
293 
294  if (pulsed)
295  ErrorList << " " << PulserList.str();
296 
297  ErrorList << std::endl;
298  }
299  }
300  } //End looping on all cells
301 
302  ErrorList << std::endl;
303 
304  if (m_printEventSummary) {
305  ErrorList << "Examined " << cellsCounter << " cells in event " << eventNb << ". Found:" << std::endl;
306  ErrorList << std::left << std::setw(25) << "Inconsistencies: "
307  << std::right << std::setw(4) << inconsistencyCounter << std::endl;
308  ErrorList << std::left << std::setw(25) << "Bad cells: "
309  << std::right << std::setw(4) << badChannelCounter << std::endl;
310  ErrorList << std::left << std::setw(25) << "Sum errors: "
311  << std::right << std::setw(4) << m_errorCounterThisEvent << std::endl;
312  ErrorList << std::left << std::setw(25) << "Disconnected cells: "
313  << std::right << std::setw(4) << disconnectedCounter << std::endl;
314  ErrorList << std::endl;
315  }
316 
318  // Compare m_errorcellsThisEvent to m_errorcellsPreviousEvent
319  if (*m_errorcellsThisEvent == *m_errorcellsPreviousEvent) { // Pray to God this is optimized.
320  // Same status as previous event, increase counter and go to next event.
322  }
323  else {
324  // A new status for this event. Print number of repeats for the previous one and print new state, if an error.
326  m_outfile << "Last error occurred in "
327  << m_numberOfEventsWithThisErrorState << " events." << std::endl << std::endl;
328 
329  if (m_errorCounterThisEvent != 0) {
330  m_outfile << "Error in event "<< std::setw(7) << eventNb
331  << " ==========================================================================" << std::endl;
332  m_outfile << "I=Inconsistency P=Pulsed S=Signal B=Bad D=Disconnected" << std::endl;
333  m_outfile << " "
334  << std::left << std::setw(10) << "FEB"
335  << std::right << std::setw(5) << "FT"
336  << std::setw(5) << "SL"
337  << std::setw(5) << "CH"
338  << std::setw(5) << "Smpl"
339  << std::setw(5) << "Eta"
340  << std::setw(5) << "Phi"
341  << std::setw(7) << "ADC"
342  << std::setw(7) << "DAC"
343  << " Pulsed by calibchannel slot line"
344  << std::endl;
345 
346  m_outfile << ErrorList.str();
347  }
348 
350  }
351  }
352  else { // m_PrintAllCellsAndEvents==true
353  m_outfile << "Status of event "<< std::setw(7) << eventNb
354  << " ==========================================================================" << std::endl;
355  m_outfile << "I=Inconsistency P=Pulsed S=Signal B=Bad D=Disconnected" << std::endl;
356  m_outfile << " "
357  << std::left << std::setw(10) << "FEB"
358  << std::right << std::setw(5) << "FT"
359  << std::setw(5) << "SL"
360  << std::setw(5) << "CH"
361  << std::setw(5) << "Smpl"
362  << std::setw(5) << "Eta"
363  << std::setw(5) << "Phi"
364  << std::setw(7) << "ADC"
365  << std::setw(7) << "DAC"
366  << " Pulsed by slot line"
367  << std::endl;
368 
369  m_outfile << ErrorList.str();
370  }
371 
372  return StatusCode::SUCCESS;
373 }
374 
377  m_outfile << "Last error occurred in " << m_numberOfEventsWithThisErrorState << " events." << std::endl << std::endl;
378 
379  m_outfile.close();
380 
381  delete m_errorcellsThisEvent;
383 
384  return StatusCode::SUCCESS;
385 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
LArCablingChecker::m_emId
const LArEM_ID * m_emId
Definition: LArCablingChecker.h:40
LArEM_Base_ID::phi
int phi(const Identifier id) const
return phi according to :
checkFileSG.line
line
Definition: checkFileSG.py:75
LArOnlineID_Base::channel_Hash
IdentifierHash channel_Hash(HWIdentifier channelId) const
Create channel_hash from channel_Id.
Definition: LArOnlineID_Base.cxx:1632
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CaloCell_ID::em_idHelper
const LArEM_ID * em_idHelper() const
access to EM idHelper
Definition: CaloCell_ID.h:63
LArCablingChecker::execute
StatusCode execute()
Definition: LArCablingChecker.cxx:76
LArCablingChecker::m_count
int m_count
Definition: LArCablingChecker.h:33
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
LArBadXCont
Conditions-Data class holding LAr Bad Channel or Bad Feb information.
Definition: LArBadChannelCont.h:28
LArCalibLineMapping
Definition: LArCalibLineMapping.h:17
LArCablingChecker::m_CLKey
SG::ReadCondHandleKey< LArCalibLineMapping > m_CLKey
Definition: LArCablingChecker.h:37
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
LArCalibParams
Definition: LArCalibParams.h:28
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
LArOnlineID_Base::slot
int slot(const HWIdentifier id) const
Return the slot number of a hardware cell identifier: slot = [1,15] Slot-ID in top part of the crat...
Definition: LArOnlineID_Base.cxx:1957
Identifier::get_compact
value_type get_compact() const
Get the compact id.
LArEM_Base_ID::sampling
int sampling(const Identifier id) const
return sampling according to :
checkRpcDigits.digit
digit
Definition: checkRpcDigits.py:186
HWIdentifier
Definition: HWIdentifier.h:13
LArCablingChecker::initialize
StatusCode initialize()
Definition: LArCablingChecker.cxx:44
LArEM_Base_ID::eta
int eta(const Identifier id) const
return eta according to :
LArCablingChecker::m_PrintAllCellsAndEvents
bool m_PrintAllCellsAndEvents
Definition: LArCablingChecker.h:55
CaloCell_ID.h
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
LArCablingChecker::m_DACMediumGainThreshold
int m_DACMediumGainThreshold
Definition: LArCablingChecker.h:59
LArCablingChecker::m_numberOfEventsWithThisErrorState
int m_numberOfEventsWithThisErrorState
Definition: LArCablingChecker.h:51
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
LArOnlineID_Base::channel
int channel(const HWIdentifier id) const
Return the channel number of a hardware cell identifier channel = [0,127] in all FEB.
Definition: LArOnlineID_Base.cxx:1963
LArCablingChecker::LArCablingChecker
LArCablingChecker(const std::string &name, ISvcLocator *pSvcLocator)
Definition: LArCablingChecker.cxx:14
LArCablingChecker::m_onlineHelper
const LArOnlineID * m_onlineHelper
Definition: LArCablingChecker.h:39
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
LArDigit.h
LArCablingChecker::m_BCKey
SG::ReadCondHandleKey< LArBadChannelCont > m_BCKey
Definition: LArCablingChecker.h:36
LArCablingChecker::m_outFileName
std::string m_outFileName
Definition: LArCablingChecker.h:44
LArDigit
Liquid Argon digit base class.
Definition: LArDigit.h:25
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LArCablingChecker::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: LArCablingChecker.h:35
LArCalibParams::isPulsed
bool isPulsed(const unsigned event, const HWIdentifier calibLineID) const
Definition: LArCalibParams.cxx:151
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CaloCell_ID
Helper class for offline cell identifiers.
Definition: CaloCell_ID.h:34
LArCablingChecker::m_PrintDisconnectedCells
bool m_PrintDisconnectedCells
Definition: LArCablingChecker.h:56
LArCablingChecker::m_outfile
std::ofstream m_outfile
Definition: LArCablingChecker.h:42
LArCablingChecker::m_errorcellsThisEvent
std::vector< bool > * m_errorcellsThisEvent
Definition: LArCablingChecker.h:47
AthAlgorithm
Definition: AthAlgorithm.h:47
LArOnlineID_Base::feb_Id
HWIdentifier feb_Id(int barrel_ec, int pos_neg, int feedthrough, int slot) const
Create feb_Id from fields.
Definition: LArOnlineID_Base.cxx:1479
LArCablingChecker::m_key
std::string m_key
Definition: LArCablingChecker.h:43
LArCablingChecker::m_errorCounterThisEvent
int m_errorCounterThisEvent
Definition: LArCablingChecker.h:48
LArCalibParams::DAC
unsigned DAC(const unsigned event, const HWIdentifier calibLineID) const
Definition: LArCalibParams.cxx:131
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
LArCablingChecker::m_DACLowGainThreshold
int m_DACLowGainThreshold
Definition: LArCablingChecker.h:60
LArOnlineID_Base::channelHashMax
size_type channelHashMax(void) const
Define channel hash tables max size.
Definition: LArOnlineID_Base.cxx:1897
LArCablingChecker::~LArCablingChecker
~LArCablingChecker()
Definition: LArCablingChecker.cxx:40
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
CaloGain::LARHIGHGAIN
@ LARHIGHGAIN
Definition: CaloGain.h:18
EventInfo.h
CaloGain::CaloGain
CaloGain
Definition: CaloGain.h:11
CaloGain::LARMEDIUMGAIN
@ LARMEDIUMGAIN
Definition: CaloGain.h:18
LArOnlineID_Base::feedthrough
int feedthrough(const HWIdentifier id) const
Return the feedthrough of a hardware cell identifier : feedthrough = [0,31] Barrel - A/C side or H/...
Definition: LArOnlineID_Base.cxx:1944
LArCalibParams.h
LArCablingChecker::m_DACHighGainThreshold
int m_DACHighGainThreshold
Definition: LArCablingChecker.h:58
LArDigitContainer
Container class for LArDigit.
Definition: LArDigitContainer.h:24
LArCablingChecker::m_useBadChannelTool
bool m_useBadChannelTool
Definition: LArCablingChecker.h:62
LArCablingChecker::finalize
StatusCode finalize()
Definition: LArCablingChecker.cxx:375
LArCablingChecker::m_channelHashMax
LArOnlineID::size_type m_channelHashMax
Definition: LArCablingChecker.h:52
CaloGain::LARLOWGAIN
@ LARLOWGAIN
Definition: CaloGain.h:18
LArID_Exception
Exception class for LAr Identifiers.
Definition: LArID_Exception.h:20
LArCablingChecker::m_errorCounterPreviousEvent
int m_errorCounterPreviousEvent
Definition: LArCablingChecker.h:50
LArCablingChecker.h
LArCablingChecker::m_printEventSummary
bool m_printEventSummary
Definition: LArCablingChecker.h:61
LArOnOffIdMapping
Definition: LArOnOffIdMapping.h:20
LArCablingChecker::m_ADCThreshold
int m_ADCThreshold
Definition: LArCablingChecker.h:57
LArCablingChecker::m_errorcellsPreviousEvent
std::vector< bool > * m_errorcellsPreviousEvent
Definition: LArCablingChecker.h:49
Identifier
Definition: IdentifierFieldParser.cxx:14