ATLAS Offline Software
ITkPixelOfflineCalibCondAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 #include "Identifier/Identifier.h"
8 #include "GaudiKernel/EventIDRange.h"
10 #include <memory>
11 #include <sstream>
12 
13 namespace ITk
14 {
15 
16 PixelOfflineCalibCondAlg::PixelOfflineCalibCondAlg(const std::string& name, ISvcLocator* pSvcLocator):
17  ::AthReentrantAlgorithm(name, pSvcLocator)
18 {
19 }
20 
21 
23  ATH_MSG_DEBUG("ITkPixelOfflineCalibCondAlg::initialize()");
24 
25  ATH_CHECK(detStore()->retrieve(m_pixelid, "PixelID")) ;
26 
27  if (m_inputSource==2 && m_readKey.key().empty()) {
28  ATH_MSG_ERROR("The database is set to be input source (2) but the ReadKey is empty.");
29  }
31 
33 
34  return StatusCode::SUCCESS;
35 }
36 
37 
38 
39 StatusCode PixelOfflineCalibCondAlg::execute(const EventContext& ctx) const {
40  ATH_MSG_DEBUG("ITkPixelOfflineCalibCondAlg::execute()");
41 
43  if (writeHandle.isValid()) {
44  ATH_MSG_DEBUG("CondHandle " << writeHandle.fullKey() << " is already valid.. In theory this should not be called, but may happen if multiple concurrent events are being processed out of order.");
45  return StatusCode::SUCCESS;
46  }
47 
48  // Construct the output Cond Object and fill it in
49  std::unique_ptr<PixelOfflineCalibData> writeCdo(std::make_unique<PixelOfflineCalibData>());
50 
51  if (m_inputSource==0) {
52  ATH_MSG_WARNING("So far do nothing!! return StatusCode::FAILURE");
53  return StatusCode::FAILURE;
54  }
55  else if (m_inputSource==1) {
56  ATH_MSG_WARNING("Pixel ITk constants read from text file. Only supported for local developments and debugging!");
57 
58  auto calibData = std::make_unique<PixelOfflineCalibData>();
59  PixelClusterErrorData* pced = calibData->getClusterErrorData();
60 
61  // Find and open the text file
62  ATH_MSG_INFO("Load ITkPixelErrorData constants from text file");
63  std::string fileName = PathResolver::find_file(m_textFileName, "DATAPATH");
64  if (fileName.empty()) { ATH_MSG_WARNING("Input file " << fileName << " not found! Default (hardwired) values to be used!"); }
65  else { pced->load(fileName); }
66 
67  ATH_MSG_DEBUG("Get error constants");
68  std::vector<float> constants = calibData->getConstants();
69  if (!constants.empty()) { ATH_MSG_VERBOSE("constants are defined"); }
70  else { ATH_MSG_ERROR("constants size is NULL!!!"); }
71 
72 
73  const EventIDBase start{EventIDBase::UNDEFNUM, EventIDBase::UNDEFEVT, 0, 0, EventIDBase::UNDEFNUM, EventIDBase::UNDEFNUM};
74  const EventIDBase stop {EventIDBase::UNDEFNUM, EventIDBase::UNDEFEVT, EventIDBase::UNDEFNUM-1, EventIDBase::UNDEFNUM-1, EventIDBase::UNDEFNUM, EventIDBase::UNDEFNUM};
75  const EventIDRange rangeW{start, stop};
76 
77  ATH_MSG_DEBUG("Range of input is " << rangeW);
78 
79  if (!constants.empty()) {
80  ATH_MSG_DEBUG("Found constants with new-style Identifier key");
81  writeCdo->setConstants(constants);
82  }
83 
84  if (writeHandle.record(rangeW, std::move(writeCdo)).isFailure()) {
85  ATH_MSG_FATAL("Could not record PixelCalib::ITkPixelOfflineCalibData " << writeHandle.key() << " with EventRange " << rangeW << " into Conditions Store");
86  return StatusCode::FAILURE;
87  }
88  ATH_MSG_DEBUG("recorded new CDO " << writeHandle.key() << " with range " << rangeW << " into Conditions Store");
89 
90  if (m_dump!=0) {
91  ATH_MSG_DEBUG("Dump the constants to file");
92  calibData->dump();
93  }
94  }
95 
96  else if (m_inputSource==2) {
97 
99  const CondAttrListCollection* readCdo{*readHandle};
100  if (readCdo==nullptr) {
101  ATH_MSG_FATAL("Null pointer to the read conditions object");
102  return StatusCode::FAILURE;
103  }
104 
105  // Get the validitiy range
106  EventIDRange rangeW;
107  if (not readHandle.range(rangeW)) {
108  ATH_MSG_FATAL("Failed to retrieve validity range for " << readHandle.key());
109  return StatusCode::FAILURE;
110  }
111 
112  ATH_MSG_DEBUG("Range of input is " << rangeW);
113 
114  std::vector<float> constants;
115 
116  for(const auto & attrList : *readCdo){
117 
118  std::ostringstream attrStr;
119  attrList.second.toOutputStream(attrStr);
120  ATH_MSG_DEBUG( "ChanNum " << attrList.first << " Attribute list " << attrStr.str() );
121 
122  std::string stringData = attrList.second["data_array"].data<std::string>();
123  std::string delimiter = "],";
124  size_t pos = 0;
125  std::vector<std::string> component;
126  std::string buffer;
127  while ((pos = stringData.find(delimiter)) != std::string::npos) {
128  buffer = stringData.substr(0,pos);
129  component.push_back(buffer);
130  stringData.erase(0, pos + delimiter.length());
131  }
132  component.push_back(stringData);
133  ATH_MSG_INFO("Last component="<<stringData);
134 
135  for (auto & i : component) {
136  std::string checkModule = i;
137  std::vector<std::string> moduleString;
138  delimiter = ":[";
139  pos = 0;
140  while ((pos = checkModule.find(delimiter)) != std::string::npos) {
141  buffer = checkModule.substr(0,pos);
142  moduleString.push_back(buffer);
143  checkModule.erase(0, pos + delimiter.length());
144  }
145  moduleString.push_back(checkModule);
146 
147  if (moduleString.size()!=2) {
148  ATH_MSG_FATAL("String size (moduleString) is not 2. " << moduleString.size() << " in " << i << " channel " << attrList.first << " read from " << readHandle.fullKey());
149  return StatusCode::FAILURE;
150  }
151 
152  std::stringstream checkModuleHash(moduleString[0]);
153  std::vector<std::string> moduleStringHash;
154  while (std::getline(checkModuleHash,buffer,'"')) { moduleStringHash.push_back(buffer); }
155 
156  int waferHash = std::atoi(moduleStringHash[1].c_str());
157  IdentifierHash waferID_hash(waferHash);
158  Identifier pixelID = m_pixelid->wafer_id(waferID_hash);
159  constants.emplace_back( pixelID.get_compact() );
160 
161  std::stringstream moduleConstants(moduleString[1]);
162  std::vector<float> moduleConstantsVec;
163  while (std::getline(moduleConstants,buffer,',')) { moduleConstantsVec.emplace_back(std::atof(buffer.c_str())); }
164 
165  // Format v1 with no incident angle dependance
166  if(moduleConstantsVec.size()==4){
167  constants.emplace_back(0); // period_phi
168  constants.emplace_back(0); // period_sinheta
169  constants.emplace_back(0); // delta_x_slope
170  constants.emplace_back(moduleConstantsVec[0]); // delta_x_offset
171  constants.emplace_back(moduleConstantsVec[1]); // delta_error_x
172  constants.emplace_back(0); // delta_y_slope
173  constants.emplace_back(moduleConstantsVec[2]); // delta_y_offset
174  constants.emplace_back(moduleConstantsVec[3]); // delta_error_y
175  }
176 
177  else if(moduleConstantsVec.size()==7){
178  constants.emplace_back(moduleConstantsVec[0]); // period_phi
179  for( auto& x : moduleConstantsVec ) constants.emplace_back(x);
180  }
181 
182  // Format v3 with incident angle dependance + different eta-phi periods
183  else if(moduleConstantsVec.size()==8){
184  for( auto& x : moduleConstantsVec ) constants.emplace_back(x);
185  }
186 
187  }
188 
189  }
190 
191  writeCdo->setConstants(constants);
192 
193  if (writeHandle.record(rangeW, std::move(writeCdo)).isFailure()) {
194  ATH_MSG_FATAL("Could not record PixelCalib::ITkPixelOfflineCalibData " << writeHandle.key() << " with EventRange " << rangeW << " into Conditions Store");
195  return StatusCode::FAILURE;
196  }
197  ATH_MSG_DEBUG("recorded new CDO " << writeHandle.key() << " with range " << rangeW << " into Conditions Store");
198 
199  }
200 
201  return StatusCode::SUCCESS;
202 }
203 
204 } // namespace ITk
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
PathResolver::find_file
static std::string find_file(const std::string &logical_file_name, const std::string &search_path, SearchType search_type=LocalSearch)
Definition: PathResolver.cxx:251
ITk::PixelOfflineCalibCondAlg::m_writeKey
SG::WriteCondHandleKey< ITk::PixelOfflineCalibData > m_writeKey
Definition: ITkPixelOfflineCalibCondAlg.h:47
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:14
ITkPixelOfflineCalibCondAlg.h
ITk::PixelClusterErrorData::load
void load(const std::string &file)
Definition: ITkPixelClusterErrorData.cxx:104
ITk::PixelOfflineCalibCondAlg::initialize
virtual StatusCode initialize() override final
Definition: ITkPixelOfflineCalibCondAlg.cxx:22
Identifier::get_compact
value_type get_compact() const
Get the compact id.
ITk::PixelOfflineCalibCondAlg::m_inputSource
Gaudi::Property< int > m_inputSource
Definition: ITkPixelOfflineCalibCondAlg.h:35
PixelModuleFeMask_create_db.stop
int stop
Definition: PixelModuleFeMask_create_db.py:76
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
SG::WriteCondHandle::record
StatusCode record(const EventIDRange &range, T *t)
record handle, with explicit range DEPRECATED
Definition: WriteCondHandle.h:157
ITk::PixelOfflineCalibCondAlg::m_pixelid
const PixelID * m_pixelid
Definition: ITkPixelOfflineCalibCondAlg.h:49
CondAttrListCollection
This class is a collection of AttributeLists where each one is associated with a channel number....
Definition: CondAttrListCollection.h:52
x
#define x
PixelID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module) const
For a single crystal.
Definition: PixelID.h:364
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:83
ITk::PixelClusterErrorData
Definition: ITkPixelClusterErrorData.h:20
python.AthDsoLogger.delimiter
delimiter
Definition: AthDsoLogger.py:71
createCoolChannelIdFile.buffer
buffer
Definition: createCoolChannelIdFile.py:12
FortranAlgorithmOptions.fileName
fileName
Definition: FortranAlgorithmOptions.py:13
SG::WriteCondHandle::fullKey
const DataObjID & fullKey() const
Definition: WriteCondHandle.h:41
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
lumiFormat.i
int i
Definition: lumiFormat.py: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
ITk::PixelOfflineCalibCondAlg::PixelOfflineCalibCondAlg
PixelOfflineCalibCondAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: ITkPixelOfflineCalibCondAlg.cxx:16
CxxUtils::atof
double atof(std::string_view str)
Converts a string into a double / float.
Definition: Control/CxxUtils/Root/StringUtils.cxx:91
PathResolver.h
ITk
Definition: ITkPixelOfflineCalibCondAlg.cxx:14
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
SG::WriteCondHandle::key
const std::string & key() const
Definition: WriteCondHandle.h:40
IdentifierHash.h
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
ITk::PixelOfflineCalibCondAlg::m_dump
Gaudi::Property< int > m_dump
Definition: ITkPixelOfflineCalibCondAlg.h:41
constants
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:1
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ITk::PixelOfflineCalibCondAlg::execute
virtual StatusCode execute(const EventContext &ctx) const override final
Definition: ITkPixelOfflineCalibCondAlg.cxx:39
SG::WriteCondHandle::isValid
bool isValid() const
Definition: WriteCondHandle.h:248
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
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
SG::WriteCondHandle
Definition: WriteCondHandle.h:26
ITk::PixelOfflineCalibCondAlg::m_readKey
SG::ReadCondHandleKey< CondAttrListCollection > m_readKey
Definition: ITkPixelOfflineCalibCondAlg.h:44
ITk::PixelOfflineCalibCondAlg::m_textFileName
Gaudi::Property< std::string > m_textFileName
Definition: ITkPixelOfflineCalibCondAlg.h:38
Identifier
Definition: IdentifierFieldParser.cxx:14