ITk::SiSpacePointsProSeed Class Reference

#include <ITkSiSpacePointsProSeed.h>

Collaboration diagram for ITk::SiSpacePointsProSeed:

Public Member Functions
	SiSpacePointsProSeed ()
	SiSpacePointsProSeed (SiSpacePointForSeed *&, SiSpacePointForSeed *&, SiSpacePointForSeed *&, float)
	SiSpacePointsProSeed (const SiSpacePointsProSeed &)
SiSpacePointsProSeed &	operator= (const SiSpacePointsProSeed &)
	SiSpacePointsProSeed (SiSpacePointsProSeed &&)=default
SiSpacePointsProSeed &	operator= (SiSpacePointsProSeed &&)=default
	~SiSpacePointsProSeed ()=default
SiSpacePointForSeed *	spacepoint0 ()
SiSpacePointForSeed *	spacepoint1 ()
SiSpacePointForSeed *	spacepoint2 ()
const float &	z () const
const float &	quality () const
void	set (SiSpacePointForSeed *&, SiSpacePointForSeed *&, SiSpacePointForSeed *&, float)
bool	setQuality (float)
bool	set3 (InDet::SiSpacePointsSeed &, float pTPerHelixRadius)
void	set2 (InDet::SiSpacePointsSeed &)

Private Member Functions
void	estimateParameters (float pTPerHelixRadius)

Private Attributes
SiSpacePointForSeed *	m_s0 {}
SiSpacePointForSeed *	m_s1 {}
SiSpacePointForSeed *	m_s2 {}
float	m_z {}
float	m_q {}

Detailed Description

Definition at line 28 of file ITkSiSpacePointsProSeed.h.

Constructor & Destructor Documentation

SiSpacePointsProSeed() [1/4]

ITk::SiSpacePointsProSeed::SiSpacePointsProSeed

(

)

Definition at line 15 of file ITkSiSpacePointsProSeed.cxx.

    {
      m_s0 = nullptr ;
      m_s1 = nullptr ;
      m_s2 = nullptr ;
      m_z  = 0.;
      m_q  = 0.;
    }

SiSpacePointsProSeed() [2/4]

ITk::SiSpacePointsProSeed::SiSpacePointsProSeed	(	SiSpacePointForSeed *&	s0,
		SiSpacePointForSeed *&	s1,
		SiSpacePointForSeed *&	s2,
		float	z )

Definition at line 38 of file ITkSiSpacePointsProSeed.cxx.

    {
      set(s0,s1,s2,z); m_q = 0.;
    }

SiSpacePointsProSeed() [3/4]

ITk::SiSpacePointsProSeed::SiSpacePointsProSeed

(

const SiSpacePointsProSeed &

sp

)

Definition at line 48 of file ITkSiSpacePointsProSeed.cxx.

                                                                           : m_s0(sp.m_s0),m_s1(sp.m_s1),m_s2(sp.m_s2)
    {
      *this = sp;
    }

SiSpacePointsProSeed() [4/4]

ITk::SiSpacePointsProSeed::SiSpacePointsProSeed ( SiSpacePointsProSeed && )

default

~SiSpacePointsProSeed()

ITk::SiSpacePointsProSeed::~SiSpacePointsProSeed ( )

default

Member Function Documentation

estimateParameters()

void ITk::SiSpacePointsProSeed::estimateParameters ( float pTPerHelixRadius )

private

