Monopole track representation. More...

#include <MplTrackRep.h>

Inheritance diagram for MplTrackRep:

[legend]

Collaboration diagram for MplTrackRep:

[legend]

Public Member Functions
	MplTrackRep (int pdgCode, float magCharge, char propDir=0)

double	RKPropagate (M1x7 &state7, M7x7 *jacobian, M1x3 &SA, double S, bool varField=true, bool calcOnlyLastRowOfJ=false) const override
	The actual Runge Kutta propagation. More...

double	getCharge (const StateOnPlane &state) const override
	Get the (fitted) charge of a state. More...

virtual AbsTrackRep *	clone () const override
	Clone the trackRep.

virtual double	extrapolateToPlane (StateOnPlane &state, const SharedPlanePtr &plane, bool stopAtBoundary=false, bool calcJacobianNoise=false) const override
	Extrapolates the state to plane, and returns the extrapolation length and, via reference, the extrapolated state. More...

virtual double	extrapolateToLine (StateOnPlane &state, const TVector3 &linePoint, const TVector3 &lineDirection, bool stopAtBoundary=false, bool calcJacobianNoise=false) const override
	Extrapolates the state to the POCA to a line, and returns the extrapolation length and, via reference, the extrapolated state. More...

virtual double	extrapolateToLine (StateOnPlane &state, const TVector3 &linePoint, const TVector3 &lineDirection, bool stopAtBoundary=false, bool calcJacobianNoise=false) const=0
	Extrapolates the state to the POCA to a line, and returns the extrapolation length and, via reference, the extrapolated state. More...

virtual double	extrapolateToLine (StateOnPlane &state, const TVector3 &point1, const TVector3 &point2, TVector3 &poca, TVector3 &dirInPoca, TVector3 &poca_onwire, bool stopAtBoundary=false, bool calcJacobianNoise=false) const
	Resembles the interface of GFAbsTrackRep in old versions of genfit. More...

virtual double	extrapolateToLine (StateOnPlane &state, const TVector3 &point1, const TVector3 &point2, TVector3 &poca, TVector3 &dirInPoca, TVector3 &poca_onwire, bool stopAtBoundary=false, bool calcJacobianNoise=false) const
	Resembles the interface of GFAbsTrackRep in old versions of genfit. More...

virtual double	extrapolateToPoint (StateOnPlane &state, const TVector3 &point, bool stopAtBoundary=false, bool calcJacobianNoise=false) const override
	Extrapolates the state to the POCA to a point, and returns the extrapolation length and, via reference, the extrapolated state. More...

virtual double	extrapolateToPoint (StateOnPlane &state, const TVector3 &point, const TMatrixDSym &G, bool stopAtBoundary=false, bool calcJacobianNoise=false) const override
	Extrapolates the state to the POCA to a point in the metric of G, and returns the extrapolation length and, via reference, the extrapolated state. More...

virtual double	extrapolateToCylinder (StateOnPlane &state, double radius, const TVector3 &linePoint=TVector3(0., 0., 0.), const TVector3 &lineDirection=TVector3(0., 0., 1.), bool stopAtBoundary=false, bool calcJacobianNoise=false) const override
	Extrapolates the state to the cylinder surface, and returns the extrapolation length and, via reference, the extrapolated state. More...

virtual double	extrapolateToCone (StateOnPlane &state, double radius, const TVector3 &linePoint=TVector3(0., 0., 0.), const TVector3 &lineDirection=TVector3(0., 0., 1.), bool stopAtBoundary=false, bool calcJacobianNoise=false) const override
	Extrapolates the state to the cone surface, and returns the extrapolation length and, via reference, the extrapolated state. More...

virtual double	extrapolateToSphere (StateOnPlane &state, double radius, const TVector3 &point=TVector3(0., 0., 0.), bool stopAtBoundary=false, bool calcJacobianNoise=false) const override
	Extrapolates the state to the sphere surface, and returns the extrapolation length and, via reference, the extrapolated state. More...

virtual double	extrapolateBy (StateOnPlane &state, double step, bool stopAtBoundary=false, bool calcJacobianNoise=false) const override
	Extrapolates the state by step (cm) and returns the extrapolation length and, via reference, the extrapolated state. More...

unsigned int	getDim () const override
	Get the dimension of the state vector used by the track representation.

virtual TVector3	getPos (const StateOnPlane &state) const override
	Get the cartesian position of a state.

virtual TVector3	getMom (const StateOnPlane &state) const override
	Get the cartesian momentum vector of a state.

virtual void	getPosMom (const StateOnPlane &state, TVector3 &pos, TVector3 &mom) const override
	Get cartesian position and momentum vector of a state.

