ActsTrk::NNinput Class Reference

#include <NNPixelClusterCalibratorHelpers.h>

Collaboration diagram for ActsTrk::NNinput:

Public Types
enum class	Index : index_t {   chargeOffset = 0 , windowSize = 7 , center = (windowSize - 1) / 2 , halfSize = center ,   chargeEnd = windowSize * windowSize , pitchYOffset = chargeEnd , pitchXOffset = pitchYOffset + windowSize , layer = pitchXOffset + windowSize ,   bec = layer + 1 , phi = bec + 1 , theta = phi + 1 , totalSize = theta + 1 }
using	payload_t = float
using	index_t = int

Public Member Functions
	NNinput ()
std::vector< payload_t > &	payload ()
float	totCharge () const
void	setPixelCharge (index_t x, index_t y, payload_t charge)
void	setPixelXPitch (index_t i, payload_t pitch)
payload_t	getPixelXPitch (index_t i) const
void	setPixelYPitch (index_t i, payload_t pitch)
void	set (Index i, payload_t v)
float	indexCoordToRealCoord (float coord, Index pitchOffset)
	translates position returned from the network to mm The position returned from the network is given in the "index" space while it needs to be be in mm.
float	precisionToRealCoord (float prec, Index pitchOffset)
	translate RMS that is output from NN to detector units (mm) Conversion is done by integrating the actual pitches, so non-uniform pitch (ITk long/end pixels, 25 um modules) is handled.

Static Public Member Functions
static int	toNNinputIndex (index_t pixelIndex, index_t centerIndex)
	Translate from module indices to NNinput indices e.g.
static int	toModuleIndex (index_t nnIndex, index_t centerIndex)
	Reverse operation to toNNInputIndex.
static bool	inWindow (index_t x, index_t y)

Public Attributes
InDetDD::SiCellId	centerCell
	!
InDetDD::SiLocalPosition	centerPosition

Private Member Functions
void	checkRange (index_t i, const std::string &context) const
	! storage for NN input

Private Attributes
std::vector< payload_t >	m_payload

Detailed Description

Definition at line 20 of file NNPixelClusterCalibratorHelpers.h.

Member Typedef Documentation

index_t

using ActsTrk::NNinput::index_t = int

Definition at line 23 of file NNPixelClusterCalibratorHelpers.h.

payload_t

using ActsTrk::NNinput::payload_t = float

Definition at line 22 of file NNPixelClusterCalibratorHelpers.h.

Member Enumeration Documentation

Index

enum class ActsTrk::NNinput::Index : index_t

strong

Enumerator
chargeOffset
windowSize
center
halfSize
chargeEnd
pitchYOffset
pitchXOffset
layer
bec
phi
theta
totalSize

Definition at line 24 of file NNPixelClusterCalibratorHelpers.h.

                   : index_t {
    chargeOffset = 0,
    windowSize = 7,
    center = (windowSize - 1) / 2,  // this should be index of center point
    halfSize = center,
    chargeEnd = windowSize * windowSize,
    pitchYOffset = chargeEnd,
    pitchXOffset = pitchYOffset + windowSize,
    layer = pitchXOffset + windowSize,
    bec = layer + 1,
    phi = bec + 1,
    theta = phi + 1,
    totalSize = theta + 1
  };

Constructor & Destructor Documentation

NNinput()

ActsTrk::NNinput::NNinput ( )

inline

Definition at line 38 of file NNPixelClusterCalibratorHelpers.h.

: m_payload(static_cast<index_t>(Index::totalSize), {}) {}

Member Function Documentation

checkRange()

void ActsTrk::NNinput::checkRange ( index_t i, const std::string & context ) const

inlineprivate

! storage for NN input

validates index arguments passed to setters

Definition at line 176 of file NNPixelClusterCalibratorHelpers.h.

                                                             {
    if (i >= static_cast<index_t>(Index::windowSize))
      throw std::domain_error(
          "Filling the NNinput for pixel calibration, the value should be "
          "within 0-6, while it "
          "is " +
          std::to_string(i) + " " + context);
  }

getPixelXPitch()

