PixelDistortionData Class Reference

#include <PixelDistortionData.h>

Collaboration diagram for PixelDistortionData:

Public Member Functions
void	setVersion (int version)
void	setIds (const std::unordered_map< uint32_t, unsigned long long > &ids)
void	setDistortionMap (const std::unordered_map< uint32_t, std::vector< float > > &distortionMap)
int	getVersion () const
unsigned long long	getId (uint32_t hashID) const
std::vector< float >	getDistortionMap (uint32_t id) const
Amg::Vector2D	correction (uint32_t hashID, const Amg::Vector2D &locpos, const Amg::Vector3D &direction) const
Amg::Vector2D	correctReconstruction (uint32_t hashID, const Amg::Vector2D &locpos, const Amg::Vector3D &direction) const
Amg::Vector2D	correctSimulation (uint32_t hashID, const Amg::Vector2D &locpos, const Amg::Vector3D &direction) const
void	clear ()

Static Public Member Functions
static double	getInSituZ (const double localeta, const double eta_size, const double localphi, const double phi_size, const float *disto)
static double	getSurveyZ (const double localeta, const double localphi, const float *disto)
static bool	isOldParam (const unsigned long long ull_id)
static bool	isIBL3D (const unsigned long long ull_id)

Private Attributes
int	m_version {}
std::unordered_map< uint32_t, unsigned long long >	m_ids
std::unordered_map< uint32_t, std::vector< float > >	m_distortionMap

Detailed Description

Definition at line 20 of file PixelDistortionData.h.

Member Function Documentation

clear()

void PixelDistortionData::clear

(

)

Definition at line 314 of file PixelDistortionData.cxx.

                                {
  m_distortionMap.clear();
}

correction()

Amg::Vector2D PixelDistortionData::correction	(	uint32_t	hashID,
		const Amg::Vector2D &	locpos,
		const Amg::Vector3D &	direction ) const

Definition at line 120 of file PixelDistortionData.cxx.

                                                                                                                            {
  double localphi = locpos[0];
  double localeta = locpos[1];
  const Amg::Vector2D nullCorrection(0.0,0.0);
  const unsigned long long ull_id = getId(hashID);
 
  // No corrections available for this module
  if (ull_id == 0 && m_version > 1) { return nullCorrection; }
 
  // This is needed to avoid rounding errors if the z component of the
  // direction vector is too small.
  if (std::fabs(direction.z())<1.*CLHEP::micrometer) { return nullCorrection; }
 
  // If a particle has a too shallow trajectory with respect to the
  // module direction, it is likely to be a secondary particle and no
  // shift should be applied.
  double invtanphi = direction.x()/direction.z();
  double invtaneta = direction.y()/direction.z();
  if (std::sqrt(invtanphi*invtanphi+invtaneta*invtaneta)>100.0) { return nullCorrection; }
 
  double localZ = 0;
  std::vector<float> map = getDistortionMap(hashID);
 
  // If old database versions, the corrections are from the pixel survey, otherwise corrections are from
  // insitu shape measurements.
  if (m_version < 2) {
     localZ = getSurveyZ(localeta, localphi, map.data());
  } else if (isOldParam(ull_id)) {
     localZ = getSurveyZ(localeta, localphi, map.data());
  } else {
     float modEtaSize, modPhiSize;
 
     // set module sizes in millimetre
     if (ull_id >= 0x200000000000000 && ull_id <= 0x20d980000000000) {
       if (isIBL3D(ull_id)) {
         modEtaSize = 19.75 * CLHEP::millimeter;
         modPhiSize = 16.75 * CLHEP::millimeter;
       } else {
         modEtaSize = 40.4 * CLHEP::millimeter;
         modPhiSize = 16.8 * CLHEP::millimeter;
       }
     } else {
       modEtaSize = 60.2 * CLHEP::millimeter;
       modPhiSize = 16.44 * CLHEP::millimeter;
     }
 
     localZ = getInSituZ(localeta, modEtaSize, localphi, modPhiSize, map.data());
  }
 
  double localetaCor = -localZ * invtaneta;
  double localphiCor = -localZ * invtanphi;
 
  // In earlies code version there was a bug in the sign of the correction.
  // In MC this was not seen as reco just corrects back what was done in digitization.
  // In order to maintain backward compatibilty in older MC we need to reproduce this wrong behaviour.
  if (getVersion()==0) { localphiCor = -localphiCor; }
 
  return Amg::Vector2D(localphiCor, localetaCor);
}

correctReconstruction()

Amg::Vector2D PixelDistortionData::correctReconstruction	(	uint32_t	hashID,
		const Amg::Vector2D &	locpos,
		const Amg::Vector3D &	direction ) const

