gar_content::Helix Class Reference

Helix class. More...

#include <Helix.h>

Public Member Functions
	Helix (const float phi0, const float d0, const float x0, const float omega, const float tanlambda, const float bField)
	Constructor using canonical (LEP-wise) parameterisation. More...
	Helix (const pandora::CartesianVector &position, const pandora::CartesianVector &momentum, const float charge, const float bField)
	Constructor. More...
pandora::StatusCode	GetPointInZY (const float z0, const float y0, const float az, const float ay, const pandora::CartesianVector &referencePoint, pandora::CartesianVector &intersectionPoint) const
	Get helix intersection point with a plane parallel to x axis. The plane is defined by two coordinates in the plane (z0,y0) and a normal vector (az,ay). More...
pandora::StatusCode	GetPointInZY (const float z0, const float y0, const float az, const float ay, const pandora::CartesianVector &referencePoint, pandora::CartesianVector &intersectionPoint, float &genericTime) const
	Get helix intersection point with a plane parallel to x axis. The plane is defined by two coordinates in the plane (z0,y0) and a normal vector (az,ay). More...
pandora::StatusCode	GetPointInX (const float xPlane, const pandora::CartesianVector &referencePoint, pandora::CartesianVector &intersectionPoint) const
	Get helix intersection point with a plane perpendicular to x axis. More...
pandora::StatusCode	GetPointInX (const float xPlane, const pandora::CartesianVector &referencePoint, pandora::CartesianVector &intersectionPoint, float &genericTime) const
	Get helix intersection point with a plane perpendicular to x axis. More...
pandora::StatusCode	GetPointOnCircle (const float radius, const pandora::CartesianVector &referencePoint, pandora::CartesianVector &intersectionPoint) const
	Get coordinates of helix intersection with cylinder, aligned along z-axis. More...
pandora::StatusCode	GetPointOnCircle (const float radius, const pandora::CartesianVector &referencePoint, pandora::CartesianVector &intersectionPoint, float &genericTime) const
	Get coordinates of helix intersection with cylinder, aligned along z-axis. More...
pandora::StatusCode	GetDistanceToPoint (const pandora::CartesianVector &point, pandora::CartesianVector &distance) const
	Get distance of the closest approach of helix to an arbitrary point in space. More...
pandora::StatusCode	GetDistanceToPoint (const pandora::CartesianVector &point, pandora::CartesianVector &distance, float &genericTime) const
	Get distance of the closest approach of helix to an arbitrary point in space. More...
pandora::StatusCode	GetDistanceToHelix (const Helix *const pHelix, pandora::CartesianVector &positionOfClosestApproach, pandora::CartesianVector &v0momentum, float &helixDistance) const
	Get distance between two helices. More...
pandora::CartesianVector	GetExtrapolatedMomentum (const pandora::CartesianVector &position) const
const pandora::CartesianVector &	GetMomentum () const
	Get momentum of particle at the point of closest approach to IP. More...
const pandora::CartesianVector &	GetReferencePoint () const
	Get reference point of track. More...
float	GetPhi0 () const
	Get phi angle of the momentum vector at the point of closest approach to IP. More...
float	GetD0 () const
	Get x signed distance of closest approach to IP in the R-Phi plane. More...
float	GetX0 () const
	Get x coordinate of the point of closest approach to IP in the R-Phi plane. More...
float	GetOmega () const
	Get signed curvature of the track. More...
float	GetTanLambda () const
	Get tangent of dip angle of the track. More...
float	GetPzy () const
	Get transverse momentum of the track. More...
float	GetCharge () const
	Get charge. More...
float	GetZCentre () const
	Get z coordinate of circumference. More...
float	GetYCentre () const
	Get y coordinate of circumference. More...
float	GetRadius () const
	Get radius of circumference. More...

Private Attributes
pandora::CartesianVector	m_referencePoint
	The coordinates of the reference point. More...
pandora::CartesianVector	m_momentum
	The momentum vector at reference point. More...
float	m_phi0
	phi0 in canonical parameterization More...
float	m_d0
	d0 in canonical parameterisation More...
float	m_x0
	x0 in canonical parameterisation More...
float	m_omega
	signed curvature in canonical parameterisation More...
float	m_tanLambda
	tanLambda More...
float	m_pzy
	The transverse momentum. More...
float	m_charge
	The particle charge. More...
float	m_zCentre
	The circle centre z coordinate. More...
float	m_yCentre
	The circle centre y coordinate. More...
float	m_radius
	The radius of circle in ZY plane. More...
float	m_phiRefPoint
	Phi w.r.t. (Z0, Y0) of circle at reference point. More...
float	m_phiAtPCA
	Phi w.r.t. (Z0, Y0) of circle at point of closest approach. More...
float	m_zAtPCA
	z coordinate at point of closest approach More...
