fastsim::StraightTrajectory Class Reference

Mathematical representation of a straight trajectory. More...

#include <StraightTrajectory.h>

Inheritance diagram for fastsim::StraightTrajectory:

Public Member Functions
bool	crosses (const BarrelSimplifiedGeometry &layer) const override
	Check if an intersection of the trajectory with a barrel layer exists. More...
void	move (double deltaTimeC) override
	Move the particle along the helix trajectory for a given time. More...
double	nextCrossingTimeC (const BarrelSimplifiedGeometry &layer, bool onLayer=false) const override
	Return delta time (t*c) of the next intersection of trajectory and barrel layer. More...
	StraightTrajectory (const Particle &particle)
	Constructor. More...
Public Member Functions inherited from fastsim::Trajectory
const math::XYZTLorentzVector &	getMomentum ()
	Simple getter: return momentum of the particle that was used to create trajectory. More...
const math::XYZTLorentzVector &	getPosition ()
	Simple getter: return position of the particle that was used to create trajectory. More...
double	nextCrossingTimeC (const SimplifiedGeometry &layer, bool onLayer=false) const
	Return delta time (t*c) of the next intersection of trajectory and generic layer. More...
double	nextCrossingTimeC (const ForwardSimplifiedGeometry &layer, bool onLayer=false) const
	Return delta time (t*c) of the next intersection of trajectory and forward layer. More...
virtual	~Trajectory ()

Additional Inherited Members
Static Public Member Functions inherited from fastsim::Trajectory
static std::unique_ptr< Trajectory >	createTrajectory (const fastsim::Particle &particle, const double magneticFieldZ)
	Calls constructor of derived classes. More...
Protected Member Functions inherited from fastsim::Trajectory
	Trajectory (const fastsim::Particle &particle)
	Constructor of base class. More...
Protected Attributes inherited from fastsim::Trajectory
math::XYZTLorentzVector	momentum_
	momentum of the particle that was used to create trajectory More...
math::XYZTLorentzVector	position_
	position of the particle that was used to create trajectory More...

Detailed Description

Mathematical representation of a straight trajectory.

Reflects trajectory of a uncharged particle.

Definition at line 19 of file StraightTrajectory.h.

Constructor & Destructor Documentation

fastsim::StraightTrajectory::StraightTrajectory ( const Particle &  particle )

inline

Constructor.

Definition at line 26 of file StraightTrajectory.h.

: Trajectory(particle) {;}

Member Function Documentation

bool fastsim::StraightTrajectory::crosses ( const BarrelSimplifiedGeometry &  layer ) const

inlineoverridevirtual

Check if an intersection of the trajectory with a barrel layer exists.

There is always an intersection between a straight line and a barrel layer unless the trajectory is parallel to z axis. In this case, the particle is not propagated anyways since it will not hit any detector material.

Parameters

layer

A barrel layer.

Returns

true

Implements fastsim::Trajectory.

Definition at line 34 of file StraightTrajectory.h.

References move(), and nextCrossingTimeC().

{return true;}

void fastsim::StraightTrajectory::move ( double  deltaTimeC )

overridevirtual

Move the particle along the helix trajectory for a given time.

Parameters

deltaTimeC

Time in units of t*c..

Implements fastsim::Trajectory.

Definition at line 81 of file StraightTrajectory.cc.

References fastsim::Trajectory::momentum_, fastsim::Trajectory::position_, and fastsim::Constants::speedOfLight.

Referenced by Vispa.Gui.WidgetContainer.WidgetContainer::autosize(), crosses(), Vispa.Gui.VispaWidget.VispaWidget::dragWidget(), Vispa.Gui.VispaWidget.VispaWidget::setZoom(), and Vispa.Gui.PortConnection.PointToPointConnection::updateConnection().

{
    position_.SetXYZT(
        position_.X() + momentum_.X()/momentum_.E()*deltaTimeC,
        position_.Y() + momentum_.Y()/momentum_.E()*deltaTimeC,
        position_.Z() + momentum_.Z()/momentum_.E()*deltaTimeC,
        position_.T() + deltaTimeC / fastsim::Constants::speedOfLight);
}

double fastsim::StraightTrajectory::nextCrossingTimeC ( const BarrelSimplifiedGeometry &  layer, bool  onLayer = false  ) const

overridevirtual

Return delta time (t*c) of the next intersection of trajectory and barrel layer.

This function solves the quadratic equation (basically intersection a circle with a given radius and a straight line) in order to calculate the moment in time when the particle's trajectory intersects with a given barrel layer.

Parameters

layer	A barrel layer.
onLayer	Specify if the particle already is on the layer (in that case the second solution has to be picked).

Returns

t*c [ns * cm/ns] of next intersection (-1 if there is none).

Implements fastsim::Trajectory.

Definition at line 8 of file StraightTrajectory.cc.

References a, b, EnergyCorrector::c, delta, fastsim::BarrelSimplifiedGeometry::getRadius(), fastsim::Trajectory::momentum_, fastsim::Trajectory::position_, and mathSSE::sqrt().

Referenced by crosses().

{
    //
    // solve the equation
    // (x^2 + y^2 = R^2),   (1)
    // x = x_0 + v_x*t,     (2)
    // y = y_0 + v_y*t      (3)
    // for t
    // 
    // subsitute (2) and (3) in (1):
    // => t^2*(v_x^2 + v_y^2) + t*( 2*x_0*v_x + 2*y_0*v_y ) + x_0^2 + y_0^2 - R^2 = 0
    // => t = (-b +/- sqrt(b^2 - ac) ) / a       see https://en.wikipedia.org/wiki/Quadratic_formula, divide equation by 2
    // with a = v_x^2 + v_y^2;
    // with b = x_0*v_x + y_0*v_y
    // with c = x_0^2 + y_0^2 - R^2
    //
    // substitute: v_x = p_x / E * c  ( note: extra * c absorbed in p_x units)
    // substitute: v_y = p_y / E * c  ( note: extra * c absorbed in p_y units)
    // => t*c = (-b +/- sqrt(b^2 - ac) ) / a * E
    // with a = p_x^2 + p_y^2
    // with b = p_x*x_0 + p_y*y_0
    // with c = x_0^2 + y_0^2 - R^2
    double a = momentum_.Perp2();
    double b = (position_.X()*momentum_.X() + position_.Y()*momentum_.Y() );
    double c = position_.Perp2() - layer.getRadius()*layer.getRadius();

    double delta = b*b - a*c;
    if(delta < 0)
    {
       return -1;
    }
    double sqrtDelta = sqrt(delta);

    //
    // return the earliest solution > 0, 
    // return -1 if no positive solution exists
    // note: 'a' always positive, sqrtDelta always positive
    //
    double tc1 = (-b - sqrtDelta)/a*momentum_.E();
    double tc2 = (-b + sqrtDelta)/a*momentum_.E();

    if(onLayer && tc2 > 0)
    {
        bool particleMovesInwards = momentum_.X()*position_.X() + momentum_.Y()*position_.Y() < 0;

        double posX2 = position_.X() + momentum_.X()/momentum_.E()*tc2;
        double posY2 = position_.Y() + momentum_.Y()/momentum_.E()*tc2;
        bool particleMovesInwards2 = momentum_.X()*posX2 + momentum_.Y()*posY2 < 0;

        if(particleMovesInwards != particleMovesInwards2)   
        {
            return tc2;
        }

        return -1;

    }

    if(tc1 > 0)
    {
        return tc1;
    }
    else if(tc2 > 0)
    {
        return tc2;
    }

    return -1.;


    
}