InDet::SiDetElementsLayer_xk Class Reference

#include <SiDetElementsLayer_xk.h>

Collaboration diagram for InDet::SiDetElementsLayer_xk:

Public Member Functions
	SiDetElementsLayer_xk ()
	SiDetElementsLayer_xk (double, double, double, double, double)
	SiDetElementsLayer_xk (const SiDetElementsLayer_xk &)=default
	SiDetElementsLayer_xk (SiDetElementsLayer_xk &&)=default
	~SiDetElementsLayer_xk ()=default
SiDetElementsLayer_xk &	operator= (const SiDetElementsLayer_xk &)=default
SiDetElementsLayer_xk &	operator= (SiDetElementsLayer_xk &&)=default
const float &	r () const
const float &	dr () const
const float &	z () const
const float &	dz () const
const float &	dfe () const
std::vector< SiDetElementLink_xk > &	elements ()
const std::vector< SiDetElementLink_xk > &	elements () const
void	set (double, double, double, double, double)
void	add (const SiDetElementLink_xk &)
int	nElements () const
void	getBarrelDetElements (const std::array< float, 6 > &startingPoint, const std::array< float, 3 > &searchDirection, std::vector< InDet::SiDetElementLink_xk::ElementWay > &lDE, std::vector< bool > &used) const
	Get barrel detector elements Input parameters: startPoint[0] - X searchDirection[0] - Ax startPoint[1] - Y searchDirection[1] - Ay startPoint[2] - Z searchDirection[2] - Az startPoint[3] - R startPoint[4] - width startPoint[5] - step Will populate 'lDE' and update 'used' with the detector elements compatible with a crossing by a straight trajectory starting at 'startPoint' and moving in direction 'searchDirection'.
void	getITkBarrelDetElements (const std::array< float, 6 > &startingPoint, const std::array< float, 3 > &searchDirection, std::vector< InDet::SiDetElementLink_xk::ElementWay > &lDE, std::vector< bool > &used) const
void	getEndcapDetElements (const std::array< float, 6 > &startingPoint, const std::array< float, 3 > &searchDirection, std::vector< InDet::SiDetElementLink_xk::ElementWay > &lDE, std::vector< bool > &used) const
void	getITkEndcapDetElements (const std::array< float, 6 > &startingPoint, const std::array< float, 3 > &searchDirection, std::vector< InDet::SiDetElementLink_xk::ElementWay > &lDE, std::vector< bool > &used) const
void	sortDetectorElements ()

Protected Member Functions
void	getDetElements (const std::array< float, 6 > &startingPoint, const std::array< float, 3 > &searchDirection, float phiCrossing, float reducedRoadWidth, std::vector< InDet::SiDetElementLink_xk::ElementWay > &lDE, std::vector< bool > &used) const
	internal helper which resolves the phi-multiplicity of elements within a layer.

Protected Attributes
float	m_z
float	m_dz
float	m_r
float	m_dr
float	m_dfe
std::vector< SiDetElementLink_xk >	m_elements

Detailed Description

Definition at line 27 of file SiDetElementsLayer_xk.h.

Constructor & Destructor Documentation

SiDetElementsLayer_xk() [1/4]

InDet::SiDetElementsLayer_xk::SiDetElementsLayer_xk ( )

inline

Definition at line 137 of file SiDetElementsLayer_xk.h.

  {
    m_z   = 0.;
    m_dz  = 0.;
    m_r   = 0.;
    m_dr  = 0.;
    m_dfe = 0.;
  } 

SiDetElementsLayer_xk() [2/4]

InDet::SiDetElementsLayer_xk::SiDetElementsLayer_xk ( double r, double dr, double z, double dz, double df )

inline

Definition at line 146 of file SiDetElementsLayer_xk.h.

    {
      m_r  = float(r );
      m_dr = float(dr);
      m_z  = float(z );
      m_dz = float(dz);
      m_dfe= float(df);
    } 

SiDetElementsLayer_xk() [3/4]

InDet::SiDetElementsLayer_xk::SiDetElementsLayer_xk ( const SiDetElementsLayer_xk & )

