EmulatedDefects.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef INDET_EMULATEDDEFECTS_H
#define INDET_EMULATEDDEFECTS_H
 
#include <vector>
#include <algorithm>
#include <utility>
 
#include "InDetReadoutGeometry/SiDetectorElementCollection.h"
 
namespace InDet {
   template <class T_ModuleHelper>
   class EmulatedDefects : public std::vector<std::vector< typename T_ModuleHelper::KEY_TYPE> >
   {
   public:
      static constexpr bool s_needMasking = T_ModuleHelper::RANGE_FLAG_MASK != 0;
      static constexpr unsigned int MASK_FOR_COMPARISON = T_ModuleHelper::CHIP_MASK | T_ModuleHelper::ROW_MASK | T_ModuleHelper::COL_MASK;
      using KEY_TYPE = typename T_ModuleHelper::KEY_TYPE;
 
      EmulatedDefects(const InDetDD::SiDetectorElementCollection &detector_elements)
         : m_detectorElements(&detector_elements)
      {
         resize( m_detectorElements->size() );
      }

      class greater {
      public:
         /*static (c++23) */ bool operator()(KEY_TYPE key_a, KEY_TYPE key_b) {
            if constexpr(s_needMasking) {
               return (key_a & MASK_FOR_COMPARISON)
                    > (key_b & MASK_FOR_COMPARISON);
            }
            else {
               return key_a
                    > key_b;
            }
         }
      };

      static std::pair< typename std::vector<KEY_TYPE>::iterator,
                        typename std::vector<KEY_TYPE>::iterator> lower_bound(std::vector<KEY_TYPE> &module_defects,
                                                                              KEY_TYPE key) {
         return std::make_pair(  std::lower_bound( module_defects.begin(),module_defects.end(), key, greater()),
                                 module_defects.end());
      }

      static std::pair< typename std::vector<KEY_TYPE>::const_iterator,
                        typename std::vector<KEY_TYPE>::const_iterator> lower_bound(const std::vector<KEY_TYPE> &module_defects,
                                                                                    KEY_TYPE key) {
         return std::make_pair(  std::lower_bound( module_defects.begin(),module_defects.end(), key, greater()),
                                 module_defects.end());
      }

      std::pair< typename std::vector<KEY_TYPE>::const_iterator,
                 typename std::vector<KEY_TYPE>::const_iterator> lower_bound(unsigned int id_hash, KEY_TYPE key) const {
         const std::vector<KEY_TYPE> &module_defects = this->at(id_hash);
         return std::make_pair(  std::lower_bound( module_defects.begin(),module_defects.end(), key, greater()),
                                 module_defects.end());
      }

      static std::pair<KEY_TYPE,KEY_TYPE> getRange(typename std::vector<KEY_TYPE>::const_iterator key_iter) {
         if (T_ModuleHelper::isRangeKey(*key_iter)) {
            auto prev = key_iter;
            --prev;
            return std::make_pair(*key_iter,*prev);
         }
         else {
            return std::make_pair(*key_iter,*key_iter);
         }
      }

      bool isDefect(const T_ModuleHelper &helper, unsigned int id_hash, KEY_TYPE key) const {
         auto [defect_iter, end_iter] =lower_bound(id_hash, key);
         return (defect_iter != end_iter) &&  helper.isMatchingDefect(*defect_iter,key);
      }

      bool isDefect(const T_ModuleHelper &helper, unsigned int id_hash, unsigned int row_idx_aka_phi, unsigned int col_idx_aka_eta) const {
         return isDefect(helper, id_hash, helper.hardwareCoordinates(row_idx_aka_phi, col_idx_aka_eta) );
      }

      bool isModuleDefect(unsigned int id_hash) const {
         return m_moduleIsDefect.at(id_hash);
      }

      void setModuleDefect(unsigned int id_hash) {
         m_moduleIsDefect.at(id_hash)=true;
      }

      const InDetDD::SiDetectorElement &getDetectorElement(unsigned int id_hash) const {
         return *(m_detectorElements->at(id_hash));
      }

      const InDetDD::SiDetectorElementCollection &getDetectorElementCollection() const {
         return *m_detectorElements;
      }
   protected:
      void resize( std::size_t n_modules) {
         std::vector<std::vector< typename T_ModuleHelper::KEY_TYPE> >::resize(n_modules);
         m_moduleIsDefect.resize(n_modules,false);
      }
      std::vector<bool> m_moduleIsDefect;
      const InDetDD::SiDetectorElementCollection *m_detectorElements; // pointer to the detector element collection these defects are for
   };
}
 
#endif