RectangularPixelPhase2Topology Class Reference

#include <RectangularPixelPhase2Topology.h>

Inheritance diagram for RectangularPixelPhase2Topology:

Public Member Functions
bool	bigpixelsX () const override
bool	bigpixelsY () const override
int	bigpixperrocX () const
int	bigpixperrocY () const
int	channel (const LocalPoint &lp) const override
int	colsperroc () const override
bool	containsBigPixelInX (int ixmin, int ixmax) const override
bool	containsBigPixelInY (int iymin, int iymax) const override
bool	isItBigPixelInX (const int ixbin) const override
bool	isItBigPixelInY (const int iybin) const override
bool	isItEdgePixel (int ixbin, int iybin) const override
bool	isItEdgePixelInX (int ixbin) const override
bool	isItEdgePixelInY (int iybin) const override
LocalError	localError (const MeasurementPoint &, const MeasurementError &) const override
LocalPoint	localPosition (const MeasurementPoint &mp) const override
float	localX (const float mpX) const override
float	localY (const float mpY) const override
MeasurementError	measurementError (const LocalPoint &, const LocalError &) const override
MeasurementPoint	measurementPosition (const LocalPoint &lp) const override
int	ncolumns () const override
int	nrows () const override
std::pair< float, float >	pitch () const override
float	pitchbigpixelX () const
float	pitchbigpixelY () const
std::pair< float, float >	pixel (const LocalPoint &p) const override
float	pixelFractionInX (const int ixbin) const override
float	pixelFractionInY (const int iybin) const override
	RectangularPixelPhase2Topology (int nrows, int ncols, float pitchx, float pitchy, int ROWS_PER_ROC, int COLS_PER_ROC, int BIG_PIX_PER_ROC_X, int BIG_PIX_PER_ROC_Y, float BIG_PIX_PITCH_X, float BIG_PIX_PITCH_Y, int ROCS_X, int ROCS_Y)
int	rocsX () const override
int	rocsY () const override
int	rowsperroc () const override
float	xoffset () const
float	yoffset () const
Public Member Functions inherited from PixelTopology
virtual float	localX (const float mpX, const Topology::LocalTrackPred &) const
virtual float	localY (const float mpY, const Topology::LocalTrackPred &) const
virtual std::pair< float, float >	pixel (const LocalPoint &p, const Topology::LocalTrackAngles &) const
	conversion taking also the angle from the track state More...
	~PixelTopology () override
Public Member Functions inherited from Topology
virtual int	channel (const LocalPoint &lp, const LocalTrackAngles &) const
	conversion taking also the angle from the track state More...
virtual LocalError	localError (const MeasurementPoint &mp, const MeasurementError &me, const LocalTrackPred &) const
	conversion taking also the angle from the predicted track state More...
virtual LocalPoint	localPosition (const MeasurementPoint &mp, const LocalTrackPred &) const
	conversion taking also the angle from the predicted track state More...
virtual MeasurementError	measurementError (const LocalPoint &lp, const LocalError &le, const LocalTrackAngles &) const
	conversion taking also the angle from the track state More...
virtual MeasurementPoint	measurementPosition (const LocalPoint &lp, const LocalTrackAngles &) const
	conversion taking also the angle from the track state More...
virtual	~Topology ()

Private Member Functions
bool	containsBigPixel (int iMin, int iMax, int nPxTot, int nPxBigPerROC) const

Private Attributes
int	m_BIG_PIX_PER_ROC_X
int	m_BIG_PIX_PER_ROC_Y
float	m_BIG_PIX_PITCH_X
float	m_BIG_PIX_PITCH_Y
int	m_COLS_PER_ROC
int	m_ncols
int	m_nrows
float	m_pitchx
float	m_pitchy
int	m_ROCS_X
int	m_ROCS_Y
int	m_ROWS_PER_ROC
float	m_xoffset
float	m_yoffset

Additional Inherited Members
Public Types inherited from Topology
typedef Point2DBase< double, LocalTag >	Local2DPoint
typedef Vector2D::MathVector	MathVector2D
typedef Basic2DVector< double >	Vector2D

Detailed Description

Topology for rectangular pixel detector with BIG pixels.

Definition at line 26 of file RectangularPixelPhase2Topology.h.

Constructor & Destructor Documentation

RectangularPixelPhase2Topology()

RectangularPixelPhase2Topology::RectangularPixelPhase2Topology ( int  nrows, int  ncols, float  pitchx, float  pitchy, int  ROWS_PER_ROC, int  COLS_PER_ROC, int  BIG_PIX_PER_ROC_X, int  BIG_PIX_PER_ROC_Y, float  BIG_PIX_PITCH_X, float  BIG_PIX_PITCH_Y, int  ROCS_X, int  ROCS_Y  )

inline

Definition at line 29 of file RectangularPixelPhase2Topology.h.

