ATLAS Offline Software
MuonAlignmentCondAlg.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 "MuonCondAlg/MuonAlignmentCondAlg.h"
6 
7 #include <fstream>
8 #include <map>
9 #include <string>
10 #include "AthenaKernel/IOVInfiniteRange.h"
11 #include "AthenaPoolUtilities/AthenaAttributeList.h"
12 #include "AthenaPoolUtilities/CondAttrListCollection.h"
13 #include "CoralBase/Attribute.h"
14 #include "CoralBase/AttributeListSpecification.h"
15 #include "GaudiKernel/ConcurrencyFlags.h"
16 #include "CxxUtils/StringUtils.h"
17 #include "MuonReadoutGeometry/GlobalUtilities.h"
18 #include "PathResolver/PathResolver.h"
19 #include "SGTools/TransientAddress.h"
20 
21 MuonAlignmentCondAlg::MuonAlignmentCondAlg(const std::string& name, ISvcLocator* pSvcLocator) :
22  AthReentrantAlgorithm(name, pSvcLocator) {
23 
24 }
25 
26 StatusCode MuonAlignmentCondAlg::initialize() {
27  ATH_MSG_DEBUG("Initilalizing");
28  if (!m_loadALines && !m_loadBLines) {
29  ATH_MSG_ERROR("There's no point in setting up this algorithm if neither A or B Lines shall be processed");
30  return StatusCode::FAILURE;
31  }
32  ATH_MSG_INFO("In initialize ---- # of folders registered is " << m_alignKeys.size());
33  // Read Handles Keys
34  ATH_CHECK(m_alignKeys.initialize(m_readFromJSON.value().empty()));
35  // Write Handles
36  ATH_CHECK(m_writeALineKey.initialize(m_loadALines));
37  ATH_CHECK(m_writeBLineKey.initialize(m_loadBLines));
38  ATH_CHECK(m_idHelperSvc.retrieve());
39  return StatusCode::SUCCESS;
40 }
41 
42 StatusCode MuonAlignmentCondAlg::execute(const EventContext& ctx) const {
43  ATH_MSG_DEBUG("execute " << name());
44 
45  if (m_loadALines) {
46  SG::WriteCondHandle<ALineContainer> writeALineHandle{m_writeALineKey, ctx};
47  if (writeALineHandle.isValid()) {
48  ATH_MSG_DEBUG("CondHandle " << writeALineHandle.fullKey() << " is already valid."
49  << ". In theory this should not be called, but may happen"
50  << " if multiple concurrent events are being processed out of order.");
51  return StatusCode::SUCCESS;
52  }
53  }
55  // =======================
56  // Write BLine Cond Handle
57  // =======================
58  if (m_loadBLines) {
59  SG::WriteCondHandle<BLineContainer> writeBLineHandle{m_writeBLineKey, ctx};
60  if (writeBLineHandle.isValid()) {
61  ATH_MSG_DEBUG("CondHandle " << writeBLineHandle.fullKey() << " is already valid."
62  << ". In theory this should not be called, but may happen"
63  << " if multiple concurrent events are being processed out of order.");
64  return StatusCode::SUCCESS;
65  }
66  }
68  std::unique_ptr<ALineContainer> writeALineCdo{std::make_unique<ALineContainer>()};
69  std::unique_ptr<BLineContainer> writeBLineCdo{std::make_unique<BLineContainer>()};
70 
71  for (const SG::ReadCondHandleKey<CondAttrListCollection>& key: m_alignKeys){
72  ATH_CHECK(loadCoolFolder(ctx, key, *writeALineCdo, *writeBLineCdo));
73  }
74  if (!m_readFromJSON.value().empty()) {
75  std::ifstream inStream{PathResolverFindCalibFile(m_readFromJSON)};
76  if (!inStream.good()) {
77  ATH_MSG_FATAL("No such file or directory");
78  return StatusCode::FAILURE;
79  }
80  nlohmann::json lines;
81  inStream >> lines;
82  ATH_CHECK(parseDataFromJSON(lines, *writeALineCdo, *writeBLineCdo));
83  }
84  ATH_CHECK(writeContainer(ctx, m_writeALineKey, std::move(writeALineCdo)));
85  ATH_CHECK(writeContainer(ctx, m_writeBLineKey, std::move(writeBLineCdo)));
86 
87  return StatusCode::SUCCESS;
88 }
89 template <class ContType>
90  StatusCode MuonAlignmentCondAlg::writeContainer(const EventContext& ctx,
91  const SG::WriteCondHandleKey<ContType>& writeKey,
92  std::unique_ptr<ContType>&& container) const {
93  if (writeKey.empty()) {
94  ATH_MSG_DEBUG("The key of type "<<typeid(ContType).name()<<" is not set. Assume that nothing shall be written.");
95  return StatusCode::SUCCESS;
96  }
97  SG::WriteCondHandle<ContType> writeHandle{writeKey, ctx};
98  writeHandle.addDependency(EventIDRange(IOVInfiniteRange::infiniteTime()));
100  for (const SG::ReadCondHandleKey<CondAttrListCollection>& key : m_alignKeys) {
101  SG::ReadCondHandle<CondAttrListCollection> readHandle{key, ctx};
102  if (!readHandle.isValid()){
103  ATH_MSG_FATAL("Failed to load alignment folder "<<key.fullKey());
104  return StatusCode::FAILURE;
105  }
106  ATH_MSG_INFO("Attach new dependency from <"<<readHandle.key()<<"> to the "<<typeid(ContType).name()<<". IOV: "<<readHandle.getRange());
107  writeHandle.addDependency(readHandle);
108  }
109  ATH_CHECK(writeHandle.record(std::move(container)));
110  return StatusCode::SUCCESS;
111 }
112 StatusCode MuonAlignmentCondAlg::loadCoolFolder(const EventContext& ctx,
113  const SG::ReadCondHandleKey<CondAttrListCollection>& key,
114  ALineContainer& writeALineCdo,
115  BLineContainer& writeBLineCdo) const {
116 
117  SG::ReadCondHandle<CondAttrListCollection> readHandle{key, ctx};
118  if (!readHandle.isValid()){
119  ATH_MSG_FATAL("Failed to load alignment folder "<<key.fullKey());
120  return StatusCode::FAILURE;
121  }
122  ATH_MSG_VERBOSE("Load constants from folder "<<key.key());
123  // unpack the strings in the collection and update the
124  // ALlineContainer in TDS
125  for (CondAttrListCollection::const_iterator itr = readHandle->begin(); itr != readHandle->end(); ++itr) {
126  const coral::AttributeList& atr = itr->second;
127  std::string data{};
128  if (atr["data"].specification().type() == typeid(coral::Blob)) {
129  ATH_MSG_VERBOSE("Loading data as a BLOB, uncompressing...");
130  if (!CoralUtilities::readBlobAsString(atr["data"].data<coral::Blob>(), data)) {
131  ATH_MSG_FATAL("Cannot uncompress BLOB! Aborting...");
132  return StatusCode::FAILURE;
133  }
134  } else {
135  data = *(static_cast<const std::string*>((atr["data"]).addressOfData()));
136  }
137  nlohmann::json lines;
138 
139  // new format -----------------------------------
140  if (m_newFormat2020) {
141  nlohmann::json j = nlohmann::json::parse(data);
142  lines = j["corrections"];
143  }
144  // old format -----------------------------------
145  else {
146  ATH_CHECK(loadDataFromLegacy(data, lines, true));
147  }
148  ATH_CHECK(parseDataFromJSON(lines, writeALineCdo, writeBLineCdo));
149  }
150  return StatusCode::SUCCESS;
151 }
152 
153 StatusCode MuonAlignmentCondAlg::parseDataFromJSON(const nlohmann::json& lines,
154  ALineContainer& writeALineCdo,
155  BLineContainer& writeBLineCdo) const{
156  // loop over corrections ------------------------
157  for (auto& corr : lines.items()) {
158  nlohmann::json line = corr.value();
159 
161  const std::string stationType = line["typ"];
162  const int stationPhi = line["jff"];
163  const int stationEta = line["jzz"];
164  const int multiLayer = line["job"];
165  Identifier id{0};
167  if (stationType[0] == 'M') {
168  if (!m_idHelperSvc->hasMM()) {
169  ATH_MSG_VERBOSE("No Mms defined skipping: "<<stationType<<","<<","<<stationEta<<","<<stationPhi<<","<<multiLayer);
170  continue;
171  }
172  id = m_idHelperSvc->mmIdHelper().channelID(stationType, stationEta, stationPhi, multiLayer, 1, 1);
173  } else if (stationType[0] == 'S') {
174  if (!m_idHelperSvc->hasSTGC()) {
175  ATH_MSG_VERBOSE("No sTgcs defined skipping: "<<stationType<<","<<","<<stationEta<<","<<stationPhi<<","<<multiLayer);
176  continue;
177  }
178  id = m_idHelperSvc->stgcIdHelper().elementID(stationType, stationEta, stationPhi);
179  id = m_idHelperSvc->stgcIdHelper().multilayerID(id, multiLayer);
180  } else if (stationType[0] == 'T') {
182  if (!m_idHelperSvc->hasTGC()) {
183  ATH_MSG_VERBOSE("No Tgcs defined skipping: "<<stationType<<","<<","<<stationEta<<","<<stationPhi);
184  continue;
185  }
186  int stPhi = MuonGM::stationPhiTGC(stationType, stationPhi, stationEta);
187  int stEta = stationEta > 0 ? 1 : -1;
188  if (multiLayer != 0) {
189  // this should become the default now
190  stEta = stationEta > 0 ? multiLayer: - multiLayer;
191  }
192  id = m_idHelperSvc->tgcIdHelper().elementID(stationType, stEta, stPhi);
193  } else if (stationType[0] == 'C') {
194  if (!m_idHelperSvc->hasCSC()) {
195  ATH_MSG_VERBOSE("No Cscs defined skipping: "<<stationType<<","<<","<<stationEta<<","<<stationPhi);
196  continue;
197  }
198  id = m_idHelperSvc->cscIdHelper().elementID(stationType, stationEta, stationPhi);
199  } else if (stationType.substr(0, 3) == "BML" && std::abs(stationEta) == 7) {
200  if (!m_idHelperSvc->hasRPC()) {
201  ATH_MSG_VERBOSE("No Rpcs defined skiping "<<stationType<<","<<","<<stationEta<<","<<stationPhi);
202  continue;
203  }
204  // rpc case
205  id = m_idHelperSvc->rpcIdHelper().elementID(stationType, stationEta, stationPhi, 1);
206  } else if (m_idHelperSvc->hasMDT()) {
207  id = m_idHelperSvc->mdtIdHelper().elementID(stationType, stationEta, stationPhi);
208  } else {
209  continue;
210  }
211  ALinePar newALine{};
212  newALine.setIdentifier(id);
213  newALine.setAmdbId(stationType, stationEta, stationPhi, multiLayer);
214  newALine.setParameters(line["svalue"], line["zvalue"], line["tvalue"],
215  line["tsv"], line["tzv"], line["ttv"]);
216  auto aLineInsert = writeALineCdo.insert(newALine);
217  if (newALine && !aLineInsert.second) {
218  ATH_MSG_WARNING("Failed to insert A line "<<newALine<<" for "<<m_idHelperSvc->toString(id)
219  <<" because "<<(*aLineInsert.first)<<" has been added before");
220  }
221  ATH_MSG_VERBOSE("Inserted new a Line "<<newALine<<" "<<m_idHelperSvc->toString(id));
222 
223  if (line.find("bz") == line.end()) {
224  continue;
225  }
226  BLinePar newBLine{};
227  newBLine.setParameters(line["bz"], line["bp"], line["bn"],
228  line["sp"], line["sn"], line["tw"],
229  line["pg"], line["tr"], line["eg"],
230  line["ep"], line["en"]);
231  newBLine.setIdentifier(id);
232  newBLine.setAmdbId(stationType, stationEta, stationPhi, multiLayer);
233  ATH_MSG_VERBOSE(" HardwareChamberName " << static_cast<std::string>(line["hwElement"]));
234  auto bLineInsert = writeBLineCdo.insert(newBLine);
235  if (newBLine && !bLineInsert.second){
236  ATH_MSG_WARNING("Failed to insert B line "<<newBLine<<" for "<<m_idHelperSvc->toString(id)
237  <<" because "<<(*bLineInsert.first)<<" has been added before.");
238  }
239  }
240  return StatusCode::SUCCESS;
241 }
242 
243 StatusCode MuonAlignmentCondAlg::loadDataFromLegacy(const std::string& data, nlohmann::json& json,
244  bool loadBLines) const {
245 
246  // Parse corrections
247  constexpr std::string_view delimiter{"\n"};
248 
249  json = nlohmann::json::array();
250  auto lines = CxxUtils::tokenize(data, delimiter);
251  for (const std::string& blobline : lines) {
252  nlohmann::json line;
253  constexpr std::string_view delimiter{":"};
254  const auto tokens = CxxUtils::tokenize(blobline, delimiter);
255 
256  // Check if tokens is not empty
257  if (tokens.empty()) {
258  ATH_MSG_FATAL("Empty string retrieved from DB in folder ");
259  return StatusCode::FAILURE;
260  }
261  const std::string_view &type = tokens[0];
262  // Parse line
263  if (type[0] == '#') {
264  continue;
265  }
266  //#: Corr line is counter typ, jff, jzz, job, * Chamber information
267  //#: svalue, zvalue, tvalue, tsv, tzv, ttv, * A lines
268  //#: bz, bp, bn, sp, sn, tw, pg, tr, eg, ep, en * B lines
269  //#: chamber * Chamber name
270  //.... example
271  // Corr: EMS 4 1 0 2.260 3.461 28.639 -0.002402 -0.002013 0.000482 -0.006 -0.013 -0.006000 0.000000
272  // 0.000000 0.026 -0.353 0.000000 0.070000 0.012000 -0.012 EMS1A08
273 
274  if (type.compare(0, 4, "Corr") == 0) {
275  constexpr std::string_view delimiter{" "};
276  auto tokens = CxxUtils::tokenize(blobline, delimiter);
277  if (tokens.size() != 25) {
278  ATH_MSG_FATAL("Invalid length in string retrieved. String length is " << tokens.size());
279  return StatusCode::FAILURE;
280  }
281  // Start parsing
282  int ival = 1;
283  // Station Component identification
284  line["typ"] = std::string(tokens[ival++]);
285  line["jff"] = CxxUtils::atoi(tokens[ival++]);
286  line["jzz"] = CxxUtils::atoi(tokens[ival++]);
287  line["job"] = CxxUtils::atoi(tokens[ival++]);
288 
289  // A-line
290  line["svalue"] = CxxUtils::atof(tokens[ival++]);
291  line["zvalue"] = CxxUtils::atof(tokens[ival++]);
292  line["tvalue"] = CxxUtils::atof(tokens[ival++]);
293 
294  line["tsv"] = CxxUtils::atof(tokens[ival++]);
295  line["tzv"] = CxxUtils::atof(tokens[ival++]);
296  line["ttv"] = CxxUtils::atof(tokens[ival++]);
297 
298  // B-line
299  if (loadBLines) {
300  line["bz"] = CxxUtils::atof(tokens[ival++]);
301  line["bp"] = CxxUtils::atof(tokens[ival++]);
302  line["bn"] = CxxUtils::atof(tokens[ival++]);
303  line["sp"] = CxxUtils::atof(tokens[ival++]);
304  line["sn"] = CxxUtils::atof(tokens[ival++]);
305  line["tw"] = CxxUtils::atof(tokens[ival++]);
306  line["pg"] = CxxUtils::atof(tokens[ival++]);
307  line["tr"] = CxxUtils::atof(tokens[ival++]);
308  line["eg"] = CxxUtils::atof(tokens[ival++]);
309  line["ep"] = CxxUtils::atof(tokens[ival++]);
310  line["en"] = CxxUtils::atof(tokens[ival++]);
311 
312  line["xAtlas"] = CxxUtils::atof(tokens[ival++]);
313  line["yAtlas"] = CxxUtils::atof(tokens[ival++]);
314 
315  // ChamberName (hardware convention)
316  line["hwElement"] = std::string(tokens[ival++]);
317  }
318  json.push_back(std::move(line));
319  }
320  }
321  return StatusCode::SUCCESS;
322 }
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:158
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
checkFileSG.line
line
Definition: checkFileSG.py:75
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
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
json
nlohmann::json json
Definition: HistogramDef.cxx:9
ALinePar
Definition: ALinePar.h:15
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
MuonAlignmentPar::setIdentifier
void setIdentifier(const Identifier &id)
Setters and getters for the Athena Identifier.
Definition: MuonAlignmentPar.cxx:10
parse
std::map< std::string, std::string > parse(const std::string &list)
Definition: egammaLayerRecalibTool.cxx:1054
StringUtils.h
python.subdetectors.tile.Blob
Blob
Definition: tile.py:17
MuonAlignmentCondAlg::MuonAlignmentCondAlg
MuonAlignmentCondAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: MuonAlignmentCondAlg.cxx:21
MuonAlignmentCondAlg::execute
virtual StatusCode execute(const EventContext &ctx) const override
Definition: MuonAlignmentCondAlg.cxx:42
MuonAlignmentCondAlg::initialize
virtual StatusCode initialize() override
Definition: MuonAlignmentCondAlg.cxx:26
python.PyKernel.AttributeList
AttributeList
Definition: PyKernel.py:36
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
beamspotman.tokens
tokens
Definition: beamspotman.py:1284
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
AthenaAttributeList.h
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:83
WriteCellNoiseToCool.ival
ival
Definition: WriteCellNoiseToCool.py:337
python.AthDsoLogger.delimiter
delimiter
Definition: AthDsoLogger.py:71
BLinePar::setParameters
void setParameters(float bz, float bp, float bn, float sp, float sn, float tw, float pg, float tr, float eg, float ep, float en)
Cast the parameter to an unsigned int
Definition: BLinePar.cxx:26
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CaloCondBlobAlgs_fillNoiseFromASCII.lines
lines
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:104
CoralUtilities::readBlobAsString
bool readBlobAsString(const coral::Blob &, std::string &)
Definition: blobaccess.cxx:85
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
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MuonAlignmentCondAlg::m_newFormat2020
Gaudi::Property< bool > m_newFormat2020
Definition: MuonAlignmentCondAlg.h:78
ALineContainer
std::set< ALinePar, std::less<> > ALineContainer
Definition: CorrContainer.h:16
BLinePar
Definition: BLinePar.h:14
MuonAlignmentCondAlg::m_writeALineKey
SG::WriteCondHandleKey< ALineContainer > m_writeALineKey
Definition: MuonAlignmentCondAlg.h:67
GlobalUtilities.h
MuonAlignmentCondAlg::m_writeBLineKey
SG::WriteCondHandleKey< BLineContainer > m_writeBLineKey
Definition: MuonAlignmentCondAlg.h:69
CxxUtils::atof
double atof(std::string_view str)
Converts a string into a double / float.
Definition: Control/CxxUtils/Root/StringUtils.cxx:91
MuonAlignmentCondAlg::m_loadBLines
Gaudi::Property< bool > m_loadBLines
Definition: MuonAlignmentCondAlg.h:76
lumiFormat.array
array
Definition: lumiFormat.py:91
MuonAlignmentCondAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonAlignmentCondAlg.h:72
IOVInfiniteRange.h
PathResolver.h
MuonAlignmentCondAlg::writeContainer
StatusCode writeContainer(const EventContext &ctx, const SG::WriteCondHandleKey< ContType > &writeKey, std::unique_ptr< ContType > &&container) const
Attaches the dependencies of the Alignment keys onto the A & Bline container.
Definition: MuonAlignmentCondAlg.cxx:90
MuonAlignmentCondAlg::m_alignKeys
SG::ReadCondHandleKeyArray< CondAttrListCollection > m_alignKeys
Definition: MuonAlignmentCondAlg.h:57
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
MuonAlignmentCondAlg::loadDataFromLegacy
StatusCode loadDataFromLegacy(const std::string &data, nlohmann::json &json, bool loadBLines) const
Load the Alignment data from the legacy format where the channels are parsed line wise The data is th...
Definition: MuonAlignmentCondAlg.cxx:243
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
MuonAlignmentCondAlg.h
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
SG::ReadCondHandleKey< CondAttrListCollection >
MuonAlignmentCondAlg::m_readFromJSON
Gaudi::Property< std::string > m_readFromJSON
Load the alignment parameters from a JSON file.
Definition: MuonAlignmentCondAlg.h:81
MuonAlignmentCondAlg::parseDataFromJSON
StatusCode parseDataFromJSON(const nlohmann::json &lines, ALineContainer &writeALineCdo, BLineContainer &writeBLineCdo) const
Parse the JSON blob to fill the A & B Line containers.
Definition: MuonAlignmentCondAlg.cxx:153
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CondAttrListCollection::const_iterator
ChanAttrListMap::const_iterator const_iterator
Definition: CondAttrListCollection.h:63
MuonAlignmentCondAlg::m_loadALines
Gaudi::Property< bool > m_loadALines
Definition: MuonAlignmentCondAlg.h:75
TransientAddress.h
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
MuonGM::stationPhiTGC
int stationPhiTGC(std::string_view stName, int fi, int zi_input)
Converts the AMDB phi index to the Identifier phi Index.
Definition: GlobalUtilities.cxx:44
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
SG::WriteCondHandleKey
Definition: WriteCondHandleKey.h:20
IOVInfiniteRange::infiniteTime
static EventIDRange infiniteTime()
Produces an EventIDRange that is inifinite in Time and invalid in RunLumi.
Definition: IOVInfiniteRange.h:47
BLineContainer
std::set< BLinePar, std::less<> > BLineContainer
Definition: CorrContainer.h:20
Muon::nsw::STGTPSegments::moduleIDBits::stationEta
constexpr uint8_t stationEta
1 to 3
Definition: NSWSTGTPDecodeBitmaps.h:156
MuonAlignmentCondAlg::loadCoolFolder
StatusCode loadCoolFolder(const EventContext &ctx, const SG::ReadCondHandleKey< CondAttrListCollection > &key, ALineContainer &writeALineCdo, BLineContainer &writeBLineCdo) const
Retrieves the alignment parameters from a COOL folder.
Definition: MuonAlignmentCondAlg.cxx:112
sTgcDigitEffiDump.multiLayer
int multiLayer
Definition: sTgcDigitEffiDump.py:36
SG::WriteCondHandle
Definition: WriteCondHandle.h:26
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Nov 7 2024 21:21:42 for ATLAS Offline Software by   doxygen 1.8.18