float	m_yAtPCA
	y coordinate at point of closest approach More...
float	m_pzAtPCA
	Momentum z component at point of closest approach. More...
float	m_pyAtPCA
	Momentum y component at point of closest approach. More...
float	m_phiMomRefPoint
	Phi of Momentum vector at reference point. More...

Static Private Attributes
static const float	FCT = 2.99792458E-4f
static const float	TWO_PI = static_cast<float>(2. * std::acos(-1.0))
static const float	HALF_PI = static_cast<float>(0.5 * std::acos(-1.0))

Detailed Description

Helix class.

Definition at line 14 of file Helix.h.

Constructor & Destructor Documentation

gar_content::Helix::Helix	(	const float	phi0,
		const float	d0,
		const float	x0,
		const float	omega,
		const float	tanlambda,
		const float	bField
	)

Constructor using canonical (LEP-wise) parameterisation.

Parameters

phi0	phi angle of momentum vector at the point of closest approach to IP in R-Phi plane
d0	signed distance of closest approach in R-Phi plane
x0	x coordinate of the point of closest approach to IP in R-Phi plane
omega	signed curvature
tanLambda	tangent of dip angle
bField	magnetic field (in Tesla)

Definition at line 16 of file Helix.cc.

    : m_referencePoint(0.f, 0.f, 0.f),
    m_momentum(0.f, 0.f, 0.f),
    m_phi0(phi0),
    m_d0(d0),
    m_x0(x0),
    m_omega(omega),
    m_tanLambda(tanLambda)
    {
        if ((bField < std::numeric_limits<float>::epsilon()) || (std::fabs(omega) < std::numeric_limits<float>::epsilon()))
        {
            std::cout << "Helix, invalid parameter: bField " << bField << ", omega " << omega << std::endl;
            throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
        }

        m_charge = omega / std::fabs(omega);
        m_radius = 1.f / std::fabs(omega);
        m_zAtPCA = -m_d0 * std::sin(m_phi0);
        m_yAtPCA = m_d0 * std::cos(m_phi0);
        m_referencePoint.SetValues(m_zAtPCA, m_yAtPCA, m_x0);
        m_pzy = FCT * bField * m_radius;
        m_momentum.SetValues(m_pzy * std::cos(m_phi0), m_pzy * std::sin(m_phi0), m_tanLambda * m_pzy);
        m_pzAtPCA = m_momentum.GetZ();
        m_pyAtPCA = m_momentum.GetY();
        m_phiMomRefPoint = std::atan2(m_pyAtPCA, m_pzAtPCA);
        m_zCentre = m_referencePoint.GetZ() + m_radius * std::cos(m_phi0 - HALF_PI * m_charge);
        m_yCentre = m_referencePoint.GetY() + m_radius * std::sin(m_phi0 - HALF_PI * m_charge);
        m_phiAtPCA = std::atan2(-m_yCentre, -m_zCentre);
        m_phiRefPoint = m_phiAtPCA;
    }

gar_content::Helix::Helix	(	const pandora::CartesianVector &	position,
		const pandora::CartesianVector &	momentum,
		const float	charge,
		const float	bField
	)

Constructor.

Parameters

position	position of the reference point
momentum	momentum vector at the reference point
charge	particle charge
bField	magnetic field (in Tesla)