default

SiDetElementsLayer_xk() [4/4]

InDet::SiDetElementsLayer_xk::SiDetElementsLayer_xk ( SiDetElementsLayer_xk && )

default

~SiDetElementsLayer_xk()

InDet::SiDetElementsLayer_xk::~SiDetElementsLayer_xk ( )

default

Member Function Documentation

add()

void InDet::SiDetElementsLayer_xk::add ( const SiDetElementLink_xk & link )

inline

Definition at line 166 of file SiDetElementsLayer_xk.h.

    {
      m_elements.push_back(link);
    }

dfe()

const float & InDet::SiDetElementsLayer_xk::dfe ( ) const

inline

Definition at line 56 of file SiDetElementsLayer_xk.h.

{return m_dfe     ;}

dr()

const float & InDet::SiDetElementsLayer_xk::dr ( ) const

inline

Definition at line 53 of file SiDetElementsLayer_xk.h.

{return m_dr      ;}

dz()

const float & InDet::SiDetElementsLayer_xk::dz ( ) const

inline

Definition at line 55 of file SiDetElementsLayer_xk.h.

{return m_dz      ;}

elements() [1/2]

std::vector< SiDetElementLink_xk > & InDet::SiDetElementsLayer_xk::elements ( )

inline

Definition at line 57 of file SiDetElementsLayer_xk.h.

{return m_elements;}

elements() [2/2]

const std::vector< SiDetElementLink_xk > & InDet::SiDetElementsLayer_xk::elements ( ) const

inline

Definition at line 58 of file SiDetElementsLayer_xk.h.

{return m_elements;}

getBarrelDetElements()

void InDet::SiDetElementsLayer_xk::getBarrelDetElements	(	const std::array< float, 6 > &	startingPoint,
		const std::array< float, 3 > &	searchDirection,
		std::vector< InDet::SiDetElementLink_xk::ElementWay > &	lDE,
		std::vector< bool > &	used ) const

Get barrel detector elements Input parameters: startPoint[0] - X searchDirection[0] - Ax startPoint[1] - Y searchDirection[1] - Ay startPoint[2] - Z searchDirection[2] - Az startPoint[3] - R startPoint[4] - width startPoint[5] - step Will populate 'lDE' and update 'used' with the detector elements compatible with a crossing by a straight trajectory starting at 'startPoint' and moving in direction 'searchDirection'.

The two additional elements of startPoint are the road width used as tolerance in the crossing test (in mm) and the step (distance to travel to the module).

In the following, identify where we cross the layer in r by solving the quadratic equation ( startingPoint_xy + s * searchDirection_xy )² = r_layer²

solutions of our equation

pick one: if both solution occur for the same direction, we pick the crossing that occurs first

otherwise, pick the one in the positive direction

Z-coordinate of the layer crossing

radial component of the search direction

Check if we miss the layer completely: If the distance of our crossing point to the layer centre along z exceeds the half width in z of the layer by more than a tolerance obtained as the z movement expected when traversing along the layer radial half-width (dr_half / tan(theta_searchDirection)) plus the road width divided by sin(theta)

Phi coordinate of the crossing

road width divided by the radius of the layer

Definition at line 31 of file SiDetElementsLayer_xk.cxx.