payload_t ActsTrk::NNinput::getPixelXPitch ( index_t i ) const

inline

Definition at line 58 of file NNPixelClusterCalibratorHelpers.h.

                                            {
    return m_payload[static_cast<index_t>(Index::pitchXOffset) + i];
  }

indexCoordToRealCoord()

float ActsTrk::NNinput::indexCoordToRealCoord ( float coord, Index pitchOffset )

inline

translates position returned from the network to mm The position returned from the network is given in the "index" space while it needs to be be in mm.

Simplifying, the returned position need to be multiplied by pitch however, due to uneven pitch size the translation is slightly trickier. The code is reverse engineered from: https://pixsplit.docs.cern.ch/export/ and associated python implementation

Parameters

coord	- position in nn coordinates
pitchOffset	- either pitchXOffset or pitchYOffset - place where pitches vectors are stored

Returns

position shift in mm

Definition at line 103 of file NNPixelClusterCalibratorHelpers.h.

                                                              {
    std::span<payload_t, static_cast<index_t>(Index::windowSize)> pitches(
        m_payload.begin() + static_cast<index_t>(pitchOffset),
        m_payload.begin() + static_cast<index_t>(pitchOffset) +
            static_cast<index_t>(Index::windowSize));
    const std::size_t windowSize = static_cast<std::size_t>(Index::windowSize);
 
    std::array<double, static_cast<std::size_t>(Index::windowSize)>
        cumulative{};
    double acc = 0.0;
    for (std::size_t j = 0; j < windowSize; ++j) {
      acc += pitches[j];
      cumulative[j] = acc;
    }
 
    const std::size_t centerIdx = static_cast<std::size_t>(Index::center);
    const double centerValue = cumulative[centerIdx];
    for (double& value : cumulative) {
      value -= centerValue;
    }
 
    const double coordsIdx = coord + static_cast<double>(Index::center) ;
    const double floorValue = std::floor(coordsIdx);
    const double frac = floorValue - coordsIdx;
    const long intIdx = static_cast<long>(floorValue);
    const long clippedIdx = std::clamp(intIdx, static_cast<long>(0),
                                       static_cast<long>(windowSize) - 1);
    const double base = cumulative[clippedIdx];
    const double pitchAtIdx = pitches[clippedIdx];
    const double centerOfCluster = pitchOffset == Index::pitchXOffset
                                       ? this->centerPosition.xPhi()
                                       : this->centerPosition.xEta();
    return base + std::abs(frac) * pitchAtIdx + centerOfCluster;
  }

inWindow()

bool ActsTrk::NNinput::inWindow ( index_t x, index_t y )

inlinestatic

Definition at line 87 of file NNPixelClusterCalibratorHelpers.h.

                                             {
    return x >= 0 && x < static_cast<index_t>(Index::windowSize) && y >= 0 &&
           y < static_cast<index_t>(Index::windowSize);
  }

payload()

std::vector< payload_t > & ActsTrk::NNinput::payload ( )

inline

Definition at line 39 of file NNPixelClusterCalibratorHelpers.h.

{ return m_payload; }

precisionToRealCoord()

float ActsTrk::NNinput::precisionToRealCoord ( float prec, Index pitchOffset )

inline

translate RMS that is output from NN to detector units (mm) Conversion is done by integrating the actual pitches, so non-uniform pitch (ITk long/end pixels, 25 um modules) is handled.

size is m_sizeX in phi (x), m_sizeY in eta (y). this code is adopted from NNClusterizationFactory

Parameters

prec	precision returned by NN
pitchOffset	either pitchXOffset or pitchYOffset

Returns