Definition at line 49 of file Helix.cc.

    : m_referencePoint(position),
    m_momentum(momentum),
    m_charge(charge)
    {
        const double pz(momentum.GetZ()), py(momentum.GetY());
        const double pzy(std::sqrt(pz * pz + py * py));

        if ((bField < std::numeric_limits<float>::epsilon()) || (std::fabs(pzy) < std::numeric_limits<float>::epsilon()))
        {
            std::cout << "Helix, invalid parameter: bField " << bField << ", pzy " << pzy << std::endl;
            throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
        }

        const double radius(pzy / (FCT * bField));
        m_pzy    = static_cast<float>(pzy);
        m_radius = static_cast<float>(radius);

        m_omega     = charge / m_radius;
        m_tanLambda = momentum.GetX() / m_pzy;
        m_phiMomRefPoint = static_cast<float>(std::atan2(py, pz));

        const double z(position.GetZ()), y(position.GetY());
        const double zCentre(z + radius * static_cast<double>(std::cos(m_phiMomRefPoint - HALF_PI * charge)));
        const double yCentre(y + radius * static_cast<double>(std::sin(m_phiMomRefPoint - HALF_PI * charge)));
        m_zCentre = static_cast<float>(zCentre);
        m_yCentre = static_cast<float>(yCentre);

        double d0;
        if (charge > 0)
        {
            d0 = static_cast<double>(charge) * radius - static_cast<double>(std::sqrt(zCentre * zCentre + yCentre * yCentre));
        }
        else
        {
            d0 = static_cast<double>(charge) * radius + static_cast<double>(std::sqrt(zCentre * zCentre + yCentre * yCentre));
        }
        m_d0 = static_cast<float>(d0);

        m_phiRefPoint   =  static_cast<float>(std::atan2(y - yCentre, z - zCentre));
        m_phiAtPCA      =  static_cast<float>(std::atan2(-yCentre, -zCentre));
        m_phi0          = -HALF_PI * charge + m_phiAtPCA;

        while (m_phi0 < 0.)
        m_phi0 += TWO_PI;

        while (m_phi0 >= TWO_PI)
        m_phi0 -= TWO_PI;

        m_zAtPCA    = m_zCentre + m_radius * std::cos(m_phiAtPCA);
        m_yAtPCA    = m_yCentre + m_radius * std::sin(m_phiAtPCA);
        m_pzAtPCA   = m_pzy * std::cos(m_phi0);
        m_pyAtPCA   = m_pzy * std::sin(m_phi0);

        float deltaPhi = m_phiRefPoint - m_phiAtPCA;
        float zCircles = (-position.GetX() * charge) / (TWO_PI * ((m_radius * m_tanLambda) - deltaPhi));

        int n1, n2;
        if (zCircles >= std::numeric_limits<float>::epsilon())
        {
            n1 = static_cast<int>(zCircles);
            n2 = n1 + 1;
        }
        else
        {
            n1 = static_cast<int>(zCircles) - 1;
            n2 = n1 + 1;
        }

        const int nCircles((std::fabs(n1 - zCircles) < std::fabs(n2 - zCircles) ? n1 : n2));
        m_x0 = position.GetX() + m_radius * m_tanLambda * charge * (deltaPhi + TWO_PI * nCircles);
    }

Member Function Documentation

float gar_content::Helix::GetCharge ( ) const

inline

Get charge.

Returns

the charge

Definition at line 356 of file Helix.h.

    {
        return m_charge;
    }

float gar_content::Helix::GetD0 ( ) const

inline

Get x signed distance of closest approach to IP in the R-Phi plane.

Returns

the signed distance of closest approach

Definition at line 321 of file Helix.h.

    {
        return m_d0;
    }

pandora::StatusCode gar_content::Helix::GetDistanceToHelix	(	const Helix *const	pHelix,
		pandora::CartesianVector &	positionOfClosestApproach,
		pandora::CartesianVector &	v0momentum,
		float &	helixDistance
	)		const

Get distance between two helices.

Parameters

pHelix	address of a second helix
positionOfClosestApproach	to receive position of the point of closest approach
v0momentum	to receive the v0 momentum
helixDistance	to receive the distance between the two helices