{
  // Tell clang to optimize assuming that FP exceptions can trap.
  // Otherwise, it can vectorize the division, which can lead to
  // spurious division-by-zero traps from unused vector lanes.
  CXXUTILS_TRAPPING_FP;

  float minusB  =2*( searchDirection[0]*startingPoint[0]
                    +searchDirection[1]*startingPoint[1]); 
  float C  = (m_r-startingPoint[0]-startingPoint[1])
            *(m_r+startingPoint[0]+startingPoint[1])
            +2.*startingPoint[0]*startingPoint[1];
  float twoA  = 2.*( searchDirection[0]*searchDirection[0]
                    +searchDirection[1]*searchDirection[1]); 
  if(twoA == 0.) return;
  float sq = minusB*minusB+2.*C*twoA;  
  if (sq > 0){ 
    sq=std::sqrt(sq);
  }
  else {
    sq=0.;
  }
  float s1 =-(minusB+sq)/twoA;
  float s2 =-(minusB-sq)/twoA; 
  float s;
  if((s1*s2) > 0.) {
    s = (std::abs(s1) < std::abs(s2) ? s1 : s2); 
  }
  else{     
    s = (s1  > 0. ? s1 : s2); 
  }  
  float zc   = startingPoint[2]+searchDirection[2]*s;
  float At   = std::sqrt(1.-searchDirection[2]*searchDirection[2]);
  
  if(At != 0. && std::abs(zc-m_z) > (m_dz+(m_dr*std::abs(searchDirection[2])+startingPoint[4])/At)) return;
  float phiCrossing   = std::atan2(startingPoint[1]+searchDirection[1]*s,startingPoint[0]+searchDirection[0]*s);
  float reducedRoadWidth   = startingPoint[4]/m_r;
  getDetElements(startingPoint,searchDirection,phiCrossing,reducedRoadWidth,lDE,used);
 
}

getDetElements()

void InDet::SiDetElementsLayer_xk::getDetElements ( const std::array< float, 6 > & startingPoint, const std::array< float, 3 > & searchDirection, float phiCrossing, float reducedRoadWidth, std::vector< InDet::SiDetElementLink_xk::ElementWay > & lDE, std::vector< bool > & used ) const

protected

internal helper which resolves the phi-multiplicity of elements within a layer.

Same logic as above. Extra args: 'phiCrossing' is the phi coordinate of the layer crossing and 'reducedRoadWidth' is a phi tolerance obtained by dividing the search road width by the radius of the layer

iteratively search for the index of the crossing by splitting the remaining search region in half

first, rotate in the positive phi direction

if detector element i on this layer is not already used for this road

project delta phi into -pi..pi

dPhi must be compatible with the phi half-width within a tolerance specified by the road width divided by the radius

intersect our projection with the detector element. Output: intersectionOutcome[0] - close distance in azimuthal direction intersectionOutcome[1] - close distance in r or z direction intersectionOutcome[2] - step to detector element

closest distance in both directions has to be compatible within the road width

we found a compatible detector element - add to our list

loop around if we have to

stop when we have tried all detector elements

we get here by triggering the 'break' clause in the positive-direction loop above

now rotate in the negative phi direction

loop around at zero

stop at full circle

Definition at line 311 of file SiDetElementsLayer_xk.cxx.

{
  constexpr float pi = M_PI;
  constexpr float pi2 = 2.*pi; 
  int im  = int(m_elements.size())-1; 
  if(im<0) return;
  int i0  = 0;
  int i1  = im;

  if (phiCrossing> m_elements[i0].phi() && phiCrossing< m_elements[i1].phi()) {
    while((i1-i0)>1) {
      int i = (i0+i1)/2; 
      if (m_elements[i].phi() > phiCrossing){
        i1=i;
      }
      else{
        i0=i;
      }
    }
    i0 = i1;
  }
  //
  std::array<float,3> intersectionOutcome{};
  int i = i0;
  while(1) {
    assert( static_cast<unsigned int>(i)<m_elements.size() );
    if(!used[i]) {
      float dPhi =std::abs(m_elements[i].phi()-phiCrossing); 
      if(dPhi>pi) dPhi=std::abs(dPhi-pi2);    

      if((dPhi-reducedRoadWidth)>m_dfe) break;

      m_elements[i].intersect(&(startingPoint[0]),&(searchDirection[0]),&(intersectionOutcome[0]));

      if  (     intersectionOutcome[0]<=startingPoint[4] 
            && (intersectionOutcome[1]<=startingPoint[4])
          ) {
         lDE.emplace_back(&m_elements[i],startingPoint[5]+intersectionOutcome[2],std::max(intersectionOutcome[0],intersectionOutcome[1])); 
         used[i]=true;
      }
    }
    ++i; 
    if(i>im) i=0; 
    if(i==i0) return; 
  }
  i1 = i; i = i0;
  while(1) {
    --i; 
    if(i<0) i=im; 
    if(i==i1) return;
    assert( static_cast<unsigned int>(i)<m_elements.size() );
    if(!used[i]) {
      float dPhi =std::abs(m_elements[i].phi()-phiCrossing); 
      if(dPhi>pi) dPhi=std::abs(dPhi-pi2);
      if((dPhi-reducedRoadWidth)>m_dfe) return;
      m_elements[i].intersect(&(startingPoint[0]),&(searchDirection[0]),&(intersectionOutcome[0]));
 
      if((intersectionOutcome[0]-startingPoint[4])<=0 && (intersectionOutcome[1]-startingPoint[4])<=0.) {
         lDE.emplace_back(&m_elements[i],startingPoint[5]+intersectionOutcome[2],std::max(intersectionOutcome[0],intersectionOutcome[1])); 
         used[i]=true;
      }
    }
  }
}

