ATLAS Offline Software
SCT_CablingCondAlgFromCoraCool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
14 //package includes
16 #include "SCT_CablingUtilities.h"
17 
18 //indet includes
19 #include "InDetIdentifier/SCT_ID.h"
20 
21 //Athena includes
22 #include "Identifier/Identifier.h"
24 
25 //STL
26 #include <algorithm>
27 #include <iostream>
28 #include <set>
29 #include <utility>
30 
31 //Constants at file scope
32 //Run1: folder names in COMP200 database
33 static const std::string rodFolderName{"/SCT/DAQ/Configuration/ROD"};
34 static const std::string rodMurFolderName{"/SCT/DAQ/Configuration/RODMUR"};
35 static const std::string murFolderName{"/SCT/DAQ/Configuration/MUR"};
36 static const std::string geoFolderName{"/SCT/DAQ/Configuration/Geog"};
37 //Run2: folders change name in CONDBR2 database
38 static const std::string rodFolderName2{"/SCT/DAQ/Config/ROD"};
39 static const std::string rodMurFolderName2{"/SCT/DAQ/Config/RODMUR"};
40 static const std::string murFolderName2{"/SCT/DAQ/Config/MUR"};
41 static const std::string geoFolderName2{"/SCT/DAQ/Config/Geog"};
42 
43 //the following applied to run1 (pre Sept 2014)
44 //static const unsigned int possibleSlots[]={6,7,8,10,11,12,14,15,16,18,19,20};// strange numbering of slots for the rods, found in DB.
45 //...now the 'expanding DAQ' has all slots filled; the TIM sits in slot 13, so...
46 //static const unsigned int possibleSlots[]={5,6,7,8,9,10,11,12,14,15,16,17,18,19,20,21};
47 // earlier uploads were then found to have slots 0-11... how to resolve the two?
48 static const int disabledFibre{255};
49 static const int defaultLink{128};
50 // for run1:
51 //static const int slotsPerCrate(12);//max. 12 slots filled with rods in the crate
52 //for run 2:
53 static const int slotsPerCrate{16};
54 static const int fibresPerMur{12};
55 static const int fibresPerRod{96};
56 static const int mursPerRod{8};
57 
58 //More look up tables
59 //Disk harnesses
60 static const int HO1[]{5,4,3,2,1,0}; //mur on disk C, position 0
61 static const int HO2[]{12,11,10,9,8,7}; //diskC position 1
62 static const int HM1[]{6,16,15,14,13,-1}; //diskC position 2 (no 6th position)
63 static const int HM2[]{22,21,20,19,18,17}; //diskC position 3
64 static const int HI1[]{28,30,32,29,31,-1}; //diskC position 4
65 static const int HI2[]{26,27,25,23,24,-1}; //diskC position 5
66 //
67 //Disk 9 quadrant reassignment
68 static const int qc[]{-1,3,2,1,0};
69 static const int qa[]{-1,2,1,0,3};
70 
71 //utility functions in file scope
72 namespace {
73  enum SubDetectors{ENDCAP_C=-2, BARREL=0, ENDCAP_A=2};
74  // WJM: Reversed ordering for layer 6/(Disk 7) eta 0 on EC C (-2)
75  //Possibly inverted modules in disk 6C (counting 0-8 for disks) at eta=1. At eta=0, all modules are inverted
76  bool isOdd(int value) {
77  return ((value % 2) ==1);
78  }
79 
80  //Endcap Harness fibre-to-position assignments
81  int positionNumber(const unsigned int murPosition, const unsigned int indx) {
82  int number{-1};
83  switch (murPosition){
84  case 0: number = HO1[indx]; break; // 0-5
85  case 1: number = HO2[indx]; break; // 7-12
86  case 2: number = HM1[indx]; break;
87  case 3: number = HM2[indx]; break; // 17-22
88  case 4: number = HI1[indx]; break;
89  case 5: number = HI2[indx]; break;
90  }
91  return number;
92  }
93 
94  //is the quadrant a special quadrant on disk 9?
95  bool specialQuadrant(const unsigned int disk, const unsigned int quadrant) {
96  return ((disk==8) and (quadrant==4));
97  }
98 
99  // special quadrant on disk 9 is not really a quadrant, its 4 positions in the middle of each quadrant
100  int reassignSpecialQuadrant(const int bec, const unsigned int module) {
101  int q{-1};
102  if (module>4) return q;
103  if (bec==ENDCAP_C) {
104  q=qc[module];
105  } else if (bec==ENDCAP_A) {
106  q=qa[module];
107  }
108  return q;
109  }
110 
111  //convert to athena coords; an approx. copy of Bruce Gallop's online code
112  std::pair<int, int>
113  convertToAthenaCoords(const int bec, const unsigned int disk, const unsigned int quadrant, const int harnessPosition, const unsigned int module) {
114  int q{-1};
115  int number{-1};
116  int phi{-1};
117  int eta{-1}, internalPhi{-1};
118  const std::pair<int, int> errorValue{std::make_pair(eta, phi)};
119  if (specialQuadrant(disk, quadrant)) {
120  q=reassignSpecialQuadrant(bec,module);
121  if (-1==q) return errorValue;
122  number = 6;
123  } else {
124  number=positionNumber(harnessPosition, module);
125  q=quadrant;
126  }
127  if ((number <0) or (number>32)) {
128  return errorValue;
129  }
130  if (number<13) {
131  eta=0;
132  internalPhi=q * 13 + number;
133  } else if (number < 23) {
134  eta=1;
135  internalPhi=q * 10 + number -13;
136  } else {
137  eta=2;
138  internalPhi=q * 10 + number -23;
139  }
140  if (bec<0){ //C
141  if (disk==8) { //disk 9 is reversed
142  phi = (internalPhi +14) % 52;
143  } else if (eta==0) {//outer
144  phi = (64-internalPhi) % 52;
145  } else {//inner, middle
146  phi = (49-internalPhi) % 40;
147  }
148  } else { //A
149  if (disk==8) {//disk 9, reversed
150  phi=(64 - internalPhi) % 52;
151  } else if (eta==0) {//outer
152  phi = (52 + 14 +internalPhi) % 52;
153  } else if (eta==1) {//middle
154  phi = (10 + 40 +internalPhi) % 40;
155  } else {//inners
156  phi = (internalPhi + 40 + 11) % 40;
157  }
158  }
159  return std::make_pair(eta, phi);
160  }
161  //valid numbers for an rx1 or rx0Fibre
162  bool
163  validLinkNumber(const int link) {
164  return ((link>-1) and (link<96)) or (link==defaultLink) or (link==disabledFibre);
165  }
166 }//end of anonymous namespace
167 
168 // Constructor
169 SCT_CablingCondAlgFromCoraCool::SCT_CablingCondAlgFromCoraCool(const std::string& name, ISvcLocator* pSvcLocator):
170  AthReentrantAlgorithm(name, pSvcLocator)
171 {
172 }
173 
174 //
177  // Check conditions folder names
178  if((m_readKeyRod.key()!=rodFolderName) and (m_readKeyRod.key()!=rodFolderName2)) {
179  ATH_MSG_FATAL(m_readKeyRod.key() << " is incorrect.");
180  return StatusCode::FAILURE;
181  }
182  if((m_readKeyRodMur.key()!=rodMurFolderName) and (m_readKeyRodMur.key()!=rodMurFolderName2)) {
183  ATH_MSG_FATAL(m_readKeyRodMur.key() << " is incorrect.");
184  return StatusCode::FAILURE;
185  }
186  if((m_readKeyMur.key()!=murFolderName) and (m_readKeyMur.key()!=murFolderName2)) {
187  ATH_MSG_FATAL(m_readKeyMur.key() << " is incorrect.");
188  return StatusCode::FAILURE;
189  }
190  if((m_readKeyGeo.key()!=geoFolderName) and (m_readKeyGeo.key()!=geoFolderName2)) {
191  ATH_MSG_FATAL(m_readKeyGeo.key() << " is incorrect.");
192  return StatusCode::FAILURE;
193  }
194 
195  // SCT_ID
196  ATH_CHECK(detStore()->retrieve(m_idHelper, "SCT_ID"));
197 
198  // Read Cond Handle
203 
204  // Write Cond Handle
206 
207  return StatusCode::SUCCESS;
208 }
209 
210 //
211 StatusCode
213  return StatusCode::SUCCESS;
214 }
215 
216 //
218 SCT_CablingCondAlgFromCoraCool::execute(const EventContext& ctx) const {
219  // Write Cond Handle
221  if (writeHandle.isValid()) {
222  ATH_MSG_DEBUG("CondHandle " << writeHandle.fullKey() << " is already valid."
223  << ". In theory this should not be called, but may happen"
224  << " if multiple concurrent events are being processed out of order.");
225  return StatusCode::SUCCESS;
226  }
227 
228  // Determine the folders are Run2 or Run1
229  bool isRun2{m_readKeyRod.key()==rodFolderName2};
230 
231  // let's get the ROD AttrLists
233  const CondAttrListVec* pRod{*readHandleRod};
234  if (pRod==nullptr) {
235  ATH_MSG_FATAL("Could not find ROD configuration data: " << m_readKeyRod.key());
236  return StatusCode::FAILURE;
237  }
238  // build rod-rob map, and store the crate/slot to RobId mapping
239  CondAttrListVec::const_iterator rodIt{pRod->begin()};
240  CondAttrListVec::const_iterator last_rod{pRod->end()};
241  using IntMap = std::map<int, int>;
242  IntMap slotMap;
243  //there are now 16 crate slots, but they may be numbered (in the DB) as some non-monotonic sequence
244  //so here we take whatever is in the database and map it onto numbers 0-15
245  {//scope this calculation, only slotMap should emerge
246  //map slots onto 0-15
247  using S = std::set<int>;
248  S slots;
249  for (; rodIt != last_rod; ++rodIt) {
250  //type of 'slot' changed between COMP200 and CONDBR2:
251  if (isRun2) {
252  slots.insert(int(rodIt->second["slot"].data<unsigned char>())); //all but 15 inserts will fail, and these 15 should be sorted
253  } else {
254  slots.insert(int(rodIt->second["slot"].data<short>())); //all but 15 inserts will fail, and these 15 should be sorted
255  }
256  }
257  int counter{0};
258  for (S::const_iterator i{slots.begin()};i != slots.end();++i) {
259  slotMap[*i]=counter++;
260  }
261  ATH_MSG_INFO("Number of SCT rod slots inserted: " << counter);
262  }
263  IntMap crateSlot2RobMap; //local data structure
264  bool allInsertsSucceeded{true};
265  rodIt=pRod->begin();
266  int nrods{0};
267  std::set<int> tempRobSet;
268  for (; rodIt != last_rod; ++rodIt) {
269  const coral::AttributeList& rodAttributes{rodIt->second};
270  int rob{rodAttributes["ROB"].data<int>()};
271  if (not tempRobSet.insert(rob).second) ATH_MSG_WARNING("Duplicate rob? :" << std::hex << rob << std::dec);
272  int crate{isRun2 ? static_cast<int>(rodAttributes["crate"].data<unsigned char>()) : (rodAttributes["crate"].data<int>())};
273  int crateSlot{isRun2 ? static_cast<int>(rodAttributes["slot"].data<unsigned char>()) : static_cast<int>(rodAttributes["slot"].data<short>())};
274  //see note in header; these may be 0-15, but not necessarily, so we need to map these onto 0-15
275  IntMap::const_iterator pSlot{slotMap.find(crateSlot)};
276  int slot{(pSlot==slotMap.end()) ? -1 : pSlot->second};
277  if (slot==-1) ATH_MSG_ERROR("Failed to find a crate slot in the crate map");
278  int rodPosition{(crate * slotsPerCrate) +slot};//generate identifier using crate and slot for use later
279  //use the return type of insert which is a pair with the second component(bool) indicating whether the insert was successful
280  bool thisInsertSucceeded{crateSlot2RobMap.insert(IntMap::value_type(rodPosition, rob)).second};
281  if (not thisInsertSucceeded) {
282  ATH_MSG_WARNING("Insert (rodPosition, rob) " << rodPosition << ", " << rob << " failed.");
283  ATH_MSG_INFO("map(rod position) is already " << crateSlot2RobMap[rodPosition]);
284  ATH_MSG_INFO("crate, slot, slots per crate: " << crate << ", " << slot << ", " << slotsPerCrate);
285  }
286  allInsertsSucceeded = thisInsertSucceeded and allInsertsSucceeded;
287  ++nrods;
288  }
289  ATH_MSG_INFO(nrods << " rods entered, of which " << tempRobSet.size() << " are unique.");
290 
291  if (not allInsertsSucceeded) ATH_MSG_WARNING("Some Rod-Rob map inserts failed.");
292 
297  IntMap geoMurMap;
299  const CondAttrListVec* pGeo{*readHandleGeo};
300  if (pGeo==nullptr) {
301  ATH_MSG_FATAL("Could not find Geog configuration data: " << m_readKeyGeo.key());
302  return StatusCode::FAILURE;
303  }
304  CondAttrListVec::const_iterator geoIt{pGeo->begin()};
305  CondAttrListVec::const_iterator last_geo{pGeo->end()};
306  for (;geoIt != last_geo;++geoIt) {
307  const coral::AttributeList& geoAttributes{geoIt->second};
308  int mur{isRun2 ? static_cast<int>(geoAttributes["MUR"].data<unsigned int>()) : (geoAttributes["MUR"].data<int>())};
309  int position{isRun2 ? static_cast<int>(geoAttributes["position"].data<short>()) : (geoAttributes["position"].data<int>())};
310  if (mur > 10000) geoMurMap[mur]=position; //only for endcap case
311  }
312 
317  IntMap murPositionMap;
319  const CondAttrListVec* pRodMur{*readHandleRodMur};
320  if (pRodMur==nullptr) {
321  ATH_MSG_FATAL("Could not find RodMur configuration data: " << m_readKeyRodMur.key());
322  return StatusCode::FAILURE;
323  }
324  CondAttrListVec::const_iterator rodMurIt{pRodMur->begin()};
325  CondAttrListVec::const_iterator last_rodMur{pRodMur->end()};
326  allInsertsSucceeded = true;
327  std::set<int> tempRobSet2;
328  for (; rodMurIt!=last_rodMur; ++rodMurIt) {
329  const coral::AttributeList& rodMurAttributes{rodMurIt->second};
330  int mur{isRun2 ? static_cast<int>(rodMurAttributes["MUR"].data<unsigned int>()) : (rodMurAttributes["MUR"].data<int>())};
331  int crate{isRun2 ? static_cast<int>(rodMurAttributes["crate"].data<unsigned char>()) : (rodMurAttributes["crate"].data<int>())};
332  int crateSlot{isRun2 ? static_cast<int>(rodMurAttributes["rod"].data<unsigned char>()) : (rodMurAttributes["rod"].data<int>())};//slot is int16, others are int32
333  //map slot onto 0-15 range
334  IntMap::const_iterator pSlot{slotMap.find(crateSlot)};
335  int slot{(pSlot==slotMap.end()) ? -1 : pSlot->second};
336  if (slot==-1) ATH_MSG_ERROR("Failed to find a crate slot in the crate map");
337  //
338  int order{isRun2 ? static_cast<int>(rodMurAttributes["position"].data<unsigned char>()) : (rodMurAttributes["position"].data<int>())};
339  int fibreOrder{((((crate * slotsPerCrate) + slot ) * mursPerRod) + order) * fibresPerMur};
340  bool thisInsertSucceeded{murPositionMap.insert(IntMap::value_type(mur, fibreOrder)).second};
341  if (not thisInsertSucceeded) ATH_MSG_WARNING("Insert (mur, fibre) " << mur << ", " << fibreOrder << " failed.");
342  allInsertsSucceeded = thisInsertSucceeded and allInsertsSucceeded;
343  }
344  if (not allInsertsSucceeded) ATH_MSG_WARNING("Some MUR-position map inserts failed.");
345 
346  // let's get the MUR AttrLists
348  const CondAttrListVec* pMur{*readHandleMur};
349  if (pMur==nullptr) {
350  ATH_MSG_FATAL("Could not find ROD configuration data: " << m_readKeyMur.key());
351  return StatusCode::FAILURE;
352  }
353 
354  // Add dependency
355  writeHandle.addDependency(readHandleRod);
356  writeHandle.addDependency(readHandleRodMur);
357  writeHandle.addDependency(readHandleMur);
358  writeHandle.addDependency(readHandleGeo);
359 
360  // Construct the output Cond Object and fill it in
361  std::unique_ptr<SCT_CablingData> writeCdo{std::make_unique<SCT_CablingData>()};
362 
363  //build identifier map
364  CondAttrListVec::const_iterator murIt{pMur->begin()};
365  CondAttrListVec::const_iterator last_mur{pMur->end()};
366  int numEntries{0};
367  std::set<int> onlineIdSet, robSet;
368  std::set<Identifier> offlineIdSet;
369  long long lastSerialNumber{0};
370  for (; murIt != last_mur; ++murIt) {
371  const coral::AttributeList& murAttributes{murIt->second};
372  int mur{isRun2 ? static_cast<int>(murAttributes["MUR"].data<unsigned int>()) : (murAttributes["MUR"].data<int>())};
373  bool nullMur{murAttributes["moduleID"].isNull() or murAttributes["module"].isNull()};
374  if (9999 == mur or nullMur) continue;
375  int fibreInMur{ (isRun2 ? static_cast<int>(murAttributes["module"].data<unsigned char>()) : (murAttributes["module"].data<int>()) ) - 1};
376  long long sn{murAttributes["moduleID"].data<long long>()};
377  if (lastSerialNumber==sn) { //old version (<2.6) of Coral/Cool doesn't detect a 'null' value, instead it simply repeats the last known value.
378  continue;
379  }
380  lastSerialNumber=sn;
381  std::string snString{std::to_string(sn)};
382  IntMap::const_iterator pFibre{murPositionMap.find(mur)};
383  int fibreOffset{-1};
384  if (pFibre==murPositionMap.end()) {
385  ATH_MSG_WARNING("Failed to find an MUR position in the cabling");
386  } else {
387  fibreOffset = pFibre->second;
388  }
389  int encodedCrateSlot{fibreOffset / (fibresPerMur * mursPerRod)};
390  int rob{-1};
391  IntMap::const_iterator pCrate{crateSlot2RobMap.find(encodedCrateSlot)};
392  if (pCrate == crateSlot2RobMap.end()) {
393  ATH_MSG_WARNING("Failed to find a crate slot in the cabling, slot " << encodedCrateSlot);
394  } else {
395  rob=pCrate->second;
396  tempRobSet2.insert(rob);
397  }
398 
399  //cheat to get the geography: use the MUR notation
400  int bec{0},eta{0}, layer{0}, phi{0};
401  std::pair<int, int> etaPhiPair;
402  int harnessPosition{-1};
403  if (mur > 10000) { //its an endcap, so has 5 digits in the mur
404  layer = (mur/10000) - 1; //first digit is the disk number, 1-9, so subtract 1
405  bec = (((mur /1000) % 2)==0) ? ENDCAP_A : ENDCAP_C; //bec is +2 for A if second digit is 0
406  int quadrant{(mur/100) % 10}; //3rd digit is quadrant
407  //eta = ((mur /10) % 10); //eta of the harness is the 4th digit
408  //int harness = (mur % 10) -1; //last digit is harness, 1 or 2
409  harnessPosition=geoMurMap[mur];
410  etaPhiPair= convertToAthenaCoords(bec,layer, quadrant, harnessPosition, fibreInMur);
411  eta=etaPhiPair.first;
412  phi=etaPhiPair.second;
413  } else {
414  bec = 0;
415  layer= (mur /1000) - 3;//first digit is layer, 3-6
416  phi= (mur % 100) - 1; //lower 2 digits are phi check whether this wraps around!
417  eta = (((mur / 100) % 10) *2 -1) * (fibreInMur+1);//second digit gives eta sign, 0-> -, 1-> +
418  }
419  int rxLink[2];
420  if (isRun2) {
421  rxLink[0]=murAttributes["rx0Fibre"].data<unsigned char>();rxLink[1]= murAttributes["rx1Fibre"].data<unsigned char>();
422  } else {
423  rxLink[0]=murAttributes["rx0Fibre"].data<int>();rxLink[1]=murAttributes["rx1Fibre"].data<int>();
424  }
425  if (not (validLinkNumber(rxLink[0]) and validLinkNumber(rxLink[1]))) {
426  ATH_MSG_WARNING("Invalid link number in database in one of these db entries: rx0Fibre=" << rxLink[0] << ", rx1Fibre=" << rxLink[1]);
427  continue;
428  }
429  //normal ordering is like rx0=0, rx1=1; i.e. odd links in rx1.
430  bool normalOrdering{true};
431  if (rxLink[0] != disabledFibre) { //if the first link is not disabled, use that and check its even
432  normalOrdering=(rxLink[0] % 2)==0;
433  } else { //...otherwise use link1 and check its odd
434  normalOrdering=(rxLink[1] % 2)==1;
435  }
436 
437  int possibleLinks[2]{0,0};
438  if (normalOrdering) {
439  possibleLinks[0]=(rxLink[0]!=disabledFibre) ? rxLink[0] : (rxLink[1]-1);
440  possibleLinks[1]=(rxLink[1]!=disabledFibre) ? rxLink[1] : (rxLink[0]+1);
441  } else {
442  possibleLinks[0]=(rxLink[0]!=disabledFibre) ? rxLink[0] : (rxLink[1]+1);
443  possibleLinks[1]=(rxLink[1]!=disabledFibre) ? rxLink[1] : (rxLink[0]-1);
444  }
445  for (int side{0}; side!=2; ++side) {
446  if ((-1==phi) and (-1==eta)) {
447  ATH_MSG_WARNING("Invalid eta, phi..skipping insertion to map for module " << snString << " (may be already present in map)");
448  continue;
449  }
451  int link{rxLink[side]};
452  if (defaultLink==link) {
453  link = (fibreOffset % fibresPerRod) + fibreInMur*2 + side;
454  }
455  if (disabledFibre==link) {
456  int otherLink{rxLink[1-side]};
457  if (otherLink==possibleLinks[0]) link=possibleLinks[1];
458  if (otherLink==possibleLinks[1]) link=possibleLinks[0];
459  }
460  bool flippedModule{isOdd(side)!=isOdd(link)};
461  if (flippedModule) {
462  link = (link==possibleLinks[0]) ? possibleLinks[1] : possibleLinks[0];
463  }
464  int onlineId{(rob & 0xFFFFFF)|(link << 24)};
465  //check uniqueness
466  if (not onlineIdSet.insert(onlineId).second) ATH_MSG_WARNING("Insert of online Id : " << onlineId << " failed.");
467  if (not offlineIdSet.insert(offlineId).second) {
468  ATH_MSG_WARNING("Insert of offline Id : " << offlineId << " failed.");
469  ATH_MSG_WARNING(bec << " " << layer << " " << phi << " " << eta << " " << side);
470  ATH_MSG_INFO("MUR, position " << mur << ", " << harnessPosition);
471  }
472  IdentifierHash offlineIdHash{m_idHelper->wafer_hash(offlineId)};
473  insert(offlineIdHash, onlineId, SCT_SerialNumber(sn), writeCdo.get());
474  numEntries++;
475  }
476  }
477 
478  if (writeHandle.record(std::move(writeCdo)).isFailure()) {
479  ATH_MSG_FATAL("Could not record SCT_CablingData " << writeHandle.key()
480  << " with EventRange " << writeHandle.getRange()
481  << " into Conditions Store");
482  return StatusCode::FAILURE;
483  }
484  ATH_MSG_INFO("recorded new CDO " << writeHandle.key() << " with range " << writeHandle.getRange() << " into Conditions Store");
485 
486  const int robLo{*(tempRobSet2.cbegin())};
487  const int robHi{*(tempRobSet2.crbegin())};
488  ATH_MSG_INFO(numEntries << " entries were made to the identifier map.");
489  ATH_MSG_INFO(tempRobSet2.size() << " unique rob ids were used, spanning 0x" << std::hex << robLo << " to 0x" << robHi << std::dec);
490  if (tempRobSet.size() != tempRobSet2.size()) {
491  ATH_MSG_WARNING("The following existing rods were not inserted : ");
492  std::cout << std::hex;
493  std::set_difference(tempRobSet.cbegin(), tempRobSet.cend(),
494  tempRobSet2.cbegin(), tempRobSet2.cend(),
495  std::ostream_iterator<int>(std::cout,", "));
496  std::cout << std::dec << std::endl;
497  }
498  tempRobSet.clear();
499  return (numEntries==0) ? (StatusCode::FAILURE) : (StatusCode::SUCCESS);
500 }
501 
502 //
503 bool
505  if (not sn.isWellFormed()) {
506  ATH_MSG_FATAL("Serial number is not in correct format");
507  return false;
508  }
509  if (not hash.is_valid()) {
510  ATH_MSG_FATAL("Invalid hash: " << hash);
511  return false;
512  }
513  // Check if the pointer of derived conditions object is valid.
514  if (data==nullptr) {
515  ATH_MSG_FATAL("Pointer of derived conditions object is null");
516  return false;
517  }
518 
519  if (not data->setHashForOnlineId(hash, onlineId)) return false;
520  if (not data->setOnlineIdForHash(onlineId, hash)) return false;
521 
522  bool successfulInsert{data->setHashForSerialNumber(hash, sn)};
523  successfulInsert &= data->setSerialNumberForHash(sn, hash);
524  // in this form, the data->getHashEntries() will be half the number of hashes
525  if (successfulInsert) {
526  data->setRod(onlineId.rod()); //move this here so insertion only happens for valid onlineId, hash
527  }
528  return true;
529 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
SCT_CablingUtilities.h
SCT_CablingCondAlgFromCoraCool::m_idHelper
const SCT_ID * m_idHelper
Definition: SCT_CablingCondAlgFromCoraCool.h:63
SCT_CablingCondAlgFromCoraCool::m_readKeyMur
SG::ReadCondHandleKey< CondAttrListVec > m_readKeyMur
Definition: SCT_CablingCondAlgFromCoraCool.h:58
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
SCT_ID.h
This is an Identifier helper class for the SCT subdetector. This class is a factory for creating comp...
SCT_CablingCondAlgFromCoraCool::m_readKeyGeo
SG::ReadCondHandleKey< CondAttrListVec > m_readKeyGeo
Definition: SCT_CablingCondAlgFromCoraCool.h:59
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ParticleGun_SamplingFraction.bec
int bec
Definition: ParticleGun_SamplingFraction.py:89
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
SCT_OnlineId
Definition: SCT_OnlineId.h:22
athena.value
value
Definition: athena.py:124
SCT_CablingCondAlgFromCoraCool::insert
bool insert(const IdentifierHash &hash, const SCT_OnlineId &onlineId, const SCT_SerialNumber &sn, SCT_CablingData *data) const
Definition: SCT_CablingCondAlgFromCoraCool.cxx:504
python.PyKernel.AttributeList
AttributeList
Definition: PyKernel.py:36
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
JetTiledMap::S
@ S
Definition: TiledEtaPhiMap.h:44
SCT_CablingCondAlgFromCoraCool::SCT_CablingCondAlgFromCoraCool
SCT_CablingCondAlgFromCoraCool(const std::string &name, ISvcLocator *svc)
Definition: SCT_CablingCondAlgFromCoraCool.cxx:169
SCT_CablingCondAlgFromCoraCool::m_writeKey
SG::WriteCondHandleKey< SCT_CablingData > m_writeKey
Output condition data.
Definition: SCT_CablingCondAlgFromCoraCool.h:61
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
TRT::Hit::side
@ side
Definition: HitInfo.h:83
SCT_CablingCondAlgFromCoraCool.h
Fills an SCT cabling object from the database.
SCT_CablingCondAlgFromCoraCool::execute
virtual StatusCode execute(const EventContext &ctx) const override
Definition: SCT_CablingCondAlgFromCoraCool.cxx:218
python.PyAthena.module
module
Definition: PyAthena.py:131
SCT_CablingCondAlgFromCoraCool::m_readKeyRod
SG::ReadCondHandleKey< CondAttrListVec > m_readKeyRod
Input conditions folders.
Definition: SCT_CablingCondAlgFromCoraCool.h:56
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CondAttrListVec
Definition: CondAttrListVec.h:31
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
mc.order
order
Configure Herwig7.
Definition: mc.Herwig7_Dijet.py:12
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
SCT_ID::wafer_hash
IdentifierHash wafer_hash(const Identifier &wafer_id) const
wafer hash from id - optimized
Definition: SCT_ID.h:492
SCT_Monitoring::ENDCAP_A
@ ENDCAP_A
Definition: SCT_MonitoringNumbers.h:21
python.TrigConfigSvcUtils.isRun2
def isRun2(cursor, schemaname)
Definition: TrigConfigSvcUtils.py:290
CondAttrListVec::const_iterator
AttrListVec::const_iterator const_iterator
Definition: CondAttrListVec.h:36
python.selection.number
number
Definition: selection.py:20
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
IdentifierHash.h
SCT_Monitoring::ENDCAP_C
@ ENDCAP_C
Definition: SCT_MonitoringNumbers.h:21
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
SCT_SerialNumber
Definition: SCT_SerialNumber.h:22
SCT_CablingData
Definition: SCT_CablingData.h:35
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
SCT_CablingCondAlgFromCoraCool::finalize
virtual StatusCode finalize() override
Definition: SCT_CablingCondAlgFromCoraCool.cxx:212
SCT_SerialNumber::isWellFormed
bool isWellFormed() const
Cursory check on whether the serial number is well formed N.B.
Definition: SCT_SerialNumber.cxx:81
SCT_CablingCondAlgFromCoraCool::m_readKeyRodMur
SG::ReadCondHandleKey< CondAttrListVec > m_readKeyRodMur
Definition: SCT_CablingCondAlgFromCoraCool.h:57
SCT_CablingCondAlgFromCoraCool::initialize
virtual StatusCode initialize() override
Definition: SCT_CablingCondAlgFromCoraCool.cxx:176
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
BARREL
@ BARREL
Definition: TRTRadiatorParameters.h:10
extractSporadic.q
list q
Definition: extractSporadic.py:98
SCT_ID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module, int side) const
For a single side of module.
Definition: SCT_ID.h:464
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
test_pyathena.counter
counter
Definition: test_pyathena.py:15
SG::WriteCondHandle
Definition: WriteCondHandle.h:26
SCT_OnlineId::rod
std::uint32_t rod() const
Return the rod/rob Id.
Definition: SCT_OnlineId.cxx:59
Identifier
Definition: IdentifierFieldParser.cxx:14