virtual double	getMomMag (const StateOnPlane &state) const override
	get the magnitude of the momentum in GeV.

virtual double	getMomVar (const MeasuredStateOnPlane &state) const override
	get the variance of the absolute value of the momentum .

virtual TMatrixDSym	get6DCov (const MeasuredStateOnPlane &state) const override
	Get the 6D covariance.

virtual void	getPosMomCov (const MeasuredStateOnPlane &state, TVector3 &pos, TVector3 &mom, TMatrixDSym &cov) const override
	Translates MeasuredStateOnPlane into 3D position, momentum and 6x6 covariance.

virtual double	getQop (const StateOnPlane &state) const override
	Get charge over momentum.

double	getSpu (const StateOnPlane &state) const

double	getTime (const StateOnPlane &state) const override
	Get the time corresponding to the StateOnPlane. Extrapolation.

virtual void	getForwardJacobianAndNoise (TMatrixD &jacobian, TMatrixDSym &noise, TVectorD &deltaState) const override
	Get the jacobian and noise matrix of the last extrapolation.

virtual void	getBackwardJacobianAndNoise (TMatrixD &jacobian, TMatrixDSym &noise, TVectorD &deltaState) const override
	Get the jacobian and noise matrix of the last extrapolation if it would have been done in opposite direction.

std::vector< genfit::MatStep >	getSteps () const override
	Get stepsizes and material properties of crossed materials of the last extrapolation.

virtual double	getRadiationLenght () const override
	Get the accumulated X/X0 (path / radiation length) of the material crossed in the last extrapolation.

virtual void	setPosMom (StateOnPlane &state, const TVector3 &pos, const TVector3 &mom) const override
	Set position and momentum of state.

virtual void	setPosMom (StateOnPlane &state, const TVectorD &state6) const override
	Set position and momentum of state.

virtual void	setPosMomErr (MeasuredStateOnPlane &state, const TVector3 &pos, const TVector3 &mom, const TVector3 &posErr, const TVector3 &momErr) const override
	Set position and momentum and error of state.

virtual void	setPosMomCov (MeasuredStateOnPlane &state, const TVector3 &pos, const TVector3 &mom, const TMatrixDSym &cov6x6) const override
	Set position, momentum and covariance of state.

virtual void	setPosMomCov (MeasuredStateOnPlane &state, const TVectorD &state6, const TMatrixDSym &cov6x6) const override
	Set position, momentum and covariance of state.

virtual void	setChargeSign (StateOnPlane &state, double charge) const override
	Set the sign of the charge according to charge.

virtual void	setQop (StateOnPlane &state, double qop) const override
	Set charge/momentum.

void	setSpu (StateOnPlane &state, double spu) const

void	setTime (StateOnPlane &state, double time) const override
	Set time at which the state was defined.

virtual bool	isSameType (const AbsTrackRep *other) override
	check if other is of same type (e.g. RKTrackRep).

virtual bool	isSame (const AbsTrackRep *other) override
	check if other is of same type (e.g. RKTrackRep) and has same pdg code.

double	extrapolateToMeasurement (StateOnPlane &state, const AbsMeasurement *measurement, bool stopAtBoundary=false, bool calcJacobianNoise=false) const
	extrapolate to an AbsMeasurement

TVector3	getDir (const StateOnPlane &state) const
	Get the direction vector of a state.

void	getPosDir (const StateOnPlane &state, TVector3 &pos, TVector3 &dir) const
	Get cartesian position and direction vector of a state.

virtual TVectorD	get6DState (const StateOnPlane &state) const
	Get the 6D state vector (x, y, z, p_x, p_y, p_z).

virtual void	get6DStateCov (const MeasuredStateOnPlane &state, TVectorD &stateVec, TMatrixDSym &cov) const
	Translates MeasuredStateOnPlane into 6D state vector (x, y, z, p_x, p_y, p_z) and 6x6 covariance.

int	getPDG () const
	Get the pdg code.

double	getPDGCharge () const
	Get the charge of the particle of the pdg code.

double	getMass (const StateOnPlane &state) const
	Get tha particle mass in GeV/c^2.

char	getPropDir () const
	Get propagation direction. (-1, 0, 1) -> (backward, auto, forward).

void	calcJacobianNumerically (const genfit::StateOnPlane &origState, const genfit::SharedPlanePtr destPlane, TMatrixD &jacobian) const
	Calculate Jacobian of transportation numerically. More...

bool	switchPDGSign ()
	try to multiply pdg code with -1. (Switch from particle to anti-particle and vice versa).

