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_INFO("Initilalizing");
28  ATH_MSG_INFO("In initialize ---- # of folders registered is " << m_alignKeys.size());
29  // Read Handles Keys
30  ATH_CHECK(m_alignKeys.initialize(m_readFromJSON.value().empty()));
31 
32  // Write Handles
33  ATH_CHECK(m_writeALineKey.initialize());
34  ATH_CHECK(m_writeBLineKey.initialize());
35  ATH_CHECK(m_idHelperSvc.retrieve());
36  return StatusCode::SUCCESS;
37 }
38 
39 StatusCode MuonAlignmentCondAlg::execute(const EventContext& ctx) const {
40  ATH_MSG_DEBUG("execute " << name());
41 
42  SG::WriteCondHandle<ALineContainer> writeALineHandle{m_writeALineKey, ctx};
43  if (writeALineHandle.isValid()) {
44  ATH_MSG_DEBUG("CondHandle " << writeALineHandle.fullKey() << " is already valid."
45  << ". In theory this should not be called, but may happen"
46  << " if multiple concurrent events are being processed out of order.");
47  return StatusCode::SUCCESS;
48  }
50  // =======================
51  // Write BLine Cond Handle
52  // =======================
53  SG::WriteCondHandle<BLineContainer> writeBLineHandle{m_writeBLineKey, ctx};
54  if (writeBLineHandle.isValid()) {
55  ATH_MSG_DEBUG("CondHandle " << writeBLineHandle.fullKey() << " is already valid."
56  << ". In theory this should not be called, but may happen"
57  << " if multiple concurrent events are being processed out of order.");
58  return StatusCode::SUCCESS;
59  }
61  ATH_CHECK(attachDependencies(ctx, writeALineHandle, writeBLineHandle));
63  std::unique_ptr<ALineContainer> writeALineCdo{std::make_unique<ALineContainer>()};
64  std::unique_ptr<BLineContainer> writeBLineCdo{std::make_unique<BLineContainer>()};
65 
66  for (const SG::ReadCondHandleKey<CondAttrListCollection>& key: m_alignKeys){
67  ATH_CHECK(loadCoolFolder(ctx, key, *writeALineCdo, *writeBLineCdo));
68  }
69  if (!m_readFromJSON.value().empty()) {
70  std::ifstream inStream{PathResolverFindCalibFile(m_readFromJSON)};
71  if (!inStream.good()) {
72  ATH_MSG_FATAL("No such file or directory");
73  return StatusCode::FAILURE;
74  }
75  nlohmann::json lines;
76  inStream >> lines;
77  ATH_CHECK(parseDataFromJSON(lines, *writeALineCdo, *writeBLineCdo));
78  }
79  ATH_CHECK(writeALineHandle.record(std::move(writeALineCdo)));
80  ATH_CHECK(writeBLineHandle.record(std::move(writeBLineCdo)));
81 
82  return StatusCode::SUCCESS;
83 }
84 StatusCode MuonAlignmentCondAlg::attachDependencies(const EventContext& ctx,
85  SG::WriteCondHandle<ALineContainer>& alines,
86  SG::WriteCondHandle<BLineContainer>& blines ) const {
87  alines.addDependency(EventIDRange(IOVInfiniteRange::infiniteTime()));
88  blines.addDependency(EventIDRange(IOVInfiniteRange::infiniteTime()));
90  for (const SG::ReadCondHandleKey<CondAttrListCollection>& key : m_alignKeys) {
91  SG::ReadCondHandle<CondAttrListCollection> readHandle{key, ctx};
92  if (!readHandle.isValid()){
93  ATH_MSG_FATAL("Failed to load alignment folder "<<key.fullKey());
94  return StatusCode::FAILURE;
95  }
96  ATH_MSG_INFO("Attach new dependency from <"<<readHandle.key()<<"> to the A & B lines. IOV: "<<readHandle.getRange());
97  alines.addDependency(readHandle);
98  blines.addDependency(readHandle);
99  }
100  return StatusCode::SUCCESS;
101 }
102 StatusCode MuonAlignmentCondAlg::loadCoolFolder(const EventContext& ctx,
103  const SG::ReadCondHandleKey<CondAttrListCollection>& key,
104  ALineContainer& writeALineCdo,
105  BLineContainer& writeBLineCdo) const {
106 
107  SG::ReadCondHandle<CondAttrListCollection> readHandle{key, ctx};
108  if (!readHandle.isValid()){
109  ATH_MSG_FATAL("Failed to load alignment folder "<<key.fullKey());
110  return StatusCode::FAILURE;
111  }
112  ATH_MSG_VERBOSE("Load constants from folder "<<key.key());
113  // unpack the strings in the collection and update the
114  // ALlineContainer in TDS
115  for (CondAttrListCollection::const_iterator itr = readHandle->begin(); itr != readHandle->end(); ++itr) {
116  const coral::AttributeList& atr = itr->second;
117  std::string data{};
118  if (atr["data"].specification().type() == typeid(coral::Blob)) {
119  ATH_MSG_VERBOSE("Loading data as a BLOB, uncompressing...");
120  if (!CoralUtilities::readBlobAsString(atr["data"].data<coral::Blob>(), data)) {
121  ATH_MSG_FATAL("Cannot uncompress BLOB! Aborting...");
122  return StatusCode::FAILURE;
123  }
124  } else {
125  data = *(static_cast<const std::string*>((atr["data"]).addressOfData()));
126  }
127  nlohmann::json lines;
128 
129  // new format -----------------------------------
130  if (m_newFormat2020) {
131  nlohmann::json j = nlohmann::json::parse(data);
132  lines = j["corrections"];
133  }
134  // old format -----------------------------------
135  else {
136  ATH_CHECK(loadDataFromLegacy(data, lines, true));
137  }
138  ATH_CHECK(parseDataFromJSON(lines, writeALineCdo, writeBLineCdo));
139  }
140  return StatusCode::SUCCESS;
141 }
142 
143 StatusCode MuonAlignmentCondAlg::parseDataFromJSON(const nlohmann::json& lines,
144  ALineContainer& writeALineCdo,
145  BLineContainer& writeBLineCdo) const{
146  // loop over corrections ------------------------
147  for (auto& corr : lines.items()) {
148  nlohmann::json line = corr.value();
149 
151  const std::string stationType = line["typ"];
152  const int stationPhi = line["jff"];
153  const int stationEta = line["jzz"];
154  const int multiLayer = line["job"];
155  Identifier id{0};
157  if (stationType[0] == 'M') {
158  if (!m_idHelperSvc->hasMM()) {
159  ATH_MSG_VERBOSE("No Mms defined skipping: "<<stationType<<","<<","<<stationEta<<","<<stationPhi<<","<<multiLayer);
160  continue;
161  }
162  id = m_idHelperSvc->mmIdHelper().channelID(stationType, stationEta, stationPhi, multiLayer, 1, 1);
163  } else if (stationType[0] == 'S') {
164  if (!m_idHelperSvc->hasTGC()) {
165  ATH_MSG_VERBOSE("No sTgcs defined skipping: "<<stationType<<","<<","<<stationEta<<","<<stationPhi<<","<<multiLayer);
166  continue;
167  }
168  id = m_idHelperSvc->stgcIdHelper().elementID(stationType, stationEta, stationPhi);
169  id = m_idHelperSvc->stgcIdHelper().multilayerID(id, multiLayer);
170  } else if (stationType[0] == 'T') {
172  if (!m_idHelperSvc->hasTGC()) {
173  ATH_MSG_VERBOSE("No Tgcs defined skipping: "<<stationType<<","<<","<<stationEta<<","<<stationPhi);
174  continue;
175  }
176  int stPhi = MuonGM::stationPhiTGC(stationType, stationPhi, stationEta);
177  int stEta = stationEta > 0 ? 1 : -1;
178  if (multiLayer != 0) {
179  // this should become the default now
180  stEta = stationEta > 0 ? multiLayer: - multiLayer;
181  }
182  id = m_idHelperSvc->tgcIdHelper().elementID(stationType, stEta, stPhi);
183  } else if (stationType[0] == 'C') {
184  if (!m_idHelperSvc->hasCSC()) {
185  ATH_MSG_VERBOSE("No Cscs defined skipping: "<<stationType<<","<<","<<stationEta<<","<<stationPhi);
186  continue;
187  }
188  id = m_idHelperSvc->cscIdHelper().elementID(stationType, stationEta, stationPhi);
189  } else if (stationType.substr(0, 3) == "BML" && std::abs(stationEta) == 7) {
190  if (!m_idHelperSvc->hasRPC()) {
191  ATH_MSG_VERBOSE("No Rpcs defined skiping "<<stationType<<","<<","<<stationEta<<","<<stationPhi);
192  continue;
193  }
194  // rpc case
195  id = m_idHelperSvc->rpcIdHelper().elementID(stationType, stationEta, stationPhi, 1);
196  } else if (m_idHelperSvc->hasMDT()) {
197  id = m_idHelperSvc->mdtIdHelper().elementID(stationType, stationEta, stationPhi);
198  } else {
199  continue;
200  }
201  ALinePar newALine{};
202  newALine.setIdentifier(id);
203  newALine.setAmdbId(stationType, stationEta, stationPhi, multiLayer);
204  newALine.setParameters(line["svalue"], line["zvalue"], line["tvalue"],
205  line["tsv"], line["tzv"], line["ttv"]);
206  auto aLineInsert = writeALineCdo.insert(newALine);
207  if (newALine && !aLineInsert.second) {
208  ATH_MSG_WARNING("Failed to insert A line "<<newALine<<" for "<<m_idHelperSvc->toString(id)
209  <<" because "<<(*aLineInsert.first)<<" has been added before");
210  }
211  ATH_MSG_VERBOSE("Inserted new a Line "<<newALine<<" "<<m_idHelperSvc->toString(id));
212 
213  if (line.find("bz") == line.end()) {
214  continue;
215  }
216  BLinePar newBLine{};
217  newBLine.setParameters(line["bz"], line["bp"], line["bn"],
218  line["sp"], line["sn"], line["tw"],
219  line["pg"], line["tr"], line["eg"],
220  line["ep"], line["en"]);
221  newBLine.setIdentifier(id);
222  newBLine.setAmdbId(stationType, stationEta, stationPhi, multiLayer);
223  ATH_MSG_VERBOSE(" HardwareChamberName " << static_cast<std::string>(line["hwElement"]));
224  auto bLineInsert = writeBLineCdo.insert(newBLine);
225  if (newBLine && !bLineInsert.second){
226  ATH_MSG_WARNING("Failed to insert B line "<<newBLine<<" for "<<m_idHelperSvc->toString(id)
227  <<" because "<<(*bLineInsert.first)<<" has been added before.");
228  }
229  }
230  return StatusCode::SUCCESS;
231 }
232 
233 StatusCode MuonAlignmentCondAlg::loadDataFromLegacy(const std::string& data, nlohmann::json& json,
234  bool loadBLines) const {
235 
236  // Parse corrections
237  constexpr std::string_view delimiter{"\n"};
238 
239  json = nlohmann::json::array();
240  auto lines = CxxUtils::tokenize(data, delimiter);
241  for (const std::string& blobline : lines) {
242  nlohmann::json line;
243  constexpr std::string_view delimiter{":"};
244  const auto tokens = CxxUtils::tokenize(blobline, delimiter);
245 
246  // Check if tokens is not empty
247  if (tokens.empty()) {
248  ATH_MSG_FATAL("Empty string retrieved from DB in folder ");
249  return StatusCode::FAILURE;
250  }
251  const std::string_view &type = tokens[0];
252  // Parse line
253  if (type[0] == '#') {
254  continue;
255  }
256  //#: Corr line is counter typ, jff, jzz, job, * Chamber information
257  //#: svalue, zvalue, tvalue, tsv, tzv, ttv, * A lines
258  //#: bz, bp, bn, sp, sn, tw, pg, tr, eg, ep, en * B lines
259  //#: chamber * Chamber name
260  //.... example
261  // 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
262  // 0.000000 0.026 -0.353 0.000000 0.070000 0.012000 -0.012 EMS1A08
263 
264  if (type.compare(0, 4, "Corr") == 0) {
265  constexpr std::string_view delimiter{" "};
266  auto tokens = CxxUtils::tokenize(blobline, delimiter);
267  if (tokens.size() != 25) {
268  ATH_MSG_FATAL("Invalid length in string retrieved. String length is " << tokens.size());
269  return StatusCode::FAILURE;
270  }
271  // Start parsing
272  int ival = 1;
273  // Station Component identification
274  line["typ"] = std::string(tokens[ival++]);
275  line["jff"] = CxxUtils::atoi(tokens[ival++]);
276  line["jzz"] = CxxUtils::atoi(tokens[ival++]);
277  line["job"] = CxxUtils::atoi(tokens[ival++]);
278 
279  // A-line
280  line["svalue"] = CxxUtils::atof(tokens[ival++]);
281  line["zvalue"] = CxxUtils::atof(tokens[ival++]);
282  line["tvalue"] = CxxUtils::atof(tokens[ival++]);
283 
284  line["tsv"] = CxxUtils::atof(tokens[ival++]);
285  line["tzv"] = CxxUtils::atof(tokens[ival++]);
286  line["ttv"] = CxxUtils::atof(tokens[ival++]);
287 
288  // B-line
289  if (loadBLines) {
290  line["bz"] = CxxUtils::atof(tokens[ival++]);
291  line["bp"] = CxxUtils::atof(tokens[ival++]);
292  line["bn"] = CxxUtils::atof(tokens[ival++]);
293  line["sp"] = CxxUtils::atof(tokens[ival++]);
294  line["sn"] = CxxUtils::atof(tokens[ival++]);
295  line["tw"] = CxxUtils::atof(tokens[ival++]);
296  line["pg"] = CxxUtils::atof(tokens[ival++]);
297  line["tr"] = CxxUtils::atof(tokens[ival++]);
298  line["eg"] = CxxUtils::atof(tokens[ival++]);
299  line["ep"] = CxxUtils::atof(tokens[ival++]);
300  line["en"] = CxxUtils::atof(tokens[ival++]);
301 
302  line["xAtlas"] = CxxUtils::atof(tokens[ival++]);
303  line["yAtlas"] = CxxUtils::atof(tokens[ival++]);
304 
305  // ChamberName (hardware convention)
306  line["hwElement"] = std::string(tokens[ival++]);
307  }
308  json.push_back(std::move(line));
309  }
310  }
311  return StatusCode::SUCCESS;
312 }
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:129
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:983
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:39
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
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
CaloCondBlobAlgs_fillNoiseFromASCII.lines
lines
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:104
CoralUtilities::readBlobAsString
bool readBlobAsString(const coral::Blob &, std::string &)
Definition: blobaccess.cxx:85
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
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:72
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:64
GlobalUtilities.h
MuonAlignmentCondAlg::m_writeBLineKey
SG::WriteCondHandleKey< BLineContainer > m_writeBLineKey
Definition: MuonAlignmentCondAlg.h:66
CxxUtils::atof
double atof(std::string_view str)
Converts a string into a double / float.
Definition: Control/CxxUtils/Root/StringUtils.cxx:91
lumiFormat.array
array
Definition: lumiFormat.py:98
MuonAlignmentCondAlg::attachDependencies
StatusCode attachDependencies(const EventContext &ctx, SG::WriteCondHandle< ALineContainer > &alines, SG::WriteCondHandle< BLineContainer > &blines) const
Attaches the dependencies of the Alignment keys onto the A & Bline container.
Definition: MuonAlignmentCondAlg.cxx:84
MuonAlignmentCondAlg::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonAlignmentCondAlg.h:69
IOVInfiniteRange.h
PathResolver.h
MuonAlignmentCondAlg::m_alignKeys
SG::ReadCondHandleKeyArray< CondAttrListCollection > m_alignKeys
Definition: MuonAlignmentCondAlg.h:54
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
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:233
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:75
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:143
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
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
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:127
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:102
sTgcDigitEffiDump.multiLayer
int multiLayer
Definition: sTgcDigitEffiDump.py:36
SG::WriteCondHandle
Definition: WriteCondHandle.h:26
SG::WriteCondHandle::addDependency
void addDependency(const EventIDRange &range)
Definition: WriteCondHandle.h:275
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Tue Jul 2 2024 21:22:20 for ATLAS Offline Software by   doxygen 1.8.18