getEndcapDetElements()

void InDet::SiDetElementsLayer_xk::getEndcapDetElements	(	const std::array< float, 6 > &	startingPoint,
		const std::array< float, 3 > &	searchDirection,
		std::vector< InDet::SiDetElementLink_xk::ElementWay > &	lDE,
		std::vector< bool > &	used ) const

solve the linear equation z_layer = z_startingPont + s * z_searchDirection

obtain x,y,r coordinates of the layer crossing in z

search direction z (== cos(theta_search)) * radius of starting point

Kick out cases where we do not expect to cross the layer at all. Do this by checking if the distance of the radial location of the z-crossing from the layer centre in r exceeds the r-half-width by more than the r-movement expected when traversing the half-width in z + the search road width

Definition at line 206 of file SiDetElementsLayer_xk.cxx.

{
  float s   =(m_z-startingPoint[2])/searchDirection[2];
  float xc  = startingPoint[0]+searchDirection[0]*s;
  float yc  = startingPoint[1]+searchDirection[1]*s;
  float rc  = std::sqrt(xc*xc+yc*yc);
  float A23 = searchDirection[2]*startingPoint[3];
  if(A23 != 0. && std::abs(rc-m_r) > m_dr+std::abs(2.*(startingPoint[0]*searchDirection[0]+startingPoint[1]*searchDirection[1])*m_dz/A23)+startingPoint[4]) return;
  float phiCrossing  = std::atan2(yc,xc);
  float reducedRoadWidth  = startingPoint[4]/rc;
  getDetElements(startingPoint,searchDirection,phiCrossing,reducedRoadWidth,lDE,used);
 
}

getITkBarrelDetElements()

void InDet::SiDetElementsLayer_xk::getITkBarrelDetElements	(	const std::array< float, 6 > &	startingPoint,
		const std::array< float, 3 > &	searchDirection,
		std::vector< InDet::SiDetElementLink_xk::ElementWay > &	lDE,
		std::vector< bool > &	used ) const

In the following, identify where we cross the layer in r by solving the quadratic equation ( startingPoint_xy + s * searchDirection_xy )² = r_layer²

solutions of our equation

pick one: if both solution occur for the same direction, we pick the crossing that occurs first

otherwise, pick the one in the positive direction

Z-coordinate of the layer crossing

radial component of the search direction

Check if we miss the layer completely: If the distance of our crossing point to the layer centre along z exceeds the half width in z of the layer by more than a tolerance obtained as the z movement expected when traversing along the layer radial half-width (dr_half / tan(theta_searchDirection)) plus the road width divided by sin(theta)

road width divided by the radius of the layer

Phi coordinate of the crossing

Definition at line 94 of file SiDetElementsLayer_xk.cxx.