Definition at line 123 of file ITkSiSpacePointsProSeed.cxx.

  {
 
    ITk::SiSpacePointForSeed& bottom = *m_s0;
    ITk::SiSpacePointForSeed& medium = *m_s1;
    ITk::SiSpacePointForSeed& top    = *m_s2;
 
    bool isPixel = !m_s2->spacepoint->clusterList().second;
 
    auto extractCoordinates =
      [] (const ITk::SiSpacePointForSeed& sp) -> std::array<float,4>
      {
        std::array<float, 4> coordinates {sp.x(), sp.y(), sp.z(), sp.radius()};
        return coordinates;
      };
 
    auto extractQuantities =
      [] (const std::array<float, 4>& sp,
      const std::array<float, 4>& spM,
      bool isBottom) -> std::array<float, 5>
      {
        const auto& [xM, yM, zM, rM] = spM;
        const auto& [xO, yO, zO, rO] = sp;
 
        float cosPhiM = xM / rM;
        float sinPhiM = yM / rM;
        float deltaX = xO - xM;
        float deltaY = yO - yM;
        float deltaZ = zO - zM;
        float x = deltaX * cosPhiM + deltaY * sinPhiM;
        float y = deltaY * cosPhiM - deltaX * sinPhiM;
        float iDeltaR2 = 1. / (deltaX * deltaX + deltaY * deltaY);
        float iDeltaR = std::sqrt(iDeltaR2);
        int bottomFactor = 1 * (int(not isBottom)) - 1 * (int(isBottom));
        float cot_theta = deltaZ * iDeltaR * bottomFactor;
 
        // cotTheta, Zo, iDeltaR, U, V
        std::array<float, 5> params =
        {
          cot_theta,
          zM - rM * cot_theta,
          iDeltaR,
          x * iDeltaR2,
          y * iDeltaR2
        };
 
        return params;
      };
 
    auto coo_b = extractCoordinates(bottom);
    auto coo_m = extractCoordinates(medium);
    auto coo_t = extractCoordinates(top);
 
    // Compute the variables we need
    auto [cotThetaB, Zob, iDeltaRB, Ub, Vb] = extractQuantities(coo_b, coo_m, true);
    auto [cotThetaT, Zot, iDeltaRT, Ut, Vt] = extractQuantities(coo_t, coo_m, false);
 
    float squarediDeltaR2B = iDeltaRB*iDeltaRB;
    float squarediDeltaR2T = iDeltaRB*iDeltaRT;
    float squarediDeltaR = std::min(squarediDeltaR2B, squarediDeltaR2T);
 
    auto& [xB, yB, zB, rB] = coo_b;
    auto& [xM, yM, zM, rM] = coo_m;
    auto& [xT, yT, zT, rT] = coo_t;
 
    float ax = xM / rM;
    float ay = yM/ rM;
 
    float dxb = xM - xB;
    float dyb = yM - yB;
    float dzb = zM - zB;
    float xb = dxb * ax + dyb *ay;
    float yb = dyb * ax - dxb * ay;
    float dxyb = xb * xb + yb * yb;
    float drb = std::sqrt( xb*xb + yb*yb + dzb*dzb );
 
    float dxt = xT - xM;
    float dyt = yT - yM;
    float dzt = zT - zM;
    float xt = dxt * ax + dyt *ay;
    float yt = dyt * ax - dxt * ay;
    float dxyt = xt * xt + yt * yt;
    float drt = std::sqrt( xt*xt + yt*yt + dzt*dzt );
 
    float tzb = dzb * std::sqrt( 1.f/dxyb );
    float tzt = dzt * std::sqrt( 1.f/dxyt );
 
    float sTzb2 = std::sqrt(1.f + tzb*tzb);
 
    float dU = Ut - Ub;
    if (dU == 0.) {
      return;
    }
 
    float A = (Vt - Vb) / dU;
    float S2 = 1.f + A * A;
    float B = Vb - A * Ub;
    if (B==0)
      return;
    float B2 = B * B;
 
    // dzdr
    float dzdr_b = (zM - zB) / (rM - rB);
    float dzdr_t = (zT - zM) / (rT - rM);
 
    // eta
    float meanOneOverTanThetaSquare = isPixel ? (cotThetaB * cotThetaT) :
                                                 std::pow((cotThetaB + cotThetaT) / 2.f,2);
    if (meanOneOverTanThetaSquare <= 0) {
      return;
    }
    float theta = std::atan(1.f / std::sqrt(meanOneOverTanThetaSquare)); // [0, pi/2)
    if (top.z()<0) {theta = -theta;} // (-pi/2, pi/2)
    if (theta < 0.) {theta = theta + M_PI;} // [0, pi)
    float eta = -std::log(std::tan(0.5f * theta));
 
    // pt
    float pt = pTPerHelixRadius*std::sqrt(S2 / B2);
 
    // d0
    float d0 = std::abs((A - B * rM) * rM);
 
    // Attach variables to SPs
    top.setDR(drt);
    top.setDZDR(dzdr_t);
    top.setScorePenalty( std::abs((tzb - tzt) / (squarediDeltaR * sTzb2)) );
    top.setParam(d0);
    top.setEta(eta);
    top.setPt(pt);
 
    bottom.setDR(drb);
    bottom.setDZDR(dzdr_b);
 
  }

operator=() [1/2]

SiSpacePointsProSeed & ITk::SiSpacePointsProSeed::operator=

(

const SiSpacePointsProSeed &

sp

)

Definition at line 24 of file ITkSiSpacePointsProSeed.cxx.

    {
      if(&sp!=this) {
 
    m_z   = sp.m_z ;
    m_q   = sp.m_q ;
    m_s0  = sp.m_s0;
    m_s1  = sp.m_s1;
    m_s2  = sp.m_s2;
      }
      return(*this);
    }

operator=() [2/2]

SiSpacePointsProSeed & ITk::SiSpacePointsProSeed::operator= ( SiSpacePointsProSeed && )

default

quality()

const float & ITk::SiSpacePointsProSeed::quality ( ) const

inline

Definition at line 49 of file ITkSiSpacePointsProSeed.h.