void	setPropDir (int dir)
	Set propagation direction. (-1, 0, 1) -> (backward, auto, forward).

void	switchPropDir ()
	Switch propagation direction. Has no effect if propDir_ is set to 0.

virtual void	setDebugLvl (unsigned int lvl=1)

virtual void	Print (const Option_t *="") const

Protected Attributes
StateOnPlane	lastStartState_

StateOnPlane	lastEndState_
	state where the last extrapolation has started

int	pdgCode_
	Particle code.

char	propDir_
	propagation direction (-1, 0, 1) -> (backward, auto, forward)

unsigned int	debugLvl_

Private Member Functions
void	initArrays () const

virtual double	extrapToPoint (StateOnPlane &state, const TVector3 &point, const TMatrixDSym *G=nullptr, bool stopAtBoundary=false, bool calcJacobianNoise=false) const

void	getState7 (const StateOnPlane &state, M1x7 &state7) const

void	getState5 (StateOnPlane &state, const M1x7 &state7) const

void	calcJ_pM_5x7 (M5x7 &J_pM, const TVector3 &U, const TVector3 &V, const M1x3 &pTilde, double spu) const

void	transformPM6 (const MeasuredStateOnPlane &state, M6x6 &out6x6) const

void	calcJ_Mp_7x5 (M7x5 &J_Mp, const TVector3 &U, const TVector3 &V, const TVector3 &W, const M1x3 &A) const

void	calcForwardJacobianAndNoise (const M1x7 &startState7, const DetPlane &startPlane, const M1x7 &destState7, const DetPlane &destPlane) const

void	transformM6P (const M6x6 &in6x6, const M1x7 &state7, MeasuredStateOnPlane &state) const

bool	RKutta (const M1x4 &SU, const DetPlane &plane, double charge, double mass, M1x7 &state7, M7x7 jacobianT, M1x7 J_MMT_unprojected_lastRow, double &coveredDistance, double &flightTime, bool &checkJacProj, M7x7 &noiseProjection, StepLimits &limits, bool onlyOneStep=false, bool calcOnlyLastRowOfJ=false) const
	Propagates the particle through the magnetic field. More...

double	estimateStep (const M1x7 &state7, const M1x4 &SU, const DetPlane &plane, const double &charge, double &relMomLoss, StepLimits &limits) const

TVector3	pocaOnLine (const TVector3 &linePoint, const TVector3 &lineDirection, const TVector3 &point) const

double	Extrap (const DetPlane &startPlane, const DetPlane &destPlane, double charge, double mass, bool &isAtBoundary, M1x7 &state7, double &flightTime, bool fillExtrapSteps, TMatrixDSym *cov=nullptr, bool onlyOneStep=false, bool stopAtBoundary=false, double maxStep=1.E99) const
	Handles propagation and material effects. More...

void	checkCache (const StateOnPlane &state, const SharedPlanePtr *plane) const

double	momMag (const M1x7 &state7) const

Private Attributes
const double	m_magCharge

const double	m_mass

std::vector< RKStep >	RKSteps_
	state where the last extrapolation has ended

int	RKStepsFXStart_
	RungeKutta steps made in the last extrapolation.

int	RKStepsFXStop_

std::vector< ExtrapStep >	ExtrapSteps_

TMatrixD	fJacobian_
	steps made in Extrap during last extrapolation

TMatrixDSym	fNoise_

bool	useCache_

unsigned int	cachePos_
	use cached RKSteps_ for extrapolation

StepLimits	limits_

M7x7	noiseArray_

M7x7	noiseProjection_
	noise matrix of the last extrapolation

M7x7	J_MMT_

Detailed Description

Monopole track representation.

It is a minimal modification of RKTrackRep with a different equations of motion for magnetic charges.

In the current implementation the states on plane are 5-d: u, v, u', v', q/p except that q in this case is magnetic, and the monopole has no electic charge.

Definition at line 33 of file MplTrackRep.h.

Member Function Documentation

◆ calcJacobianNumerically()

void calcJacobianNumerically	(	const genfit::StateOnPlane &	origState,
		const genfit::SharedPlanePtr	destPlane,
		TMatrixD &	jacobian
	)		const

inherited

Calculate Jacobian of transportation numerically.

Slow but accurate. Can be used to validate (semi)analytic calculations.

Definition at line 105 of file AbsTrackRep.cc.

◆ Extrap()

double Extrap	(	const DetPlane &	startPlane,
		const DetPlane &	destPlane,
		double	charge,
		double	mass,
		bool &	isAtBoundary,
		M1x7 &	state7,
		double &	flightTime,
		bool	fillExtrapSteps,
		TMatrixDSym *	cov = `nullptr`,
		bool	onlyOneStep = `false`,
		bool	stopAtBoundary = `false`,
		double	maxStep = `1.E99`
	)		const

