ATLAS Offline Software
MuonMDT_CablingAlg.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 "MuonMDT_CablingAlg.h"
6 
7 #include <fstream>
8 #include <map>
9 #include "AthenaPoolUtilities/AthenaAttributeList.h"
10 #include "AthenaPoolUtilities/CondAttrListCollection.h"
11 #include "AthenaKernel/IOVInfiniteRange.h"
12 #include "CoralBase/Attribute.h"
13 #include "CoralBase/AttributeListSpecification.h"
14 #include "CxxUtils/StringUtils.h"
15 #include "MuonIdHelpers/MdtIdHelper.h"
16 #include "PathResolver/PathResolver.h"
17 #include "SGTools/TransientAddress.h"
18 
19 #include <CoralBase/Blob.h>
20 #include <CoralUtilities/blobaccess.h>
21 
22 
23 using DataSource = MuonMDT_CablingMap::DataSource;
24 
25 MuonMDT_CablingAlg::MuonMDT_CablingAlg(const std::string& name, ISvcLocator* pSvcLocator) : AthReentrantAlgorithm(name, pSvcLocator) {}
26 
27 StatusCode MuonMDT_CablingAlg::initialize() {
28  ATH_MSG_DEBUG("initialize " << name());
29  ATH_CHECK(m_readKeyMez.initialize());
30  ATH_CHECK(m_readKeyMap.initialize());
31  ATH_CHECK(m_writeKey.initialize());
32  ATH_CHECK(m_idHelperSvc.retrieve());
33  return StatusCode::SUCCESS;
34 }
35 
36 StatusCode MuonMDT_CablingAlg::execute(const EventContext& ctx) const {
37  ATH_MSG_VERBOSE("MuonMDT_CablingAlg::execute()");
38  // Write Cond Handle
39  SG::WriteCondHandle<MuonMDT_CablingMap> writeHandle{m_writeKey, ctx};
40  if (writeHandle.isValid()) {
41  ATH_MSG_DEBUG("CondHandle " << writeHandle.fullKey() << " is already valid."
42  << ". In theory this should not be called, but may happen"
43  << " if multiple concurrent events are being processed out of order.");
44  return StatusCode::SUCCESS;
45  }
46  writeHandle.addDependency(EventIDRange(IOVInfiniteRange::infiniteRunLB()));
47  ATH_MSG_INFO("Load the Mdt cabling");
48  std::unique_ptr<MuonMDT_CablingMap> writeCdo{std::make_unique<MuonMDT_CablingMap>()};
49 
50  ATH_CHECK(loadMezzanineSchema(ctx, writeHandle, *writeCdo));
51  ATH_CHECK(loadCablingSchema(ctx, writeHandle, *writeCdo));
52  if (!writeCdo->finalize_init(msgStream())) return StatusCode::FAILURE;
53 
54  ATH_CHECK(writeHandle.record(std::move(writeCdo)));
55  ATH_MSG_INFO("recorded new " << writeHandle.key() << " with range " << writeHandle.getRange() << " into Conditions Store");
56  return StatusCode::SUCCESS;
57 }
58 
59 StatusCode MuonMDT_CablingAlg::dbPayloadToJson(SG::ReadCondHandle<CondAttrListCollection>& readHandle, nlohmann::json& json) const {
60  for (CondAttrListCollection::const_iterator itr = readHandle->begin();
61  itr != readHandle->end(); ++itr) {
62  const coral::AttributeList& atr = itr->second;
63  std::string data{};
64  if (atr["data"].specification().type() == typeid(coral::Blob)) {
65 
66  ATH_MSG_VERBOSE("Loading data as a BLOB, uncompressing...");
67  if (!CoralUtilities::readBlobAsString(atr["data"].data<coral::Blob>(), data)) {
68  ATH_MSG_FATAL("Cannot uncompress BLOB! Aborting...");
69  return StatusCode::FAILURE;
70  }
71  } else {
72  data = *(static_cast<const std::string*>((atr["data"]).addressOfData()));
73  }
74  json = nlohmann::json::parse(data);
75  }
76  return StatusCode::SUCCESS;
77 }
78 
79 StatusCode MuonMDT_CablingAlg::loadCablingSchema(const EventContext& ctx, SG::WriteCondHandle<MuonMDT_CablingMap>& writeHandle,
80  MuonMDT_CablingMap& cabling_map) const {
81 
82  if (m_chambJSON.value().size()){
83  std::ifstream in_json{m_chambJSON};
84  if (!in_json.good()) {
85  ATH_MSG_FATAL("Failed to open external JSON file "<<m_chambJSON);
86  return StatusCode::FAILURE;
87  }
88  nlohmann::json payload{};
89  in_json >> payload;
90  ATH_CHECK(loadCablingSchemaFromJSON( std::move(payload), cabling_map));
91  return StatusCode::SUCCESS;
92  }
93  SG::ReadCondHandle<CondAttrListCollection> readHandleMap{m_readKeyMap, ctx};
94  if (!readHandleMap.isValid()) {
95  ATH_MSG_ERROR("Null pointer to the read conditions object "<<readHandleMap.fullKey());
96  return StatusCode::FAILURE;
97  }
98  writeHandle.addDependency(readHandleMap);
99 
100  ATH_MSG_INFO("Size of CondAttrListCollection " << readHandleMap.fullKey()
101  << " readCdoMap->size()= " << readHandleMap->size());
102 
103  ATH_MSG_VERBOSE("Collection CondAttrListCollection CLID " << readHandleMap->clID());
104  if (m_useJSONFormat) {
105  nlohmann::json json;
106  ATH_CHECK(dbPayloadToJson(readHandleMap, json));
107  ATH_CHECK(loadCablingSchemaFromJSON(std::move(json),cabling_map));
108  return StatusCode::SUCCESS;
109  }
110  // access to Map Schema Table to obtained the Map
111  CondAttrListCollection::const_iterator itrMap;
112  for (itrMap = readHandleMap->begin(); itrMap != readHandleMap->end(); ++itrMap) {
113  const coral::AttributeList& atr = itrMap->second;
114 
115  CablingData map_data;
116  if (!extractStationInfo(atr, map_data)) continue;
117 
118  constexpr std::string_view delimiter{","};
119  const std::string map = *(static_cast<const std::string*>((atr["Map"]).addressOfData()));
120  std::vector<std::string> info_map = CxxUtils::tokenize(map, delimiter);
121 
122  while (extractLayerInfo(info_map, map_data)) {
124  ATH_MSG_VERBOSE("Adding new mezzanine stationName: " << m_idHelperSvc->mdtIdHelper().stationNameString(map_data.stationIndex)
125  << " " << map_data);
126  if (!cabling_map.addMezzanine(map_data, DataSource::LegacyCOOL, msgStream())) {
127  ATH_MSG_ERROR("Failed to add cabling " << map_data);
128  return StatusCode::FAILURE;
129  } else
130  ATH_MSG_VERBOSE("Added new cabling channel " << map_data);
131  }
132  } // end of CondAttrListCollection loop
134  if (m_isRun3) {
135  ATH_MSG_INFO("Found a round 3 setup. Will add the cabling for BIS78 manually");
136  const int BIS_stat = m_idHelperSvc->mdtIdHelper().stationNameIndex("BIS");
137  constexpr int eta_index = 7;
138  for (unsigned int sector = 1; sector <= 8; ++sector) {
139  int is_biy{0}, tdcId{0};
140  auto increment_tdc = [&is_biy, &tdcId]() {
141  ++tdcId;
142  constexpr int tdcMax = 17; // Maximum 18 tdcs per CSM
143  if (tdcId > tdcMax) {
144  tdcId = 0;
145  ++is_biy;
146  }
147  };
148  constexpr int tubesPerCsm = 54;
149  bool added_tdc = true;
150  while (added_tdc) {
151  added_tdc = false;
152  for (int ml = 1; ml <= 2; ++ml) {
153  const Identifier layer_id = m_idHelperSvc->mdtIdHelper().channelID(BIS_stat, eta_index, sector, ml, 1, 1);
154  const int tubes_per_layer = m_idHelperSvc->mdtIdHelper().tubeMax(layer_id);
155 
156  const int first_tube = 6 * (1 + tdcId / 2) + tubesPerCsm * is_biy;
157  const bool valid_tube = (first_tube <= tubes_per_layer);
158  added_tdc |= valid_tube;
159  if (!valid_tube) {
160  increment_tdc();
161  continue;
162  }
163 
164  CablingData bis78_data{};
165  bis78_data.tubes_per_layer = MdtIdHelper::maxNTubesPerLayer;
166  bis78_data.stationIndex = BIS_stat;
167  bis78_data.eta = eta_index;
168  bis78_data.phi = sector;
171  bis78_data.mrod = (is_biy ? -1 : 7) + sector;
172  bis78_data.csm = is_biy ? 5 : 0;
173  bis78_data.subdetectorId = 99;
174 
175  bis78_data.mezzanine_type = sector != 6 ? 61 : 71;
176  const unsigned int tube_coding = first_tube + bis78_data.tubes_per_layer * (4 + bis78_data.layer_block * ml);
177  ATH_MSG_VERBOSE("ooooh BIS78 is being hacked in " << m_idHelperSvc->toString(layer_id) << " tubes_per_layer "
178  << m_idHelperSvc->mdtIdHelper().tubeMax(layer_id) << " tdcId: "
179  << tdcId << " is_Biy: " << is_biy << " first_tube: " << first_tube);
180 
181  std::vector<std::string> db_coding{std::to_string(tdcId), "0", std::to_string(tube_coding)};
182  if (extractLayerInfo(db_coding, bis78_data)) {
183  ATH_MSG_VERBOSE("Adding new mezzanine stationName: "
184  << m_idHelperSvc->mdtIdHelper().stationNameString(bis78_data.stationIndex) << " " << bis78_data);
185  if (!cabling_map.addMezzanine(bis78_data, DataSource::LegacyCOOL, msgStream())) {
186  ATH_MSG_ERROR("Failed to add mezzanine card " << bis78_data);
187  return StatusCode::FAILURE;
188  }
189  }
190  if (bis78_data.tube != first_tube) {
191  ATH_MSG_ERROR("BIS78 data tube encoding failed. Expected " << first_tube << " got " << bis78_data.tube << ".");
192  return StatusCode::FAILURE;
193  } else if (bis78_data.multilayer != ml) {
194  ATH_MSG_ERROR("BIS78 data ml encoding failed. Expected " << ml << " got " << bis78_data.multilayer << ".");
195  return StatusCode::FAILURE;
196  }
197  increment_tdc();
198  }
199  }
200  }
201  }
202  return StatusCode::SUCCESS;
203 }
204 
205 bool MuonMDT_CablingAlg::extractStationInfo(const coral::AttributeList& atr, CablingData& map_data) const {
206  map_data.eta = *(static_cast<const int*>((atr["Eta"]).addressOfData()));
207  map_data.phi = *(static_cast<const int*>((atr["Phi"]).addressOfData()));
208  map_data.mrod = *(static_cast<const int*>((atr["MROD"]).addressOfData()));
209  map_data.csm = *(static_cast<const int*>((atr["CSM"]).addressOfData()));
210  map_data.channelId = *(static_cast<const int*>((atr["Chan"]).addressOfData()));
211  map_data.mezzanine_type = *(static_cast<const int*>((atr["Mezzanine_Type"]).addressOfData()));
212 
213  const std::string chamber_name = *(static_cast<const std::string*>((atr["Chamber_Name"]).addressOfData()));
214  const std::string subdetector_id = *(static_cast<const std::string*>((atr["SubDet_Id"]).addressOfData()));
215 
216  // convert the string name to index
217  std::string stationNameString = chamber_name.substr(0, 3);
218  // fix for the BOE chambers, which in the offline are treated as BOL
219  if (stationNameString == "BOE") { stationNameString = "BOL"; }
221  if (stationNameString == "BIX" || stationNameString == "BIY") {
222  stationNameString = "BIS";
223  static std::atomic<bool> sInfoPrinted{false};
224  if (!sInfoPrinted)
225  ATH_MSG_INFO("Found an entry concerning the new BIS78 chambers. Will increase the number of tube per layer to "
226  << MdtIdHelper::maxNTubesPerLayer);
227  sInfoPrinted = true;
228 
229  map_data.tubes_per_layer = MdtIdHelper::maxNTubesPerLayer;
230  }
232  if (m_isRun3) {
234  if ((stationNameString == "EIS" && (!m_idHelperSvc->hasCSC() || chamber_name.find('A') != std::string::npos)) ||
235  chamber_name.find("BIS7A") != std::string::npos) {
236  ATH_MSG_VERBOSE("It's sooo sad but the chamber " << chamber_name << " is no longer with us");
237  return false;
238  }
239  }
240  map_data.stationIndex = m_idHelperSvc->mdtIdHelper().stationNameIndex(stationNameString);
241  ATH_MSG_VERBOSE("station name: " << stationNameString << " index: " << static_cast<int>(map_data.stationIndex));
242  // convert the subdetector id to integer
243  map_data.subdetectorId = CxxUtils::atoi(subdetector_id);
244 
245  ATH_MSG_VERBOSE("Data load is chamber_Name = " << chamber_name <<" translated to "<<map_data<<" FINISHED HERE ");
246 
247  if (map_data.stationIndex < 0) {
248  static std::atomic<bool> stWarningPrinted{false};
249  if (!stWarningPrinted) {
250  ATH_MSG_WARNING("Found stationIndex=" << static_cast<int>(map_data.stationIndex)
251  << " which is not reasonable, maybe related to ATLASRECTS-5961, continuing...");
252  stWarningPrinted = true;
253  }
254  }
255  return map_data.stationIndex >= 0;
256 }
257 bool MuonMDT_CablingAlg::extractLayerInfo(std::vector<std::string>& info_map, CablingData& map_data) const {
258  ATH_MSG_VERBOSE(" parsing of the map");
261  constexpr unsigned int coding_block_size = 3;
262  const unsigned int n = info_map.size() >= coding_block_size ? coding_block_size : info_map.size();
263  bool decoded_full_block{false};
264  for (unsigned int i = 0; i < n; ++i) {
265  ATH_MSG_VERBOSE(i << "..." << info_map[i]);
266  int info = CxxUtils::atoi(info_map[i]);
267  // this is a tdcid
268  if (i == 0) {
269  map_data.tdcId = info;
270  }
271  // this is a channel Id
272  else if (i == 1) {
273  map_data.channelId = info;
274  }
275  // this is a tube id that must be unpacked
276  else if (i == 2) {
278  map_data.tube = info % map_data.tubes_per_layer;
279  map_data.layer = ((info - map_data.tube) / map_data.tubes_per_layer) % map_data.layer_block;
280  map_data.multilayer = (((info - map_data.tube) / map_data.tubes_per_layer) - map_data.layer) / map_data.layer_block;
281  decoded_full_block = true;
282  }
283  }
284 
285  // the stationIndex is later on passed to the MdtIdHelper, thus, it must be a reasonable station name, i.e. not < 0
286  if (decoded_full_block) info_map.erase(info_map.begin(), info_map.begin() + coding_block_size);
287  return decoded_full_block;
288 }
289 
290 StatusCode MuonMDT_CablingAlg::loadMezzanineSchema(const EventContext& ctx,SG::WriteCondHandle<MuonMDT_CablingMap>& writeHandle,
291  MuonMDT_CablingMap& cabling_map) const{
292  if (m_mezzJSON.value().size()){
293  std::ifstream in_json{m_mezzJSON};
294  if (!in_json.good()) {
295  ATH_MSG_FATAL("Failed to open external JSON file "<<m_mezzJSON);
296  return StatusCode::FAILURE;
297  }
298  nlohmann::json payload{};
299  in_json >> payload;
300  ATH_CHECK(loadMezzanineFromJSON(std::move(payload), cabling_map));
301  return StatusCode::SUCCESS;
302  }
303 
305  SG::ReadCondHandle<CondAttrListCollection> readHandleMez{m_readKeyMez, ctx};
306  if (!readHandleMez.isValid()) {
307  ATH_MSG_ERROR("Null pointer to the read conditions object "<<m_readKeyMez.fullKey());
308  return StatusCode::FAILURE;
309  }
310  writeHandle.addDependency(readHandleMez);
311 
312  ATH_MSG_INFO("Size of CondAttrListCollection " << readHandleMez.fullKey()
313  << " readCdoMez->size()= " << readHandleMez->size());
314 
315  if (m_useJSONFormat) {
316  nlohmann::json json;
317  ATH_CHECK(dbPayloadToJson(readHandleMez, json));
318  ATH_CHECK(loadMezzanineFromJSON(std::move(json),cabling_map));
319  return StatusCode::SUCCESS;
320  }
321  CondAttrListCollection::const_iterator itrMez;
322  for (itrMez = readHandleMez->begin(); itrMez != readHandleMez->end(); ++itrMez) {
323  const coral::AttributeList& atr = itrMez->second;
324  int sequence{0}, layer{0}, mezzanine_type{0};
325 
326  mezzanine_type = *(static_cast<const int*>((atr["Mezzanine_Type"]).addressOfData()));
327  layer = *(static_cast<const int*>((atr["Layer"]).addressOfData()));
328  sequence = *(static_cast<const int*>((atr["Sequence"]).addressOfData()));
329  ATH_MSG_VERBOSE("Sequence load is " << sequence << " for the mezzanine type = " << mezzanine_type
330  << " for the layer number = " << layer);
331 
332  // here add the mezzanine type to the cabling class
333  if (!cabling_map.addMezzanineLine(mezzanine_type, layer, sequence, msgStream())) {
334  ATH_MSG_ERROR("Could not add the mezzanine sequence to the map ");
335  return StatusCode::FAILURE;
336  } else {
337  ATH_MSG_VERBOSE("Sequence added successfully to the map");
338  }
339  }
340  return StatusCode::SUCCESS;
341 }
342 StatusCode MuonMDT_CablingAlg::loadMezzanineFromJSON(nlohmann::json&& payload, MuonMDT_CablingMap& cabling_map) const {
343  using MezzMapping = MdtMezzanineCard::Mapping;
344  for (const auto &cabl_chan : payload.items()) {
345  nlohmann::json mezz_payload = cabl_chan.value();
346  const uint8_t id = mezz_payload["mezzId"];
347  const uint8_t nLay = mezz_payload["nTubeLayer"];
348  const MezzMapping mapping = mezz_payload["tdcToTubeMap"];
349  if(!cabling_map.addMezanineLayout(std::make_unique<MdtMezzanineCard>(mapping, nLay, id),
350  msgStream())) return StatusCode::FAILURE;
351  }
352  return StatusCode::SUCCESS;
353 }
354 StatusCode MuonMDT_CablingAlg::loadCablingSchemaFromJSON(nlohmann::json&& payload, MuonMDT_CablingMap& cabling_map) const {
355  const MdtIdHelper& id_helper = m_idHelperSvc->mdtIdHelper();
356  for (const auto &db_channel : payload.items()) {
357  nlohmann::json ms_payload = db_channel.value();
358  CablingData ms_channel{};
359  ms_channel.stationIndex = id_helper.stationNameIndex(ms_payload["station"]);
360  ms_channel.eta = ms_payload["eta"];
361  ms_channel.phi = ms_payload["phi"];
362  ms_channel.multilayer = ms_payload["ml"];
363 
364  ms_channel.subdetectorId = ms_payload["subDet"];
365  ms_channel.csm = ms_payload["csm"];
366  ms_channel.mrod = ms_payload["mrod"];
367 
368  ms_channel.mezzanine_type = ms_payload["mezzId"];
369  ms_channel.tdcId = ms_payload["tdcId"];
370  ms_channel.tube = ms_payload["tubeZero"];
371 
372  ms_channel.layer = 1;
373  MdtMezzanineCard::MezzCardPtr hedgeHogCard = cabling_map.getHedgeHogMapping(ms_channel.mezzanine_type);
374  ms_channel.channelId = hedgeHogCard ? (*std::min_element(
375  hedgeHogCard->tubeToTdcMap().begin(),
376  hedgeHogCard->tubeToTdcMap().end())) : 0;
377  if (!cabling_map.addMezzanine(ms_channel, DataSource::JSON, msgStream())) return StatusCode::FAILURE;
378  }
379  return StatusCode::SUCCESS;
380 }
381 
grepfile.info
info
Definition: grepfile.py:38
MuonIdHelper::stationNameIndex
int stationNameIndex(const std::string &name) const
Definition: MuonIdHelper.cxx:846
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
CondAttrListCollection::end
const_iterator end() const
Definition: CondAttrListCollection.h:315
MuonMDT_CablingAlg::MuonMDT_CablingAlg
MuonMDT_CablingAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: MuonMDT_CablingAlg.cxx:25
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
MuonMDT_CablingAlg::extractStationInfo
bool extractStationInfo(const coral::AttributeList &atr, CablingData &map_data) const
Retrieves the general MDT station info from the coral attribute.
Definition: MuonMDT_CablingAlg.cxx:205
MuonMDT_CablingAlg::m_writeKey
SG::WriteCondHandleKey< MuonMDT_CablingMap > m_writeKey
Definition: MuonMDT_CablingAlg.h:37
CondAttrListCollection.h
This file defines the class for a collection of AttributeLists where each one is associated with a ch...
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
MdtCablingData::tube
int tube
Layer inside the multilayer.
Definition: MdtCablingData.h:86
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
MdtCablingOffData::eta
int8_t & eta
Station of the chamber (i.e, BIL,BIS,etc.)
Definition: MdtCablingData.h:28
json
nlohmann::json json
Definition: HistogramDef.cxx:9
MuonMDT_CablingMap::addMezzanine
bool addMezzanine(CablingData cabling_data, DataSource source, MsgStream &log)
Add a new fully configured mezzanine card.
Definition: MuonMDT_CablingMap.cxx:184
MdtCablingData::mezzanine_type
uint8_t mezzanine_type
Tube number in the layer.
Definition: MdtCablingData.h:88
MdtCablingOffData::stationIndex
int8_t & stationIndex
Definition: MdtCablingData.h:26
MuonMDT_CablingMap::DataSource::JSON
@ JSON
CxxUtils::tokenize
std::vector< std::string > tokenize(const std::string &the_str, std::string_view delimiters)
Splits the string into smaller substrings.
Definition: Control/CxxUtils/Root/StringUtils.cxx:15
MdtCablingOnData::mrod
uint8_t & mrod
Definition: MdtCablingData.h:52
MdtMezzanineCard::Mapping
std::array< uint8_t, 24 > Mapping
Definition: MdtMezzanineCard.h:39
MuonMDT_CablingAlg::loadCablingSchema
StatusCode loadCablingSchema(const EventContext &ctx, SG::WriteCondHandle< MuonMDT_CablingMap > &writeHandle, MuonMDT_CablingMap &cabling_map) const
Load the cabling schema of the tubes.
Definition: MuonMDT_CablingAlg.cxx:79
parse
std::map< std::string, std::string > parse(const std::string &list)
Definition: egammaLayerRecalibTool.cxx:1040
StringUtils.h
CondAttrListCollection::begin
const_iterator begin() const
Access to Chan/AttributeList pairs via iterators.
Definition: CondAttrListCollection.h:309
python.subdetectors.tile.Blob
Blob
Definition: tile.py:17
python.PyKernel.AttributeList
AttributeList
Definition: PyKernel.py:36
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
AthenaAttributeList.h
find_tgc_unfilled_channelids.mapping
mapping
Definition: find_tgc_unfilled_channelids.py:17
MuonMDT_CablingAlg::m_mezzJSON
Gaudi::Property< std::string > m_mezzJSON
Definition: MuonMDT_CablingAlg.h:59
MuonMDT_CablingAlg::initialize
virtual StatusCode initialize() override
Definition: MuonMDT_CablingAlg.cxx:27
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:83
MuonMDT_CablingAlg::extractLayerInfo
bool extractLayerInfo(std::vector< std::string > &, CablingData &map_data) const
Retrieves the channel info from the coral attribute.
Definition: MuonMDT_CablingAlg.cxx:257
createDCubeDigitHistograms_withSel.chamber_name
chamber_name
Definition: createDCubeDigitHistograms_withSel.py:109
MuonMDT_CablingAlg::dbPayloadToJson
StatusCode dbPayloadToJson(SG::ReadCondHandle< CondAttrListCollection > &readHandle, nlohmann::json &json) const
Definition: MuonMDT_CablingAlg.cxx:59
MdtCablingOffData::phi
int8_t & phi
Eta of the MDT station.
Definition: MdtCablingData.h:29
MuonMDT_CablingMap::getHedgeHogMapping
MezzCardPtr getHedgeHogMapping(uint8_t mezzCardId) const
Definition: MuonMDT_CablingMap.cxx:176
MuonMDT_CablingMap
Definition: MuonMDT_CablingMap.h:24
MdtCablingData::layer_block
int layer_block
Definition: MdtCablingData.h:106
python.AthDsoLogger.delimiter
delimiter
Definition: AthDsoLogger.py:71
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
MdtMezzanineCard::MezzCardPtr
std::shared_ptr< const MdtMezzanineCard > MezzCardPtr
Definition: MdtMezzanineCard.h:38
lumiFormat.i
int i
Definition: lumiFormat.py:92
MdtCablingData::tubes_per_layer
int tubes_per_layer
Helper constants to extract tube,layer, multilayer information.
Definition: MdtCablingData.h:105
MuonMDT_CablingAlg::m_readKeyMap
SG::ReadCondHandleKey< CondAttrListCollection > m_readKeyMap
Definition: MuonMDT_CablingAlg.h:36
CoralUtilities::readBlobAsString
bool readBlobAsString(const coral::Blob &, std::string &)
Definition: blobaccess.cxx:85
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
beamspotman.n
n
Definition: beamspotman.py:731
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
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
IOVInfiniteRange::infiniteRunLB
static EventIDRange infiniteRunLB()
Produces an EventIDRange that is infinite in RunLumi and invalid in Time.
Definition: IOVInfiniteRange.h:39
MdtIdHelper
Definition: MdtIdHelper.h:61
MdtIdHelper.h
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MdtCablingData
Definition: MdtCablingData.h:82
createCablingJSON.eta_index
int eta_index
Definition: createCablingJSON.py:9
MuonMDT_CablingAlg::m_readKeyMez
SG::ReadCondHandleKey< CondAttrListCollection > m_readKeyMez
Definition: MuonMDT_CablingAlg.h:35
IOVInfiniteRange.h
PathResolver.h
MuonMDT_CablingAlg::loadMezzanineSchema
StatusCode loadMezzanineSchema(const EventContext &ctx, SG::WriteCondHandle< MuonMDT_CablingMap > &writeHandle, MuonMDT_CablingMap &cabling_map) const
Load the mezzanine schema into the cabling.
Definition: MuonMDT_CablingAlg.cxx:290
MdtCablingData::tdcId
uint8_t tdcId
Mezzanine type.
Definition: MdtCablingData.h:90
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
MdtCablingData::layer
int layer
Definition: MdtCablingData.h:85
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
MuonMDT_CablingAlg::execute
virtual StatusCode execute(const EventContext &ctx) const override
Definition: MuonMDT_CablingAlg.cxx:36
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
MdtCablingOnData::csm
uint8_t & csm
MROD number.
Definition: MdtCablingData.h:53
PixelModuleFeMask_create_db.payload
string payload
Definition: PixelModuleFeMask_create_db.py:69
MdtCablingData::channelId
uint8_t channelId
Identifier of the corresponding tdc.
Definition: MdtCablingData.h:92
MuonMDT_CablingMap::DataSource::LegacyCOOL
@ LegacyCOOL
MdtCablingOffData::multilayer
int8_t & multilayer
Phi sector of the MDT station.
Definition: MdtCablingData.h:30
MuonMDT_CablingAlg::m_isRun3
Gaudi::Property< bool > m_isRun3
Definition: MuonMDT_CablingAlg.h:39
MuonMDT_CablingAlg::loadMezzanineFromJSON
StatusCode loadMezzanineFromJSON(nlohmann::json &&payload, MuonMDT_CablingMap &cabling_map) const
Definition: MuonMDT_CablingAlg.cxx:342
blobaccess.h
MuonMDT_CablingMap::addMezanineLayout
bool addMezanineLayout(std::unique_ptr< MdtMezzanineCard > card, MsgStream &log)
Adds a new mezzanine card mapping.
Definition: MuonMDT_CablingMap.cxx:576
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CondAttrListCollection::const_iterator
ChanAttrListMap::const_iterator const_iterator
Definition: CondAttrListCollection.h:63
TransientAddress.h
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
MuonMDT_CablingAlg::m_useJSONFormat
Gaudi::Property< bool > m_useJSONFormat
Definition: MuonMDT_CablingAlg.h:65
MuonMDT_CablingMap::DataSource
DataSource
Definition: MuonMDT_CablingMap.h:87
MdtCablingOnData::subdetectorId
uint8_t & subdetectorId
CSM number.
Definition: MdtCablingData.h:54
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
MuonMDT_CablingAlg::loadCablingSchemaFromJSON
StatusCode loadCablingSchemaFromJSON(nlohmann::json &&payload, MuonMDT_CablingMap &cabling_map) const
Definition: MuonMDT_CablingAlg.cxx:354
MdtIdHelper::maxNTubesPerLayer
static constexpr int maxNTubesPerLayer
The maxNTubesPerLayer represents the absolute maximum of tubes which are built into a single multilay...
Definition: MdtIdHelper.h:68
MuonMDT_CablingAlg.h
MuonMDT_CablingAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonMDT_CablingAlg.h:34
SG::WriteCondHandle
Definition: WriteCondHandle.h:26
MuonMDT_CablingMap::addMezzanineLine
bool addMezzanineLine(const int type, const int layer, const int sequence, MsgStream &log)
Add a new line describing a mezzanine type.
Definition: MuonMDT_CablingMap.cxx:69
SG::WriteCondHandle::addDependency
void addDependency(const EventIDRange &range)
Definition: WriteCondHandle.h:275
MuonMDT_CablingAlg::m_chambJSON
Gaudi::Property< std::string > m_chambJSON
Definition: MuonMDT_CablingAlg.h:62
Generated on Thu Jul 4 2024 21:22:54 for ATLAS Offline Software by   doxygen 1.8.18