Definition at line 341 of file Helix.cc.

    {
        if (this == pHelix)
        return pandora::STATUS_CODE_INVALID_PARAMETER;

        const float z01(this->GetZCentre());
        const float y01(this->GetYCentre());

        const float z02(pHelix->GetZCentre());
        const float y02(pHelix->GetYCentre());

        const float rad1(this->GetRadius());
        const float rad2(pHelix->GetRadius());

        const float distance(std::sqrt((z01-z02) * (z01-z02) + (y01-y02) * (y01-y02)));

        bool singlePoint(true);
        float phi1(0.), phi2(0.);

        if (rad1 + rad2 < distance)
        {
            phi1 = std::atan2(y02 - y01, z02 - z01);
            phi2 = std::atan2(y01 - y02, z01 - z02);
        }
        else if (distance + rad2 < rad1)
        {
            phi1 = std::atan2(y02 - y01, z02 - z01);
            phi2 = phi1;
        }
        else if (distance + rad1 < rad2)
        {
            phi1 = std::atan2(y01 - y02, z01 - z02);
            phi2 = phi1;
        }
        else
        {
            if ((std::fabs(distance) < std::numeric_limits<float>::epsilon()) || (std::fabs(rad2) < std::numeric_limits<float>::epsilon()))
            return pandora::STATUS_CODE_FAILURE;

            singlePoint = false;
            float cosAlpha = 0.5f * (distance * distance + rad2 * rad2 - rad1 * rad1) / (distance * rad2);
            float alpha = std::acos(cosAlpha);
            float phi0 = std::atan2(y01 - y02, z01 - z02);
            phi1 = phi0 + alpha;
            phi2 = phi0 - alpha;
        }

        const pandora::CartesianVector &referencePoint1(m_referencePoint);
        const pandora::CartesianVector &referencePoint2(pHelix->GetReferencePoint());

        pandora::CartesianVector position1(0.f, 0.f, 0.f), position2(0.f, 0.f, 0.f);

        if (singlePoint)
        {
            const float zSect1(z01 + rad1 * std::cos(phi1));
            const float ySect1(y01 + rad1 * std::sin(phi1));
            const float zSect2(z02 + rad2 * std::cos(phi2));
            const float ySect2(y02 + rad2 * std::sin(phi2));
            const float r1(std::sqrt(zSect1 * zSect1 + ySect1 * ySect1));
            const float r2(std::sqrt(zSect2 * zSect2 + ySect2 * ySect2));

            PANDORA_RETURN_RESULT_IF(pandora::STATUS_CODE_SUCCESS, !=, this->GetPointOnCircle(r1, referencePoint1, position1));
            PANDORA_RETURN_RESULT_IF(pandora::STATUS_CODE_SUCCESS, !=, pHelix->GetPointOnCircle(r2, referencePoint2, position2));
        }
        else
        {
            const float zSect1(z02 + rad2*std::cos(phi1));
            const float ySect1(y02 + rad2*std::sin(phi1));
            const float zSect2(z02 + rad2*std::cos(phi2));
            const float ySect2(y02 + rad2*std::sin(phi2));

            const float phiI2(std::atan2(referencePoint2.GetY() - y02, referencePoint2.GetZ() - z02));
            const float phiF21(std::atan2(ySect1 - y02, zSect1 - z02));
            const float phiF22(std::atan2(ySect2 - y02, zSect2 - z02));
            const float charge2(pHelix->GetCharge());

            float deltaPhi21(phiF21 - phiI2);
            float deltaPhi22(phiF22 - phiI2);

            if (deltaPhi21 < 0 && charge2 < 0)
            {
                deltaPhi21 += TWO_PI;
            }
            else if (deltaPhi21 > 0 && charge2 > 0)
            {
                deltaPhi21 -= TWO_PI;
            }

            if (deltaPhi22 < 0 && charge2 < 0)
            {
                deltaPhi22 += TWO_PI;
            }
            else if (deltaPhi22 > 0 && charge2 > 0)
            {
                deltaPhi22 -= TWO_PI;
            }

            const float pzy2(pHelix->GetPzy());
            const float genericTime21(-charge2 * deltaPhi21 * rad2 / pzy2);
            const float genericTime22(-charge2 * deltaPhi22 * rad2 / pzy2);

            const float px2(pHelix->GetMomentum().GetX());
            const float X21(referencePoint2.GetX() + genericTime21 * px2);
            const float X22(referencePoint2.GetX() + genericTime22 * px2);

            const pandora::CartesianVector temp21(X21, ySect1, zSect1);
            const pandora::CartesianVector temp22(X22, ySect2, zSect2);

            const float phiI1(std::atan2(referencePoint1.GetY() - y01, referencePoint1.GetZ() - z01));
            const float phiF11(std::atan2(ySect1-y01,zSect1-z01));
            const float phiF12(std::atan2(ySect2-y01,zSect2-z01));
            const float charge1(m_charge);

            float deltaPhi11(phiF11 - phiI1);
            float deltaPhi12(phiF12 - phiI1);

            if (deltaPhi11 < 0 && charge1 < 0)
            {
                deltaPhi11 += TWO_PI;
            }
            else if (deltaPhi11 > 0 && charge1 > 0)
            {
                deltaPhi11 -= TWO_PI;
            }

            if (deltaPhi12 < 0 && charge1 < 0)
            {
                deltaPhi12 += TWO_PI;
            }
            else if (deltaPhi12 > 0 && charge1 > 0)
            {
                deltaPhi12 -= TWO_PI;
            }

            const float pzy1(m_pzy);
            const float genericTime11(-charge1 * deltaPhi11 * rad1 / pzy1);
            const float genericTime12(-charge1 * deltaPhi12 * rad1 / pzy1);

            const float px1(m_momentum.GetX());
            const float X11(referencePoint1.GetX() + genericTime11 * px1);
            const float X12(referencePoint1.GetX() + genericTime12 * px1);

            const pandora::CartesianVector temp11(X11, ySect1, zSect1);
            const pandora::CartesianVector temp12(X12, ySect2, zSect2);

            const float dist1((temp11 - temp21).GetMagnitudeSquared());
            const float dist2((temp12 - temp22).GetMagnitudeSquared());

            if (dist1 < dist2)
            {
                position1 = temp11;
                position2 = temp21;
            }
            else
            {
                position1 = temp12;
                position2 = temp22;
            }
        }

        const pandora::CartesianVector momentum1(this->GetExtrapolatedMomentum(position1));
        const pandora::CartesianVector momentum2(pHelix->GetExtrapolatedMomentum(position2));

        helixDistance = (position1 - position2).GetMagnitude();
        positionOfClosestApproach = (position1 + position2) * 0.5;
        v0momentum = momentum1 + momentum2;

        return pandora::STATUS_CODE_SUCCESS;
    }

pandora::StatusCode gar_content::Helix::GetDistanceToPoint ( const pandora::CartesianVector &  point, pandora::CartesianVector &  distance  ) const