privateinherited

Handles propagation and material effects.

extrapolateToPlane(), extrapolateToPoint() and extrapolateToLine() etc. call this function. Extrap() needs a plane as an argument, hence extrapolateToPoint() and extrapolateToLine() create virtual detector planes. In this function, RKutta() is called and the resulting points and point paths are filtered so that the direction doesn't change and tiny steps are filtered out. After the propagation the material effects are called via the MaterialEffects singleton. Extrap() will loop until the plane is reached, unless the propagation fails or the maximum number of iterations is exceeded.

fNoMaterial &&

Definition at line 2307 of file RKTrackRep.cc.

 {
  
   static const unsigned int maxNumIt(500);
   unsigned int numIt(0);
  
   double coveredDistance(0.);
   double dqop(0.);
  
   const TVector3 W(destPlane.getNormal());
   M1x4 SU = {{W.X(), W.Y(), W.Z(), destPlane.distance(0., 0., 0.)}};
  
   // make SU vector point away from origin
   if (W*destPlane.getO() < 0) {
     SU[0] *= -1;
     SU[1] *= -1;
     SU[2] *= -1;
   }
  
  
   M1x7 startState7 = state7;
  
   while(true){
  
     if (debugLvl_ > 0) {
       debugOut << "\n============ RKTrackRep::Extrap loop nr. " << numIt << " ============\n";
       debugOut << "Start plane: "; startPlane.Print();
       debugOut << "fillExtrapSteps " << fillExtrapSteps << "\n";
     }
  
     if(++numIt > maxNumIt){
       Exception exc("RKTrackRep::Extrap ==> maximum number of iterations exceeded",__LINE__,__FILE__);
       exc.setFatal();
       throw exc;
     }
  
     // initialize jacobianT with unit matrix
     for(int i = 0; i < 7*7; ++i) J_MMT_[i] = 0;
     for(int i=0; i<7; ++i) J_MMT_[8*i] = 1.;
  
     M7x7* noise = nullptr;
     isAtBoundary = false;
  
     // propagation
     bool checkJacProj = false;
     limits_.reset();
     limits_.setLimit(stp_sMaxArg, maxStep-fabs(coveredDistance));
  
     M1x7 J_MMT_unprojected_lastRow = {{0, 0, 0, 0, 0, 0, 1}};
  
     if( ! RKutta(SU, destPlane, charge, mass, state7, &J_MMT_, &J_MMT_unprojected_lastRow,
      coveredDistance, flightTime, checkJacProj, noiseProjection_,
      limits_, onlyOneStep, !fillExtrapSteps) ) {
       Exception exc("RKTrackRep::Extrap ==> Runge Kutta propagation failed",__LINE__,__FILE__);
       exc.setFatal();
       throw exc;
     }
  
     bool atPlane(limits_.getLowestLimit().first == stp_plane);
     if (limits_.getLowestLimit().first == stp_boundary)
       isAtBoundary = true;
  
  
     if (debugLvl_ > 0) {
       debugOut<<"RKSteps \n";
       for (std::vector<RKStep>::iterator it = RKSteps_.begin(); it != RKSteps_.end(); ++it){
         debugOut << "stepSize = " << it->matStep_.stepSize_ << "\t";
         it->matStep_.material_.Print();
       }
       debugOut<<"\n";
     }
  
  
  
     // call MatFX
     if(fillExtrapSteps) {
       noise = &noiseArray_;
       for(int i = 0; i < 7*7; ++i) noiseArray_[i] = 0; // set noiseArray_ to 0
     }
  
     unsigned int nPoints(RKStepsFXStop_ - RKStepsFXStart_);
     if ( nPoints>0){
       // momLoss has a sign - negative loss means momentum gain
       double momLoss = MaterialEffects::getInstance()->effects(RKSteps_,
                                                                RKStepsFXStart_,
                                                                RKStepsFXStop_,
                                                                fabs(charge/state7[6]), // momentum
                                                                pdgCode_,
                                                                noise);
  
       RKStepsFXStart_ = RKStepsFXStop_;
  
       if (debugLvl_ > 0) {
         debugOut << "momLoss: " << momLoss << " GeV; relative: " << momLoss/fabs(charge/state7[6])
             << "; coveredDistance = " << coveredDistance << "\n";
         if (debugLvl_ > 1 && noise != nullptr) {
           debugOut << "7D noise: \n";
           RKTools::printDim(noise->begin(), 7, 7);
         }
       }
  
       // do momLoss only for defined 1/momentum .ne.0
       if(fabs(state7[6])>1.E-10) {
  
         if (debugLvl_ > 0) {
           debugOut << "correct state7 with dx/dqop, dy/dqop ...\n";
         }
  
         dqop = charge/(fabs(charge/state7[6])-momLoss) - state7[6];
  
         // Correct coveredDistance and flightTime and momLoss if checkJacProj == true
         // The idea is to calculate the state correction (based on the mometum loss) twice:
         // Once with the unprojected Jacobian (which preserves coveredDistance),
         // and once with the projected Jacobian (which is constrained to the plane and does NOT preserve coveredDistance).
         // The difference of these two corrections can then be used to calculate a correction factor.
         if (checkJacProj && fabs(coveredDistance) > MINSTEP) {
           M1x3 state7_correction_unprojected = {{0, 0, 0}};
           for (unsigned int i=0; i<3; ++i) {
             state7_correction_unprojected[i] = 0.5 * dqop * J_MMT_unprojected_lastRow[i];
             //debugOut << "J_MMT_unprojected_lastRow[i] " << J_MMT_unprojected_lastRow[i] << "\n";
             //debugOut << "state7_correction_unprojected[i] " << state7_correction_unprojected[i] << "\n";
           }
  
           M1x3 state7_correction_projected = {{0, 0, 0}};
           for (unsigned int i=0; i<3; ++i) {
             state7_correction_projected[i] = 0.5 * dqop * J_MMT_[6*7 + i];
             //debugOut << "J_MMT_[6*7 + i] " << J_MMT_[6*7 + i] << "\n";
             //debugOut << "state7_correction_projected[i] " << state7_correction_projected[i] << "\n";
           }
  
           // delta distance
           M1x3 delta_state = {{0, 0, 0}};
           for (unsigned int i=0; i<3; ++i) {
             delta_state[i] = state7_correction_unprojected[i] - state7_correction_projected[i];
           }
  
           double Dist( sqrt(delta_state[0]*delta_state[0]
               + delta_state[1]*delta_state[1]
               + delta_state[2]*delta_state[2] )  );
  
           // sign: delta * a
           if (delta_state[0]*state7[3] + delta_state[1]*state7[4] + delta_state[2]*state7[5] > 0)
             Dist *= -1.;
  
           double correctionFactor( 1. + Dist / coveredDistance );
           flightTime *= correctionFactor;
           momLoss *= correctionFactor;
           coveredDistance = coveredDistance + Dist;
  
           if (debugLvl_ > 0) {
             debugOut << "correctionFactor-1 = " << correctionFactor-1. << "; Dist = " << Dist << "\n";
             debugOut << "corrected momLoss: " << momLoss << " GeV; relative: " << momLoss/fabs(charge/state7[6])
                 << "; corrected coveredDistance = " << coveredDistance << "\n";
           }
         }
  
         // correct state7 with dx/dqop, dy/dqop ... Greatly improves extrapolation accuracy!
         double qop( charge/(fabs(charge/state7[6])-momLoss) );
         dqop = qop - state7[6];
         state7[6] = qop;
  
         for (unsigned int i=0; i<6; ++i) {
           state7[i] += 0.5 * dqop * J_MMT_[6*7 + i];
         }
         // normalize direction, just to make sure
         double norm( 1. / sqrt(state7[3]*state7[3] + state7[4]*state7[4] + state7[5]*state7[5]) );
         for (unsigned int i=3; i<6; ++i)
           state7[i] *= norm;
  
       }
     } // finished MatFX
  
  
     // fill ExtrapSteps_
     if (fillExtrapSteps) {
       static const ExtrapStep defaultExtrapStep;
       ExtrapSteps_.push_back(defaultExtrapStep);
       std::vector<ExtrapStep>::iterator lastStep = ExtrapSteps_.end() - 1;
  
       // Store Jacobian of this step for final calculation.
       lastStep->jac7_ = J_MMT_;
  
       if( checkJacProj == true ){
         //project the noise onto the destPlane
         RKTools::Np_N_NpT(noiseProjection_, noiseArray_);
  
         if (debugLvl_ > 1) {
           debugOut << "7D noise projected onto plane: \n";
           RKTools::printDim(noiseArray_.begin(), 7, 7);
         }
       }
  
       // Store this step's noise for final calculation.
       lastStep->noise7_ = noiseArray_;
  
       if (debugLvl_ > 2) {
         debugOut<<"ExtrapSteps \n";
         for (std::vector<ExtrapStep>::iterator it = ExtrapSteps_.begin(); it != ExtrapSteps_.end(); ++it){
           debugOut << "7D Jacobian: "; RKTools::printDim((it->jac7_.begin()), 5,5);
           debugOut << "7D noise:    "; RKTools::printDim((it->noise7_.begin()), 5,5);
         }
         debugOut<<"\n";
       }
     }
  
  
  
     // check if at boundary
     if (stopAtBoundary and isAtBoundary) {
       if (debugLvl_ > 0) {
         debugOut << "stopAtBoundary -> break; \n ";
       }
       break;
     }
  
     if (onlyOneStep) {
       if (debugLvl_ > 0) {
         debugOut << "onlyOneStep -> break; \n ";
       }
       break;
     }
  
     //break if we arrived at destPlane
     if(atPlane) {
       if (debugLvl_ > 0) {
         debugOut << "arrived at destPlane with a distance of  " << destPlane.distance(state7[0], state7[1], state7[2]) << " cm left. ";
         if (destPlane.isInActive(state7[0], state7[1], state7[2],  state7[3], state7[4], state7[5]))
           debugOut << "In active area of destPlane. \n";
         else
           debugOut << "NOT in active area of plane. \n";
  
         debugOut << "  position:  "; TVector3(state7[0], state7[1], state7[2]).Print();
         debugOut << "  direction: "; TVector3(state7[3], state7[4], state7[5]).Print();
       }
       break;
     }
  
   }
  
   if (fillExtrapSteps) {
     // propagate cov and add noise
     calcForwardJacobianAndNoise(startState7, startPlane, state7, destPlane);
  
     if (cov != nullptr) {
       cov->Similarity(fJacobian_);
       *cov += fNoise_;
     }
  
     if (debugLvl_ > 0) {
       if (cov != nullptr) {
         debugOut << "final covariance matrix after Extrap: "; cov->Print();
       }
     }
   }
  
   return coveredDistance;
 }