{return m_q ;}

set()

void ITk::SiSpacePointsProSeed::set	(	SiSpacePointForSeed *&	s0,
		SiSpacePointForSeed *&	s1,
		SiSpacePointForSeed *&	s2,
		float	z )

Definition at line 58 of file ITkSiSpacePointsProSeed.cxx.

    {
      m_z   = z ;
      m_s0  = s0;
      m_s1  = s1;
      m_s2  = s2;
    }

set2()

void ITk::SiSpacePointsProSeed::set2

(

InDet::SiSpacePointsSeed &

s

)

Definition at line 71 of file ITkSiSpacePointsProSeed.cxx.

    {
      s.erase();
      s.add(m_s0->spacepoint);
      s.add(m_s1->spacepoint);
      s.setZVertex(double(m_z));
    }

set3()

bool ITk::SiSpacePointsProSeed::set3	(	InDet::SiSpacePointsSeed &	s,
		float	pTPerHelixRadius )

Definition at line 83 of file ITkSiSpacePointsProSeed.cxx.

    {
      bool pixt = !m_s2->spacepoint->clusterList().second;
      
      if(pixt) {
        if(m_q > m_s0->quality() && m_q > m_s1->quality() && m_q > m_s2->quality()) return false;
      }
     
      m_s0->setQuality(m_q);
      m_s1->setQuality(m_q);
      m_s2->setQuality(m_q);
      
      s.erase();
      s.add(m_s0->spacepoint);
      s.add(m_s1->spacepoint);
      s.add(m_s2->spacepoint);
      s.setZVertex(double(m_z)); 
      s.setX1(m_s0->x());
      s.setX2(m_s1->x());
      s.setX3(m_s2->x());
      s.setY1(m_s0->y());
      s.setY2(m_s1->y());
      s.setY3(m_s2->y());
      s.setZ1(m_s0->z());
      s.setZ2(m_s1->z());
      s.setZ3(m_s2->z());
      s.setR1(m_s0->radius());
      s.setR2(m_s1->radius());
      s.setR3(m_s2->radius());
 
      estimateParameters(pTPerHelixRadius);
      s.setD0(m_s2->param());
      s.setEta(m_s2->eta());
      s.setDZDR_B(m_s0->dzdr());
      s.setDZDR_T(m_s2->dzdr());
      s.setPt(m_s2->pt());
 
      return true;
    }

setQuality()

bool ITk::SiSpacePointsProSeed::setQuality

(

float

q

)

Definition at line 262 of file ITkSiSpacePointsProSeed.cxx.

    {
      m_q = q;
 
      if(!m_s2->spacepoint->clusterList().second) {
        if(q > m_s0->quality() && q > m_s1->quality() && q > m_s2->quality()) return false;
      }
      m_s0->setQuality(m_q);
      m_s1->setQuality(m_q);
      m_s2->setQuality(m_q);
      return true;
    }

spacepoint0()

SiSpacePointForSeed * ITk::SiSpacePointsProSeed::spacepoint0 ( )

inline

Definition at line 45 of file ITkSiSpacePointsProSeed.h.

{return m_s0;}

spacepoint1()

SiSpacePointForSeed * ITk::SiSpacePointsProSeed::spacepoint1 ( )

inline

Definition at line 46 of file ITkSiSpacePointsProSeed.h.

{return m_s1;}

spacepoint2()

SiSpacePointForSeed * ITk::SiSpacePointsProSeed::spacepoint2 ( )

inline

Definition at line 47 of file ITkSiSpacePointsProSeed.h.

{return m_s2;}

z()

const float & ITk::SiSpacePointsProSeed::z ( ) const

inline

Definition at line 48 of file ITkSiSpacePointsProSeed.h.

{return m_z ;}

Member Data Documentation

m_q

float ITk::SiSpacePointsProSeed::m_q {}

private

Definition at line 63 of file ITkSiSpacePointsProSeed.h.

{} ;

m_s0

SiSpacePointForSeed* ITk::SiSpacePointsProSeed::m_s0 {}

private

Definition at line 59 of file ITkSiSpacePointsProSeed.h.

{};

m_s1

SiSpacePointForSeed* ITk::SiSpacePointsProSeed::m_s1 {}

private

Definition at line 60 of file ITkSiSpacePointsProSeed.h.

{};

m_s2

SiSpacePointForSeed* ITk::SiSpacePointsProSeed::m_s2 {}

private

Definition at line 61 of file ITkSiSpacePointsProSeed.h.

{};

m_z

float ITk::SiSpacePointsProSeed::m_z {}

private

Definition at line 62 of file ITkSiSpacePointsProSeed.h.

{} ;

---

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

• ITkSiSpacePointsProSeed.h
• ITkSiSpacePointsProSeed.cxx