inline

Get distance of the closest approach of helix to an arbitrary point in space.

Parameters

point	coordinates of the specified point
distance	to receive a vector of distances from helix to point in the following projections: x component: distance in R-Phi plane y-component: distance along Z axis z-component: 3D distance magnitude

Definition at line 289 of file Helix.h.

    {
        float genericTime;
        return this->GetDistanceToPoint(point, distance, genericTime);
    }

pandora::StatusCode gar_content::Helix::GetDistanceToPoint	(	const pandora::CartesianVector &	point,
		pandora::CartesianVector &	distance,
		float &	genericTime
	)		const

Get distance of the closest approach of helix to an arbitrary point in space.

Parameters

point	coordinates of the specified point
distance	to receive a vector of distances from helix to point in the following projections: x component: distance in R-Phi plane y-component: distance along Z axis z-component: 3D distance magnitude
genericTime	to receive the generic time (helix length, from reference point to intersection, divided by particle momentum)

Definition at line 290 of file Helix.cc.

    {
        const float phi(std::atan2(point.GetY() - m_yCentre, point.GetZ() - m_zCentre));
        const float phi0(std::atan2(m_referencePoint.GetY() - m_yCentre, m_referencePoint.GetZ() - m_zCentre));

        int nCircles = 0;
        if (std::fabs(m_tanLambda * m_radius) > 1.e-20)
        {
            const float zCircles((phi0 - phi - m_charge * (point.GetX() - m_referencePoint.GetX()) / (m_tanLambda * m_radius)) / TWO_PI);

            int n1, n2;
            if (zCircles >= std::numeric_limits<float>::epsilon())
            {
                n1 = static_cast<int>(zCircles);
                n2 = n1 + 1;
            }
            else
            {
                n1 = static_cast<int>(zCircles) - 1;
                n2 = n1 + 1;
            }

            nCircles = ((std::fabs(n1 - zCircles) < std::fabs(n2 - zCircles) ? n1 : n2));
        }

        const float dPhi(TWO_PI * (static_cast<float>(nCircles)) + phi - phi0);
        const float xOnHelix(m_referencePoint.GetX() - m_charge * m_radius * m_tanLambda * dPhi);

        const float distZ(std::fabs(m_zCentre - point.GetZ()));
        const float distY(std::fabs(m_yCentre - point.GetY()));
        const float distX(std::fabs(xOnHelix - point.GetX()));

        float distZY(std::sqrt(distZ * distZ + distY * distY));
        distZY = std::fabs(distZY - m_radius);

        distance.SetValues(distX, distZY, std::sqrt(distZY * distZY + distZ * distZ));

        if (std::fabs(m_momentum.GetX()) > 0)
        {
            genericTime = (xOnHelix - m_referencePoint.GetX()) / m_momentum.GetX();
        }
        else
        {
            genericTime = m_charge * m_radius * dPhi / m_pzy;
        }

        return pandora::STATUS_CODE_SUCCESS;
    }

pandora::CartesianVector gar_content::Helix::GetExtrapolatedMomentum

(

const pandora::CartesianVector &

position

)

const

Parameters

Get	extrapolated momentum at a specified position
position	the specified position

Returns

the extrapolated momentum

Definition at line 514 of file Helix.cc.

    {
        float phi = std::atan2(position.GetY() - m_yCentre, position.GetZ() - m_zCentre);

        if (phi < 0.)
        phi += TWO_PI;

        phi = phi - m_phiAtPCA + m_phi0;

        return pandora::CartesianVector(m_momentum.GetX(), m_pzy * std::sin(phi), m_pzy * std::cos(phi));
    }

const pandora::CartesianVector & gar_content::Helix::GetMomentum ( ) const

inline

Get momentum of particle at the point of closest approach to IP.

Returns

the momentum of particle

Definition at line 297 of file Helix.h.

    {
        return m_momentum;
    }

float gar_content::Helix::GetOmega ( ) const

inline

Get signed curvature of the track.

Returns

the signed curvature of the track

Definition at line 335 of file Helix.h.

    {
        return m_omega;
    }

float gar_content::Helix::GetPhi0 ( ) const

inline

Get phi angle of the momentum vector at the point of closest approach to IP.

Returns

the phi angle of the momentum vector

Definition at line 311 of file Helix.h.

    {
        if (m_phi0 < 0.)
        return m_phi0 + TWO_PI;

        return m_phi0;
    }

pandora::StatusCode gar_content::Helix::GetPointInX ( const float  xPlane, const pandora::CartesianVector &  referencePoint, pandora::CartesianVector &  intersectionPoint  ) const

inline

Get helix intersection point with a plane perpendicular to x axis.

Parameters

xPlane	the x coordinate for the specified plane
referencePoint	the reference point of the helix
intersectionPoint	to receive the coordinates of the intersection point