◆ extrapolateBy()

double extrapolateBy	(	StateOnPlane &	state,
		double	step,
		bool	stopAtBoundary = `false`,
		bool	calcJacobianNoise = `false`
	)		const

overridevirtualinherited

Extrapolates the state by step (cm) and returns the extrapolation length and, via reference, the extrapolated state.

If stopAtBoundary is true, the extrapolation stops as soon as a material boundary is encountered.

If state has a covariance, jacobian and noise matrices will be calculated and the covariance will be propagated. If state has no covariance, jacobian and noise will only be calculated if calcJacobianNoise == true.

Implements AbsTrackRep.

Definition at line 721 of file RKTrackRep.cc.

◆ extrapolateToCone()

double extrapolateToCone	(	StateOnPlane &	state,
		double	radius,
		const TVector3 &	linePoint = `TVector3(0., 0., 0.)`,
		const TVector3 &	lineDirection = `TVector3(0., 0., 1.)`,
		bool	stopAtBoundary = `false`,
		bool	calcJacobianNoise = `false`
	)		const

overridevirtualinherited

Extrapolates the state to the cone surface, and returns the extrapolation length and, via reference, the extrapolated state.

If stopAtBoundary is true, the extrapolation stops as soon as a material boundary is encountered.

If state has a covariance, jacobian and noise matrices will be calculated and the covariance will be propagated. If state has no covariance, jacobian and noise will only be calculated if calcJacobianNoise == true.