References LogDebug, m_BIG_PIX_PER_ROC_X, m_BIG_PIX_PER_ROC_Y, m_BIG_PIX_PITCH_X, m_BIG_PIX_PITCH_Y, m_COLS_PER_ROC, m_ncols, m_nrows, m_pitchx, m_pitchy, m_ROCS_X, m_ROCS_Y, m_ROWS_PER_ROC, m_xoffset, and m_yoffset.

      : m_pitchx(pitchx),
        m_pitchy(pitchy),
        m_nrows(nrows),
        m_ncols(ncols),
        m_ROWS_PER_ROC(ROWS_PER_ROC),            // Num of Rows per ROC
        m_COLS_PER_ROC(COLS_PER_ROC),            // Num of Cols per ROC
        m_BIG_PIX_PER_ROC_X(BIG_PIX_PER_ROC_X),  //
        m_BIG_PIX_PER_ROC_Y(BIG_PIX_PER_ROC_Y),  //
        m_BIG_PIX_PITCH_X(BIG_PIX_PITCH_X),
        m_BIG_PIX_PITCH_Y(BIG_PIX_PITCH_Y),
        m_ROCS_X(ROCS_X),  //
        m_ROCS_Y(ROCS_Y)   //
  {
    // Calculate the edge of the active sensor with respect to the center,
    // that is simply the half-size.
    // Take into account large pixels
    m_xoffset = -(
        (m_nrows / 2 - m_BIG_PIX_PER_ROC_X) * m_pitchx +
        m_BIG_PIX_PER_ROC_X *
            m_BIG_PIX_PITCH_X);  // assuming the big pixel pitch is well computed it gets always in the middle regardless the number of big pixel.  Quad is 670*0.025 + 2*0.0875; double is 336* 0.025; 3D is 336*0.025; old geom is 672*faxe x pitch
    m_yoffset = -((m_ncols / 2 - m_BIG_PIX_PER_ROC_Y) * m_pitchy + m_BIG_PIX_PER_ROC_Y * m_BIG_PIX_PITCH_Y);

    LogDebug("RectangularPixelPhase2Topology")
        << "nrows " << m_nrows << ", ncols " << m_ncols << ", pitchx " << m_pitchx << ", pitchy " << m_pitchy
        << ", xoffset " << m_xoffset << ", yoffset " << m_yoffset << ", BIG_PIX_PER_ROC_X " << BIG_PIX_PER_ROC_X
        << ", BIG_PIX_PER_ROC_Y " << BIG_PIX_PER_ROC_Y << ", BIG_PIX_PITCH_X " << BIG_PIX_PITCH_X
        << ", BIG_PIX_PITCH_Y " << BIG_PIX_PITCH_Y << ", ROWS_PER_ROC " << ROWS_PER_ROC << ", COLS_PER_ROC "
        << COLS_PER_ROC << ", ROCS_X " << ROCS_X << ", ROCS_Y " << ROCS_Y << "\nNROWS " << m_ROWS_PER_ROC * m_ROCS_X
        << ", NCOL " << m_COLS_PER_ROC * m_ROCS_Y;
  }

Member Function Documentation

bigpixelsX()