Definition at line 180 of file PixelDistortionData.cxx.

                                                                                                                                       {
  Amg::Vector2D newlocpos(locpos);
  newlocpos += correction(hashID, locpos, direction);
  return newlocpos;
}

correctSimulation()

Amg::Vector2D PixelDistortionData::correctSimulation	(	uint32_t	hashID,
		const Amg::Vector2D &	locpos,
		const Amg::Vector3D &	direction ) const

Definition at line 186 of file PixelDistortionData.cxx.

                                                                                                                                   {
  Amg::Vector2D newlocpos(locpos);
  newlocpos -= correction(hashID, locpos, direction);
  return newlocpos;
}

getDistortionMap()

std::vector< float > PixelDistortionData::getDistortionMap

(

uint32_t

id

)

const

Definition at line 100 of file PixelDistortionData.cxx.

                                                                            {
  int distosize;
  if (m_version < 2) distosize = 3;
  else distosize = 441;
 
  auto itr = m_distortionMap.find(hashID);
  if (itr!=m_distortionMap.end()) {
    return itr->second;
  }
  std::vector<float> map(distosize, 0.0);
  return map;
}

getId()

unsigned long long PixelDistortionData::getId

(

uint32_t

hashID

)

const

Definition at line 113 of file PixelDistortionData.cxx.

                                                                   {
  auto search = m_ids.find(hashID);
  if (search != m_ids.end()) return search->second;
 
  return 0;
}

getInSituZ()

double PixelDistortionData::getInSituZ ( const double localeta, const double eta_size, const double localphi, const double phi_size, const float * disto )

static

Definition at line 192 of file PixelDistortionData.cxx.

{
  double etaHalfRangeBB = eta_size * 10. / 21.;
  double phiHalfRangeBB = phi_size * 10. / 21.;
  double etaRangeBB = eta_size * 20. / 21.;
  double phiRangeBB = phi_size * 20. / 21.;
  double eta, phi;
 
  // map positions on interval [- edge, 1 + edge]
  // edge is the part outside of the Bezier-Bernstein range
  if (std::abs(localeta) - etaHalfRangeBB > 0) {
    if (localeta < 0)
      eta = (localeta + etaHalfRangeBB) / etaRangeBB;
    else
      eta = 1. + (localeta - etaHalfRangeBB) / etaRangeBB;
  } else {
    eta = localeta / etaRangeBB + 0.5;
  }
  if (std::abs(localphi) - phiHalfRangeBB > 0) {
    if (localphi < 0)
      phi = (localphi + phiHalfRangeBB) / phiRangeBB;
    else
      phi = 1. + (localphi - phiHalfRangeBB) / phiRangeBB;
  } else {
    phi = localphi / phiRangeBB + 0.5;
  }
  return bernstein_bezier(eta, phi, disto);
}

getSurveyZ()

double PixelDistortionData::getSurveyZ ( const double localeta, const double localphi, const float * disto )

static

Definition at line 221 of file PixelDistortionData.cxx.

{
  const double xFE = 22.0 * CLHEP::millimeter; // Distance between the 2 Front-End line, where bows have been measured
  const double yFE = 60.8 * CLHEP::millimeter; // Length of the active surface of each module
 
  double data0 = disto[0] / CLHEP::meter;           // curvature is in m-1
  double data1 = disto[1] / CLHEP::meter;           // curvature is in m-1
  double data2 = std::tan(0.5 * disto[2] * CLHEP::degree);   // twist angle in degree
 
  double twist1 = -data2;
  double twist2 = data2;
  double b1 = std::sqrt((1. + twist1*twist1) * (1. + twist1*twist1) * (1. + twist1*twist1));
  double b2 = std::sqrt((1. + twist2*twist2) * (1. + twist2*twist2) * (1. + twist2*twist2));
  double z1 = localeta * twist1 - 0.5 * b1 * localeta*localeta * data1;
  double z2 = localeta * twist2 - 0.5 * b2 * localeta*localeta * data0;
  double zoff1 = (b1 * yFE*yFE * data1) / 24.;
  double zoff2 = (b2 * yFE*yFE * data0) / 24.;
  z1 = z1 + zoff1;
  z2 = z2 + zoff2;
 
  return z1 + ((z2 - z1) / xFE) * (localphi + xFE / 2.);
}

getVersion()

int PixelDistortionData::getVersion ( ) const

inline

Definition at line 50 of file PixelDistortionData.h.

{ return m_version; }

isIBL3D()

bool PixelDistortionData::isIBL3D ( const unsigned long long ull_id )

static