Implements AbsTrackRep.

Definition at line 476 of file RKTrackRep.cc.

◆ extrapolateToCylinder()

double extrapolateToCylinder	(	StateOnPlane &	state,
		double	radius,
		const TVector3 &	linePoint = `TVector3(0., 0., 0.)`,
		const TVector3 &	lineDirection = `TVector3(0., 0., 1.)`,
		bool	stopAtBoundary = `false`,
		bool	calcJacobianNoise = `false`
	)		const

overridevirtualinherited

Extrapolates the state to the cylinder surface, and returns the extrapolation length and, via reference, the extrapolated state.

If stopAtBoundary is true, the extrapolation stops as soon as a material boundary is encountered.

If state has a covariance, jacobian and noise matrices will be calculated and the covariance will be propagated. If state has no covariance, jacobian and noise will only be calculated if calcJacobianNoise == true.

Implements AbsTrackRep.

Definition at line 351 of file RKTrackRep.cc.

◆ extrapolateToLine() [1/4]

double extrapolateToLine	(	StateOnPlane &	state,
		const TVector3 &	linePoint,
		const TVector3 &	lineDirection,
		bool	stopAtBoundary = `false`,
		bool	calcJacobianNoise = `false`
	)		const

overridevirtualinherited

Extrapolates the state to the POCA to a line, and returns the extrapolation length and, via reference, the extrapolated state.