bool RectangularPixelPhase2Topology::bigpixelsX ( ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 165 of file RectangularPixelPhase2Topology.h.

{ return false; }

bigpixelsY()

bool RectangularPixelPhase2Topology::bigpixelsY ( ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 166 of file RectangularPixelPhase2Topology.h.

{ return false; }

bigpixperrocX()

int RectangularPixelPhase2Topology::bigpixperrocX ( ) const

inline

Definition at line 192 of file RectangularPixelPhase2Topology.h.

References m_BIG_PIX_PER_ROC_X.

{ return m_BIG_PIX_PER_ROC_X; }

bigpixperrocY()

int RectangularPixelPhase2Topology::bigpixperrocY ( ) const

inline

Definition at line 193 of file RectangularPixelPhase2Topology.h.

References m_BIG_PIX_PER_ROC_Y.

{ return m_BIG_PIX_PER_ROC_Y; }

channel()

int RectangularPixelPhase2Topology::channel ( const LocalPoint &  lp ) const

inlineoverridevirtual

Implements Topology.

Definition at line 95 of file RectangularPixelPhase2Topology.h.

References AlCaHLTBitMon_ParallelJobs::p, pixel(), and PixelChannelIdentifier::pixelToChannel().

                                                   {
    std::pair<float, float> p = pixel(lp);
    return PixelChannelIdentifier::pixelToChannel(int(p.first), int(p.second));
  }

colsperroc()

int RectangularPixelPhase2Topology::colsperroc ( ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 191 of file RectangularPixelPhase2Topology.h.

References m_COLS_PER_ROC.

{ return m_COLS_PER_ROC; }

containsBigPixel()

bool RectangularPixelPhase2Topology::containsBigPixel ( int  iMin, int  iMax, int  nPxTot, int  nPxBigPerROC  ) const

inlineprivate

Definition at line 215 of file RectangularPixelPhase2Topology.h.

Referenced by containsBigPixelInX(), and containsBigPixelInY().

                                                                                {
    // nPxTot/2 should lie in the upper half of the dimension
    auto firstBigPixel = nPxTot / 2 - nPxBigPerROC;
    auto lastBigPixel = nPxTot / 2 - 1 + nPxBigPerROC;

    // the interval contains no big pixel when either of the following is met:
    // - there are no big pixels
    // - the whole interval lies to the right of the big pixel chunk
    // - the whole interval lies to the left of the big pixel chunk
    bool noBigPixel = (nPxBigPerROC == 0) || (iMin > lastBigPixel) || (iMax < firstBigPixel);

    return !noBigPixel;
  }

containsBigPixelInX()

bool RectangularPixelPhase2Topology::containsBigPixelInX ( int  ixmin, int  ixmax  ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 157 of file RectangularPixelPhase2Topology.h.

References containsBigPixel(), m_BIG_PIX_PER_ROC_X, and m_nrows.

                                                                {
    return containsBigPixel(ixmin, ixmax, m_nrows, m_BIG_PIX_PER_ROC_X);
  }

containsBigPixelInY()

bool RectangularPixelPhase2Topology::containsBigPixelInY ( int  iymin, int  iymax  ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 161 of file RectangularPixelPhase2Topology.h.

References containsBigPixel(), m_BIG_PIX_PER_ROC_Y, and m_ncols.

                                                                {
    return containsBigPixel(iymin, iymax, m_ncols, m_BIG_PIX_PER_ROC_Y);
  }

isItBigPixelInX()

bool RectangularPixelPhase2Topology::isItBigPixelInX ( const int  ixbin ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 109 of file RectangularPixelPhase2Topology.h.

References funct::abs(), m_BIG_PIX_PER_ROC_X, and m_nrows.

Referenced by localError().

                                                       {
    bool no_big_pixel = (m_BIG_PIX_PER_ROC_X == 0);
    if (!no_big_pixel)
      no_big_pixel = std::abs((ixbin - m_nrows / 2) + 0.5) > m_BIG_PIX_PER_ROC_X;

    return !no_big_pixel;
  }

isItBigPixelInY()

bool RectangularPixelPhase2Topology::isItBigPixelInY ( const int  iybin ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 117 of file RectangularPixelPhase2Topology.h.

References funct::abs(), m_BIG_PIX_PER_ROC_Y, and m_ncols.

Referenced by localError().

                                                       {
    bool no_big_pixel = (m_BIG_PIX_PER_ROC_Y == 0);
    if (!no_big_pixel)
      no_big_pixel = std::abs((iybin - m_ncols / 2) + 0.5) > m_BIG_PIX_PER_ROC_Y;

    return !no_big_pixel;
  }

isItEdgePixel()

bool RectangularPixelPhase2Topology::isItEdgePixel ( int  ixbin, int  iybin  ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 173 of file RectangularPixelPhase2Topology.h.

References isItEdgePixelInX(), and isItEdgePixelInY().

                                                          {
    return (isItEdgePixelInX(ixbin) || isItEdgePixelInY(iybin));
  }

isItEdgePixelInX()

bool RectangularPixelPhase2Topology::isItEdgePixelInX ( int  ixbin ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 171 of file RectangularPixelPhase2Topology.h.

References m_nrows.

Referenced by isItEdgePixel().

{ return ((ixbin == 0) | (ixbin == (m_nrows - 1))); }

isItEdgePixelInY()

bool RectangularPixelPhase2Topology::isItEdgePixelInY ( int  iybin ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 172 of file RectangularPixelPhase2Topology.h.

References m_ncols.

Referenced by isItEdgePixel().

{ return ((iybin == 0) | (iybin == (m_ncols - 1))); }

localError()

LocalError RectangularPixelPhase2Topology::localError ( const MeasurementPoint &  mp, const MeasurementError &  me  ) const

overridevirtual

Implements Topology.

Definition at line 281 of file RectangularPixelPhase2Topology.cc.

References nano_mu_digi_cff::float, createfilelist::int, isItBigPixelInX(), isItBigPixelInY(), m_pitchx, m_pitchy, hlt_dqm_clientPB-live_cfg::me, PV2DBase< T, PVType, FrameType >::x(), and PV2DBase< T, PVType, FrameType >::y().

                                                                                                                  {
  float pitchy = m_pitchy;
  int binoffy = int(mp.y());
  if (isItBigPixelInY(binoffy))
    pitchy = 2. * m_pitchy;

  float pitchx = m_pitchx;
  int binoffx = int(mp.x());
  if (isItBigPixelInX(binoffx))
    pitchx = 2. * m_pitchx;

  return LocalError(me.uu() * float(pitchx * pitchx), 0, me.vv() * float(pitchy * pitchy));
}

localPosition()

LocalPoint RectangularPixelPhase2Topology::localPosition ( const MeasurementPoint &  mp ) const

overridevirtual

Implements Topology.

Definition at line 157 of file RectangularPixelPhase2Topology.cc.

References hcal_dqm_sourceclient-live_cfg::debugstr, EPS, nano_mu_digi_cff::float, localX(), localY(), LogDebug, m_ncols, m_nrows, PV2DBase< T, PVType, FrameType >::x(), and PV2DBase< T, PVType, FrameType >::y().

                                                                                         {
  float mpy = mp.y();  // measurements
  float mpx = mp.x();

#ifdef EDM_ML_DEBUG
#define EPS 0
  // check limits
  std::ostringstream debugstr;

  if (mpy < 0.) {
    debugstr << " wrong mp y, fix " << mpy << " " << 0 << "\n";
    mpy = 0.;
  }
  if (mpy >= m_ncols) {
    debugstr << " wrong mp y, fix " << mpy << " " << m_ncols << "\n";
    mpy = float(m_ncols) - EPS;  // EPS is a small number
  }
  if (mpx < 0.) {
    debugstr << " wrong mp x, fix " << mpx << " " << 0 << "\n";
    mpx = 0.;
  }
  if (mpx >= m_nrows) {
    debugstr << " wrong mp x, fix " << mpx << " " << m_nrows << "\n";
    mpx = float(m_nrows) - EPS;  // EPS is a small number
  }
  if (!debugstr.str().empty())
    LogDebug("RectangularPixelPhase2Topology") << debugstr.str();
#endif  // EDM_ML_DEBUG

  float lpY = localY(mpy);
  float lpX = localX(mpx);

  // Return it as a LocalPoint
  return LocalPoint(lpX, lpY);
}

localX()

float RectangularPixelPhase2Topology::localX ( const float  mpX ) const

overridevirtual

Implements PixelTopology.

Definition at line 197 of file RectangularPixelPhase2Topology.cc.

References nano_mu_digi_cff::float, createfilelist::int, LogDebug, m_BIG_PIX_PITCH_X, m_nrows, m_pitchx, m_ROCS_X, m_ROWS_PER_ROC, and m_xoffset.

Referenced by localPosition().

                                                                  {
  int binoffx = int(mpx);                  // truncate to int
  float fractionX = mpx - float(binoffx);  // find the fraction
  float local_pitchx = m_pitchx;           // defaultpitch
  int ispix_secondhalf_x = 0;

  if (binoffx >= (m_nrows / 2 - 2 + 2 * m_nrows / m_ROWS_PER_ROC)) {  // ROC 1 - handles x on edge cluster
    binoffx = binoffx - 2 * m_nrows / m_ROWS_PER_ROC;
    ispix_secondhalf_x = 1;
  } else if (((m_nrows / 2 - 2) <= binoffx) && (binoffx < (m_nrows / 2 - 2 + 2 * m_nrows / m_ROWS_PER_ROC))) {  // ROC 1
    binoffx = m_nrows / 2 - 2;
    fractionX = mpx - float(m_nrows / 2 - 2);
    local_pitchx = m_BIG_PIX_PITCH_X;
  }

#ifdef EDM_ML_DEBUG
  if (binoffx > m_ROWS_PER_ROC * m_ROCS_X)  // too large
  {
    LogDebug("RectangularPixelPhase2Topology")
        << " very bad, binx " << binoffx << "\n"
        << mpx << " " << binoffx << " " << fractionX << " " << local_pitchx << " " << m_xoffset << "\n";
  }
#endif

  // The final position in local coordinates
  float lpX = float(binoffx * m_pitchx) + fractionX * local_pitchx +
              ispix_secondhalf_x * 2 * m_BIG_PIX_PITCH_X * m_nrows / m_ROWS_PER_ROC + m_xoffset;

#ifdef EDM_ML_DEBUG

  if (lpX < m_xoffset || lpX > (-m_xoffset)) {
    LogDebug("RectangularPixelPhase2Topology")
        << " bad lp x " << lpX << "\n"
        << mpx << " " << binoffx << " " << fractionX << " " << local_pitchx << " " << m_xoffset;
  }
#endif  // EDM_ML_DEBUG

  return lpX;
}

localY()

float RectangularPixelPhase2Topology::localY ( const float  mpY ) const

overridevirtual

Implements PixelTopology.

Definition at line 239 of file RectangularPixelPhase2Topology.cc.

References nano_mu_digi_cff::float, createfilelist::int, LogDebug, m_BIG_PIX_PITCH_Y, m_COLS_PER_ROC, m_ncols, m_pitchy, m_ROCS_Y, and m_yoffset.

Referenced by localPosition().

                                                                  {
  int binoffy = int(mpy);                  // truncate to int
  float fractionY = mpy - float(binoffy);  // find the fraction
  float local_pitchy = m_pitchy;           // defaultpitch
  int ispix_secondhalf_y = 0;

  if (binoffy >= (m_ncols / 2 - 1 + m_ncols / m_COLS_PER_ROC)) {  // ROC 1 - handles x on edge cluster
    binoffy = binoffy - m_ncols / m_COLS_PER_ROC;
    ispix_secondhalf_y = 1;
  } else if (((m_ncols / 2 - 1) <= binoffy) && (binoffy < (m_ncols / 2 - 1 + m_ncols / m_COLS_PER_ROC))) {  // ROC 1
    binoffy = m_ncols / 2 - 1;
    fractionY = mpy - float(m_ncols / 2 - 1);
    local_pitchy = m_BIG_PIX_PITCH_Y;
  }

#ifdef EDM_ML_DEBUG
  if (binoffy > m_ROCS_Y * m_COLS_PER_ROC)  // too large
  {
    LogDebug("RectangularPixelPhase2Topology")
        << " very bad, biny " << binoffy << "\n"
        << mpy << " " << binoffy << " " << fractionY << " " << local_pitchy << " " << m_yoffset;
  }
#endif

  // The final position in local coordinates   // using an int to switch first or second half of the module.
  float lpY = float(binoffy * m_pitchy) + fractionY * local_pitchy +
              ispix_secondhalf_y * m_BIG_PIX_PITCH_Y * m_ncols / m_COLS_PER_ROC + m_yoffset;

#ifdef EDM_ML_DEBUG

  if (lpY < m_yoffset || lpY > (-m_yoffset)) {
    LogDebug("RectangularPixelPhase2Topology")
        << " bad lp y " << lpY << "\n"
        << mpy << " " << binoffy << " " << fractionY << " " << local_pitchy << " " << m_yoffset;
  }
#endif  // EDM_ML_DEBUG

  return lpY;
}

measurementError()

MeasurementError RectangularPixelPhase2Topology::measurementError ( const LocalPoint &  lp, const LocalError &  le  ) const

overridevirtual

Implements Topology.

Definition at line 297 of file RectangularPixelPhase2Topology.cc.

References nano_mu_digi_cff::float, m_pitchx, m_pitchy, LocalError::xx(), and LocalError::yy().

                                                                                                                  {
  float pitchy = m_pitchy;
  float pitchx = m_pitchx;

  return MeasurementError(le.xx() / float(pitchx * pitchx), 0, le.yy() / float(pitchy * pitchy));
}

measurementPosition()

MeasurementPoint RectangularPixelPhase2Topology::measurementPosition ( const LocalPoint &  lp ) const

inlineoverridevirtual

Implements Topology.

Definition at line 77 of file RectangularPixelPhase2Topology.h.

References AlCaHLTBitMon_ParallelJobs::p, and pixel().

                                                                            {
    std::pair<float, float> p = pixel(lp);
    return MeasurementPoint(p.first, p.second);
  }

ncolumns()

int RectangularPixelPhase2Topology::ncolumns ( ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 183 of file RectangularPixelPhase2Topology.h.

References m_ncols.

{ return (m_ncols); }

nrows()

int RectangularPixelPhase2Topology::nrows ( ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 181 of file RectangularPixelPhase2Topology.h.

References m_nrows.

{ return (m_nrows); }

pitch()

std::pair<float, float> RectangularPixelPhase2Topology::pitch ( ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 179 of file RectangularPixelPhase2Topology.h.

References nano_mu_digi_cff::float, m_pitchx, and m_pitchy.

{ return std::pair<float, float>(float(m_pitchx), float(m_pitchy)); }

pitchbigpixelX()

float RectangularPixelPhase2Topology::pitchbigpixelX ( ) const

inline

Definition at line 196 of file RectangularPixelPhase2Topology.h.

References m_BIG_PIX_PITCH_X.

{ return m_BIG_PIX_PITCH_X; }

pitchbigpixelY()

float RectangularPixelPhase2Topology::pitchbigpixelY ( ) const

inline

Definition at line 197 of file RectangularPixelPhase2Topology.h.

References m_BIG_PIX_PITCH_Y.

{ return m_BIG_PIX_PITCH_Y; }

pixel()

std::pair< float, float > RectangularPixelPhase2Topology::pixel ( const LocalPoint &  p ) const

overridevirtual

Topology for rectangular pixel detector with BIG pixels.

Implements PixelTopology.

Definition at line 13 of file RectangularPixelPhase2Topology.cc.

References hcal_dqm_sourceclient-live_cfg::debugstr, createfilelist::int, LogDebug, m_BIG_PIX_PER_ROC_X, m_BIG_PIX_PER_ROC_Y, m_BIG_PIX_PITCH_X, m_BIG_PIX_PITCH_Y, m_COLS_PER_ROC, m_ncols, m_nrows, m_pitchx, m_pitchy, m_ROWS_PER_ROC, m_xoffset, m_yoffset, AlCaHLTBitMon_ParallelJobs::p, multPhiCorr_741_25nsDY_cfi::px, and multPhiCorr_741_25nsDY_cfi::py.

Referenced by channel(), and measurementPosition().

                                                                                     {
  // check limits
  float py = p.y();
  float px = p.x();

#ifdef EDM_ML_DEBUG
#define EPSCM 0
#define EPS 0
  // This will catch points which are outside the active sensor area.
  // In the digitizer during the early induce_signal phase non valid
  // location are passed here. They are cleaned later.

  std::ostringstream debugstr;
  debugstr << "py = " << py << ", m_yoffset = " << m_yoffset << "px = " << px << ", m_xoffset = " << m_xoffset << "\n";

  if (py < m_yoffset)  // m_yoffset is negative
  {
    debugstr << " wrong lp y " << py << " " << m_yoffset << "\n";
    py = m_yoffset + EPSCM;  // make sure it is in, add an EPS in cm
  }
  if (py > -m_yoffset) {
    debugstr << " wrong lp y " << py << " " << -m_yoffset << "\n";
    py = -m_yoffset - EPSCM;
  }
  if (px < m_xoffset)  // m_xoffset is negative
  {
    debugstr << " wrong lp x " << px << " " << m_xoffset << "\n";
    px = m_xoffset + EPSCM;
  }
  if (px > -m_xoffset) {
    debugstr << " wrong lp x " << px << " " << -m_xoffset << "\n";
    px = -m_xoffset - EPSCM;
  }

  if (!debugstr.str().empty())
    LogDebug("RectangularPixelPhase2Topology") << debugstr.str();
#endif  // EDM_ML_DEBUG

  float newybin = py - m_yoffset;  // m_pitchy;
  int iybin = 0;                   //int(newybin);
  float fractionY = 0;             //newybin - iybin;
  int iybin0 = 0;
  float mpY = 0.;

  if ((newybin >= m_pitchy * (m_ncols / 2 - m_BIG_PIX_PER_ROC_Y)) &&
      (newybin < (m_pitchy * (m_ncols / 2 - m_BIG_PIX_PER_ROC_Y) +
                  m_BIG_PIX_PER_ROC_Y * m_BIG_PIX_PITCH_Y * m_ncols / m_COLS_PER_ROC))) {
    iybin = m_ncols / 2 - m_BIG_PIX_PER_ROC_Y;
    iybin0 = iybin;
    fractionY = (newybin - m_pitchy * (m_ncols / 2 - m_BIG_PIX_PER_ROC_Y)) / m_BIG_PIX_PITCH_Y;
  } else if ((newybin >= (m_pitchy * (m_ncols / 2 - m_BIG_PIX_PER_ROC_Y) +
                          m_BIG_PIX_PER_ROC_Y * m_BIG_PIX_PITCH_Y * m_ncols / m_COLS_PER_ROC))) {
    iybin = int((newybin - (m_pitchy * (m_ncols / 2 - m_BIG_PIX_PER_ROC_Y) +
                            m_BIG_PIX_PER_ROC_Y * m_BIG_PIX_PITCH_Y * m_ncols / m_COLS_PER_ROC)) /
                m_pitchy) +
            m_ncols / 2 - m_BIG_PIX_PER_ROC_Y + m_BIG_PIX_PER_ROC_Y * m_ncols / m_COLS_PER_ROC;
    iybin0 = iybin - m_ncols / 2;
    fractionY = (newybin - (m_pitchy * (m_ncols / 2 - m_BIG_PIX_PER_ROC_Y) +
                            m_BIG_PIX_PER_ROC_Y * m_BIG_PIX_PITCH_Y * m_ncols / m_COLS_PER_ROC +
                            (iybin0 - m_BIG_PIX_PER_ROC_Y) * m_pitchy)) /
                m_pitchy;
  } else {
    iybin = int(newybin / m_pitchy);
    iybin0 = iybin;
    fractionY = newybin / m_pitchy - iybin;
  }

  mpY = fractionY + iybin;
#ifdef EDM_ML_DEBUG

  if (iybin0 > m_COLS_PER_ROC) {
    LogDebug("RectangularPixelPhase2Topology") << " very bad, newbiny " << iybin0 << "\n"
                                               << py << " " << m_yoffset << " " << m_pitchy << " " << newybin << " "
                                               << iybin << " " << fractionY << " " << iybin0 << " " << m_COLS_PER_ROC;
  }
#endif  // EDM_ML_DEBUG

#ifdef EDM_ML_DEBUG

  if (mpY < 0. || mpY >= 2 * m_COLS_PER_ROC) {
    LogDebug("RectangularPixelPhase2Topology")
        << " bad pix y " << mpY << "\n"
        << py << " " << m_yoffset << " " << m_pitchy << " " << newybin << " " << iybin << " " << fractionY << " "
        << iybin0 << " " << 2 * m_COLS_PER_ROC;
  }
#endif  // EDM_ML_DEBUG

  // In X
  float newxbin = (px - m_xoffset);
  int ixbin = 0;
  float fractionX = 0;
  int ixbin0 = 0;
  float mpX = 0.;

  if ((newxbin >= m_pitchx * (m_nrows / 2 - m_BIG_PIX_PER_ROC_X)) &&
      (newxbin < (m_pitchx * (m_nrows / 2 - m_BIG_PIX_PER_ROC_X) +
                  m_BIG_PIX_PER_ROC_X * m_BIG_PIX_PITCH_X * m_nrows / m_ROWS_PER_ROC))) {
    ixbin = m_nrows / 2 - m_BIG_PIX_PER_ROC_X;
    ixbin0 = ixbin;
    fractionX = (newxbin - m_pitchx * (m_nrows / 2 - m_BIG_PIX_PER_ROC_X)) / m_BIG_PIX_PITCH_X;
  } else if ((newxbin >= (m_pitchx * (m_nrows / 2 - m_BIG_PIX_PER_ROC_X) +
                          m_BIG_PIX_PER_ROC_X * m_BIG_PIX_PITCH_X * m_nrows / m_ROWS_PER_ROC))) {
    ixbin = int((newxbin - (m_pitchx * (m_nrows / 2 - m_BIG_PIX_PER_ROC_X) +
                            m_BIG_PIX_PER_ROC_X * m_BIG_PIX_PITCH_X * m_nrows / m_ROWS_PER_ROC)) /
                m_pitchx) +
            m_nrows / 2 - m_BIG_PIX_PER_ROC_X + m_BIG_PIX_PER_ROC_X * m_nrows / m_ROWS_PER_ROC;
    ixbin0 = ixbin - m_nrows / 2;
    fractionX = (newxbin - (m_pitchx * (m_nrows / 2 - m_BIG_PIX_PER_ROC_X) +
                            m_BIG_PIX_PER_ROC_X * m_BIG_PIX_PITCH_X * m_nrows / m_ROWS_PER_ROC +
                            (ixbin0 - m_BIG_PIX_PER_ROC_X) * m_pitchx)) /
                m_pitchx;
  } else {
    ixbin = int(newxbin / m_pitchx);
    ixbin0 = ixbin;
    fractionX = newxbin / m_pitchx - ixbin;
  }

  mpX = fractionX + ixbin;

#ifdef EDM_ML_DEBUG

  if (ixbin0 > m_ROWS_PER_ROC || ixbin0 < 0)  //  ixbin < 0 outside range
  {
    LogDebug("RectangularPixelPhase2Topology")
        << " very bad, newbinx " << ixbin << "\n"
        << px << " " << m_xoffset << " " << m_pitchx << " " << newxbin << " " << ixbin << " " << fractionX;
  }
#endif  // EDM_ML_DEBUG

#ifdef EDM_ML_DEBUG

  if (mpX < 0. || mpX >= 2 * m_ROWS_PER_ROC) {
    LogDebug("RectangularPixelPhase2Topology")
        << " bad pix x " << mpX << "\n"
        << px << " " << m_xoffset << " " << m_pitchx << " " << newxbin << " " << ixbin << " " << fractionX;
  }
#endif  // EDM_ML_DEBUG

  return std::pair<float, float>(mpX, mpY);
}

pixelFractionInX()

float RectangularPixelPhase2Topology::pixelFractionInX ( const int  ixbin ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 125 of file RectangularPixelPhase2Topology.h.

References nano_mu_digi_cff::float, m_BIG_PIX_PER_ROC_X, m_BIG_PIX_PITCH_X, m_nrows, m_pitchx, and m_ROWS_PER_ROC.

                                                         {
    bool no_big_pixel = (m_BIG_PIX_PER_ROC_X == 0);

    if (no_big_pixel) {
      return 1.0f;
    } else {
      if (((m_nrows / 2 - m_BIG_PIX_PER_ROC_X) <= ixbin) &&
          (ixbin < (m_nrows / 2 - m_BIG_PIX_PER_ROC_X + m_BIG_PIX_PER_ROC_X * m_nrows / m_ROWS_PER_ROC))) {
        return float(m_BIG_PIX_PITCH_X / m_pitchx);
      } else {
        return 1.0f;
      }
    }
  }

pixelFractionInY()

float RectangularPixelPhase2Topology::pixelFractionInY ( const int  iybin ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 140 of file RectangularPixelPhase2Topology.h.

References nano_mu_digi_cff::float, m_BIG_PIX_PER_ROC_Y, m_BIG_PIX_PITCH_Y, m_COLS_PER_ROC, m_ncols, and m_pitchy.

                                                         {
    bool no_big_pixel = (m_BIG_PIX_PER_ROC_Y == 0);
    if (no_big_pixel) {
      return 1.0f;
    } else {
      if (((m_ncols / 2 - m_BIG_PIX_PER_ROC_Y) <= iybin) &&
          (iybin < (m_ncols / 2 - m_BIG_PIX_PER_ROC_Y + m_BIG_PIX_PER_ROC_Y * m_ncols / m_COLS_PER_ROC))) {
        return float(m_BIG_PIX_PITCH_Y / m_pitchy);
      } else {
        return 1.0f;
      }
    }
  }

rocsX()

int RectangularPixelPhase2Topology::rocsX ( ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 187 of file RectangularPixelPhase2Topology.h.

References m_ROCS_X.

{ return m_ROCS_X; }

rocsY()

int RectangularPixelPhase2Topology::rocsY ( ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 185 of file RectangularPixelPhase2Topology.h.

References m_ROCS_Y.

{ return m_ROCS_Y; }

rowsperroc()

int RectangularPixelPhase2Topology::rowsperroc ( ) const

inlineoverridevirtual

Implements PixelTopology.

Definition at line 189 of file RectangularPixelPhase2Topology.h.

References m_ROWS_PER_ROC.

{ return m_ROWS_PER_ROC; }

xoffset()

float RectangularPixelPhase2Topology::xoffset ( ) const

inline

Definition at line 194 of file RectangularPixelPhase2Topology.h.

References m_xoffset.

{ return m_xoffset; }

yoffset()

float RectangularPixelPhase2Topology::yoffset ( ) const

inline

Definition at line 195 of file RectangularPixelPhase2Topology.h.

References m_yoffset.

{ return m_yoffset; }

Member Data Documentation

m_BIG_PIX_PER_ROC_X

int RectangularPixelPhase2Topology::m_BIG_PIX_PER_ROC_X

private

Definition at line 208 of file RectangularPixelPhase2Topology.h.

Referenced by bigpixperrocX(), containsBigPixelInX(), isItBigPixelInX(), pixel(), pixelFractionInX(), and RectangularPixelPhase2Topology().

m_BIG_PIX_PER_ROC_Y

int RectangularPixelPhase2Topology::m_BIG_PIX_PER_ROC_Y

private

Definition at line 209 of file RectangularPixelPhase2Topology.h.

Referenced by bigpixperrocY(), containsBigPixelInY(), isItBigPixelInY(), pixel(), pixelFractionInY(), and RectangularPixelPhase2Topology().

m_BIG_PIX_PITCH_X

float RectangularPixelPhase2Topology::m_BIG_PIX_PITCH_X

private

Definition at line 210 of file RectangularPixelPhase2Topology.h.

Referenced by localX(), pitchbigpixelX(), pixel(), pixelFractionInX(), and RectangularPixelPhase2Topology().

m_BIG_PIX_PITCH_Y

float RectangularPixelPhase2Topology::m_BIG_PIX_PITCH_Y

private

Definition at line 211 of file RectangularPixelPhase2Topology.h.

Referenced by localY(), pitchbigpixelY(), pixel(), pixelFractionInY(), and RectangularPixelPhase2Topology().

m_COLS_PER_ROC

int RectangularPixelPhase2Topology::m_COLS_PER_ROC

private

Definition at line 207 of file RectangularPixelPhase2Topology.h.

Referenced by colsperroc(), localY(), pixel(), pixelFractionInY(), and RectangularPixelPhase2Topology().

m_ncols

int RectangularPixelPhase2Topology::m_ncols

private

Definition at line 205 of file RectangularPixelPhase2Topology.h.

Referenced by containsBigPixelInY(), isItBigPixelInY(), isItEdgePixelInY(), localPosition(), localY(), ncolumns(), pixel(), pixelFractionInY(), and RectangularPixelPhase2Topology().

m_nrows

int RectangularPixelPhase2Topology::m_nrows

private

Definition at line 204 of file RectangularPixelPhase2Topology.h.

Referenced by containsBigPixelInX(), isItBigPixelInX(), isItEdgePixelInX(), localPosition(), localX(), nrows(), pixel(), pixelFractionInX(), and RectangularPixelPhase2Topology().

m_pitchx

float RectangularPixelPhase2Topology::m_pitchx

private

Definition at line 200 of file RectangularPixelPhase2Topology.h.

Referenced by localError(), localX(), measurementError(), pitch(), pixel(), pixelFractionInX(), and RectangularPixelPhase2Topology().

m_pitchy

float RectangularPixelPhase2Topology::m_pitchy

private

Definition at line 201 of file RectangularPixelPhase2Topology.h.

Referenced by localError(), localY(), measurementError(), pitch(), pixel(), pixelFractionInY(), and RectangularPixelPhase2Topology().

m_ROCS_X

int RectangularPixelPhase2Topology::m_ROCS_X

private

Definition at line 212 of file RectangularPixelPhase2Topology.h.

Referenced by localX(), RectangularPixelPhase2Topology(), and rocsX().

m_ROCS_Y

int RectangularPixelPhase2Topology::m_ROCS_Y

private

Definition at line 213 of file RectangularPixelPhase2Topology.h.

Referenced by localY(), RectangularPixelPhase2Topology(), and rocsY().

m_ROWS_PER_ROC

int RectangularPixelPhase2Topology::m_ROWS_PER_ROC

private

Definition at line 206 of file RectangularPixelPhase2Topology.h.

Referenced by localX(), pixel(), pixelFractionInX(), RectangularPixelPhase2Topology(), and rowsperroc().

m_xoffset

float RectangularPixelPhase2Topology::m_xoffset

private

Definition at line 202 of file RectangularPixelPhase2Topology.h.

Referenced by localX(), pixel(), RectangularPixelPhase2Topology(), and xoffset().

m_yoffset

float RectangularPixelPhase2Topology::m_yoffset

private

Definition at line 203 of file RectangularPixelPhase2Topology.h.

Referenced by localY(), pixel(), RectangularPixelPhase2Topology(), and yoffset().