ATLAS Offline Software
DefectsEmulatorAlg.icc
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "Identifier/Identifier.h"
6 #include "AtlasDetDescr/AtlasDetectorID.h"
7 #include "EventContainers/IdentifiableContainerBase.h"
8 #include "InDetRawData/InDetRawDataCollection.h"
9 #include "InDetRawData/SCT3_RawData.h"
10 #include "InDetRawData/Pixel1RawData.h"
11 #include "InDetReadoutGeometry/SiDetectorElement.h"
12 
13 #include "AthenaKernel/RNGWrapper.h"
14 #include "CLHEP/Random/RandPoisson.h"
15 #include "CLHEP/Random/RandFlat.h"
16 
17 #include "StoreGate/WriteHandle.h"
18 
19 #include <vector>
20 #include <memory>
21 #include <mutex>
22 
23 namespace InDet{
24 
25  template <class T_RDO_Container>
26  bool DefectsEmulatorAlg<T_RDO_Container>::setModuleData(const ActsDetectorElement &acts_detector_element,
27  ModuleIdentifierMatchUtil::ModuleData_t &module_data) const {
28  // It is assumed that a module is unambiguously identified by the detector type and the id hash,
29  // and all modules with the same detector type are relevant for the given RDO container.
30  if (acts_detector_element.detectorType() == DETECTOR_TYPE) {
31  const auto*si_detector_element = dynamic_cast<const InDetDD::SiDetectorElement*>(acts_detector_element.upstreamDetectorElement());
32  if(si_detector_element != nullptr) {
33  const T_ModuleDesign &moduleDesign = dynamic_cast<const T_ModuleDesign &>(si_detector_element->design());
34  ModuleIdentifierMatchUtil::setModuleData(*m_idHelper,
35  acts_detector_element.identify(),
36  moduleDesign,
37  module_data);
38  return true;
39  }
40  }
41  return false;
42  }
43 
44  template <class T_RDO_Container>
45  StatusCode DefectsEmulatorAlg<T_RDO_Container>::initialize(){
46  ATH_CHECK( m_emulatedDefects.initialize() );
47  ATH_CHECK( m_rdoOutContainerKey.initialize() );
48  ATH_CHECK( m_origRdoContainerKey.initialize() );
49  ATH_CHECK( detStore()->retrieve(m_idHelper, m_idHelperName.value()) );
50 
51  return DefectsEmulatorBase::initializeBase(m_idHelper->wafer_hash_max());
52  }
53 
54  template <class T_RDO_Container>
55  StatusCode DefectsEmulatorAlg<T_RDO_Container>::execute(const EventContext& ctx) const {
56  SG::ReadCondHandle<T_DefectsData> emulatedDefects(m_emulatedDefects,ctx);
57  ATH_CHECK(emulatedDefects.isValid());
58  SG::ReadHandle<T_RDO_Container> origRdoContainer(m_origRdoContainerKey, ctx);
59  ATH_CHECK(origRdoContainer.isValid());
60  SG::WriteHandle<T_RDO_Container> rdoOutContainer(m_rdoOutContainerKey, ctx);
61  ATH_CHECK( rdoOutContainer.record (std::make_unique<T_RDO_Container>(origRdoContainer->size(), EventContainers::Mode::OfflineFast)) );
62 
63  CLHEP::HepRandomEngine *rndmEngine{};
64  if (!m_noiseProbability.value().empty()){
65  m_rndmSvc->getEngine(this, m_rngName);
66  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, m_rngName);
67  rngWrapper->setSeed( m_rngName, ctx );
68  rndmEngine = rngWrapper->getEngine(ctx);
69  }
70 
71  unsigned int n_rejected=0u;
72  unsigned int n_split_rdos=0u;
73  unsigned int n_new=0;
74  T_ID_Adapter id_helper(m_idHelper);
75  unsigned int n_added_noise_hits=0u;
76  unsigned int n_defect_noise_hits=0u;
77 
78  std::vector<typename T_ModuleHelper::KEY_TYPE> sorted_keys;
79  for(const InDetRawDataCollection<T_RDORawData>* collection : *origRdoContainer ) {
80  const IdentifierHash idHash = collection->identifyHash();
81  T_ModuleHelper module_helper( emulatedDefects->getDetectorElement(idHash).design() );
82  std::unique_ptr<InDetRawDataCollection<T_RDORawData> >
83  clone = std::make_unique<InDetRawDataCollection<T_RDORawData> >(idHash);
84  clone->setIdentifier(collection->identify());
85  unsigned int rejected_per_mod=0u;
86  unsigned int noise_per_mod=0u;
87  if (!emulatedDefects->isModuleDefect(idHash)) {
88  unsigned int n_cells = module_helper.nCells();
89  unsigned int n_noise_hits=rndmEngine && m_noiseParamIdx.at(idHash)<m_noiseProbability.size()
90  ? CLHEP::RandPoisson::shoot(rndmEngine,
91  n_cells * m_noiseProbability.value()[ m_noiseParamIdx[idHash] ] )
92  : 0u;
93  clone->reserve( collection->size() + n_noise_hits);
94  if (!module_helper) {
95  ATH_MSG_ERROR( "Not module design for " << idHash);
96  return StatusCode::FAILURE;
97  }
98  TH2 *h2_rejected_hits=nullptr;
99  TH2 *h2_noise_hits=nullptr;
100  TH1 *h1_noise_shape=nullptr;
101  if (m_histogrammingEnabled) {
102  std::lock_guard<std::mutex> lock(m_histMutex);
103  std::tuple<TH2 *, TH2 *, TH1 *> hists = findHist(module_helper.nSensorRows(), module_helper.nSensorColumns());
104  h2_rejected_hits=std::get<0>(hists);
105  h2_noise_hits=std::get<1>(hists);
106  h1_noise_shape=std::get<2>(hists);
107  }
108 
109  sorted_keys.clear();
110  sorted_keys.reserve( collection->size()+n_noise_hits);
111  for(const auto *const rdo : *collection) {
112  const Identifier rdoID = rdo->identify();
113 
114  auto row_idx = id_helper.row_index(rdoID);
115  auto col_idx = id_helper.col_index(rdoID);
116 
117  unsigned int n_new_hits = id_helper.cloneOrRejectHit( module_helper, *(emulatedDefects.cptr()), idHash, row_idx, col_idx, *rdo, *clone);
118  if (n_new_hits>0) {
119  n_split_rdos += (n_new_hits-1);
120  for (unsigned int hit_i=n_new_hits; hit_i>0; --hit_i) {
121  auto new_hit = clone->at(clone->size()-hit_i);
122 
123  const Identifier rdoID = new_hit->identify();
124  auto row_idx = id_helper.row_index(rdoID);
125  auto col_idx = id_helper.col_index(rdoID);
126  unsigned int key = module_helper.hardwareCoordinates(row_idx,col_idx);
127  auto iter = std::lower_bound(sorted_keys.begin(), sorted_keys.end(), key);
128  if (iter == sorted_keys.end()) {
129  sorted_keys.push_back(key);
130  }
131  else {
132  if (*iter != key) {
133  sorted_keys.insert(iter, key);
134  }
135  }
136  }
137  }
138  else {
139  if (m_histogrammingEnabled && h2_rejected_hits) {
140  std::lock_guard<std::mutex> lock(m_histMutex);
141  h2_rejected_hits->Fill(col_idx, row_idx);
142  }
143  ++rejected_per_mod;
144  }
145 
146  }
147 
148  // add random noise hits
149  for (unsigned int i=0; i<n_noise_hits; ++i) {
150  for (unsigned int attempt_i=0; attempt_i<10; ++attempt_i) {
151  unsigned int cell_idx=CLHEP::RandFlat::shoot(rndmEngine,n_cells); // %pixels;
152  unsigned int row_idx = cell_idx % module_helper.rows();
153  unsigned int col_idx = cell_idx / module_helper.rows();
154  unsigned int key = module_helper.hardwareCoordinates(row_idx,col_idx);
155  if (emulatedDefects->isDefect(module_helper, idHash, row_idx, col_idx)) {
156  ++n_defect_noise_hits;
157  break;
158  }
159  auto iter = std::lower_bound(sorted_keys.begin(), sorted_keys.end(), key);
160  if (iter == sorted_keys.end()) {
161  sorted_keys.push_back(key);
162  }
163  else {
164  if (*iter != key) {
165  sorted_keys.insert(iter, key);
166  }
167  else {
168  continue;
169  }
170  }
171  float prob = CLHEP::RandFlat::shoot(rndmEngine,1.);
172  assert( m_noiseParamIdx[idHash] < m_noiseShapeCummulative.size() );
173  const std::vector<float> &noise_shape = m_noiseShapeCummulative[ m_noiseParamIdx[idHash] ];
174  unsigned int noise_value=0;
175  for (noise_value=0; noise_value<noise_shape.size(); ++noise_value) {
176  if (noise_shape[noise_value]>prob) {
177  break;
178  }
179  }
180 
181  clone->push_back( id_helper.createNoiseHit( module_helper, collection->identify(), cell_idx, noise_value).release() );
182  if (m_histogrammingEnabled && h2_noise_hits) {
183  unsigned int row_idx = cell_idx % module_helper.rows();
184  unsigned int col_idx = cell_idx / module_helper.rows();
185 
186  std::lock_guard<std::mutex> lock(m_histMutex);
187  h2_noise_hits->Fill(col_idx, row_idx);
188  h1_noise_shape->Fill(noise_value);
189  }
190  ++noise_per_mod;
191  break;
192  }
193  }
194 
195 
196  }
197  else {
198  rejected_per_mod += collection->size();
199  }
200  if (m_histogrammingEnabled) {
201  std::lock_guard<std::mutex> lock(m_histMutex);
202  unsigned int bin_i=m_moduleHist[kRejectedHits]->GetBin( idHash%100+1, idHash/100+1);
203  assert(m_moduleHist[kRejectedHits]->GetNbinsX() == m_moduleHist[kNoiseHits]->GetNbinsX());
204  assert(m_moduleHist[kRejectedHits]->GetNbinsY() == m_moduleHist[kNoiseHits]->GetNbinsY());
205  m_moduleHist[kRejectedHits]->SetBinContent(bin_i, rejected_per_mod );
206  m_moduleHist[kNoiseHits]->SetBinContent(bin_i, noise_per_mod );
207  }
208  n_added_noise_hits += noise_per_mod;
209  n_rejected += rejected_per_mod;
210  n_new += clone->size();
211  rdoOutContainer->addCollection( clone.release(), idHash).ignore();
212  }
213  m_rejectedRDOs += n_rejected;
214  m_totalRDOs += n_new;
215  m_totalNoise += n_added_noise_hits;
216  m_splitRDOs += n_split_rdos;
217  ATH_MSG_DEBUG("rejected " << m_rejectedRDOs << ", copied " << m_totalRDOs << " RDOs"
218  << " noise " << n_added_noise_hits << " (+" << n_defect_noise_hits << ")"
219  << " split hits: " << n_split_rdos);
220 
221  return StatusCode::SUCCESS;
222  }
223 
224 }