Definition at line 273 of file Helix.h.

    {
        float genericTime;
        return this->GetPointInX(xPlane, referencePoint, intersectionPoint, genericTime);
    }

pandora::StatusCode gar_content::Helix::GetPointInX	(	const float	xPlane,
		const pandora::CartesianVector &	referencePoint,
		pandora::CartesianVector &	intersectionPoint,
		float &	genericTime
	)		const

Get helix intersection point with a plane perpendicular to x axis.

Parameters

xPlane	the x coordinate for the specified plane
referencePoint	the reference point of the helix
intersectionPoint	to receive the coordinates of the intersection point
genericTime	to receive the generic time (helix length, from reference point to intersection, divided by particle momentum)

Definition at line 196 of file Helix.cc.

    {
        if (std::fabs(m_momentum.GetX()) < std::numeric_limits<float>::epsilon())
        return pandora::STATUS_CODE_NOT_FOUND;

        genericTime = (xPlane - referencePoint.GetX()) / m_momentum.GetX();

        const float phi0(std::atan2(referencePoint.GetY() - m_yCentre, referencePoint.GetZ() - m_zCentre));
        const float phi(phi0 - m_charge * m_pzy * genericTime / m_radius);

        intersectionPoint.SetValues(xPlane, m_yCentre + m_radius * std::sin(phi), m_zCentre + m_radius * std::cos(phi));

        return pandora::STATUS_CODE_SUCCESS;
    }

pandora::StatusCode gar_content::Helix::GetPointInZY ( const float  z0, const float  y0, const float  az, const float  ay, const pandora::CartesianVector &  referencePoint, pandora::CartesianVector &  intersectionPoint  ) const

inline

Get helix intersection point with a plane parallel to x axis. The plane is defined by two coordinates in the plane (z0,y0) and a normal vector (az,ay).

Parameters

z0	z coordinate in the specified plane
y0	y coordinate in the specified plane
az	z component of vector normal to specified plane
ay	y component of vector normal to specified plane
referencePoint	the reference point of the helix
intersectionPoint	to receive the coordinates of the intersection point

Definition at line 264 of file Helix.h.

    {
        float genericTime;
        return this->GetPointInZY(z0, y0, az, ay, referencePoint, intersectionPoint, genericTime);
    }

pandora::StatusCode gar_content::Helix::GetPointInZY	(	const float	z0,
		const float	y0,
		const float	az,
		const float	ay,
		const pandora::CartesianVector &	referencePoint,
		pandora::CartesianVector &	intersectionPoint,
		float &	genericTime
	)		const

Get helix intersection point with a plane parallel to x axis. The plane is defined by two coordinates in the plane (z0,y0) and a normal vector (az,ay).

Parameters

z0	z coordinate in the specified plane
y0	y coordinate in the specified plane
az	z component of vector normal to specified plane
ay	y component of vector normal to specified plane
referencePoint	the reference point of the helix
intersectionPoint	to receive the coordinates of the intersection point
genericTime	to receive the generic time (helix length, from reference point to intersection, divided by particle momentum)

Definition at line 124 of file Helix.cc.

    {
        const float AA(std::sqrt(az * az + ay * ay));

        if (AA <= 0)
        return pandora::STATUS_CODE_FAILURE;

        const float BB((az * (z0 - m_zCentre) + ay * (y0 - m_yCentre)) / AA);
        const float CC(((z0 - m_zCentre) * (z0 - m_zCentre) + (y0 - m_yCentre) * (y0 - m_yCentre) - m_radius * m_radius) / AA);

        const float DET(BB * BB - CC);

        if (DET < 0)
        return pandora::STATUS_CODE_NOT_FOUND;

        float tt1(-BB + std::sqrt(DET));
        float tt2(-BB - std::sqrt(DET));

        const float zz1(z0 + tt1 * az);
        const float yy1(y0 + tt1 * ay);
        const float zz2(z0 + tt2 * az);
        const float yy2(y0 + tt2 * ay);

        const float phi1(std::atan2(yy1 - m_yCentre, zz1 - m_zCentre));
        const float phi2(std::atan2(yy2 - m_yCentre, zz2 - m_zCentre));
        const float phi0(std::atan2(referencePoint.GetY() - m_yCentre, referencePoint.GetZ() - m_zCentre));

        float dphi1(phi1 - phi0);
        float dphi2(phi2 - phi0);

        if (dphi1 < 0 && m_charge < 0)
        {
            dphi1 = dphi1 + TWO_PI;
        }
        else if (dphi1 > 0 && m_charge > 0)
        {
            dphi1 = dphi1 - TWO_PI;
        }

        if (dphi2 < 0 && m_charge < 0)
        {
            dphi2 = dphi2 + TWO_PI;
        }
        else if (dphi2 > 0 && m_charge > 0)
        {
            dphi2 = dphi2 - TWO_PI;
        }

        // Calculate generic time
        tt1 = -m_charge * dphi1 * m_radius / m_pzy;
        tt2 = -m_charge * dphi2 * m_radius / m_pzy;

        if ((tt1 < 0.) || (tt2 < 0.))
        std::cout << "Helix:: GetPointInXY, warning - negative generic time, tt1 " << tt1 << ", tt2 " << tt2 << std::endl;

        if (tt1 < tt2)
        {
            genericTime = tt1;
            intersectionPoint.SetValues(referencePoint.GetX() + genericTime * m_momentum.GetX(), yy1, zz1);
        }
        else
        {
            genericTime = tt2;
            intersectionPoint.SetValues(referencePoint.GetX() + genericTime * m_momentum.GetX(), yy2, zz2);
        }

        return pandora::STATUS_CODE_SUCCESS;
    }