If stopAtBoundary is true, the extrapolation stops as soon as a material boundary is encountered.

If state has a covariance, jacobian and noise matrices will be calculated and the covariance will be propagated. If state has no covariance, jacobian and noise will only be calculated if calcJacobianNoise == true.

Implements AbsTrackRep.

Definition at line 135 of file RKTrackRep.cc.

◆ extrapolateToLine() [2/4]

virtual double extrapolateToLine

inherited

Extrapolates the state to the POCA to a line, and returns the extrapolation length and, via reference, the extrapolated state.

If stopAtBoundary is true, the extrapolation stops as soon as a material boundary is encountered.

If state has a covariance, jacobian and noise matrices will be calculated and the covariance will be propagated. If state has no covariance, jacobian and noise will only be calculated if calcJacobianNoise == true.

◆ extrapolateToLine() [3/4]

virtual double extrapolateToLine

inlineinherited

Resembles the interface of GFAbsTrackRep in old versions of genfit.

This interface to extrapolateToLine is intended to resemble the interface of GFAbsTrackRep in old versions of genfit and is implemented by default via the preceding function.

If stopAtBoundary is true, the extrapolation stops as soon as a material boundary is encountered.

If state has a covariance, jacobian and noise matrices will be calculated and the covariance will be propagated. If state has no covariance, jacobian and noise will only be calculated if calcJacobianNoise == true.

Definition at line 120 of file AbsTrackRep.h.

◆ extrapolateToLine() [4/4]

virtual double extrapolateToLine	(	StateOnPlane &	state,
		const TVector3 &	point1,
		const TVector3 &	point2,
		TVector3 &	poca,
		TVector3 &	dirInPoca,
		TVector3 &	poca_onwire,
		bool	stopAtBoundary = `false`,
		bool	calcJacobianNoise = `false`
	)		const

inlinevirtualinherited

Resembles the interface of GFAbsTrackRep in old versions of genfit.

This interface to extrapolateToLine is intended to resemble the interface of GFAbsTrackRep in old versions of genfit and is implemented by default via the preceding function.

If stopAtBoundary is true, the extrapolation stops as soon as a material boundary is encountered.

If state has a covariance, jacobian and noise matrices will be calculated and the covariance will be propagated. If state has no covariance, jacobian and noise will only be calculated if calcJacobianNoise == true.

Definition at line 120 of file AbsTrackRep.h.

◆ extrapolateToPlane()

double extrapolateToPlane	(	StateOnPlane &	state,
		const SharedPlanePtr &	plane,
		bool	stopAtBoundary = `false`,
		bool	calcJacobianNoise = `false`
	)		const

overridevirtualinherited

Extrapolates the state to plane, and returns the extrapolation length and, via reference, the extrapolated state.

If stopAtBoundary is true, the extrapolation stops as soon as a material boundary is encountered.

If state has a covariance, jacobian and noise matrices will be calculated and the covariance will be propagated. If state has no covariance, jacobian and noise will only be calculated if calcJacobianNoise == true.

Implements AbsTrackRep.

Definition at line 80 of file RKTrackRep.cc.

◆ extrapolateToPoint() [1/2]

virtual double extrapolateToPoint	(	StateOnPlane &	state,
		const TVector3 &	point,
		bool	stopAtBoundary = `false`,
		bool	calcJacobianNoise = `false`
	)		const

inlineoverridevirtualinherited

Extrapolates the state to the POCA to a point, and returns the extrapolation length and, via reference, the extrapolated state.

If stopAtBoundary is true, the extrapolation stops as soon as a material boundary is encountered.

If state has a covariance, jacobian and noise matrices will be calculated and the covariance will be propagated. If state has no covariance, jacobian and noise will only be calculated if calcJacobianNoise == true.

Implements AbsTrackRep.

Definition at line 100 of file RKTrackRep.h.

                                                      {
     return extrapToPoint(state, point, nullptr, stopAtBoundary, calcJacobianNoise);
   }

◆ extrapolateToPoint() [2/2]

virtual double extrapolateToPoint	(	StateOnPlane &	state,
		const TVector3 &	point,
		const TMatrixDSym &	G,
		bool	stopAtBoundary = `false`,
		bool	calcJacobianNoise = `false`
	)		const

inlineoverridevirtualinherited

Extrapolates the state to the POCA to a point in the metric of G, and returns the extrapolation length and, via reference, the extrapolated state.

If stopAtBoundary is true, the extrapolation stops as soon as a material boundary is encountered.

