Trk::MeasurementBaseComparisonFunction Class Reference

Class implementing a comparison function for sorting MeasurementBase objects. More...

#include <MeasurementBaseComparisonFunction.h>

Collaboration diagram for Trk::MeasurementBaseComparisonFunction:

Public Member Functions
	MeasurementBaseComparisonFunction ()=delete
	~MeasurementBaseComparisonFunction ()=default
	MeasurementBaseComparisonFunction (const Amg::Vector3D &sp, const Amg::Vector3D &dir)
	Full relation definition using a straight line propagation.
	MeasurementBaseComparisonFunction (const MeasurementBaseComparisonFunction &MCF)=default
MeasurementBaseComparisonFunction &	operator= (MeasurementBaseComparisonFunction &MCF)=default
	MeasurementBaseComparisonFunction (MeasurementBaseComparisonFunction &&MCF)=default
MeasurementBaseComparisonFunction &	operator= (MeasurementBaseComparisonFunction &&MCF)=default
bool	operator() (const Trk::MeasurementBase *one, const Trk::MeasurementBase *two) const
	The comparison function defining in what case a Measurement is 'smaller' than a second one.

Private Member Functions
double	pathIntersectWithPlane (const Trk::PlaneSurface &psf) const
double	pathIntersectWithLine (const Trk::StraightLineSurface &lsf) const
double	pathIntersectWithLine (const Trk::PerigeeSurface &pgsf) const
double	pathIntersectWithDisc (const Trk::DiscSurface &dsf) const
double	pathIntersectWithCylinder (const Trk::CylinderSurface &csf, const Amg::Vector3D &globalHit) const

Private Attributes
Amg::Vector3D	m_point
Amg::Vector3D	m_direction

Detailed Description

Class implementing a comparison function for sorting MeasurementBase objects.

Definition at line 39 of file MeasurementBaseComparisonFunction.h.

Constructor & Destructor Documentation

MeasurementBaseComparisonFunction() [1/4]

Trk::MeasurementBaseComparisonFunction::MeasurementBaseComparisonFunction ( )

delete

~MeasurementBaseComparisonFunction()

Trk::MeasurementBaseComparisonFunction::~MeasurementBaseComparisonFunction ( )

default

MeasurementBaseComparisonFunction() [2/4]

Trk::MeasurementBaseComparisonFunction::MeasurementBaseComparisonFunction ( const Amg::Vector3D & sp, const Amg::Vector3D & dir )

inline

Full relation definition using a straight line propagation.

Definition at line 45 of file MeasurementBaseComparisonFunction.h.

    : m_point(sp)
    , m_direction(dir.unit())
  {}

MeasurementBaseComparisonFunction() [3/4]

Trk::MeasurementBaseComparisonFunction::MeasurementBaseComparisonFunction ( const MeasurementBaseComparisonFunction & MCF )

default

MeasurementBaseComparisonFunction() [4/4]

Trk::MeasurementBaseComparisonFunction::MeasurementBaseComparisonFunction ( MeasurementBaseComparisonFunction && MCF )

default

Member Function Documentation

operator()()

bool Trk::MeasurementBaseComparisonFunction::operator() ( const Trk::MeasurementBase * one, const Trk::MeasurementBase * two ) const

inline

The comparison function defining in what case a Measurement is 'smaller' than a second one.