pandora::StatusCode gar_content::Helix::GetPointOnCircle ( const float  radius, const pandora::CartesianVector &  referencePoint, pandora::CartesianVector &  intersectionPoint  ) const

inline

Get coordinates of helix intersection with cylinder, aligned along z-axis.

Parameters

radius	the radius of the cylinder
referencePoint	the reference point of the helix
intersectionPoint	to receive the coordinates of the intersection point

Definition at line 281 of file Helix.h.

    {
        float genericTime;
        return this->GetPointOnCircle(radius, referencePoint, intersectionPoint, genericTime);
    }

pandora::StatusCode gar_content::Helix::GetPointOnCircle	(	const float	radius,
		const pandora::CartesianVector &	referencePoint,
		pandora::CartesianVector &	intersectionPoint,
		float &	genericTime
	)		const

Get coordinates of helix intersection with cylinder, aligned along z-axis.

Parameters

radius	the radius of the cylinder
referencePoint	the reference point of the helix
intersectionPoint	to receive the coordinates of the intersection point
genericTime	to receive the generic time (helix length, from reference point to intersection, divided by particle momentum)

Definition at line 214 of file Helix.cc.

    {
        const float distCenterToIP(std::sqrt(m_zCentre * m_zCentre + m_yCentre * m_yCentre));

        if ( ((distCenterToIP + m_radius) < radius) || ((m_radius + radius) < distCenterToIP) )
        return pandora::STATUS_CODE_NOT_FOUND;

        const float phiCentre(std::atan2(m_yCentre, m_zCentre));

        float phiStar(radius * radius + distCenterToIP * distCenterToIP - m_radius * m_radius);
        phiStar = 0.5f * phiStar / std::max(1.e-20f, radius * distCenterToIP);

        if (phiStar > 1.f)
        phiStar = 0.9999999f;

        if (phiStar < -1.f)
        phiStar = -0.9999999f;

        phiStar = std::acos(phiStar);

        const float zz1(radius * std::cos(phiCentre + phiStar));
        const float yy1(radius * std::sin(phiCentre + phiStar));

        const float zz2(radius * std::cos(phiCentre-phiStar));
        const float yy2(radius * std::sin(phiCentre-phiStar));

        const float phi1(std::atan2(yy1 - m_yCentre, zz1 - m_zCentre));
        const float phi2(std::atan2(yy2 - m_yCentre, zz2 - m_zCentre));
        const float phi0(std::atan2(referencePoint.GetY() - m_yCentre, referencePoint.GetZ() - m_zCentre));

        float dphi1(phi1 - phi0);
        float dphi2(phi2 - phi0);

        if (dphi1 < 0 && m_charge < 0)
        {
            dphi1 = dphi1 + TWO_PI;
        }
        else if (dphi1 > 0 && m_charge > 0)
        {
            dphi1 = dphi1 - TWO_PI;
        }

        if (dphi2 < 0 && m_charge < 0)
        {
            dphi2 = dphi2 + TWO_PI;
        }
        else if (dphi2 > 0 && m_charge > 0)
        {
            dphi2 = dphi2 - TWO_PI;
        }

        // Calculate generic time
        const float tt1(-m_charge * dphi1 * m_radius / m_pzy);
        const float tt2(-m_charge * dphi2 * m_radius / m_pzy);

        if ((tt1 < 0.) || (tt2 < 0.))
        std::cout << "Helix:: GetPointOnCircle, warning - negative generic time, tt1 " << tt1 << ", tt2 " << tt2 << std::endl;

        // Previously returned both xx1, xx2, etc.
        if (tt1 < tt2)
        {
            genericTime = tt1;
            intersectionPoint.SetValues(referencePoint.GetX() + genericTime * m_momentum.GetX(), yy1, zz1);
        }
        else
        {
            genericTime = tt2;
            intersectionPoint.SetValues(referencePoint.GetX() + genericTime * m_momentum.GetX(), yy2, zz2);
        }

        return pandora::STATUS_CODE_SUCCESS;
    }