If state has a covariance, jacobian and noise matrices will be calculated and the covariance will be propagated. If state has no covariance, jacobian and noise will only be calculated if calcJacobianNoise == true.

Implements AbsTrackRep.

Definition at line 107 of file RKTrackRep.h.

◆ extrapolateToSphere()

double extrapolateToSphere	(	StateOnPlane &	state,
		double	radius,
		const TVector3 &	point = `TVector3(0., 0., 0.)`,
		bool	stopAtBoundary = `false`,
		bool	calcJacobianNoise = `false`
	)		const

overridevirtualinherited

Extrapolates the state to the sphere surface, and returns the extrapolation length and, via reference, the extrapolated state.

If stopAtBoundary is true, the extrapolation stops as soon as a material boundary is encountered.

If state has a covariance, jacobian and noise matrices will be calculated and the covariance will be propagated. If state has no covariance, jacobian and noise will only be calculated if calcJacobianNoise == true.

Implements AbsTrackRep.

Definition at line 610 of file RKTrackRep.cc.

◆ getCharge()

double getCharge ( const StateOnPlane & state ) const

overridevirtual

Get the (fitted) charge of a state.

This is not always equal the pdg charge (e.g. if the charge sign was flipped during the fit).

Reimplemented from RKTrackRep.

Definition at line 44 of file MplTrackRep.cc.

                                                              {
  
   if (dynamic_cast<const MeasurementOnPlane*>(&state) != nullptr) {
     Exception exc("RKTrackRep::getCharge - cannot get charge from MeasurementOnPlane",__LINE__,__FILE__);
     exc.setFatal();
     throw exc;
   }
  
   double pdgCharge( m_magCharge * (this->getPDGCharge() > 0 ? 1.0 : -1.0));
  
   // return pdgCharge with sign of q/p
   if (state.getState()(0) * pdgCharge < 0)
     return -pdgCharge;
   else
     return pdgCharge;
 }

◆ RKPropagate()

double RKPropagate	(	M1x7 &	state7,
		M7x7 *	jacobian,
		M1x3 &	SA,
		double	S,
		bool	varField = `true`,
		bool	calcOnlyLastRowOfJ = `false`
	)		const

overridevirtual

The actual Runge Kutta propagation.

propagate state7 with step S. Fills SA (Start directions derivatives dA/S). This is a single Runge-Kutta step. If jacobian is nullptr, only the state is propagated, otherwise also the 7x7 jacobian is calculated. If varField is false, the magnetic field will only be evaluated at the starting position. The return value is an estimation on how good the extrapolation is, and it is usually fine if it is > 1. It gives a suggestion how you must scale S so that the quality will be sufficient.

Reimplemented from RKTrackRep.

Definition at line 61 of file MplTrackRep.cc.

◆ RKutta()

bool RKutta	(	const M1x4 &	SU,
		const DetPlane &	plane,
		double	charge,
		double	mass,
		M1x7 &	state7,
		M7x7 *	jacobianT,
		M1x7 *	J_MMT_unprojected_lastRow,
		double &	coveredDistance,
		double &	flightTime,
		bool &	checkJacProj,
		M7x7 &	noiseProjection,
		StepLimits &	limits,
		bool	onlyOneStep = `false`,
		bool	calcOnlyLastRowOfJ = `false`
	)		const

privateinherited

Propagates the particle through the magnetic field.

If the propagation is successful and the plane is reached, the function returns true. Propagated state and the jacobian of the extrapolation are written to state7 and jacobianT. The jacobian is only calculated if jacobianT != nullptr. In the main loop of the Runge Kutta algorithm, the estimateStep() is called and may reduce the estimated stepsize so that a maximum momentum loss will not be exceeded, and stop at material boundaries. If this is the case, RKutta() will only propagate the reduced distance and then return. This is to ensure that material effects, which are calculated after the propagation, are taken into account properly.

Definition at line 1799 of file RKTrackRep.cc.

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

genfit2/code2/trackReps/include/MplTrackRep.h
genfit2/code2/trackReps/src/MplTrackRep.cc

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Function Documentation

◆ calcJacobianNumerically()

◆ Extrap()

◆ extrapolateBy()

◆ extrapolateToCone()

◆ extrapolateToCylinder()

◆ extrapolateToLine() [1/4]

◆ extrapolateToLine() [2/4]

◆ extrapolateToLine() [3/4]

◆ extrapolateToLine() [4/4]

◆ extrapolateToPlane()

◆ extrapolateToPoint() [1/2]

◆ extrapolateToPoint() [2/2]

◆ extrapolateToSphere()

◆ getCharge()

◆ RKPropagate()

◆ RKutta()