{
  constexpr float pi = M_PI;
  constexpr float pi2 = 2.*pi;

  float minusB  =2*( searchDirection[0]*startingPoint[0]
                    +searchDirection[1]*startingPoint[1]);
  float C  = (m_r-startingPoint[0]-startingPoint[1])
            *(m_r+startingPoint[0]+startingPoint[1])
            +2.*startingPoint[0]*startingPoint[1];
  float twoA  = 2.*( searchDirection[0]*searchDirection[0]
                    +searchDirection[1]*searchDirection[1]);
  if(twoA == 0.) return;
  float sq = minusB*minusB+2.*C*twoA;
  if (sq > 0){
    sq=std::sqrt(sq);
  }
  else {
    sq=0.;
  }
  float s1 =-(minusB+sq)/twoA;
  float s2 =-(minusB-sq)/twoA;
  float s;
  if((s1*s2) > 0.) {
    s = (std::abs(s1) < std::abs(s2) ? s1 : s2);
  }
  else{
    s = (s1  > 0. ? s1 : s2);
  }
  float zc   = startingPoint[2]+searchDirection[2]*s;
  float At   = std::sqrt(1.-searchDirection[2]*searchDirection[2]);
  float Sz = (m_dr*std::abs(searchDirection[2])+startingPoint[4])/At;

  if(At != 0. && std::abs(zc-m_z) > (m_dz+Sz)) return;
  float reducedRoadWidth = startingPoint[4]/m_r + m_dfe;
  float phiCrossing = std::atan2(startingPoint[1]+searchDirection[1]*s,startingPoint[0]+searchDirection[0]*s) - reducedRoadWidth;
  if(phiCrossing<-pi) phiCrossing += pi2;
 
  int   ie   = m_elements.size();
  int   i1   = ie-1;
 
  if     (phiCrossing <= m_elements[ 0].phi()) i1 = 0 ;
  else if(phiCrossing >  m_elements[i1].phi()) i1 = ie;
  else  {
    int i0=0;
    while((i1-i0)>1) {
      int i = (i0+i1)/2;
      if (m_elements[i].phi() > phiCrossing) i1=i;
      else i0=i;
    }
  }
 
  phiCrossing += 2.*reducedRoadWidth;
 
  for(int i = i1; i!=ie; ++i) {
 
    if( m_elements[i].phi() > phiCrossing ) return;
 
    if(std::abs(zc-m_elements[i].z()) < (m_elements[i].dz()+Sz)
       &&  m_elements[i].intersectITk(&(startingPoint[0]),&(searchDirection[0]),s)) {
      lDE.emplace_back(&m_elements[i],s,0); //distance not used for ITk?
      used[i]=true;
    }
  }
 
  phiCrossing -= pi2;
 
  for(int i=0; i!=i1; ++i)  {
 
    if( m_elements[i].phi() > phiCrossing) return;
 
    if(std::abs(zc-m_elements[i].z()) < (m_elements[i].dz()+Sz)
       &&  m_elements[i].intersectITk(&(startingPoint[0]),&(searchDirection[0]),s)) {
      lDE.emplace_back(&m_elements[i],s,0);
      used[i]=true;
    }
  }
 
}

getITkEndcapDetElements()

void InDet::SiDetElementsLayer_xk::getITkEndcapDetElements	(	const std::array< float, 6 > &	startingPoint,
		const std::array< float, 3 > &	searchDirection,
		std::vector< InDet::SiDetElementLink_xk::ElementWay > &	lDE,
		std::vector< bool > &	used ) const

solve the linear equation z_layer = z_startingPont + s * z_searchDirection

obtain x,y,r coordinates of the layer crossing in z

search direction z (== cos(theta_search)) * radius of starting point

Kick out cases where we do not expect to cross the layer at all. Do this by checking if the distance of the radial location of the z-crossing from the layer centre in r exceeds the r-half-width by more than the r-movement expected when traversing the half-width in z + the search road width

Definition at line 233 of file SiDetElementsLayer_xk.cxx.