Definition at line 146 of file NNPixelClusterCalibratorHelpers.h.

                                                            {
    std::span<payload_t, static_cast<index_t>(Index::windowSize)> pitches(
        m_payload.begin() + static_cast<index_t>(pitchOffset),
        m_payload.begin() + static_cast<index_t>(pitchOffset) +
            static_cast<index_t>(Index::windowSize));
 
    const float p = ((prec > 0) ? std::sqrt(1.0f / prec) : 0.01f) +
                    static_cast<float>(Index::center);
    float pitchPos = -100;     // unset position
    float pitchCenter = -100;  // unset position
    float pitchActual = 0;     // integral of pitch sizes
    for (index_t i = 0; i < static_cast<index_t>(Index::windowSize); i++) {
      if (p >= i and p <= (i + 1))
        pitchPos = pitchActual + (p - i + 0.5) * pitches[i];
      if (i == static_cast<index_t>(Index::center))
        pitchCenter = pitchActual + 0.5 * pitches[i];
      pitchActual += pitches[i];
    }
    return std::abs(pitchPos - pitchCenter);
  }

set()

void ActsTrk::NNinput::set ( Index i, payload_t v )

inline

Definition at line 67 of file NNPixelClusterCalibratorHelpers.h.

{ m_payload[static_cast<index_t>(i)] = v; }

setPixelCharge()

void ActsTrk::NNinput::setPixelCharge ( index_t x, index_t y, payload_t charge )

inline

Definition at line 45 of file NNPixelClusterCalibratorHelpers.h.

                                                              {
    checkRange(x, "x of coordinate of the charge");
    checkRange(y, "x of coordinate of the charge");
 
    m_payload[static_cast<index_t>(Index::chargeOffset) +
              x * static_cast<index_t>(Index::windowSize) + y] = charge;
  }

setPixelXPitch()

void ActsTrk::NNinput::setPixelXPitch ( index_t i, payload_t pitch )

inline

Definition at line 53 of file NNPixelClusterCalibratorHelpers.h.

                                                  {
    checkRange(i, "x pitch");
    m_payload[static_cast<index_t>(Index::pitchXOffset) + i] = pitch;
  }

setPixelYPitch()

void ActsTrk::NNinput::setPixelYPitch ( index_t i, payload_t pitch )

inline

Definition at line 62 of file NNPixelClusterCalibratorHelpers.h.

                                                  {
    checkRange(i, "y pitch");
    m_payload[static_cast<index_t>(Index::pitchYOffset) + i] = pitch;
  }

toModuleIndex()

int ActsTrk::NNinput::toModuleIndex ( index_t nnIndex, index_t centerIndex )

inlinestatic

Reverse operation to toNNInputIndex.

Parameters

nnIndex	pixel index in NN repsentation
centerIndex	cluster center

Returns

pixel index in module

Definition at line 83 of file NNPixelClusterCalibratorHelpers.h.

                                                                 {
    return nnIndex + centerIndex - static_cast<NNinput::index_t>(Index::center);
  }

toNNinputIndex()

int ActsTrk::NNinput::toNNinputIndex ( index_t pixelIndex, index_t centerIndex )

inlinestatic

Translate from module indices to NNinput indices e.g.

if the cluster is of size 3 and indices of pixels are 23,24,25

Parameters

pixelIndex
centerIndex

Returns

Definition at line 75 of file NNPixelClusterCalibratorHelpers.h.

                                                                     {
    return pixelIndex - centerIndex +
           static_cast<NNinput::index_t>(Index::center);
  }

totCharge()

float ActsTrk::NNinput::totCharge ( ) const

inline

Definition at line 40 of file NNPixelClusterCalibratorHelpers.h.

                          {
    return std::accumulate(
        std::begin(m_payload) + static_cast<index_t>(Index::chargeOffset),
        std::begin(m_payload) + static_cast<index_t>(Index::chargeEnd), 0.0f);
  }

Member Data Documentation

centerCell

InDetDD::SiCellId ActsTrk::NNinput::centerCell

!

to avoid need to calculate them once more time when translating from index biases to local module coordinates

Definition at line 169 of file NNPixelClusterCalibratorHelpers.h.

centerPosition

InDetDD::SiLocalPosition ActsTrk::NNinput::centerPosition

Definition at line 170 of file NNPixelClusterCalibratorHelpers.h.

m_payload

std::vector<payload_t> ActsTrk::NNinput::m_payload

private

Definition at line 173 of file NNPixelClusterCalibratorHelpers.h.

---

The documentation for this class was generated from the following file:

• NNPixelClusterCalibratorHelpers.h