Definition at line 65 of file MeasurementBaseComparisonFunction.h.

  {
 
    // --- flexible sorting along a predicted direction
    double path1 = 0;
    const Trk::Surface& sf1 = one->associatedSurface();
    const Trk::SurfaceType surfType1 = sf1.type();
    switch (surfType1) {
      case Trk::SurfaceType::Plane: {
        const Trk::PlaneSurface& opsf =
          static_cast<const Trk::PlaneSurface&>(sf1);
        path1 = this->pathIntersectWithPlane(opsf);
      } break;
      case Trk::SurfaceType::Line: {
        const Trk::StraightLineSurface& ossf =
          static_cast<const Trk::StraightLineSurface&>(sf1);
        path1 = this->pathIntersectWithLine(ossf);
      } break;
      case Trk::SurfaceType::Disc: {
        const Trk::DiscSurface& odsf =
          static_cast<const Trk::DiscSurface&>(sf1);
        path1 = this->pathIntersectWithDisc(odsf);
      } break;
      case Trk::SurfaceType::Cylinder: {
        const Trk::CylinderSurface& ocsf =
          static_cast<const Trk::CylinderSurface&>(sf1);
        path1 = this->pathIntersectWithCylinder(ocsf, one->globalPosition());
      } break;
      case Trk::SurfaceType::Perigee: {
        const Trk::PerigeeSurface& ogsf =
          static_cast<const Trk::PerigeeSurface&>(sf1);
        path1 = this->pathIntersectWithLine(ogsf);
      } break;
      default: {
        throw std::runtime_error(
          "MeasurementBaseComparisonFunction: surface type error for Sf1!");
      }
    }
 
    // --- identify the 2nd surface type and get intersection path for surface 1
    double path2 = 0;
    const Trk::Surface& sf2 = two->associatedSurface();
    const Trk::SurfaceType surfType2 = sf2.type();
    switch (surfType2) {
      case Trk::SurfaceType::Plane: {
        const Trk::PlaneSurface& tpsf =
          static_cast<const Trk::PlaneSurface&>(sf2);
        path2 = this->pathIntersectWithPlane(tpsf);
      } break;
      case Trk::SurfaceType::Line: {
        const Trk::StraightLineSurface& tssf =
          static_cast<const Trk::StraightLineSurface&>(sf2);
        path2 = this->pathIntersectWithLine(tssf);
      } break;
      case Trk::SurfaceType::Disc: {
        const Trk::DiscSurface& tdsf =
          static_cast<const Trk::DiscSurface&>(sf2);
        path2 = this->pathIntersectWithDisc(tdsf);
      } break;
      case Trk::SurfaceType::Cylinder: {
        const Trk::CylinderSurface& tcsf =
          static_cast<const Trk::CylinderSurface&>(sf2);
        path2 = this->pathIntersectWithCylinder(tcsf, two->globalPosition());
      } break;
      case Trk::SurfaceType::Perigee: {
        const Trk::PerigeeSurface& tgsf =
          static_cast<const Trk::PerigeeSurface&>(sf2);
        path2 = this->pathIntersectWithLine(tgsf);
      } break;
      default: {
        throw std::runtime_error(
          "MeasurementBaseComparisonFunction: surface type error for Sf2!");
      }
    }
    return path1 < path2;
  }

operator=() [1/2]

MeasurementBaseComparisonFunction & Trk::MeasurementBaseComparisonFunction::operator= ( MeasurementBaseComparisonFunction && MCF )

default

operator=() [2/2]

MeasurementBaseComparisonFunction & Trk::MeasurementBaseComparisonFunction::operator= ( MeasurementBaseComparisonFunction & MCF )

default

pathIntersectWithCylinder()

double Trk::MeasurementBaseComparisonFunction::pathIntersectWithCylinder ( const Trk::CylinderSurface & csf, const Amg::Vector3D & globalHit ) const

inlineprivate

