ModuleIdentifierMatchUtil.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef INDET_MODULEIDENTIFIERMATCHUTIL_H
#define INDET_MODULEIDENTIFIERMATCHUTIL_H
 
#include "Identifier/Identifier.h"
 
namespace InDet {
 
   namespace ModuleIdentifierMatchUtil {
      namespace detail {
         template <typename T_ID>
         concept IdentifierHelperWithSideConecpt = requires(T_ID id_helper, Identifier id) { id_helper.side(id); };
 
         // helper to to return the side part of an identifier if available or zero
         template <class T_ID>
         inline int getZeroOrSide(const T_ID &id_helper,const Identifier &id) {
            if constexpr(IdentifierHelperWithSideConecpt<decltype(id_helper)>) {
               return id_helper.side(id);
            }
            else {
               return 0;
            }
         }
      }
 
      // helper templates to detect whether a type has the method columns or cells
      template <typename T_ModuleDesign>
      concept HasColumns = requires(T_ModuleDesign design) { design.columns(); };
      template <typename T_ModuleDesign>
      concept HasCells = requires(T_ModuleDesign design) { design.cells(); };
 
      template <typename T_ModuleDesign>
      concept ModuleDesignConcept = HasColumns<T_ModuleDesign> || HasCells<T_ModuleDesign>;
 
      // Get a unique module type identifier which is either based on the number of
      // columns (for pixel) or number of cells (or strips; for strips)
      template <ModuleDesignConcept T_ModuleDesign>
      int getColumnsOrCells(const T_ModuleDesign &moduleDesign) {
         if constexpr(HasColumns<T_ModuleDesign>) {
            return moduleDesign.columns();
         }
         else {
            return moduleDesign.cells();
         }
      }
 

      enum EModulePatternPart {
         kBarrelEndcapSelectRange=0,
         kLayerRange=2,
         kEtaRange=4,
         kPhiRange=6,
         kColumnStripRange=8,
         kLength=10,
         kSideRange=12,
         kAllRows=14,
         kNParts=15
      };
 
      using ModuleData_t = std::array< int, ModuleIdentifierMatchUtil::kAllRows/2 >;

      template <bool test_order, typename T>
      inline bool verifyElementCountAndOrder(const std::vector<std::vector<T> > &arr, std::size_t n_expected, [[maybe_unused]] std::size_t test_n=0) {
         for (const auto &sub_arr : arr) {
            if (sub_arr.size() != n_expected) return false;
            if (test_n%2 != 0 || test_n>=n_expected) return false;
            if constexpr(test_order) {
               for (unsigned int i=0; i<test_n; i+=2) {
                  if (sub_arr.at(i)>sub_arr.at(i+1)) {
                     if (sub_arr.at(i+1)!=-2 || (sub_arr.at(i)!=0 && sub_arr.at(i)!=1)) {
                        return false;
                     }
                  }
               }
            }
         }
         return true;
      }

      inline bool verifyModulePatternList(const std::vector<std::vector<int> > &arr) {
         return verifyElementCountAndOrder<true,int>(arr,kNParts, kAllRows);
      }

      template <typename T>
      inline bool verifyElementCount(const std::vector<std::vector<T> > &arr, std::size_t n_expected) {
         return verifyElementCountAndOrder<false,T>(arr,n_expected, 0);
      }

      inline void setModuleData(EModulePatternPart part, int value, std::array< int, kAllRows/2 > &dest) {
         assert( part%2==0 && static_cast<unsigned int>(part/2)<dest.size());
         dest[part/2] = value;
      }

      template <class T_ID, class T_ModuleDesign>
      inline void setModuleData(const T_ID &id_helper,
                                const Identifier &identifier,
                                const T_ModuleDesign &module_design,
                                ModuleData_t &module_data) {
         setModuleData(kBarrelEndcapSelectRange, id_helper.barrel_ec(identifier), module_data);
         setModuleData(kLayerRange, id_helper.layer_disk(identifier), module_data);
         setModuleData(kEtaRange, id_helper.eta_module(identifier), module_data);
         setModuleData(kPhiRange, id_helper.phi_module(identifier), module_data);
         setModuleData(kColumnStripRange, getColumnsOrCells(module_design), module_data);
         setModuleData(kLength, static_cast<int>(module_design.length()*1e3), module_data);
         setModuleData(kSideRange, detail::getZeroOrSide(id_helper,identifier),module_data);
      }

      inline void moduleMatches( const std::vector<std::vector<int> > &module_pattern,
                          const ModuleData_t &module_data,
                          std::vector<unsigned int> &module_pattern_idx)  {
         module_pattern_idx.clear();
         for (unsigned int pattern_i=0u; pattern_i<module_pattern.size(); ++pattern_i) {
            const std::vector<int> &pattern = module_pattern[pattern_i];
            unsigned int range_i=0;
            bool match=true;
            for (int module_value : module_data) {
               assert( range_i+1 < pattern.size());
               if (module_value<pattern[range_i] || module_value>pattern[range_i+1]) {
                  // test if even/odd filter and continue if it is and that filter passes
                  if (pattern[range_i+1]>=pattern[range_i] || pattern[range_i+1]!=-2 || (module_value & 1) != (pattern[range_i] & 1)) {
                     match=false;
                     break;
                  }
               }
               range_i+=2;
            }
            if (match) {
               module_pattern_idx.push_back(pattern_i);
            }
         }
      }

      inline bool matchesBothSides(const std::vector<int> &a_module_pattern) {
         assert( ModuleIdentifierMatchUtil::kSideRange+1 < a_module_pattern.size() );
         return    a_module_pattern[ModuleIdentifierMatchUtil::kSideRange]
                != a_module_pattern[ModuleIdentifierMatchUtil::kSideRange+1];
      }

      inline bool isSideMatching(const std::vector<int> &a_module_pattern, int side) {
         assert( ModuleIdentifierMatchUtil::kSideRange+1 < a_module_pattern.size() );
         return    side >= a_module_pattern[ModuleIdentifierMatchUtil::kSideRange]
                && side <= a_module_pattern[ModuleIdentifierMatchUtil::kSideRange+1];
      }

      inline bool matchesAllModuleRowsOfSensor(const std::vector<int> &a_module_pattern) {
         assert(ModuleIdentifierMatchUtil::kAllRows < a_module_pattern.size());
         return a_module_pattern[ModuleIdentifierMatchUtil::kAllRows] != 0;
      }
   }
}
#endif