float gar_content::Helix::GetPzy ( ) const

inline

Get transverse momentum of the track.

Returns

the transverse momentum of the track

Definition at line 349 of file Helix.h.

    {
        return m_pzy;
    }

float gar_content::Helix::GetRadius ( ) const

inline

Get radius of circumference.

Returns

the radius of circumference

Definition at line 377 of file Helix.h.

    {
        return m_radius;
    }

const pandora::CartesianVector & gar_content::Helix::GetReferencePoint ( ) const

inline

Get reference point of track.

Returns

the reference point of track

Definition at line 304 of file Helix.h.

    {
        return m_referencePoint;
    }

float gar_content::Helix::GetTanLambda ( ) const

inline

Get tangent of dip angle of the track.

Returns

the tangent of dip angle of the track

Definition at line 342 of file Helix.h.

    {
        return m_tanLambda;
    }

float gar_content::Helix::GetX0 ( ) const

inline

Get x coordinate of the point of closest approach to IP in the R-Phi plane.

Returns

the x coordinate of the point of closest approach

Definition at line 328 of file Helix.h.

    {
        return m_x0;
    }

float gar_content::Helix::GetYCentre ( ) const

inline

Get y coordinate of circumference.

Returns

the y coordinate of circumference

Definition at line 370 of file Helix.h.

    {
        return m_yCentre;
    }

float gar_content::Helix::GetZCentre ( ) const

inline

Get z coordinate of circumference.

Returns

the z coordinate of circumference

Definition at line 363 of file Helix.h.

    {
        return m_zCentre;
    }

Member Data Documentation

const float gar_content::Helix::FCT = 2.99792458E-4f

staticprivate

Definition at line 236 of file Helix.h.

const float gar_content::Helix::HALF_PI = static_cast<float>(0.5 * std::acos(-1.0))

staticprivate

Definition at line 238 of file Helix.h.

float gar_content::Helix::m_charge

private

The particle charge.

Definition at line 249 of file Helix.h.

float gar_content::Helix::m_d0

private

d0 in canonical parameterisation

Definition at line 244 of file Helix.h.

pandora::CartesianVector gar_content::Helix::m_momentum

private

The momentum vector at reference point.

Definition at line 241 of file Helix.h.

float gar_content::Helix::m_omega

private

signed curvature in canonical parameterisation

Definition at line 246 of file Helix.h.

float gar_content::Helix::m_phi0

private

phi0 in canonical parameterization

Definition at line 243 of file Helix.h.

float gar_content::Helix::m_phiAtPCA

private

Phi w.r.t. (Z0, Y0) of circle at point of closest approach.

Definition at line 254 of file Helix.h.

float gar_content::Helix::m_phiMomRefPoint

private

Phi of Momentum vector at reference point.

Definition at line 259 of file Helix.h.

float gar_content::Helix::m_phiRefPoint

private

Phi w.r.t. (Z0, Y0) of circle at reference point.

Definition at line 253 of file Helix.h.

float gar_content::Helix::m_pyAtPCA

private

Momentum y component at point of closest approach.

Definition at line 258 of file Helix.h.

float gar_content::Helix::m_pzAtPCA

private

Momentum z component at point of closest approach.

Definition at line 257 of file Helix.h.

float gar_content::Helix::m_pzy

private

The transverse momentum.

Definition at line 248 of file Helix.h.

float gar_content::Helix::m_radius

private

The radius of circle in ZY plane.

Definition at line 252 of file Helix.h.

pandora::CartesianVector gar_content::Helix::m_referencePoint

private

The coordinates of the reference point.

Definition at line 240 of file Helix.h.

float gar_content::Helix::m_tanLambda

private

tanLambda

Definition at line 247 of file Helix.h.

float gar_content::Helix::m_x0

private

x0 in canonical parameterisation

Definition at line 245 of file Helix.h.

float gar_content::Helix::m_yAtPCA

private

y coordinate at point of closest approach

Definition at line 256 of file Helix.h.

float gar_content::Helix::m_yCentre

private

The circle centre y coordinate.

Definition at line 251 of file Helix.h.

float gar_content::Helix::m_zAtPCA

private

z coordinate at point of closest approach

Definition at line 255 of file Helix.h.

float gar_content::Helix::m_zCentre

private

The circle centre z coordinate.

Definition at line 250 of file Helix.h.

const float gar_content::Helix::TWO_PI = static_cast<float>(2. * std::acos(-1.0))

staticprivate

Definition at line 237 of file Helix.h.

---

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

• garsoft/Pandora/GArContent/include/GArObjects/Helix.h
• garsoft/Pandora/GArContent/src/GArObjects/Helix.cc