PixelFEUtils.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
#ifndef PIXELFEUTILS_H
#define PIXELFEUTILS_H
 
#include "InDetReadoutGeometry/SiDetectorElementStatus.h"
#include "PixelReadoutGeometry/PixelModuleDesign.h"
#include "InDetIdentifier/PixelID.h"
#include <algorithm>
#include <tuple>
#include <limits>
#include <cassert>
 
namespace Pixel {
 
   template <typename T>
   inline std::tuple<T,T> sorted_tuple(T a, T b) {
      return (a<b ? std::make_tuple(a,b) : std::make_tuple(b,a) );
   }
 
   inline double getGoodFraction(const InDet::SiDetectorElementStatus &pixelDetElStatus,
                                 const InDetDD::PixelModuleDesign &design,
                                 const PixelID &pixelID,
                                 const IdentifierHash &modulIdHash,
                                 const Identifier &startId,
                                 const Identifier &endId) {
      auto [phiStart,phiEnd] = sorted_tuple( pixelID.phi_index(startId), pixelID.phi_index(endId) );
      auto [etaStart,etaEnd] = sorted_tuple( pixelID.eta_index(startId), pixelID.eta_index(endId) );
 
      double nTotal = (phiEnd-phiStart+1.0)*(etaEnd-etaStart+1.0);
 
      unsigned int nGood=0;
      for (int i=phiStart; i<=phiEnd; i++) {
         for (int j=etaStart; j<=etaEnd; j++) {
 
            std::array<InDetDD::PixelDiodeTree::CellIndexType,2> diode_idx
               = InDetDD::PixelDiodeTree::makeCellIndex(i,j);
            InDetDD::PixelDiodeTree::DiodeProxy si_param ( design.diodeProxyFromIdx(diode_idx));
            std::uint32_t feValue = design.getFE(si_param);
 
            if (pixelDetElStatus.isChipGood(modulIdHash,feValue)) {++nGood;}
         }
      }
      return nGood/nTotal;
   }
 
   inline unsigned int makeReadoutTechnologyBit( InDetDD::PixelReadoutTechnology technology, unsigned int bit_val=1 ) {
      assert(static_cast<unsigned int>(technology) < 31);
      return bit_val << static_cast<unsigned int>(technology);
   }
 
   inline bool matchingReadoutTechnology(const InDet::SiDetectorElementStatus &elementStatus,
                                         const IdentifierHash &moduleIdHash,
                                         unsigned int readOutTechnologyMask = (    Pixel::makeReadoutTechnologyBit(InDetDD::PixelReadoutTechnology::FEI4)
                                                                               | ( Pixel::makeReadoutTechnologyBit(InDetDD::PixelReadoutTechnology::FEI3) ) ))
   {
      const InDetDD::SiDetectorElement *element = elementStatus.getDetectorElement(moduleIdHash);
      const InDetDD::PixelModuleDesign &p_design = dynamic_cast<const InDetDD::PixelModuleDesign &>(element->design());
      return ( static_cast<uint64_t>(p_design.getReadoutTechnology()) < 31ul && readOutTechnologyMask & Pixel::makeReadoutTechnologyBit(p_design.getReadoutTechnology()) );
   }
 
}
#endif