Definition at line 183 of file MeasurementBaseComparisonFunction.h.

  { // --- code from TrkExSlPropagator/LineCylinderIntersection.cxx
 
    // get the rotation by reference
    const Amg::Transform3D& locTrans = csf.transform();
    // take two points of line and calculate them to the 3D frame of the
    // cylinder
    Amg::Vector3D point1(locTrans.inverse() * m_point);
    Amg::Vector3D point2raw = m_point + m_direction;
    Amg::Vector3D point2(locTrans.inverse() * point2raw); // do it in two steps
 
    // new direction in 3D frame of cylinder
    Amg::Vector3D direc((point2 - point1).unit());
 
    if (!direc.x()) {
      return 0.;
    } else {
      // get line and circle constants
      double k = (direc.y()) / (direc.x());
      double d = (point2.x() * point1.y() - point1.x() * point2.y()) /
                 (point2.x() - point1.x());
      double R = csf.bounds().r();
      double first = 0.;
      double second = 0.;
 
      // and solve the quadratic equation  Trk::RealQuadraticEquation
      // pquad(1+k*k, 2*k*d, d*d-R*R);
      double a = 1 + k * k;
      double p = 2 * k * d;
      double q = d * d - R * R;
      double discriminant = p * p - 4 * a * q;
      if (discriminant < 0) {
        return 0.;
      } else {
        // solutions = (discriminant==0) ? one : two;
        double x0 =
          -0.5 * (p + (p > 0 ? sqrt(discriminant) : -sqrt(discriminant)));
        first = x0 / a;
        second = q / x0;
      }
      double t1 = (first - point1.x()) / direc.x();
      double t2 = (second - point1.x()) / direc.x();
      // the solutions in the 3D frame of the cylinder
      Amg::Vector3D dist1raw(point1 + t1 * direc - globalHit);
      Amg::Vector3D dist2raw(point1 + t2 * direc - globalHit);
      // return the solution which is closer to Meas'Base's global coordinates
      if (dist1raw.mag() < dist2raw.mag()) {
        return t1; 
      } else {
        return t2;
      }
    }
  }

pathIntersectWithDisc()

double Trk::MeasurementBaseComparisonFunction::pathIntersectWithDisc ( const Trk::DiscSurface & dsf ) const

inlineprivate

Definition at line 177 of file MeasurementBaseComparisonFunction.h.

  {
    double denom = m_direction.dot(dsf.normal());
    return (denom) ? dsf.normal().dot(dsf.center() - m_point) / (denom) : denom;
  }

pathIntersectWithLine() [1/2]

double Trk::MeasurementBaseComparisonFunction::pathIntersectWithLine ( const Trk::PerigeeSurface & pgsf ) const

inlineprivate

Definition at line 165 of file MeasurementBaseComparisonFunction.h.

  {
    Amg::Vector3D trackToWire(pgsf.center() - m_point);
    double parallelity = m_direction.dot(Trk::s_zAxis);
    double denom = 1 - parallelity * parallelity;
    return (fabs(denom) > 10e-7)
             ? (trackToWire.dot(m_direction) -
                trackToWire.dot(Trk::s_zAxis) * parallelity) /
                 denom
             : 0.;
  }

pathIntersectWithLine() [2/2]

double Trk::MeasurementBaseComparisonFunction::pathIntersectWithLine ( const Trk::StraightLineSurface & lsf ) const

inlineprivate

Definition at line 153 of file MeasurementBaseComparisonFunction.h.

  {
    const Amg::Vector3D& dirWire = lsf.lineDirection().normalized();
    Amg::Vector3D trackToWire(lsf.center() - m_point);
    double parallelity = m_direction.dot(dirWire);
    double denom = 1 - parallelity * parallelity;
    return (fabs(denom) > 10e-7) ? (trackToWire.dot(m_direction) -
                                    trackToWire.dot(dirWire) * parallelity) /
                                     denom
                                 : 0.;
  }

pathIntersectWithPlane()

double Trk::MeasurementBaseComparisonFunction::pathIntersectWithPlane ( const Trk::PlaneSurface & psf ) const

inlineprivate

Definition at line 147 of file MeasurementBaseComparisonFunction.h.

  {
    double denom = m_direction.dot(psf.normal()); 
    return (denom) ? psf.normal().dot(psf.center() - m_point) / (denom) : denom;
  }

Member Data Documentation

m_direction

Amg::Vector3D Trk::MeasurementBaseComparisonFunction::m_direction

private

Definition at line 145 of file MeasurementBaseComparisonFunction.h.

m_point

Amg::Vector3D Trk::MeasurementBaseComparisonFunction::m_point

private

Definition at line 144 of file MeasurementBaseComparisonFunction.h.

---

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

• MeasurementBaseComparisonFunction.h