Definition at line 253 of file PixelDistortionData.cxx.

{
  // Stave 1
  if (ull_id >= 0x200000000000000 && ull_id <= 0x200180000000000) return true;
  if (ull_id >= 0x200800000000000 && ull_id <= 0x200980000000000) return true;
 
  // Stave 2
  if (ull_id >= 0x201000000000000 && ull_id <= 0x201180000000000) return true;
  if (ull_id >= 0x201800000000000 && ull_id <= 0x201980000000000) return true;
 
  // Stave 3
  if (ull_id >= 0x202000000000000 && ull_id <= 0x202180000000000) return true;
  if (ull_id >= 0x202800000000000 && ull_id <= 0x202980000000000) return true;
 
  // Stave 4
  if (ull_id >= 0x203000000000000 && ull_id <= 0x203180000000000) return true;
  if (ull_id >= 0x203800000000000 && ull_id <= 0x203980000000000) return true;
 
  // Stave 5
  if (ull_id >= 0x204000000000000 && ull_id <= 0x204180000000000) return true;
  if (ull_id >= 0x204800000000000 && ull_id <= 0x204980000000000) return true;
 
  // Stave 6
  if (ull_id >= 0x205000000000000 && ull_id <= 0x205180000000000) return true;
  if (ull_id >= 0x205800000000000 && ull_id <= 0x205980000000000) return true;
 
  // Stave 7
  if (ull_id >= 0x206000000000000 && ull_id <= 0x206180000000000) return true;
  if (ull_id >= 0x206800000000000 && ull_id <= 0x206980000000000) return true;
 
  // Stave 8
  if (ull_id >= 0x207000000000000 && ull_id <= 0x207180000000000) return true;
  if (ull_id >= 0x207800000000000 && ull_id <= 0x207980000000000) return true;
 
  // Stave 9
  if (ull_id >= 0x208000000000000 && ull_id <= 0x208180000000000) return true;
  if (ull_id >= 0x208800000000000 && ull_id <= 0x208980000000000) return true;
 
  // Stave 10
  if (ull_id >= 0x209000000000000 && ull_id <= 0x209180000000000) return true;
  if (ull_id >= 0x209800000000000 && ull_id <= 0x209980000000000) return true;
 
  // Stave 11
  if (ull_id >= 0x20a000000000000 && ull_id <= 0x20a180000000000) return true;
  if (ull_id >= 0x20a800000000000 && ull_id <= 0x20a980000000000) return true;
 
  // Stave 12
  if (ull_id >= 0x20b000000000000 && ull_id <= 0x20b180000000000) return true;
  if (ull_id >= 0x20b800000000000 && ull_id <= 0x20b980000000000) return true;
 
  // Stave 13
  if (ull_id >= 0x20c000000000000 && ull_id <= 0x20c180000000000) return true;
  if (ull_id >= 0x20c800000000000 && ull_id <= 0x20c980000000000) return true;
 
  // Stave 14
  if (ull_id >= 0x20d000000000000 && ull_id <= 0x20d180000000000) return true;
  if (ull_id >= 0x20d800000000000 && ull_id <= 0x20d980000000000) return true;
 
  return false;
}

isOldParam()

bool PixelDistortionData::isOldParam ( const unsigned long long ull_id )

static

Definition at line 244 of file PixelDistortionData.cxx.

{
  // Only pixel modules can have the old parametrisation
  if (ull_id < 0x240000000000000) return false;
 
  // For now: no new parametrisation for Pixel
  return true;
}

setDistortionMap()

void PixelDistortionData::setDistortionMap ( const std::unordered_map< uint32_t, std::vector< float > > & distortionMap )

inline

Definition at line 48 of file PixelDistortionData.h.

{ m_distortionMap=distortionMap; }

setIds()

void PixelDistortionData::setIds ( const std::unordered_map< uint32_t, unsigned long long > & ids )

inline

Definition at line 47 of file PixelDistortionData.h.

{ m_ids=ids; }

setVersion()

void PixelDistortionData::setVersion ( int version )

inline

Definition at line 46 of file PixelDistortionData.h.

{ m_version=version; }

Member Data Documentation

m_distortionMap

std::unordered_map<uint32_t,std::vector<float> > PixelDistortionData::m_distortionMap

private

Definition at line 43 of file PixelDistortionData.h.

m_ids

std::unordered_map<uint32_t,unsigned long long> PixelDistortionData::m_ids

private

Definition at line 42 of file PixelDistortionData.h.

m_version

int PixelDistortionData::m_version {}

private

Definition at line 41 of file PixelDistortionData.h.

{};

---

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

• PixelDistortionData.h
• PixelDistortionData.cxx