{
  constexpr float pi = M_PI;
  constexpr float pi2 = 2.*pi;

  float s   =(m_z-startingPoint[2])/searchDirection[2];
  float xc  = startingPoint[0]+searchDirection[0]*s;
  float yc  = startingPoint[1]+searchDirection[1]*s;
  float rc  = std::sqrt(xc*xc+yc*yc);
  float A23 = searchDirection[2]*startingPoint[3];
  if(A23 != 0. && std::abs(rc-m_r) > m_dr+std::abs(2.*(startingPoint[0]*searchDirection[0]+startingPoint[1]*searchDirection[1])*m_dz/A23)+startingPoint[4]) return;
  float reducedRoadWidth  = startingPoint[4]/rc + m_dfe;
  float phiCrossing  = std::atan2(yc,xc)-reducedRoadWidth;
  if(phiCrossing<-pi) phiCrossing += pi2;
 
  int   ie   = m_elements.size();
  int   i1   = ie-1;
 
  if     (phiCrossing <= m_elements[ 0].phi()) i1 = 0 ;
  else if(phiCrossing >  m_elements[i1].phi()) i1 = ie;
  else  {
    int i0=0;
    while((i1-i0)>1) {
      int i = (i0+i1)/2;
      if (m_elements[i].phi() > phiCrossing) i1=i;
      else i0=i;
    }
  }
 
  phiCrossing += 2.*reducedRoadWidth;
 
  for(int i = i1; i!=ie; ++i) {
 
    if( m_elements[i].phi() > phiCrossing ) return;
 
    if(m_elements[i].intersectITk(&(startingPoint[0]),&(searchDirection[0]),s)) {
      lDE.emplace_back(&m_elements[i],s,0); //distance not used for ITk?
      used[i]=true;
    }
  }
 
  phiCrossing -= pi2;
 
  for(int i=0; i!=i1; ++i)  {
 
    if( m_elements[i].phi() > phiCrossing) return;
 
    if(m_elements[i].intersectITk(&(startingPoint[0]),&(searchDirection[0]),s)) {
      lDE.emplace_back(&m_elements[i],s,0);
      used[i]=true;
    }
  }
 
}

nElements()

int InDet::SiDetElementsLayer_xk::nElements ( ) const

inline

Definition at line 171 of file SiDetElementsLayer_xk.h.

    {
      return m_elements.size();
    }  

operator=() [1/2]

SiDetElementsLayer_xk & InDet::SiDetElementsLayer_xk::operator= ( const SiDetElementsLayer_xk & )

default

operator=() [2/2]

SiDetElementsLayer_xk & InDet::SiDetElementsLayer_xk::operator= ( SiDetElementsLayer_xk && )

default

r()

const float & InDet::SiDetElementsLayer_xk::r ( ) const

inline

Definition at line 52 of file SiDetElementsLayer_xk.h.

{return m_r       ;}

set()

void InDet::SiDetElementsLayer_xk::set ( double r, double dr, double z, double dz, double df )

inline

Definition at line 156 of file SiDetElementsLayer_xk.h.

    {
      m_r  = float(r );
      m_dr = float(dr);
      m_z  = float(z );
      m_dz = float(dz);
      m_dfe= float(df);
    } 

sortDetectorElements()

void InDet::SiDetElementsLayer_xk::sortDetectorElements

(

)

Definition at line 402 of file SiDetElementsLayer_xk.cxx.

{
  std::sort(m_elements.begin(),m_elements.end(),InDet::compDetElements_Azimuthal());
}

z()

const float & InDet::SiDetElementsLayer_xk::z ( ) const

inline

Definition at line 54 of file SiDetElementsLayer_xk.h.

{return m_z       ;}

Member Data Documentation

m_dfe

float InDet::SiDetElementsLayer_xk::m_dfe

protected

Definition at line 117 of file SiDetElementsLayer_xk.h.

m_dr

float InDet::SiDetElementsLayer_xk::m_dr

protected

Definition at line 116 of file SiDetElementsLayer_xk.h.

m_dz

float InDet::SiDetElementsLayer_xk::m_dz

protected

Definition at line 114 of file SiDetElementsLayer_xk.h.

m_elements

std::vector<SiDetElementLink_xk> InDet::SiDetElementsLayer_xk::m_elements

protected

Definition at line 118 of file SiDetElementsLayer_xk.h.

m_r

float InDet::SiDetElementsLayer_xk::m_r

protected

Definition at line 115 of file SiDetElementsLayer_xk.h.

m_z

float InDet::SiDetElementsLayer_xk::m_z

protected

Definition at line 113 of file SiDetElementsLayer_xk.h.

---

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

• SiDetElementsLayer_xk.h
• SiDetElementsLayer_xk.cxx