RecoTrack Class Reference

This is the Reconstruction Event-Data Model Track. More...

#include <RecoTrack.h>

Inheritance diagram for RecoTrack:

Public Types
enum	MatchingStatus {   c_undefined ,   c_matched ,   c_matchedWrongCharge ,   c_clone ,   c_cloneWrongCharge ,   c_background ,   c_ghost }
	Enum for the matching status of this reco track (set by the matching modules in the tracking package). More...

Public Member Functions
	RecoTrack ()
	Empty constructor for ROOT. Do not use!
	RecoTrack (const ROOT::Math::XYZVector &seedPosition, const ROOT::Math::XYZVector &seedMomentum, const short int seedCharge, const std::string &storeArrayNameOfPXDHits="", const std::string &storeArrayNameOfSVDHits="", const std::string &storeArrayNameOfCDCHits="", const std::string &storeArrayNameOfBKLMHits="", const std::string &storeArrayNameOfEKLMHits="", const std::string &storeArrayNameOfRecoHitInformation="")
	Construct a RecoTrack with the given seed helix parameters and the given names for the hits.
	RecoTrack (const RecoTrack &)=delete
	Delete the copy construtr.
RecoTrack &	operator= (RecoTrack const &)=delete
	Delete the copy construtr.
genfit::TrackCand	createGenfitTrackCand () const
	Create a genfit::TrackCand out of this reco track and copy all information to the track candidate.
RecoTrack *	copyToStoreArrayUsing (StoreArray< RecoTrack > &storeArray, const ROOT::Math::XYZVector &position, const ROOT::Math::XYZVector &momentum, short charge, const TMatrixDSym &covariance, double timeSeed) const
	Append a new RecoTrack to the given store array and copy its general properties, but not the hits themself.
RecoTrack *	copyToStoreArrayUsingSeeds (StoreArray< RecoTrack > &storeArray) const
	Append a new RecoTrack to the given store array and copy its general properties, but not the hits themself.
RecoTrack *	copyToStoreArray (StoreArray< RecoTrack > &storeArray) const
	Append a new RecoTrack to the given store array and copy its general properties, but not the hits themself.
size_t	addHitsFromRecoTrack (const RecoTrack *recoTrack, unsigned int sortingParameterOffset=0, bool reversed=false, std::optional< double > optionalMinimalWeight=std::nullopt)
	Add all hits from another RecoTrack to this RecoTrack.
bool	addCDCHit (const UsedCDCHit *cdcHit, const unsigned int sortingParameter, RightLeftInformation rightLeftInformation=RightLeftInformation::c_undefinedRightLeftInformation, OriginTrackFinder foundByTrackFinder=OriginTrackFinder::c_undefinedTrackFinder)
	Adds a cdc hit with the given information to the reco track.
bool	addPXDHit (const UsedPXDHit *pxdHit, const unsigned int sortingParameter, OriginTrackFinder foundByTrackFinder=OriginTrackFinder::c_undefinedTrackFinder)
	Adds a pxd hit with the given information to the reco track.
bool	addSVDHit (const UsedSVDHit *svdHit, const unsigned int sortingParameter, OriginTrackFinder foundByTrackFinder=OriginTrackFinder::c_undefinedTrackFinder)
	Adds a svd hit with the given information to the reco track.
bool	addBKLMHit (const UsedBKLMHit *bklmHit, const unsigned int sortingParameter, OriginTrackFinder foundByTrackFinder=OriginTrackFinder::c_undefinedTrackFinder)
	Adds a bklm hit with the given information to the reco track.
bool	addEKLMHit (const UsedEKLMHit *eklmHit, const unsigned int sortingParameter, OriginTrackFinder foundByTrackFinder=OriginTrackFinder::c_undefinedTrackFinder)
	Adds an eklm hit with the given information to the reco track.
template<class HitType >
RecoHitInformation *	getRecoHitInformation (HitType *hit) const
	Return the reco hit information for a generic hit from the storeArray.
template<class HitType >
TrackingDetector	getTrackingDetector (const HitType *hit) const
	Return the tracking detector of a given hit (every type) or throws an exception of the hit is not related to the track.
template<class HitType >
RightLeftInformation	getRightLeftInformation (const HitType *hit) const
	Return the right left information of a given hit (every type) or throws an exception of the hit is not related to the track.
template<class HitType >
OriginTrackFinder	getFoundByTrackFinder (const HitType *hit) const
	Return the found by track finder flag for the given hit (every type) or throws an exception of the hit is not related to the track.
template<class HitType >
unsigned int	getSortingParameter (const HitType *hit) const
	Return the sorting parameter for a given hit (every type) or throws an exception of the hit is not related to the track.
template<class HitType >
void	setRightLeftInformation (const HitType *hit, RightLeftInformation rightLeftInformation)
	Set the right left information or throws an exception of the hit is not related to the track. Will set the dirty flag!
template<class HitType >
void	setFoundByTrackFinder (const HitType *hit, OriginTrackFinder originTrackFinder)
	Set the found by track finder flag or throws an exception of the hit is not related to the track.
template<class HitType >
void	setSortingParameter (const HitType *hit, unsigned int sortingParameter)
	Set the sorting parameter or throws an exception of the hit is not related to the track. Will set the dirty flag!
const genfit::TrackPoint *	getCreatedTrackPoint (const RecoHitInformation *recoHitInformation) const
	Get a pointer to the TrackPoint that was created from this hit.
bool	hasPXDHits () const
	Returns true if the track has pxd hits.
bool	hasSVDHits () const
	Returns true if the track has svd hits.
bool	hasCDCHits () const
	Returns true if the track has cdc hits.
bool	hasBKLMHits () const
	Returns true if the track has bklm hits.
bool	hasEKLMHits () const
	Returns true if the track has eklm hits.
template<class HitType >
bool	hasHit (const HitType *hit) const
	Returns true if the given hit is in the track.
unsigned int	getNumberOfPXDHits () const
	Return the number of pxd hits.
unsigned int	getNumberOfSVDHits () const
	Return the number of svd hits.
unsigned int	getNumberOfCDCHits () const
	Return the number of cdc hits.
unsigned int	getNumberOfBKLMHits () const
	Return the number of bklm hits.
unsigned int	getNumberOfEKLMHits () const
	Return the number of eklm hits.
unsigned int	getNumberOfTotalHits () const
	Return the number of cdc + svd + pxd + bklm + eklm hits.
unsigned int	getNumberOfTrackingHits () const
	Return the number of cdc + svd + pxd hits.
std::vector< Belle2::RecoTrack::UsedPXDHit * >	getPXDHitList () const
	Return an unsorted list of pxd hits.
std::vector< Belle2::RecoTrack::UsedSVDHit * >	getSVDHitList () const
	Return an unsorted list of svd hits.
std::vector< Belle2::RecoTrack::UsedCDCHit * >	getCDCHitList () const
	Return an unsorted list of cdc hits.
std::vector< Belle2::RecoTrack::UsedBKLMHit * >	getBKLMHitList () const
	Return an unsorted list of bklm hits.
std::vector< Belle2::RecoTrack::UsedEKLMHit * >	getEKLMHitList () const
	Return an unsorted list of eklm hits.
std::vector< Belle2::RecoTrack::UsedPXDHit * >	getSortedPXDHitList () const
	Return a sorted list of pxd hits. Sorted by the sortingParameter.
std::vector< Belle2::RecoTrack::UsedSVDHit * >	getSortedSVDHitList () const
	Return a sorted list of svd hits. Sorted by the sortingParameter.
std::vector< Belle2::RecoTrack::UsedCDCHit * >	getSortedCDCHitList () const
	Return a sorted list of cdc hits. Sorted by the sortingParameter.
std::vector< Belle2::RecoTrack::UsedBKLMHit * >	getSortedBKLMHitList () const
	Return a sorted list of bklm hits. Sorted by the sortingParameter.
std::vector< Belle2::RecoTrack::UsedEKLMHit * >	getSortedEKLMHitList () const
	Return a sorted list of eklm hits. Sorted by the sortingParameter.
ROOT::Math::XYZVector	getPositionSeed () const
	Return the position seed stored in the reco track. ATTENTION: This is not the fitted position.
ROOT::Math::XYZVector	getMomentumSeed () const
	Return the momentum seed stored in the reco track. ATTENTION: This is not the fitted momentum.
const TVectorD &	getStateSeed () const
	Return the state seed in the form posX, posY, posZ, momX, momY, momZ. ATTENTION: This is not the fitted state.
const genfit::Track &	getGenfitTrack () const
	Returns genfit track.
short int	getChargeSeed () const
	Return the charge seed stored in the reco track. ATTENTION: This is not the fitted charge.
double	getTimeSeed () const
	Return the time seed stored in the reco track. ATTENTION: This is not the fitted time.
float	getOutgoingArmTime ()
	Return the track time of the outgoing arm.
float	getOutgoingArmTimeError ()
	Return the error of the track time of the outgoing arm.
float	getIngoingArmTime ()
	Return the track time of the ingoing arm.
float	getIngoingArmTimeError ()
	Return the error of the track time of the ingoing arm.
float	getInOutArmTimeDifference ()
	Return the difference between the track times of the ingoing and outgoing arms.
float	getInOutArmTimeDifferenceError ()
	Return the error of the difference between the track times of the ingoing and outgoing arms.
bool	hasIngoingArmTime ()
	Check if the ingoing arm time is set.
bool	hasOutgoingArmTime ()
	Check if the outgoing arm time is set.
int	getNSVDHitsOfOutgoingArm ()
	Return the number of clusters used to estimate the outgoing arm time.
int	getNSVDHitsOfIngoingArm ()
	Return the number of clusters used to estimate the ingoing arm time.
void	flipTrackDirectionAndCharge (const genfit::AbsTrackRep *representation=nullptr)
	Flip the direction of the RecoTrack by inverting the momentum vector and the charge.
std::tuple< ROOT::Math::XYZVector, ROOT::Math::XYZVector, short >	extractTrackState () const
	Return the position, the momentum and the charge of the first measured state on plane or - if unfitted - the seeds.
void	setPositionAndMomentum (const ROOT::Math::XYZVector &positionSeed, const ROOT::Math::XYZVector &momentumSeed)
	Set the position and momentum seed of the reco track. ATTENTION: This is not the fitted position or momentum.
void	setChargeSeed (const short int chargeSeed)
	Set the charge seed stored in the reco track. ATTENTION: This is not the fitted charge.
void	setTimeSeed (const double timeSeed)
	Set the time seed. ATTENTION: This is not the fitted time.
const TMatrixDSym &	getSeedCovariance () const
	Return the covariance matrix of the seed. ATTENTION: This is not the fitted covariance.
void	setSeedCovariance (const TMatrixDSym &seedCovariance)
	Set the covariance of the seed. ATTENTION: This is not the fitted covariance.
bool	wasFitSuccessful (const genfit::AbsTrackRep *representation=nullptr) const
	Returns true if the last fit with the given representation was successful.
const genfit::FitStatus *	getTrackFitStatus (const genfit::AbsTrackRep *representation=nullptr) const
	Return the track fit status for the given representation or for the cardinal one. You are not allowed to modify or delete it!
bool	hasTrackFitStatus (const genfit::AbsTrackRep *representation=nullptr) const
	Check, if there is a fit status for the given representation or for the cardinal one.
genfit::AbsTrackRep *	getCardinalRepresentation () const
	Get a pointer to the cardinal track representation. You are not allowed to modify or delete it!
const std::vector< genfit::AbsTrackRep * > &	getRepresentations () const
	Return a list of track representations. You are not allowed to modify or delete them!
genfit::AbsTrackRep *	getTrackRepresentationForPDG (int pdgCode) const
	Return an already created track representation of the given reco track for the PDG.
std::vector< RecoHitInformation * >	getRecoHitInformations (bool getSorted=false) const
	Return a list of all RecoHitInformations associated with the RecoTrack.
const genfit::MeasuredStateOnPlane &	getMeasuredStateOnPlaneFromFirstHit (const genfit::AbsTrackRep *representation=nullptr) const
	Return genfit's MeasuredStateOnPlane for the first hit in a fit useful for extrapolation of measurements to other locations Const version.
const genfit::MeasuredStateOnPlane &	getMeasuredStateOnPlaneFromLastHit (const genfit::AbsTrackRep *representation=nullptr) const
	Return genfit's MeasuredStateOnPlane for the last hit in a fit useful for extrapolation of measurements to other locations Const version.
const genfit::MeasuredStateOnPlane &	getMeasuredStateOnPlaneFromRecoHit (const RecoHitInformation *recoHitInfo, const genfit::AbsTrackRep *representation=nullptr) const
	Return genfit's MeasuredStateOnPlane on plane for associated with one RecoHitInformation.
const genfit::MeasuredStateOnPlane &	getMeasuredStateOnPlaneClosestTo (const ROOT::Math::XYZVector &closestPoint, const genfit::AbsTrackRep *representation=nullptr)
	Return genfit's MasuredStateOnPlane, that is closest to the given point useful for extrapolation of measurements other locations.
void	prune ()
	Prune the genfit track, e.g.
void	estimateArmTime ()
	This function calculates the track time of the ingoing and outgoing arms and their difference.
bool	isOutgoingArm (RecoHitInformation::RecoHitDetector pre=RecoHitInformation::RecoHitDetector::c_undefinedTrackingDetector, RecoHitInformation::RecoHitDetector post=RecoHitInformation::RecoHitDetector::c_undefinedTrackingDetector)
	This function returns true if the arm direction is Outgoing and false if the arm direction is Ingoing.
const std::vector< genfit::TrackPoint * > &	getHitPointsWithMeasurement () const
	Return a list of measurements and track points, which can be used e.g. to extrapolate. You are not allowed to modify or delete them!
bool	getDirtyFlag () const
	This returns true, if a hit was added after the last fit and measurement creation and a refit should be done.
void	setDirtyFlag (const bool &dirtyFlag=true)
	Set to true, if you want to rebuild the measurements and do the fit independent on changes of the hit content.
const std::string &	getStoreArrayNameOfPXDHits () const
	Name of the store array of the pxd hits.
const std::string &	getStoreArrayNameOfSVDHits () const
	Name of the store array of the svd hits.
const std::string &	getStoreArrayNameOfCDCHits () const
	Name of the store array of the cdc hits.
const std::string &	getStoreArrayNameOfBKLMHits () const
	Name of the store array of the bklm hits.
const std::string &	getStoreArrayNameOfEKLMHits () const
	Name of the store array of the eklm hits.
const std::string &	getStoreArrayNameOfRecoHitInformation () const
	Name of the store array of the reco hit information.
void	revertRecoHitInformationSorting ()
	Revert the sorting order of the RecoHitInformation.
template<class HitType >
void	mapOnHits (const std::string &storeArrayNameOfHits, std::function< void(RecoHitInformation &, HitType *)> const &mapFunction, std::function< bool(const RecoHitInformation &, const HitType *)> const &pickFunction)
	Call a function on all hits of the given type in the store array, that are related to this track.
template<class HitType >
void	mapOnHits (const std::string &storeArrayNameOfHits, std::function< void(const RecoHitInformation &, const HitType *)> const &mapFunction, std::function< bool(const RecoHitInformation &, const HitType *)> const &pickFunction) const
	Call a function on all hits of the given type in the store array, that are related to this track.
template<class HitType >
void	mapOnHits (const std::string &storeArrayNameOfHits, std::function< void(RecoHitInformation &, HitType *)> const &mapFunction)
	Call a function on all hits of the given type in the store array, that are related to this track.
template<class HitType >
void	mapOnHits (const std::string &storeArrayNameOfHits, std::function< void(const RecoHitInformation &, const HitType *)> const &mapFunction) const
	Call a function on all hits of the given type in the store array, that are related to this track.
MatchingStatus	getMatchingStatus () const
	Return the matching status set by the TrackMatcher module.
void	setMatchingStatus (MatchingStatus matchingStatus)
	Set the matching status (used by the TrackMatcher module)
float	getQualityIndicator () const
	Get the quality index attached to this RecoTrack given by one of the reconstruction algorithms. 0 means likely fake.
void	setQualityIndicator (const float qualityIndicator)
	Set the quality index attached to this RecoTrack. 0 means likely fake.
float	getFlipQualityIndicator () const
	Get the 1st flipping quality attached to this RecoTrack as a reference for flipping.
void	setFlipQualityIndicator (const float qualityIndicator)
	Set the 1st flipping quality attached to this RecoTrack.
float	get2ndFlipQualityIndicator () const
	Get the 2nd flipping quality attached to this RecoTrack as a reference for flipping.
void	set2ndFlipQualityIndicator (const float qualityIndicator)
	Set the 2nd flipping quality attached to this RecoTrack.
void	deleteFittedInformation ()
	Delete all fitted information for all representations.
void	deleteFittedInformationForRepresentation (const genfit::AbsTrackRep *rep)
	Delete all fitted information for the given representations.
std::string	getInfoHTML () const override
	Get useful information on EventDisplay.
void	addRelationTo (const RelationsInterface< BASE > *object, float weight=1.0, const std::string &namedRelation="") const
	Add a relation from this object to another object (with caching).
void	addRelationTo (const TObject *object, float weight=1.0, const std::string &namedRelation="") const
	Add a relation from this object to another object (no caching, can be quite slow).
void	copyRelations (const RelationsInterface< BASE > *sourceObj)
	Copies all relations of sourceObj (pointing from or to sourceObj) to this object (including weights).
template<class TO >
RelationVector< TO >	getRelationsTo (const std::string &name="", const std::string &namedRelation="") const
	Get the relations that point from this object to another store array.
template<class FROM >
RelationVector< FROM >	getRelationsFrom (const std::string &name="", const std::string &namedRelation="") const
	Get the relations that point from another store array to this object.
template<class T >
RelationVector< T >	getRelationsWith (const std::string &name="", const std::string &namedRelation="") const
	Get the relations between this object and another store array.
template<class TO >
TO *	getRelatedTo (const std::string &name="", const std::string &namedRelation="") const
	Get the object to which this object has a relation.
template<class FROM >
FROM *	getRelatedFrom (const std::string &name="", const std::string &namedRelation="") const
	Get the object from which this object has a relation.
template<class T >
T *	getRelated (const std::string &name="", const std::string &namedRelation="") const
	Get the object to or from which this object has a relation.
template<class TO >
std::pair< TO *, float >	getRelatedToWithWeight (const std::string &name="", const std::string &namedRelation="") const
	Get first related object & weight of relation pointing to an array.
template<class FROM >
std::pair< FROM *, float >	getRelatedFromWithWeight (const std::string &name="", const std::string &namedRelation="") const
	Get first related object & weight of relation pointing from an array.
template<class T >
std::pair< T *, float >	getRelatedWithWeight (const std::string &name="", const std::string &namedRelation="") const
	Get first related object & weight of relation pointing from/to an array.
virtual std::string	getName () const
	Return a short name that describes this object, e.g.
std::string	getInfo () const
	Return a short summary of this object's contents in raw text format.
std::string	getArrayName () const
	Get name of array this object is stored in, or "" if not found.
int	getArrayIndex () const
	Returns this object's array index (in StoreArray), or -1 if not found.

Static Public Member Functions
static void	registerRequiredRelations (StoreArray< RecoTrack > &recoTracks, std::string const &pxdHitsStoreArrayName="", std::string const &svdHitsStoreArrayName="", std::string const &cdcHitsStoreArrayName="", std::string const &bklmHitsStoreArrayName="", std::string const &eklmHitsStoreArrayName="", std::string const &recoHitInformationStoreArrayName="")
	Convenience method which registers all relations required to fully use a RecoTrack.
static RecoTrack *	createFromTrackCand (const genfit::TrackCand &trackCand, const std::string &storeArrayNameOfRecoTracks="", const std::string &storeArrayNameOfPXDHits="", const std::string &storeArrayNameOfSVDHits="", const std::string &storeArrayNameOfCDCHits="", const std::string &storeArrayNameOfBKLMHits="", const std::string &storeArrayNameOfEKLMHits="", const std::string &storeArrayNameOfRecoHitInformation="", const bool recreateSortingParameters=false)
	Create a reco track from a genfit::TrackCand and save it to the given store array.

Protected Member Functions
TClonesArray *	getArrayPointer () const
	Returns the pointer to the raw DataStore array holding this object (protected since these arrays are easy to misuse).

Private Types
typedef RecoHitInformation::RightLeftInformation	RightLeftInformation
	Copy the definitions from the RecoHitInformation to this class.
typedef RecoHitInformation::RecoHitDetector	TrackingDetector
	Copy the definitions from the RecoHitInformation to this class.
typedef RecoHitInformation::OriginTrackFinder	OriginTrackFinder
	Copy the definitions from the RecoHitInformation to this class.
typedef RecoHitInformation::UsedCDCHit	UsedCDCHit
	Copy the definitions from the RecoHitInformation to this class.
typedef RecoHitInformation::UsedSVDHit	UsedSVDHit
	Copy the definitions from the RecoHitInformation to this class.
typedef RecoHitInformation::UsedPXDHit	UsedPXDHit
	Copy the definitions from the RecoHitInformation to this class.
typedef RecoHitInformation::UsedBKLMHit	UsedBKLMHit
	Copy the definitions from the RecoHitInformation to this class.
typedef RecoHitInformation::UsedEKLMHit	UsedEKLMHit
	Copy the definitions from the RecoHitInformation to this class.

Private Member Functions
template<class HitType , class ... Args>
bool	addHit (const HitType *hit, Args &&... params)
	Add a generic hit with the given parameters for the reco hit information.
template<class HitType >
void	addHitWithHitInformation (const HitType *hit, RecoHitInformation *recoHitInformation)
	Add the needed relations for adding a generic hit with the given hit information and reset track time information.
template<class HitType >
RecoHitInformation *	getRecoHitInformationSafely (HitType *hit) const
	Returns the reco hit information for a given hit or throws an exception if the hit is not related to the track.
template<class HitType >
unsigned int	getNumberOfHitsOfGivenType (const std::string &storeArrayNameOfHits) const
	Get the number of hits for the given hit type in the store array that are related to this track.
template<class HitType >
std::vector< HitType * >	getSortedHitList (const std::string &storeArrayNameOfHits) const
	Return a sorted list of hits of the given type in the store array that are related to this track.
template<class HitType >
std::vector< HitType * >	getHitList (const std::string &storeArrayNameOfHits) const
	Return an unsorted list of hits of the given type in the store array that are related to this track.
void	swapArmTimes ()
	Swap arm times, booleans and nSVDHits.
void	checkDirtyFlag () const
	Helper: Check the dirty flag and produce a warning, whenever a fit result is accessed.
	ClassDefOverride (RecoTrack, 14)
	Making this class a ROOT class.
	ClassDef (RelationsInterface, 0)
	defines interface for accessing relations of objects in StoreArray.

Private Attributes
genfit::Track	m_genfitTrack
	Internal storage for the genfit track.
short int	m_charge = 1
	Storage for the charge. All other helix parameters are saved in the genfit::Track.
std::string	m_storeArrayNameOfPXDHits = ""
	Store array name of added PXD hits.
std::string	m_storeArrayNameOfSVDHits = ""
	Store array name of added SVD hits.
std::string	m_storeArrayNameOfCDCHits = ""
	Store array name of added CDC hits.
std::string	m_storeArrayNameOfBKLMHits = ""
	Store array name of added BKLM hits.
std::string	m_storeArrayNameOfEKLMHits = ""
	Store array name of added EKLM hits.
std::string	m_storeArrayNameOfRecoHitInformation = ""
	Store array of added RecoHitInformation.
bool	m_dirtyFlag = true
	Bool is hits were added to track after fitting and the measurements should be recalculated.
MatchingStatus	m_matchingStatus = MatchingStatus::c_undefined
	Flag used in the MCRecoTracksMatcherModule.
float	m_qualityIndicator = NAN
	Quality index for classification of fake vs. MC-matched Tracks.
float	m_flipqualityIndicator = NAN
	Quality index for flipping.
float	m_2ndFlipqualityIndicator = NAN
	Quality index for flipping.
float	m_outgoingArmTime = NAN
	Track time of the outgoing arm.
float	m_outgoingArmTimeError = NAN
	Error of the track time of the outgoing arm.
float	m_ingoingArmTime = NAN
	Track time of the ingoing arm.
float	m_ingoingArmTimeError = NAN
	Error of the track time of the ingoing arm.
bool	m_isArmTimeComputed = false
	true if the arms times are already computed, false otherwise
bool	m_hasIngoingArmTime = false
	Internal storage of the final ingoing arm time is set.
bool	m_hasOutgoingArmTime = false
	Internal storage of the final outgoing arm time is set.
int	m_nSVDHitsOfOutgoingArm = 0
	Number of SVD clusters of the outgoing arm.
int	m_nSVDHitsOfIngoingArm = 0
	Number of SVD clusters of the ingoing arm.
DataStore::StoreEntry *	m_cacheDataStoreEntry
	Cache of the data store entry to which this object belongs.
int	m_cacheArrayIndex
	Cache of the index in the TClonesArray to which this object belongs.

Friends
class	RecoTrackGenfitAccess
	The RecoTrackGenfitAccess need to access the genfit track (which is intended)!

Detailed Description

This is the Reconstruction Event-Data Model Track.

This class collects hits, saves the track parameters and can be used with a TrackFitter to perform fits to the hits. It can be created from a genfit::TrackCand and converted to a genfit::Track, but it is better to use this class directly in the modules, because it offers a more datastore-suited interface.

The RecoTrack itself does only store a genfit::Track internally. All hit content is stored as a relation to the hits. For each of these relations to a detector hit, there is also a relation to a RecoHitInformation, to store additional information. However, the user does not need to access these relation by himself, but can use the accessor functions of the RecoTrack.

Typically, a RecoTrack object is created with a position and momentum seed and a charge.

RecoTrack recoTrack(position, momentum, charge, ...)

Then, hits are added

recoTrack.addCDCHit(cdcHit, rlInformation, ...) ....

After that, the hits can either be accessed:

recoTrack.getCDCHitList(); recoTrack.getRightLeftInformation(cdcHit);

or the track can be fitted:

TrackFitter fitter; fitter.fit(recoTrack);

See also the TrackFitter class for possibilities to fit. After the track is fitted properly, the hit points with measurements can be used to extrapolate the track

recoTrack.getHitPointsWithMeasurement();

See the recoTrack.cc test for an overview on the hit information accessor methods.

Definition at line 79 of file RecoTrack.h.

Member Typedef Documentation

OriginTrackFinder

typedef RecoHitInformation::OriginTrackFinder OriginTrackFinder

private

Copy the definitions from the RecoHitInformation to this class.

Definition at line 89 of file RecoTrack.h.

RightLeftInformation

typedef RecoHitInformation::RightLeftInformation RightLeftInformation

private

Copy the definitions from the RecoHitInformation to this class.

Definition at line 85 of file RecoTrack.h.

TrackingDetector

typedef RecoHitInformation::RecoHitDetector TrackingDetector

private

Copy the definitions from the RecoHitInformation to this class.

Definition at line 87 of file RecoTrack.h.

UsedBKLMHit

typedef RecoHitInformation::UsedBKLMHit UsedBKLMHit

private

Copy the definitions from the RecoHitInformation to this class.

Definition at line 97 of file RecoTrack.h.

UsedCDCHit

typedef RecoHitInformation::UsedCDCHit UsedCDCHit

private

Copy the definitions from the RecoHitInformation to this class.

Definition at line 91 of file RecoTrack.h.

UsedEKLMHit

typedef RecoHitInformation::UsedEKLMHit UsedEKLMHit

private

Copy the definitions from the RecoHitInformation to this class.

Definition at line 99 of file RecoTrack.h.

UsedPXDHit

typedef RecoHitInformation::UsedPXDHit UsedPXDHit

private

Copy the definitions from the RecoHitInformation to this class.

Definition at line 95 of file RecoTrack.h.

UsedSVDHit

typedef RecoHitInformation::UsedSVDHit UsedSVDHit

private

Copy the definitions from the RecoHitInformation to this class.

Definition at line 93 of file RecoTrack.h.

Member Enumeration Documentation

MatchingStatus

enum MatchingStatus

Enum for the matching status of this reco track (set by the matching modules in the tracking package).

Definition at line 105 of file RecoTrack.h.

                        {
      c_undefined, //until the matcher module sets it
      c_matched, // hit pattern and charge are both correct
      c_matchedWrongCharge, // hit pattern is correct, but the charge is wrong
      c_clone, //a clone with the correct charge
      c_cloneWrongCharge, //a clone with the wrong charge
      c_background,
      c_ghost
    };

Constructor & Destructor Documentation

RecoTrack() [1/2]

RecoTrack ( )

inline

Empty constructor for ROOT. Do not use!

Definition at line 140 of file RecoTrack.h.

{ }

RecoTrack() [2/2]

RecoTrack	(	const ROOT::Math::XYZVector &	seedPosition,
		const ROOT::Math::XYZVector &	seedMomentum,
		const short int	seedCharge,
		const std::string &	storeArrayNameOfPXDHits = "",
		const std::string &	storeArrayNameOfSVDHits = "",
		const std::string &	storeArrayNameOfCDCHits = "",
		const std::string &	storeArrayNameOfBKLMHits = "",
		const std::string &	storeArrayNameOfEKLMHits = "",
		const std::string &	storeArrayNameOfRecoHitInformation = ""
	)

Construct a RecoTrack with the given seed helix parameters and the given names for the hits.

If you do not provide information for the hit store array names, the standard parameters are used.

Parameters

seedPosition	A position on the helix of the track seed. Only the perigee of the helix will be saved.
seedMomentum	The seed momentum of the helix on the given position.
seedCharge	The seed charge of the helix
storeArrayNameOfPXDHits	The name of the store array where the related PXD hits are stored.
storeArrayNameOfSVDHits	The name of the store array where the related SVD hits are stored.
storeArrayNameOfCDCHits	The name of the store array where the related CDC hits are stored.
storeArrayNameOfBKLMHits	The name of the store array where the related BKLM hits are stored.
storeArrayNameOfEKLMHits	The name of the store array where the related EKLM hits are stored.
storeArrayNameOfRecoHitInformation	The name of the store array where the related hit information are stored.

Definition at line 25 of file RecoTrack.cc.

                                                                          :
  m_charge(seedCharge),
  m_storeArrayNameOfPXDHits(storeArrayNameOfPXDHits),
  m_storeArrayNameOfSVDHits(storeArrayNameOfSVDHits),
  m_storeArrayNameOfCDCHits(storeArrayNameOfCDCHits),
  m_storeArrayNameOfBKLMHits(storeArrayNameOfBKLMHits),
  m_storeArrayNameOfEKLMHits(storeArrayNameOfEKLMHits),
  m_storeArrayNameOfRecoHitInformation(storeArrayNameOfRecoHitInformation)
{
  m_genfitTrack.setStateSeed(XYZToTVector(seedPosition), XYZToTVector(seedMomentum));
  // TODO Set the covariance seed (that should be done by the tracking package)
  TMatrixDSym covSeed(6);
  covSeed(0, 0) = 1e-3;
  covSeed(1, 1) = 1e-3;
  covSeed(2, 2) = 4e-3;
  covSeed(3, 3) = 0.01e-3;
  covSeed(4, 4) = 0.01e-3;
  covSeed(5, 5) = 0.04e-3;
  m_genfitTrack.setCovSeed(covSeed);
}

Member Function Documentation

addBKLMHit()

bool addBKLMHit ( const UsedBKLMHit *  bklmHit, const unsigned int  sortingParameter, OriginTrackFinder  foundByTrackFinder = OriginTrackFinder::c_undefinedTrackFinder  )

inline

Adds a bklm hit with the given information to the reco track.

You only have to provide the hit and the sorting parameter, all other parameters have default value.

Parameters

bklmHit	The pointer to a stored BKLMHit in the store array you provided earlier, which you want to add.
sortingParameter	The index of the hit. It starts with 0 with the first hit.
foundByTrackFinder	Which track finder has found the hit?

Returns

True if the hit was not already added to the track.

Definition at line 286 of file RecoTrack.h.

    {
      return addHit(bklmHit, foundByTrackFinder, sortingParameter);
    }

addCDCHit()

bool addCDCHit ( const UsedCDCHit *  cdcHit, const unsigned int  sortingParameter, RightLeftInformation  rightLeftInformation = RightLeftInformation::c_undefinedRightLeftInformation, OriginTrackFinder  foundByTrackFinder = OriginTrackFinder::c_undefinedTrackFinder  )

inline

Adds a cdc hit with the given information to the reco track.

You only have to provide the hit and the sorting parameter, all other parameters have default value.

Parameters

cdcHit	The pointer to a stored CDCHit in the store array you provided earlier, which you want to add.
sortingParameter	The index of the hit. It starts with 0 with the first hit.
rightLeftInformation	The right left information (if you know it).
foundByTrackFinder	Which track finder has found the hit?

Returns

True if the hit was not already added to the track.

Definition at line 243 of file RecoTrack.h.

    {
      return addHit(cdcHit, rightLeftInformation, foundByTrackFinder, sortingParameter);
    }

addEKLMHit()

bool addEKLMHit ( const UsedEKLMHit *  eklmHit, const unsigned int  sortingParameter, OriginTrackFinder  foundByTrackFinder = OriginTrackFinder::c_undefinedTrackFinder  )

inline

Adds an eklm hit with the given information to the reco track.

You only have to provide the hit and the sorting parameter, all other parameters have default value.

Parameters

eklmHit	The pointer to a stored BKLMHit in the store array you provided earlier, which you want to add.
sortingParameter	The index of the hit. It starts with 0 with the first hit.
foundByTrackFinder	Which track finder has found the hit?

Returns

True if the hit was not already added to the track.

Definition at line 300 of file RecoTrack.h.

    {
      return addHit(eklmHit, foundByTrackFinder, sortingParameter);
    }

addHit()

bool addHit ( const HitType *  hit, Args &&...  params  )

inlineprivate

Add a generic hit with the given parameters for the reco hit information.

Parameters

hit	a generic hit.
params	for the constructor of the reco hit information.

Returns

true if the hit was new.

Definition at line 949 of file RecoTrack.h.

    {
      if (hasHit(hit)) {
        return false;
      }
 
      StoreArray<RecoHitInformation> recoHitInformations(m_storeArrayNameOfRecoHitInformation);
      RecoHitInformation* newRecoHitInformation = recoHitInformations.appendNew(hit, params...);
 
      addHitWithHitInformation(hit, newRecoHitInformation);
 
      return true;
    }

addHitsFromRecoTrack()

size_t addHitsFromRecoTrack	(	const RecoTrack *	recoTrack,
		unsigned int	sortingParameterOffset = 0,
		bool	reversed = false,
		std::optional< double >	optionalMinimalWeight = std::nullopt
	)

Add all hits from another RecoTrack to this RecoTrack.

Parameters

recoTrack	: Pointer to the RecoTrack where the hits are copied from
sortingParameterOffset	: This number will be added to the sortingParameter of all hits copied from recoTrack. Set this to (largest sorting parameter) + 1 in order to add hits at the end of this reco track.
reversed	: add the hits in a reversed order - each sorting parameter is set to maximal sorting parameter - sorting parameter + offset
optionalMinimalWeight	: if set, do only copy hits with a weight above this (if fitted already with the DAF).

Returns

The number of hits copied.

Definition at line 240 of file RecoTrack.cc.

{
  size_t hitsCopied = 0;
 
  unsigned int maximalSortingParameter = 0;
 
  if (reversed) {
    const auto& recoHitInformations = recoTrack->getRecoHitInformations();
    const auto sortBySP = [](const RecoHitInformation * lhs, const RecoHitInformation * rhs) {
      return lhs->getSortingParameter() < rhs->getSortingParameter();
    };
    const auto& maximalElement = std::max_element(recoHitInformations.begin(), recoHitInformations.end(), sortBySP);
    if (maximalElement != recoHitInformations.end()) {
      maximalSortingParameter = (*maximalElement)->getSortingParameter();
    }
  }
 
  // Helper function to add the sorting parameter offset (or reverse the sign of the sorting parameter)
  const auto calculateSortingParameter = [maximalSortingParameter, sortingParameterOffset](unsigned int sortingParameters) {
    if (maximalSortingParameter > 0) {
      return maximalSortingParameter - sortingParameters + sortingParameterOffset;
    }
    return sortingParameters + sortingParameterOffset;
  };
 
  const auto testHitWeight = [recoTrack, optionalMinimalWeight](const RecoHitInformation * recoHitInformation) {
    if (not optionalMinimalWeight) {
      return true;
    }
    double minimalWeight = *optionalMinimalWeight;
    const genfit::TrackPoint* trackPoint = recoTrack->getCreatedTrackPoint(recoHitInformation);
    if (trackPoint) {
      genfit::KalmanFitterInfo* kalmanFitterInfo = trackPoint->getKalmanFitterInfo();
      if (not kalmanFitterInfo) {
        return false;
      }
      const std::vector<double>& weights = kalmanFitterInfo->getWeights();
      const auto checkWeight = [minimalWeight](const double weight) {
        return weight >= minimalWeight;
      };
      return std::any_of(weights.begin(), weights.end(), checkWeight);
    }
    return true;
  };
 
  for (auto* pxdHit : recoTrack->getPXDHitList()) {
    auto recoHitInfo = recoTrack->getRecoHitInformation(pxdHit);
    assert(recoHitInfo);
    if (testHitWeight(recoHitInfo)) {
      hitsCopied += addPXDHit(pxdHit, calculateSortingParameter(recoHitInfo->getSortingParameter()),
                              recoHitInfo->getFoundByTrackFinder());
    }
  }
 
  for (auto* svdHit : recoTrack->getSVDHitList()) {
    auto recoHitInfo = recoTrack->getRecoHitInformation(svdHit);
    assert(recoHitInfo);
    if (testHitWeight(recoHitInfo)) {
      hitsCopied += addSVDHit(svdHit, calculateSortingParameter(recoHitInfo->getSortingParameter()),
                              recoHitInfo->getFoundByTrackFinder());
    }
  }
 
  for (auto* cdcHit : recoTrack->getCDCHitList()) {
    auto recoHitInfo = recoTrack->getRecoHitInformation(cdcHit);
    assert(recoHitInfo);
    if (testHitWeight(recoHitInfo)) {
      hitsCopied += addCDCHit(cdcHit, calculateSortingParameter(recoHitInfo->getSortingParameter()),
                              recoHitInfo->getRightLeftInformation(),
                              recoHitInfo->getFoundByTrackFinder());
    }
  }
 
  for (auto* bklmHit : recoTrack->getBKLMHitList()) {
    auto recoHitInfo = recoTrack->getRecoHitInformation(bklmHit);
    assert(recoHitInfo);
    if (testHitWeight(recoHitInfo)) {
      hitsCopied += addBKLMHit(bklmHit, calculateSortingParameter(recoHitInfo->getSortingParameter()),
                               recoHitInfo->getFoundByTrackFinder());
    }
  }
 
  for (auto* eklmHit : recoTrack->getEKLMHitList()) {
    auto recoHitInfo = recoTrack->getRecoHitInformation(eklmHit);
    assert(recoHitInfo);
    if (testHitWeight(recoHitInfo)) {
      hitsCopied += addEKLMHit(eklmHit, calculateSortingParameter(recoHitInfo->getSortingParameter()),
                               recoHitInfo->getFoundByTrackFinder());
    }
  }
 
  return hitsCopied;
}

addHitWithHitInformation()

void addHitWithHitInformation ( const HitType *  hit, RecoHitInformation *  recoHitInformation  )

inlineprivate

Add the needed relations for adding a generic hit with the given hit information and reset track time information.

Parameters

hit	The hit to add
recoHitInformation	The reco hit information of the hit.

Definition at line 969 of file RecoTrack.h.

    {
      hit->addRelationTo(this);
      addRelationTo(recoHitInformation);
 
      m_isArmTimeComputed = false;
      m_hasIngoingArmTime = false;
      m_hasOutgoingArmTime = false;
      m_outgoingArmTime = NAN;
      m_ingoingArmTime = NAN;
      m_outgoingArmTimeError = NAN;
      m_ingoingArmTimeError = NAN;
 
      setDirtyFlag();
    }

addPXDHit()

bool addPXDHit ( const UsedPXDHit *  pxdHit, const unsigned int  sortingParameter, OriginTrackFinder  foundByTrackFinder = OriginTrackFinder::c_undefinedTrackFinder  )

inline

Adds a pxd hit with the given information to the reco track.

You only have to provide the hit and the sorting parameter, all other parameters have default value.

Parameters

pxdHit	The pointer to a stored PXDHit/Cluster in the store array you provided earlier, which you want to add.
sortingParameter	The index of the hit. It starts with 0 with the first hit.
foundByTrackFinder	Which track finder has found the hit?

Returns

True if the hit was not already added to the track.

Definition at line 258 of file RecoTrack.h.

    {
      return addHit(pxdHit, foundByTrackFinder, sortingParameter);
    }

addRelationTo() [1/2]

void addRelationTo ( const RelationsInterface< BASE > *  object, float  weight = 1.0, const std::string &  namedRelation = ""  ) const

inlineinherited

Add a relation from this object to another object (with caching).

Parameters

object	The object to which the relation should point.
weight	The weight of the relation.
namedRelation	Additional name for the relation, or "" for the default naming

Definition at line 142 of file RelationsObject.h.

    {
      if (object)
        DataStore::Instance().addRelation(this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                          object, object->m_cacheDataStoreEntry, object->m_cacheArrayIndex, weight, namedRelation);
    }

addRelationTo() [2/2]

void addRelationTo ( const TObject *  object, float  weight = 1.0, const std::string &  namedRelation = ""  ) const

inlineinherited

Add a relation from this object to another object (no caching, can be quite slow).

Parameters

object	The object to which the relation should point.
weight	The weight of the relation.
namedRelation	Additional name for the relation, or "" for the default naming

Definition at line 155 of file RelationsObject.h.

    {
      StoreEntry* toEntry = nullptr;
      int toIndex = -1;
      DataStore::Instance().addRelation(this, m_cacheDataStoreEntry, m_cacheArrayIndex, object, toEntry, toIndex, weight, namedRelation);
    }

addSVDHit()

bool addSVDHit ( const UsedSVDHit *  svdHit, const unsigned int  sortingParameter, OriginTrackFinder  foundByTrackFinder = OriginTrackFinder::c_undefinedTrackFinder  )

inline

Adds a svd hit with the given information to the reco track.

You only have to provide the hit and the sorting parameter, all other parameters have default value.

Parameters

svdHit	The pointer to a stored SVDHit in the store array you provided earlier, which you want to add.
sortingParameter	The index of the hit. It starts with 0 with the first hit.
foundByTrackFinder	Which track finder has found the hit?

Returns

True if the hit was not already added to the track.

Definition at line 272 of file RecoTrack.h.

    {
      return addHit(svdHit, foundByTrackFinder, sortingParameter);
    }

checkDirtyFlag()

void checkDirtyFlag ( ) const

inlineprivate

Helper: Check the dirty flag and produce a warning, whenever a fit result is accessed.

Definition at line 1066 of file RecoTrack.h.

    {
      if (m_dirtyFlag) {
        B2DEBUG(100, "Dirty flag is set. The result may not be in sync with the latest changes. Refit the track to be sure.");
      }
    }

copyRelations()

void copyRelations ( const RelationsInterface< BASE > *  sourceObj )

inlineinherited

Copies all relations of sourceObj (pointing from or to sourceObj) to this object (including weights).

Useful if you want to make a complete copy of a StoreArray object to make modifications to it, but retain all information on linked objects.

Note: this only works if sourceObj inherits from the same base (e.g. RelationsObject), and only for related objects that also inherit from the same base.

Definition at line 170 of file RelationsObject.h.

    {
      if (!sourceObj)
        return;
      auto fromRels = sourceObj->getRelationsFrom<RelationsInterface<BASE>>("ALL");
      for (unsigned int iRel = 0; iRel < fromRels.size(); iRel++) {
        fromRels.object(iRel)->addRelationTo(this, fromRels.weight(iRel));
      }
 
      auto toRels = sourceObj->getRelationsTo<RelationsInterface<BASE>>("ALL");
      for (unsigned int iRel = 0; iRel < toRels.size(); iRel++) {
        this->addRelationTo(toRels.object(iRel), toRels.weight(iRel));
      }
    }

copyToStoreArray()

RecoTrack * copyToStoreArray

(

StoreArray< RecoTrack > &

storeArray

)

const

Append a new RecoTrack to the given store array and copy its general properties, but not the hits themself.

The position, momentum and charge are set to the seed values of this reco track, if it was not fitted or to the values at the first hit.

Definition at line 529 of file RecoTrack.cc.

{
  if (wasFitSuccessful()) {
    const auto& mSoP = getMeasuredStateOnPlaneFromFirstHit();
    return copyToStoreArrayUsing(storeArray,
                                 ROOT::Math::XYZVector(mSoP.getPos()),
                                 ROOT::Math::XYZVector(mSoP.getMom()),
                                 static_cast<short>(mSoP.getCharge()),
                                 mSoP.get6DCov(), mSoP.getTime());
  } else {
    return copyToStoreArrayUsingSeeds(storeArray);
  }
}

copyToStoreArrayUsing()

RecoTrack * copyToStoreArrayUsing	(	StoreArray< RecoTrack > &	storeArray,
		const ROOT::Math::XYZVector &	position,
		const ROOT::Math::XYZVector &	momentum,
		short	charge,
		const TMatrixDSym &	covariance,
		double	timeSeed
	)		const

Append a new RecoTrack to the given store array and copy its general properties, but not the hits themself.

The position, momentum, charge etc. are set to the given parameters.

Definition at line 510 of file RecoTrack.cc.

{
  RecoTrack* newRecoTrack = storeArray.appendNew(position, momentum, charge,
                                                 getStoreArrayNameOfPXDHits(), getStoreArrayNameOfSVDHits(), getStoreArrayNameOfCDCHits(),
                                                 getStoreArrayNameOfBKLMHits(), getStoreArrayNameOfEKLMHits(), getStoreArrayNameOfRecoHitInformation());
 
  newRecoTrack->setTimeSeed(timeSeed);
  newRecoTrack->setSeedCovariance(covariance);
 
  return newRecoTrack;
}

copyToStoreArrayUsingSeeds()

RecoTrack * copyToStoreArrayUsingSeeds

(

StoreArray< RecoTrack > &

storeArray

)

const

Append a new RecoTrack to the given store array and copy its general properties, but not the hits themself.

The position, momentum and charge are set to the seed values of this reco track.

Definition at line 524 of file RecoTrack.cc.

{
  return copyToStoreArrayUsing(storeArray, getPositionSeed(), getMomentumSeed(), getChargeSeed(), getSeedCovariance(), getTimeSeed());
}

createFromTrackCand()

RecoTrack * createFromTrackCand ( const genfit::TrackCand &  trackCand, const std::string &  storeArrayNameOfRecoTracks = "", const std::string &  storeArrayNameOfPXDHits = "", const std::string &  storeArrayNameOfSVDHits = "", const std::string &  storeArrayNameOfCDCHits = "", const std::string &  storeArrayNameOfBKLMHits = "", const std::string &  storeArrayNameOfEKLMHits = "", const std::string &  storeArrayNameOfRecoHitInformation = "", const bool  recreateSortingParameters = false  )

static

Create a reco track from a genfit::TrackCand and save it to the given store array.

Parameters

trackCand	The genfit::TrackCand from which to create the new object.
storeArrayNameOfRecoTracks	The store array where the new object should be saved.
storeArrayNameOfPXDHits	The name of the store array where the related PXD hits are stored.
storeArrayNameOfSVDHits	The name of the store array where the related SVD hits are stored.
storeArrayNameOfCDCHits	The name of the store array where the related CDC hits are stored.
storeArrayNameOfBKLMHits	The name of the store array where the related BKLM hits are stored.
storeArrayNameOfEKLMHits	The name of the store array where the related EKLM hits are stored.
storeArrayNameOfRecoHitInformation	The name of the store array where the related hit information are stored.
recreateSortingParameters	The VXDTF does not set the sorting parameters correctly (they are all 0). This flag can be used to recover the parameters.

Returns

The newly created reco track.

Definition at line 97 of file RecoTrack.cc.

{
 
  StoreArray<RecoTrack> recoTracks(storeArrayNameOfRecoTracks);
  StoreArray<RecoHitInformation> recoHitInformations(storeArrayNameOfRecoHitInformation);
  StoreArray<UsedPXDHit> pxdHits(storeArrayNameOfPXDHits);
  StoreArray<UsedSVDHit> svdHits(storeArrayNameOfSVDHits);
  StoreArray<UsedCDCHit> cdcHits(storeArrayNameOfCDCHits);
  StoreArray<UsedBKLMHit> bklmHits(storeArrayNameOfBKLMHits);
  StoreArray<UsedEKLMHit> eklmHits(storeArrayNameOfEKLMHits);
 
  // Set the tracking parameters
  const ROOT::Math::XYZVector& position = ROOT::Math::XYZVector(trackCand.getPosSeed());
  const ROOT::Math::XYZVector& momentum = ROOT::Math::XYZVector(trackCand.getMomSeed());
  const short int charge = trackCand.getChargeSeed();
  const double time = trackCand.getTimeSeed();
 
  RecoTrack* newRecoTrack = recoTracks.appendNew(position, momentum, charge,
                                                 pxdHits.getName(), svdHits.getName(), cdcHits.getName(),
                                                 bklmHits.getName(), eklmHits.getName(),
                                                 recoHitInformations.getName());
  newRecoTrack->setTimeSeed(time);
 
  // TODO Set the covariance seed (that should be done by the tracking package)
  TMatrixDSym covSeed(6);
  covSeed(0, 0) = 1e-3;
  covSeed(1, 1) = 1e-3;
  covSeed(2, 2) = 4e-3;
  covSeed(3, 3) = 0.01e-3;
  covSeed(4, 4) = 0.01e-3;
  covSeed(5, 5) = 0.04e-3;
  newRecoTrack->m_genfitTrack.setCovSeed(covSeed);
 
  for (unsigned int hitIndex = 0; hitIndex < trackCand.getNHits(); hitIndex++) {
    genfit::TrackCandHit* trackCandHit = trackCand.getHit(hitIndex);
    const int detID = trackCandHit->getDetId();
    const int hitID = trackCandHit->getHitId();
    const unsigned int sortingParameter = recreateSortingParameters ? hitIndex : static_cast<unsigned int>
                                          (trackCandHit->getSortingParameter());
    if (detID == Const::CDC) {
      UsedCDCHit* cdcHit = cdcHits[hitID];
      // Special case for CDC hits, we add a right-left information
      const genfit::WireTrackCandHit* wireHit = dynamic_cast<const genfit::WireTrackCandHit*>(trackCandHit);
      if (not wireHit) {
        B2FATAL("CDC hit is not a wire hit. The RecoTrack can not handle such a case.");
      }
      if (wireHit->getLeftRightResolution() > 0) {
        newRecoTrack->addCDCHit(cdcHit, sortingParameter, RecoHitInformation::RightLeftInformation::c_right);
      } else if (wireHit->getLeftRightResolution() < 0) {
        newRecoTrack->addCDCHit(cdcHit, sortingParameter, RecoHitInformation::RightLeftInformation::c_left);
      } else {
        newRecoTrack->addCDCHit(cdcHit, sortingParameter, RecoHitInformation::RightLeftInformation::c_undefinedRightLeftInformation);
      }
 
    } else if (detID == Const::SVD) {
      UsedSVDHit* svdHit = svdHits[hitID];
      newRecoTrack->addSVDHit(svdHit, sortingParameter);
    } else if (detID == Const::PXD) {
      UsedPXDHit* pxdHit = pxdHits[hitID];
      newRecoTrack->addPXDHit(pxdHit, sortingParameter);
    } else if (detID == Const::BKLM) {
      UsedBKLMHit* bklmHit = bklmHits[hitID];
      newRecoTrack->addBKLMHit(bklmHit, sortingParameter);
    } else if (detID == Const::EKLM) {
      UsedEKLMHit* eklmHit = eklmHits[hitID];
      newRecoTrack->addEKLMHit(eklmHit, sortingParameter);
    }
  }
 
  return newRecoTrack;
}

createGenfitTrackCand()

genfit::TrackCand createGenfitTrackCand

(

)

const

Create a genfit::TrackCand out of this reco track and copy all information to the track candidate.

Definition at line 178 of file RecoTrack.cc.

{
  genfit::TrackCand createdTrackCand;
 
  // Set the trajectory parameters
  createdTrackCand.setPosMomSeed(XYZToTVector(getPositionSeed()), XYZToTVector(getMomentumSeed()), getChargeSeed());
  createdTrackCand.setCovSeed(getSeedCovariance());
  createdTrackCand.setTimeSeed(getTimeSeed());
 
  // Add the hits
  mapOnHits<UsedPXDHit>(m_storeArrayNameOfPXDHits, [&createdTrackCand](const RecoHitInformation & hitInformation,
  const UsedPXDHit * const hit) {
    createdTrackCand.addHit(Const::PXD, hit->getArrayIndex(), -1, hitInformation.getSortingParameter());
  });
  mapOnHits<UsedSVDHit>(m_storeArrayNameOfSVDHits, [&createdTrackCand](const RecoHitInformation & hitInformation,
  const UsedSVDHit * const hit) {
    createdTrackCand.addHit(Const::SVD, hit->getArrayIndex(), -1, hitInformation.getSortingParameter());
  });
  mapOnHits<UsedCDCHit>(m_storeArrayNameOfCDCHits, [&createdTrackCand](const RecoHitInformation & hitInformation,
  const UsedCDCHit * const hit) {
    if (hitInformation.getRightLeftInformation() == RecoHitInformation::c_left) {
      createdTrackCand.addHit(new genfit::WireTrackCandHit(Const::CDC, hit->getArrayIndex(), -1,
                                                           hitInformation.getSortingParameter(), -1));
    } else if (hitInformation.getRightLeftInformation() == RecoHitInformation::c_right) {
      createdTrackCand.addHit(new genfit::WireTrackCandHit(Const::CDC, hit->getArrayIndex(), -1,
                                                           hitInformation.getSortingParameter(), 1));
    } else {
      createdTrackCand.addHit(new genfit::WireTrackCandHit(Const::CDC, hit->getArrayIndex(), -1,
                                                           hitInformation.getSortingParameter(), 0));
    }
  });
  mapOnHits<UsedBKLMHit>(m_storeArrayNameOfBKLMHits, [&createdTrackCand](const RecoHitInformation & hitInformation,
  const UsedBKLMHit * const hit) {
    createdTrackCand.addHit(Const::BKLM, hit->getArrayIndex(), -1, hitInformation.getSortingParameter());
  });
  mapOnHits<UsedEKLMHit>(m_storeArrayNameOfEKLMHits, [&createdTrackCand](const RecoHitInformation & hitInformation,
  const UsedEKLMHit * const hit) {
    createdTrackCand.addHit(Const::EKLM, hit->getArrayIndex(), -1, hitInformation.getSortingParameter());
  });
 
  createdTrackCand.sortHits();
 
  // Set the MC Particle
  const MCParticle* relatedMCParticle = getRelatedTo<MCParticle>();
  if (relatedMCParticle) {
    createdTrackCand.setMcTrackId(relatedMCParticle->getArrayIndex());
  }
 
  // Add the hits
  return createdTrackCand;
}

deleteFittedInformation()

void deleteFittedInformation

(

)

Delete all fitted information for all representations.

This function is needed, when you want to start the fitting "from scratch". After this function, a fit will recreate all measurements and fitted information. Please be aware that any pointers will be invalid after that!

Definition at line 462 of file RecoTrack.cc.

{
  // Delete all fitted information for all representations
  for (const genfit::AbsTrackRep* rep : getRepresentations()) {
    deleteFittedInformationForRepresentation(rep);
  }
}

deleteFittedInformationForRepresentation()

void deleteFittedInformationForRepresentation

(

const genfit::AbsTrackRep *

rep

)

Delete all fitted information for the given representations.

This function is needed, when you want to start the fitting "from scratch". After this function, a fit will recreate all measurements and fitted information. Please be aware that any pointers will be invalid after that!

Definition at line 470 of file RecoTrack.cc.

{
  m_genfitTrack.deleteFittedState(rep);
}

estimateArmTime()

void estimateArmTime

(

)

This function calculates the track time of the ingoing and outgoing arms and their difference.

If they do not exists they are set to NAN by default

Definition at line 633 of file RecoTrack.cc.

{
  m_isArmTimeComputed = true;
  const std::vector<RecoHitInformation*>& recoHits = getRecoHitInformations(true);
  bool svdDone = false;
  int nSVDHits = 0;
  static RecoHitInformation::RecoHitDetector und = RecoHitInformation::RecoHitDetector::c_undefinedTrackingDetector;
  RecoHitInformation::RecoHitDetector SVD = RecoHitInformation::RecoHitDetector::c_SVD;
  RecoHitInformation::RecoHitDetector detIDpre = und;
  RecoHitInformation::RecoHitDetector detIDpost = und;
  float clusterTimeSum = 0;
  float clusterTimeSigma2Sum = 0;
  bool trackArmTimeDone = false;
 
  // loop over the recoHits of the RecoTrack
  for (const auto& recoHit : recoHits) {
    RecoHitInformation::RecoHitDetector foundin = recoHit->getTrackingDetector();
    if (!svdDone && foundin != SVD) {
      detIDpre = foundin;
      trackArmTimeDone = false;
    }
    if (foundin == SVD) {
      RelationVector<SVDCluster> svdClusters = recoHit->getRelationsTo<SVDCluster>(m_storeArrayNameOfSVDHits);
      clusterTimeSum += svdClusters[0]->getClsTime();
      clusterTimeSigma2Sum += svdClusters[0]->getClsTimeSigma() * svdClusters[0]->getClsTimeSigma();
      nSVDHits += 1;
      svdDone = true;
    } else {
      // Compute the track arm times using SVD cluster times
      if (svdDone && nSVDHits > 1) {
        detIDpost = foundin;
        if (!isOutgoingArm(detIDpre, detIDpost)) {
          m_ingoingArmTime = clusterTimeSum / nSVDHits;
          m_ingoingArmTimeError = std::sqrt(clusterTimeSigma2Sum / (nSVDHits * (nSVDHits - 1)));
          m_hasIngoingArmTime = true;
          m_nSVDHitsOfIngoingArm = nSVDHits;
        } else {
          m_outgoingArmTime = clusterTimeSum / nSVDHits;
          m_outgoingArmTimeError = std::sqrt(clusterTimeSigma2Sum / (nSVDHits * (nSVDHits - 1)));
          m_hasOutgoingArmTime = true;
          m_nSVDHitsOfOutgoingArm = nSVDHits;
        }
        svdDone = false;
        detIDpre = detIDpost;
        detIDpost = und;
        clusterTimeSum = 0;
        nSVDHits = 0;
        trackArmTimeDone = true;
      }
    }
 
    // When the last recoHit is SVD, it does not enter in the else{} of if (detID == SVD) {...} else {...}
    // where the track arm times are calculated, so they are calculated here.
    // It will not reset all variables because it is run only at the last recoHit
    if (!trackArmTimeDone && (recoHit == recoHits.back()) && nSVDHits > 1) {
      if (!isOutgoingArm(detIDpre, detIDpost)) {
        m_ingoingArmTime = clusterTimeSum / nSVDHits;
        m_ingoingArmTimeError = std::sqrt(clusterTimeSigma2Sum / (nSVDHits * (nSVDHits - 1)));
        m_hasIngoingArmTime = true;
        m_nSVDHitsOfIngoingArm = nSVDHits;
      } else {
        m_outgoingArmTime = clusterTimeSum / nSVDHits;
        m_outgoingArmTimeError = std::sqrt(clusterTimeSigma2Sum / (nSVDHits * (nSVDHits - 1)));
        m_hasOutgoingArmTime = true;
        m_nSVDHitsOfOutgoingArm = nSVDHits;
      }
    }
  }
}

extractTrackState()

std::tuple< ROOT::Math::XYZVector, ROOT::Math::XYZVector, short > extractTrackState

(

)

const

Return the position, the momentum and the charge of the first measured state on plane or - if unfitted - the seeds.

Helper function to get the seed or the measured state on plane from a track.

Definition at line 499 of file RecoTrack.cc.

{
  if (not wasFitSuccessful()) {
    return std::make_tuple(getPositionSeed(), getMomentumSeed(), getChargeSeed());
  } else {
    const auto& measuredStateOnPlane = getMeasuredStateOnPlaneFromFirstHit();
    return std::make_tuple(ROOT::Math::XYZVector(measuredStateOnPlane.getPos()), ROOT::Math::XYZVector(measuredStateOnPlane.getMom()),
                           measuredStateOnPlane.getCharge());
  }
}

flipTrackDirectionAndCharge()

void flipTrackDirectionAndCharge

(

const genfit::AbsTrackRep *

representation = nullptr

)

Flip the direction of the RecoTrack by inverting the momentum vector and the charge.

In addition, also the ingoing and outgoing arms and arm times are swapped.

Parameters

representation

Track representation to be used to get the MeasuredStateOnPlane at the last hit

Definition at line 724 of file RecoTrack.cc.

{
  const genfit::MeasuredStateOnPlane& measuredStateOnPlane = getMeasuredStateOnPlaneFromLastHit(representation);
  const ROOT::Math::XYZVector& fittedPosition = ROOT::Math::XYZVector(measuredStateOnPlane.getPos());
  const ROOT::Math::XYZVector& fittedMomentum = ROOT::Math::XYZVector(measuredStateOnPlane.getMom());
  const double& fittedCharge = measuredStateOnPlane.getCharge();
 
  // revert the charge and momentum
  setChargeSeed(-fittedCharge);
  setPositionAndMomentum(fittedPosition, -fittedMomentum);
  revertRecoHitInformationSorting();
  swapArmTimes();
  setDirtyFlag();
}

get2ndFlipQualityIndicator()

float get2ndFlipQualityIndicator ( ) const

inline

Get the 2nd flipping quality attached to this RecoTrack as a reference for flipping.

Definition at line 864 of file RecoTrack.h.

    {
      return m_2ndFlipqualityIndicator;
    }

getArrayIndex()

int getArrayIndex ( ) const

inlineinherited

Returns this object's array index (in StoreArray), or -1 if not found.

Definition at line 385 of file RelationsObject.h.

    {
      DataStore::Instance().findStoreEntry(this, m_cacheDataStoreEntry, m_cacheArrayIndex);
      return m_cacheArrayIndex;
    }

getArrayName()

std::string getArrayName ( ) const

inlineinherited

Get name of array this object is stored in, or "" if not found.

Definition at line 377 of file RelationsObject.h.

    {
      DataStore::Instance().findStoreEntry(this, m_cacheDataStoreEntry, m_cacheArrayIndex);
      return m_cacheDataStoreEntry ? m_cacheDataStoreEntry->name : "";
    }

getArrayPointer()

TClonesArray * getArrayPointer ( ) const

inlineprotectedinherited

Returns the pointer to the raw DataStore array holding this object (protected since these arrays are easy to misuse).

Definition at line 418 of file RelationsObject.h.

    {
      DataStore::Instance().findStoreEntry(this, m_cacheDataStoreEntry, m_cacheArrayIndex);
      if (!m_cacheDataStoreEntry)
        return nullptr;
      return m_cacheDataStoreEntry->getPtrAsArray();
    }

getBKLMHitList()

std::vector< Belle2::RecoTrack::UsedBKLMHit * > getBKLMHitList ( ) const

inline

Return an unsorted list of bklm hits.

Definition at line 458 of file RecoTrack.h.

{ return getHitList<UsedBKLMHit>(m_storeArrayNameOfBKLMHits); }

getCardinalRepresentation()

genfit::AbsTrackRep * getCardinalRepresentation ( ) const

inline

Get a pointer to the cardinal track representation. You are not allowed to modify or delete it!

Definition at line 631 of file RecoTrack.h.

    {
      checkDirtyFlag();
      return m_genfitTrack.getCardinalRep();
    }

getCDCHitList()

std::vector< Belle2::RecoTrack::UsedCDCHit * > getCDCHitList ( ) const

inline

Return an unsorted list of cdc hits.

Definition at line 455 of file RecoTrack.h.

{ return getHitList<UsedCDCHit>(m_storeArrayNameOfCDCHits); }

getChargeSeed()

short int getChargeSeed ( ) const

inline

Return the charge seed stored in the reco track. ATTENTION: This is not the fitted charge.

Definition at line 508 of file RecoTrack.h.

{ return m_charge; }

getCreatedTrackPoint()

const genfit::TrackPoint * getCreatedTrackPoint

(

const RecoHitInformation *

recoHitInformation

)

const

Get a pointer to the TrackPoint that was created from this hit.

Can be a nullptr if no measurement was already created. Please be aware that refitting may or may not recreate the track points and older pointers can be invalidated. Also, pruning a RecoTrack will also delete most of the TrackPoints.

Definition at line 230 of file RecoTrack.cc.

{
  int createdTrackPointID = recoHitInformation->getCreatedTrackPointID();
  if (createdTrackPointID == -1) {
    return nullptr;
  }
 
  return m_genfitTrack.getPoint(createdTrackPointID);
}

getDirtyFlag()

bool getDirtyFlag ( ) const

inline

This returns true, if a hit was added after the last fit and measurement creation and a refit should be done.

Definition at line 715 of file RecoTrack.h.

{ return m_dirtyFlag; }

getEKLMHitList()

std::vector< Belle2::RecoTrack::UsedEKLMHit * > getEKLMHitList ( ) const

inline

Return an unsorted list of eklm hits.

Definition at line 461 of file RecoTrack.h.

{ return getHitList<UsedEKLMHit>(m_storeArrayNameOfEKLMHits); }

getFlipQualityIndicator()

float getFlipQualityIndicator ( ) const

inline

Get the 1st flipping quality attached to this RecoTrack as a reference for flipping.

Definition at line 853 of file RecoTrack.h.

    {
      return m_flipqualityIndicator;
    }

getFoundByTrackFinder()

OriginTrackFinder getFoundByTrackFinder ( const HitType *  hit ) const

inline

Return the found by track finder flag for the given hit (every type) or throws an exception of the hit is not related to the track.

Definition at line 347 of file RecoTrack.h.

    {
      RecoHitInformation* recoHitInformation = getRecoHitInformationSafely(hit);
      return recoHitInformation->getFoundByTrackFinder();
    }

getGenfitTrack()

const genfit::Track & getGenfitTrack ( ) const

inline

Returns genfit track.

const casting of the return reference is forbidden! If you need to modify genfit track, please use RecoTrackGenfitAccess::getGenfitTrack(RecoTrack& recoTrack).

Returns

const reference to genfit track

Definition at line 505 of file RecoTrack.h.

{return m_genfitTrack;}

getHitList()

std::vector< HitType * > getHitList ( const std::string &  storeArrayNameOfHits ) const

inlineprivate

Return an unsorted list of hits of the given type in the store array that are related to this track.

Parameters

storeArrayNameOfHits

The StoreArray to look for.

Definition at line 1044 of file RecoTrack.h.

    {
      RelationVector<HitType> relatedHits = getRelationsFrom<HitType>(storeArrayNameOfHits);
      std::vector<HitType*> hitList;
      hitList.reserve(relatedHits.size());
      for (HitType& hit : relatedHits) {
        // cppcheck-suppress useStlAlgorithm
        hitList.push_back(&hit);
      }
      // cppcheck-suppress returnDanglingLifetime
      return hitList;
    }

getHitPointsWithMeasurement()

const std::vector< genfit::TrackPoint * > & getHitPointsWithMeasurement ( ) const

inline

Return a list of measurements and track points, which can be used e.g. to extrapolate. You are not allowed to modify or delete them!

Definition at line 708 of file RecoTrack.h.

    {
      checkDirtyFlag();
      return m_genfitTrack.getPointsWithMeasurement();
    }

getInfo()

std::string getInfo ( ) const

inlineinherited

Return a short summary of this object's contents in raw text format.

Returns the contents of getInfoHTML() while translating line-breaks etc.

Note

: You don't need to implement this function (it's not virtual), getInfoHTML() is enough.

Definition at line 370 of file RelationsObject.h.

    {
      return _RelationsInterfaceImpl::htmlToPlainText(getInfoHTML());
    }

getInfoHTML()

std::string getInfoHTML ( ) const

overridevirtual

Get useful information on EventDisplay.

Reimplemented from RelationsInterface< BASE >.

Definition at line 739 of file RecoTrack.cc.

{
  std::stringstream out;
 
  out << "<b>Charge seed</b>=" << getChargeSeed();
 
  out << "<b>pT seed</b>=" << getMomentumSeed().Rho();
  out << ", <b>pZ seed</b>=" << getMomentumSeed().Z();
  out << "<br>";
  out << "<b>position seed</b>=" << getMomentumSeed().X() << ", " << getMomentumSeed().Y() << ", " << getMomentumSeed().Z();
  out << "<br>";
 
  for (const genfit::AbsTrackRep* rep : getRepresentations()) {
    out << "<b>was fitted with " << rep->getPDG() << "</b>=" << wasFitSuccessful() << ", ";
  }
  out << "<br>";
 
  return out.str();
}

getIngoingArmTime()

float getIngoingArmTime ( )

inline

Return the track time of the ingoing arm.

Definition at line 528 of file RecoTrack.h.

    {
      if (!m_isArmTimeComputed) estimateArmTime();
      return m_ingoingArmTime;
    }

getIngoingArmTimeError()

float getIngoingArmTimeError ( )

inline

Return the error of the track time of the ingoing arm.

Definition at line 535 of file RecoTrack.h.

    {
      if (!m_isArmTimeComputed) estimateArmTime();
      return m_ingoingArmTimeError;
    }

getInOutArmTimeDifference()

float getInOutArmTimeDifference ( )

inline

Return the difference between the track times of the ingoing and outgoing arms.

Definition at line 542 of file RecoTrack.h.

    {
      if (!m_isArmTimeComputed) estimateArmTime();
      return m_ingoingArmTime - m_outgoingArmTime;
    }

getInOutArmTimeDifferenceError()

float getInOutArmTimeDifferenceError ( )

inline

Return the error of the difference between the track times of the ingoing and outgoing arms.

Definition at line 549 of file RecoTrack.h.

    {
      if (!m_isArmTimeComputed) estimateArmTime();
      return std::sqrt(m_ingoingArmTimeError * m_ingoingArmTimeError + m_outgoingArmTimeError *
                       m_outgoingArmTimeError);
    }

getMatchingStatus()

MatchingStatus getMatchingStatus ( ) const

inline

Return the matching status set by the TrackMatcher module.

Definition at line 829 of file RecoTrack.h.

    {
      return m_matchingStatus;
    }

getMeasuredStateOnPlaneClosestTo()

const genfit::MeasuredStateOnPlane & getMeasuredStateOnPlaneClosestTo	(	const ROOT::Math::XYZVector &	closestPoint,
		const genfit::AbsTrackRep *	representation = nullptr
	)

Return genfit's MasuredStateOnPlane, that is closest to the given point useful for extrapolation of measurements other locations.

Definition at line 426 of file RecoTrack.cc.

{
  checkDirtyFlag();
  const unsigned int numberOfPoints = m_genfitTrack.getNumPointsWithMeasurement();
 
  assert(numberOfPoints > 0);
 
  const genfit::MeasuredStateOnPlane* nearestStateOnPlane = nullptr;
  double minimalDistance2 = 0;
  for (unsigned int hitIndex = 0; hitIndex < numberOfPoints; hitIndex++) {
    try {
      const genfit::MeasuredStateOnPlane& measuredStateOnPlane = m_genfitTrack.getFittedState(hitIndex, representation);
 
      const double currentDistance2 = (ROOT::Math::XYZVector(measuredStateOnPlane.getPos()) - closestPoint).Mag2();
 
      if (not nearestStateOnPlane or currentDistance2 < minimalDistance2) {
        nearestStateOnPlane = &measuredStateOnPlane;
        minimalDistance2 = currentDistance2;
      }
    } catch (const genfit::Exception& exception) {
      B2DEBUG(50, "Can not get mSoP because of: " << exception.what());
      continue;
    }
  }
 
  // catch case no hit has measured state on plane (not sure how likely that is) which would lead to undefined behavior
  if (not nearestStateOnPlane) {
    B2WARNING("Non of the track hits had a MeasuredStateOnPlane! Exception thrown.");
    throw  NoStateOnPlaneFound();
  }
 
  return *nearestStateOnPlane;
}

getMeasuredStateOnPlaneFromFirstHit()

const genfit::MeasuredStateOnPlane & getMeasuredStateOnPlaneFromFirstHit

(

const genfit::AbsTrackRep *

representation = nullptr

)

const

Return genfit's MeasuredStateOnPlane for the first hit in a fit useful for extrapolation of measurements to other locations Const version.

Definition at line 605 of file RecoTrack.cc.

{
  const unsigned int trackSize = m_genfitTrack.getNumPoints();
  for (unsigned int i = 0; i < trackSize; i++) {
    try {
      return m_genfitTrack.getFittedState(i, representation);
    } catch (const genfit::Exception& exception) {
      B2DEBUG(28, "Can not get mSoP because of: " << exception.what());
    }
  }
 
  B2FATAL("There is no single hit with a valid mSoP in this track! Check if the fit failed with wasFitSuccessful before");
}

getMeasuredStateOnPlaneFromLastHit()

const genfit::MeasuredStateOnPlane & getMeasuredStateOnPlaneFromLastHit

(

const genfit::AbsTrackRep *

representation = nullptr

)

const

Return genfit's MeasuredStateOnPlane for the last hit in a fit useful for extrapolation of measurements to other locations Const version.

Definition at line 619 of file RecoTrack.cc.

{
  int trackSize = m_genfitTrack.getNumPoints();
  for (int i = -1; i >= -trackSize; i--) {
    try {
      return m_genfitTrack.getFittedState(i, representation);
    } catch (const genfit::Exception& exception) {
      B2DEBUG(28, "Can not get mSoP because of: " << exception.what());
    }
  }
 
  B2FATAL("There is no single hit with a valid mSoP in this track!");
}

getMeasuredStateOnPlaneFromRecoHit()

const genfit::MeasuredStateOnPlane & getMeasuredStateOnPlaneFromRecoHit	(	const RecoHitInformation *	recoHitInfo,
		const genfit::AbsTrackRep *	representation = nullptr
	)		const

Return genfit's MeasuredStateOnPlane on plane for associated with one RecoHitInformation.

The caller needs to ensure that recoHitInfo->useInFit() is true and the a fit has been performed on the track, a.k.a. hasTrackFitStatus() == true

Definition at line 579 of file RecoTrack.cc.

{
  checkDirtyFlag();
 
  if (!hasTrackFitStatus(representation)) {
    B2FATAL("MeasuredStateOnPlane can not be retrieved for RecoTracks where no fit has been attempted.");
  }
 
  if (!recoHitInfo->useInFit()) {
    B2FATAL("MeasuredStateOnPlane cannot be provided for RecoHit which was not used in the fit.");
  }
 
  const auto* hitTrackPoint = getCreatedTrackPoint(recoHitInfo);
  if (not hitTrackPoint) {
    B2FATAL("TrackPoint was requested which has not been created");
  }
 
  const auto* fittedResult = hitTrackPoint->getFitterInfo(representation);
  if (not fittedResult) {
    throw NoTrackFitResult();
  }
 
  return fittedResult->getFittedState();
}

getMomentumSeed()

ROOT::Math::XYZVector getMomentumSeed ( ) const

inline

Return the momentum seed stored in the reco track. ATTENTION: This is not the fitted momentum.

Definition at line 487 of file RecoTrack.h.

    {
      const TVectorD& seed = m_genfitTrack.getStateSeed();
      return ROOT::Math::XYZVector(seed(3), seed(4), seed(5));
    }

getName()

virtual std::string getName ( ) const

inlinevirtualinherited

Return a short name that describes this object, e.g.

pi+ for an MCParticle.

Reimplemented in Particle, MCParticle, and SpacePoint.

Definition at line 344 of file RelationsObject.h.

{ return ""; }

getNSVDHitsOfIngoingArm()

int getNSVDHitsOfIngoingArm ( )

inline

Return the number of clusters used to estimate the ingoing arm time.

Definition at line 575 of file RecoTrack.h.

    {
      return m_nSVDHitsOfIngoingArm;
    }

getNSVDHitsOfOutgoingArm()

int getNSVDHitsOfOutgoingArm ( )

inline

Return the number of clusters used to estimate the outgoing arm time.

Definition at line 569 of file RecoTrack.h.

    {
      return m_nSVDHitsOfOutgoingArm;
    }

getNumberOfBKLMHits()

unsigned int getNumberOfBKLMHits ( ) const

inline

Return the number of bklm hits.

Definition at line 430 of file RecoTrack.h.

{ return getNumberOfHitsOfGivenType<UsedBKLMHit>(m_storeArrayNameOfBKLMHits); }

getNumberOfCDCHits()

unsigned int getNumberOfCDCHits ( ) const

inline

Return the number of cdc hits.

Definition at line 427 of file RecoTrack.h.

{ return getNumberOfHitsOfGivenType<UsedCDCHit>(m_storeArrayNameOfCDCHits); }

getNumberOfEKLMHits()

unsigned int getNumberOfEKLMHits ( ) const

inline

Return the number of eklm hits.

Definition at line 433 of file RecoTrack.h.

{ return getNumberOfHitsOfGivenType<UsedEKLMHit>(m_storeArrayNameOfEKLMHits); }

getNumberOfHitsOfGivenType()

unsigned int getNumberOfHitsOfGivenType ( const std::string &  storeArrayNameOfHits ) const

inlineprivate

Get the number of hits for the given hit type in the store array that are related to this track.

Parameters

storeArrayNameOfHits

The StoreArray to look for.

Definition at line 1002 of file RecoTrack.h.

    {
      return getRelationsFrom<HitType>(storeArrayNameOfHits).size();
    }

getNumberOfPXDHits()

unsigned int getNumberOfPXDHits ( ) const

inline

Return the number of pxd hits.

Definition at line 421 of file RecoTrack.h.

{ return getNumberOfHitsOfGivenType<UsedPXDHit>(m_storeArrayNameOfPXDHits); }

getNumberOfSVDHits()

unsigned int getNumberOfSVDHits ( ) const

inline

Return the number of svd hits.

Definition at line 424 of file RecoTrack.h.

{ return getNumberOfHitsOfGivenType<UsedSVDHit>(m_storeArrayNameOfSVDHits); }

getNumberOfTotalHits()

unsigned int getNumberOfTotalHits ( ) const

inline

Return the number of cdc + svd + pxd + bklm + eklm hits.

Definition at line 436 of file RecoTrack.h.

    {
      return getNumberOfPXDHits() + getNumberOfSVDHits() + getNumberOfCDCHits() +
             getNumberOfBKLMHits() + getNumberOfEKLMHits();
    }

getNumberOfTrackingHits()

unsigned int getNumberOfTrackingHits ( ) const

inline

Return the number of cdc + svd + pxd hits.

Definition at line 443 of file RecoTrack.h.

    {
      return getNumberOfPXDHits() + getNumberOfSVDHits() + getNumberOfCDCHits();
    }

getOutgoingArmTime()

float getOutgoingArmTime ( )

inline

Return the track time of the outgoing arm.

Definition at line 514 of file RecoTrack.h.

    {
      if (!m_isArmTimeComputed) estimateArmTime();
      return m_outgoingArmTime;
    }

getOutgoingArmTimeError()

float getOutgoingArmTimeError ( )

inline

Return the error of the track time of the outgoing arm.

Definition at line 521 of file RecoTrack.h.

    {
      if (!m_isArmTimeComputed) estimateArmTime();
      return m_outgoingArmTimeError;
    }

getPositionSeed()

ROOT::Math::XYZVector getPositionSeed ( ) const

inline

Return the position seed stored in the reco track. ATTENTION: This is not the fitted position.

Definition at line 480 of file RecoTrack.h.

    {
      const TVectorD& seed = m_genfitTrack.getStateSeed();
      return ROOT::Math::XYZVector(seed(0), seed(1), seed(2));
    }

getPXDHitList()

std::vector< Belle2::RecoTrack::UsedPXDHit * > getPXDHitList ( ) const

inline

Return an unsorted list of pxd hits.

Definition at line 449 of file RecoTrack.h.

{ return getHitList<UsedPXDHit>(m_storeArrayNameOfPXDHits); }

getQualityIndicator()

float getQualityIndicator ( ) const

inline

Get the quality index attached to this RecoTrack given by one of the reconstruction algorithms. 0 means likely fake.

Definition at line 841 of file RecoTrack.h.

    {
      return m_qualityIndicator;
    }

getRecoHitInformation()

RecoHitInformation * getRecoHitInformation ( HitType *  hit ) const

inline

Return the reco hit information for a generic hit from the storeArray.

Parameters

hit	the hit to look for.

Returns

The connected RecoHitInformation or a nullptr when the hit is not connected to the track.

Definition at line 312 of file RecoTrack.h.

    {
      RelationVector<RecoHitInformation> relatedHitInformationToHit = hit->template getRelationsFrom<RecoHitInformation>
      (m_storeArrayNameOfRecoHitInformation);
 
      for (RecoHitInformation& recoHitInformation : relatedHitInformationToHit) {
        // cppcheck-suppress useStlAlgorithm
        if (recoHitInformation.getRelatedFrom<RecoTrack>(this->getArrayName()) == this) {
          // cppcheck-suppress returnDanglingLifetime
          return &recoHitInformation;
        }
      }
 
      return nullptr;
    }

getRecoHitInformations()

std::vector< RecoHitInformation * > getRecoHitInformations

(

bool

getSorted = false

)

const

Return a list of all RecoHitInformations associated with the RecoTrack.

This is especially useful when you want to iterate over all (fitted) hits in a track without caring whether its a CDC, VXD etc hit.

Parameters

getSorted

if true, the list of RecoHitInformations will be returned sorted by the Sorting parameter in an ascending order. If false, the hits will be returned unsorted.

Definition at line 557 of file RecoTrack.cc.

{
  std::vector<RecoHitInformation*> hitList;
  RelationVector<RecoHitInformation> recoHitInformations = getRelationsTo<RecoHitInformation>
                                                           (m_storeArrayNameOfRecoHitInformation);
 
  hitList.reserve(recoHitInformations.size());
  for (auto& recoHit : recoHitInformations) {
    hitList.push_back(&recoHit);
  }
 
  // sort the returned vector if requested
  if (getSorted) {
    std::sort(hitList.begin(), hitList.end(), [](const RecoHitInformation * a,
    const RecoHitInformation * b) -> bool {
      return a->getSortingParameter() < b->getSortingParameter();
    });
  }
 
  return hitList;
}

getRecoHitInformationSafely()

RecoHitInformation * getRecoHitInformationSafely ( HitType *  hit ) const

inlineprivate

Returns the reco hit information for a given hit or throws an exception if the hit is not related to the track.

Definition at line 987 of file RecoTrack.h.

    {
      RecoHitInformation* recoHitInformation = getRecoHitInformation(hit);
      if (recoHitInformation == nullptr) {
        B2FATAL("Queried hit is not in the reco track! Did you prune it?");
      } else {
        return recoHitInformation;
      }
    }

getRelated()

T * getRelated ( const std::string &  name = "", const std::string &  namedRelation = ""  ) const

inlineinherited

Get the object to or from which this object has a relation.

Template Parameters

T	The class of objects to or from which the relation points.

Parameters

name	The name of the store array to or from which the relation points. If empty the default store array name for class T will be used. If the special name "ALL" is given all store arrays containing objects of type T are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns

The first related object or a null pointer.

Definition at line 278 of file RelationsObject.h.

    {
      return static_cast<T*>(DataStore::Instance().getRelationWith(DataStore::c_BothSides, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                             T::Class(), name, namedRelation).object);
    }

getRelatedFrom()

FROM * getRelatedFrom ( const std::string &  name = "", const std::string &  namedRelation = ""  ) const

inlineinherited

Get the object from which this object has a relation.

Template Parameters

FROM	The class of objects from which the relation points.

Parameters

name	The name of the store array from which the relation points. If empty the default store array name for class FROM will be used. If the special name "ALL" is given all store arrays containing objects of type FROM are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns

The first related object or a null pointer.

Definition at line 263 of file RelationsObject.h.

    {
      return static_cast<FROM*>(DataStore::Instance().getRelationWith(DataStore::c_FromSide, this, m_cacheDataStoreEntry,
                                m_cacheArrayIndex, FROM::Class(), name, namedRelation).object);
    }

getRelatedFromWithWeight()

std::pair< FROM *, float > getRelatedFromWithWeight ( const std::string &  name = "", const std::string &  namedRelation = ""  ) const

inlineinherited

Get first related object & weight of relation pointing from an array.

Template Parameters

FROM	The class of objects from which the relation points.

Parameters

name	The name of the store array from which the relation points. If empty the default store array name for class FROM will be used. If the special name "ALL" is given all store arrays containing objects of type FROM are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns

Pair of first related object and the relation weight, or (NULL, 1.0) if none found.

Definition at line 314 of file RelationsObject.h.

    {
      RelationEntry entry = DataStore::Instance().getRelationWith(DataStore::c_FromSide, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                                                  FROM::Class(), name, namedRelation);
      return std::make_pair(static_cast<FROM*>(entry.object), entry.weight);
    }

getRelatedTo()

TO * getRelatedTo ( const std::string &  name = "", const std::string &  namedRelation = ""  ) const

inlineinherited

Get the object to which this object has a relation.

Template Parameters

TO	The class of objects to which the relation points.

Parameters

name	The name of the store array to which the relation points. If empty the default store array name for class TO will be used. If the special name "ALL" is given all store arrays containing objects of type TO are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns

The first related object or a null pointer.

Definition at line 248 of file RelationsObject.h.

    {
      return static_cast<TO*>(DataStore::Instance().getRelationWith(DataStore::c_ToSide, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                              TO::Class(), name, namedRelation).object);
    }

getRelatedToWithWeight()

std::pair< TO *, float > getRelatedToWithWeight ( const std::string &  name = "", const std::string &  namedRelation = ""  ) const

inlineinherited

Get first related object & weight of relation pointing to an array.

Template Parameters

TO	The class of objects to which the relation points.

Parameters

name	The name of the store array to which the relation points. If empty the default store array name for class TO will be used. If the special name "ALL" is given all store arrays containing objects of type TO are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns

Pair of first related object and the relation weight, or (NULL, 1.0) if none found.

Definition at line 297 of file RelationsObject.h.

    {
      RelationEntry entry = DataStore::Instance().getRelationWith(DataStore::c_ToSide, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                                                  TO::Class(), name, namedRelation);
      return std::make_pair(static_cast<TO*>(entry.object), entry.weight);
    }

getRelatedWithWeight()

std::pair< T *, float > getRelatedWithWeight ( const std::string &  name = "", const std::string &  namedRelation = ""  ) const

inlineinherited

Get first related object & weight of relation pointing from/to an array.

Template Parameters

T	The class of objects to or from which the relation points.

Parameters

name	The name of the store array to or from which the relation points. If empty the default store array name for class T will be used. If the special name "ALL" is given all store arrays containing objects of type T are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns

Pair of first related object and the relation weight, or (NULL, 1.0) if none found.

Definition at line 331 of file RelationsObject.h.

    {
      RelationEntry entry = DataStore::Instance().getRelationWith(DataStore::c_BothSides, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                                                  T::Class(), name, namedRelation);
      return std::make_pair(static_cast<T*>(entry.object), entry.weight);
    }

getRelationsFrom()

RelationVector< FROM > getRelationsFrom ( const std::string &  name = "", const std::string &  namedRelation = ""  ) const

inlineinherited

Get the relations that point from another store array to this object.

Template Parameters

FROM	The class of objects from which the relations point.

Parameters

name	The name of the store array from which the relations point. If empty the default store array name for class FROM will be used. If the special name "ALL" is given all store arrays containing objects of type FROM are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns

A vector of relations.

Definition at line 212 of file RelationsObject.h.

    {
      return RelationVector<FROM>(DataStore::Instance().getRelationsWith(DataStore::c_FromSide, this, m_cacheDataStoreEntry,
                                  m_cacheArrayIndex, FROM::Class(), name, namedRelation));
    }

getRelationsTo()

RelationVector< TO > getRelationsTo ( const std::string &  name = "", const std::string &  namedRelation = ""  ) const

inlineinherited

Get the relations that point from this object to another store array.

Template Parameters

TO	The class of objects to which the relations point.

Parameters

name	The name of the store array to which the relations point. If empty the default store array name for class TO will be used. If the special name "ALL" is given all store arrays containing objects of type TO are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns

A vector of relations.

Definition at line 197 of file RelationsObject.h.

    {
      return RelationVector<TO>(DataStore::Instance().getRelationsWith(DataStore::c_ToSide, this, m_cacheDataStoreEntry,
                                m_cacheArrayIndex, TO::Class(), name, namedRelation));
    }

getRelationsWith()

RelationVector< T > getRelationsWith ( const std::string &  name = "", const std::string &  namedRelation = ""  ) const

inlineinherited

Get the relations between this object and another store array.

Relations in both directions are returned.

Template Parameters

T	The class of objects to or from which the relations point.

Parameters

name	The name of the store array to or from which the relations point. If empty the default store array name for class T will be used. If the special name "ALL" is given all store arrays containing objects of type T are considered.
namedRelation	Additional name for the relation, or "" for the default naming

Returns

A vector of relations.

Definition at line 230 of file RelationsObject.h.

    {
      return RelationVector<T>(DataStore::Instance().getRelationsWith(DataStore::c_BothSides, this, m_cacheDataStoreEntry,
                               m_cacheArrayIndex, T::Class(), name, namedRelation));
    }

getRepresentations()

const std::vector< genfit::AbsTrackRep * > & getRepresentations ( ) const

inline

Return a list of track representations. You are not allowed to modify or delete them!

Definition at line 638 of file RecoTrack.h.

    {
      checkDirtyFlag();
      return m_genfitTrack.getTrackReps();
    }

getRightLeftInformation()

RightLeftInformation getRightLeftInformation ( const HitType *  hit ) const

inline

Return the right left information of a given hit (every type) or throws an exception of the hit is not related to the track.

Definition at line 339 of file RecoTrack.h.

    {
      RecoHitInformation* recoHitInformation = getRecoHitInformationSafely(hit);
      return recoHitInformation->getRightLeftInformation();
    }

getSeedCovariance()

const TMatrixDSym & getSeedCovariance ( ) const

inline

Return the covariance matrix of the seed. ATTENTION: This is not the fitted covariance.

Definition at line 611 of file RecoTrack.h.

{ return m_genfitTrack.getCovSeed(); }

getSortedBKLMHitList()

std::vector< Belle2::RecoTrack::UsedBKLMHit * > getSortedBKLMHitList ( ) const

inline

Return a sorted list of bklm hits. Sorted by the sortingParameter.

Definition at line 473 of file RecoTrack.h.

{ return getSortedHitList<UsedBKLMHit>(m_storeArrayNameOfBKLMHits); }

getSortedCDCHitList()

std::vector< Belle2::RecoTrack::UsedCDCHit * > getSortedCDCHitList ( ) const

inline

Return a sorted list of cdc hits. Sorted by the sortingParameter.

Definition at line 470 of file RecoTrack.h.

{ return getSortedHitList<UsedCDCHit>(m_storeArrayNameOfCDCHits); }

getSortedEKLMHitList()

std::vector< Belle2::RecoTrack::UsedEKLMHit * > getSortedEKLMHitList ( ) const

inline

Return a sorted list of eklm hits. Sorted by the sortingParameter.

Definition at line 476 of file RecoTrack.h.

{ return getSortedHitList<UsedEKLMHit>(m_storeArrayNameOfEKLMHits); }

getSortedHitList()

std::vector< HitType * > getSortedHitList ( const std::string &  storeArrayNameOfHits ) const

inlineprivate

Return a sorted list of hits of the given type in the store array that are related to this track.

Parameters

storeArrayNameOfHits

The StoreArray to look for.

Definition at line 1012 of file RecoTrack.h.

    {
      const RelationVector<RecoHitInformation>& relatedHitInformation = getRelationsTo<RecoHitInformation>
          (m_storeArrayNameOfRecoHitInformation);
 
      std::vector<const RecoHitInformation*> relatedHitInformationAsVector;
      relatedHitInformationAsVector.reserve(relatedHitInformation.size());
      for (const RecoHitInformation& hitInformation : relatedHitInformation) {
        // cppcheck-suppress useStlAlgorithm
        relatedHitInformationAsVector.push_back(&hitInformation);
      }
      std::sort(relatedHitInformationAsVector.begin(), relatedHitInformationAsVector.end(), [](const RecoHitInformation * a,
      const RecoHitInformation * b) -> bool {
        return a->getSortingParameter() < b->getSortingParameter();
      });
 
      std::vector<HitType*> hitList;
      hitList.reserve(relatedHitInformationAsVector.size());
      for (const RecoHitInformation* hitInformation : relatedHitInformationAsVector) {
        HitType* relatedHit = hitInformation->getRelatedTo<HitType>(storeArrayNameOfHits);
        if (relatedHit != nullptr) {
          hitList.push_back(relatedHit);
        }
      }
      return hitList;
    }

getSortedPXDHitList()

std::vector< Belle2::RecoTrack::UsedPXDHit * > getSortedPXDHitList ( ) const

inline

Return a sorted list of pxd hits. Sorted by the sortingParameter.

Definition at line 464 of file RecoTrack.h.

{ return getSortedHitList<UsedPXDHit>(m_storeArrayNameOfPXDHits); }

getSortedSVDHitList()

std::vector< Belle2::RecoTrack::UsedSVDHit * > getSortedSVDHitList ( ) const

inline

Return a sorted list of svd hits. Sorted by the sortingParameter.

Definition at line 467 of file RecoTrack.h.

{ return getSortedHitList<UsedSVDHit>(m_storeArrayNameOfSVDHits); }

getSortingParameter()

unsigned int getSortingParameter ( const HitType *  hit ) const

inline

Return the sorting parameter for a given hit (every type) or throws an exception of the hit is not related to the track.

Definition at line 355 of file RecoTrack.h.

    {
      RecoHitInformation* recoHitInformation = getRecoHitInformationSafely(hit);
      return recoHitInformation->getSortingParameter();
    }

getStateSeed()

const TVectorD & getStateSeed ( ) const

inline

Return the state seed in the form posX, posY, posZ, momX, momY, momZ. ATTENTION: This is not the fitted state.

Definition at line 494 of file RecoTrack.h.

    {
      return m_genfitTrack.getStateSeed();
    }

getStoreArrayNameOfBKLMHits()

const std::string & getStoreArrayNameOfBKLMHits ( ) const

inline

Name of the store array of the bklm hits.

Definition at line 741 of file RecoTrack.h.

{ return m_storeArrayNameOfBKLMHits; }

getStoreArrayNameOfCDCHits()

const std::string & getStoreArrayNameOfCDCHits ( ) const

inline

Name of the store array of the cdc hits.

Definition at line 738 of file RecoTrack.h.

{ return m_storeArrayNameOfCDCHits; }

getStoreArrayNameOfEKLMHits()

const std::string & getStoreArrayNameOfEKLMHits ( ) const

inline

Name of the store array of the eklm hits.

Definition at line 744 of file RecoTrack.h.

{ return m_storeArrayNameOfEKLMHits; }

getStoreArrayNameOfPXDHits()

const std::string & getStoreArrayNameOfPXDHits ( ) const

inline

Name of the store array of the pxd hits.

Definition at line 732 of file RecoTrack.h.

{ return m_storeArrayNameOfPXDHits; }

getStoreArrayNameOfRecoHitInformation()

const std::string & getStoreArrayNameOfRecoHitInformation ( ) const

inline

Name of the store array of the reco hit information.

Definition at line 747 of file RecoTrack.h.

{ return m_storeArrayNameOfRecoHitInformation; }

getStoreArrayNameOfSVDHits()

const std::string & getStoreArrayNameOfSVDHits ( ) const

inline

Name of the store array of the svd hits.

Definition at line 735 of file RecoTrack.h.

{ return m_storeArrayNameOfSVDHits; }

getSVDHitList()

std::vector< Belle2::RecoTrack::UsedSVDHit * > getSVDHitList ( ) const

inline

Return an unsorted list of svd hits.

Definition at line 452 of file RecoTrack.h.

{ return getHitList<UsedSVDHit>(m_storeArrayNameOfSVDHits); }

getTimeSeed()

double getTimeSeed ( ) const

inline

Return the time seed stored in the reco track. ATTENTION: This is not the fitted time.

Definition at line 511 of file RecoTrack.h.

{ return m_genfitTrack.getTimeSeed(); }

getTrackFitStatus()

const genfit::FitStatus * getTrackFitStatus ( const genfit::AbsTrackRep *  representation = nullptr ) const

inline

Return the track fit status for the given representation or for the cardinal one. You are not allowed to modify or delete it!

Definition at line 621 of file RecoTrack.h.

    {
      checkDirtyFlag();
      return m_genfitTrack.getFitStatus(representation);
    }

getTrackingDetector()

TrackingDetector getTrackingDetector ( const HitType *  hit ) const

inline

Return the tracking detector of a given hit (every type) or throws an exception of the hit is not related to the track.

Definition at line 331 of file RecoTrack.h.

    {
      RecoHitInformation* recoHitInformation = getRecoHitInformationSafely(hit);
      return recoHitInformation->getTrackingDetector();
    }

getTrackRepresentationForPDG()

genfit::AbsTrackRep * getTrackRepresentationForPDG

(

int

pdgCode

)

const

Return an already created track representation of the given reco track for the PDG.

You are not allowed to modify this TrackRep! Will return nulltpr if a trackRep is not available for the given pdgCode.

Parameters

pdgCode

PDG code of the track representations, only positive PDG numbers are allowed

Definition at line 475 of file RecoTrack.cc.

{
  if (pdgCode < 0) {
    B2FATAL("Only positive pdgCode is possible when calling getTrackRepresentationForPDG, got " << pdgCode);
  }
 
  const std::vector<genfit::AbsTrackRep*>& trackRepresentations = getRepresentations();
 
  for (genfit::AbsTrackRep* trackRepresentation : trackRepresentations) {
    // Check if the track representation is a RKTrackRep.
    const genfit::RKTrackRep* rkTrackRepresenation = dynamic_cast<const genfit::RKTrackRep*>(trackRepresentation);
    if (rkTrackRepresenation != nullptr) {
      // take the absolute value of the PDG code as the TrackRep holds the PDG code including the charge (so -13 or 13)
      if (std::abs(rkTrackRepresenation->getPDG()) == pdgCode) {
        return trackRepresentation;
      }
    }
  }
 
  return nullptr;
}

hasBKLMHits()

bool hasBKLMHits ( ) const

inline

Returns true if the track has bklm hits.

Definition at line 404 of file RecoTrack.h.

{ return getRelatedFrom<UsedBKLMHit>(m_storeArrayNameOfBKLMHits) != nullptr; }

hasCDCHits()

bool hasCDCHits ( ) const

inline

Returns true if the track has cdc hits.

Definition at line 401 of file RecoTrack.h.

{ return getRelatedFrom<UsedCDCHit>(m_storeArrayNameOfCDCHits) != nullptr; }

hasEKLMHits()

bool hasEKLMHits ( ) const

inline

Returns true if the track has eklm hits.

Definition at line 407 of file RecoTrack.h.

{ return getRelatedFrom<UsedEKLMHit>(m_storeArrayNameOfEKLMHits) != nullptr; }

hasHit()

bool hasHit ( const HitType *  hit ) const

inline

Returns true if the given hit is in the track.

Definition at line 411 of file RecoTrack.h.

    {
      const RelationVector<RecoTrack>& relatedTracksToHit = hit->template getRelationsTo<RecoTrack>(getArrayName());
      return std::find_if(relatedTracksToHit.begin(), relatedTracksToHit.end(), [this](const RecoTrack & recoTrack) {
        return &recoTrack == this;
      }) != relatedTracksToHit.end();
    }

hasIngoingArmTime()

bool hasIngoingArmTime ( )

inline

Check if the ingoing arm time is set.

Definition at line 557 of file RecoTrack.h.

    {
      return m_hasIngoingArmTime;
    }

hasOutgoingArmTime()

bool hasOutgoingArmTime ( )

inline

Check if the outgoing arm time is set.

Definition at line 563 of file RecoTrack.h.

    {
      return m_hasOutgoingArmTime;
    }

hasPXDHits()

bool hasPXDHits ( ) const

inline

Returns true if the track has pxd hits.

Definition at line 395 of file RecoTrack.h.

{ return getRelatedFrom<UsedPXDHit>(m_storeArrayNameOfPXDHits) != nullptr; }

hasSVDHits()

bool hasSVDHits ( ) const

inline

Returns true if the track has svd hits.

Definition at line 398 of file RecoTrack.h.

{ return getRelatedFrom<UsedSVDHit>(m_storeArrayNameOfSVDHits) != nullptr; }

hasTrackFitStatus()

bool hasTrackFitStatus

(

const genfit::AbsTrackRep *

representation = nullptr

)

const

Check, if there is a fit status for the given representation or for the cardinal one.

Definition at line 543 of file RecoTrack.cc.

{
  checkDirtyFlag();
 
  // there might be the case, where the genfit track has no trackreps, even not the cardinal
  // one because no fit attempt was performed. In this case, the "hasFitStatus" call to genfit
  // will fail with an access violation. To prevent that, check for the number of reps here before
  // actually calling genfit's hasFitStatus(...)
  if (m_genfitTrack.getNumReps() == 0)
    return false;
 
  return m_genfitTrack.hasFitStatus(representation);
}

isOutgoingArm()

bool isOutgoingArm	(	RecoHitInformation::RecoHitDetector	pre = RecoHitInformation::RecoHitDetector::c_undefinedTrackingDetector,
		RecoHitInformation::RecoHitDetector	post = RecoHitInformation::RecoHitDetector::c_undefinedTrackingDetector
	)

This function returns true if the arm direction is Outgoing and false if the arm direction is Ingoing.

The detector sequences considered are: outgoing arm: PXD-SVD-CDC, PXD-SVD, SVD-CDC; ingoing arm: CDC-SVD-PXD, CDC-SVD, SVD-PXD; pre and post are defined w.r.t SVD, so they can be PXD, CDC or undefined if one of the two is missing

Definition at line 703 of file RecoTrack.cc.

{
  static RecoHitInformation::RecoHitDetector und = RecoHitInformation::RecoHitDetector::c_undefinedTrackingDetector;
  RecoHitInformation::RecoHitDetector PXD = RecoHitInformation::RecoHitDetector::c_PXD;
  RecoHitInformation::RecoHitDetector CDC = RecoHitInformation::RecoHitDetector::c_CDC;
  bool isOutgoing = true;
  if (pre == PXD && post == CDC) isOutgoing = true;
  else if (pre == und && post == CDC) isOutgoing = true;
  else if (pre == PXD && post == und) isOutgoing = true;
  else if (pre == CDC && post == PXD) isOutgoing = false;
  else if (pre == und && post == PXD) isOutgoing = false;
  else if (pre == CDC && post == und) isOutgoing = false;
  else {
    //TO DO
    B2DEBUG(29,
            "SVD-only? PXD-SVD-PXD??? --- use layer information to determine if the track arm is outgoing or ingoing! Considered --> 'OUT'");
    isOutgoing = true;
  }
  return isOutgoing;
}

mapOnHits() [1/4]

void mapOnHits ( const std::string &  storeArrayNameOfHits, std::function< void(const RecoHitInformation &, const HitType *)> const &  mapFunction  ) const

inline

Call a function on all hits of the given type in the store array, that are related to this track.

Const version.

Parameters

storeArrayNameOfHits	The store array the hits should come from.
mapFunction	Call this function for every hit (with its reco hit information)

Definition at line 821 of file RecoTrack.h.

    {
      mapOnHits<HitType>(storeArrayNameOfHits, mapFunction, [](const RecoHitInformation&, const HitType*) -> bool { return true; });
    }

mapOnHits() [2/4]

void mapOnHits ( const std::string &  storeArrayNameOfHits, std::function< void(const RecoHitInformation &, const HitType *)> const &  mapFunction, std::function< bool(const RecoHitInformation &, const HitType *)> const &  pickFunction  ) const

inline

Call a function on all hits of the given type in the store array, that are related to this track.

Const version.

Parameters

storeArrayNameOfHits	The store array the hits should come from.
mapFunction	Call this function for every hit (with its reco hit information)
pickFunction	Use only those hits where the function returns true.

Definition at line 788 of file RecoTrack.h.

    {
      RelationVector<RecoHitInformation> relatedHitInformation = getRelationsTo<RecoHitInformation>
                                                                 (m_storeArrayNameOfRecoHitInformation);
 
      for (const RecoHitInformation& hitInformation : relatedHitInformation) {
        const HitType* const hit = hitInformation.getRelatedTo<HitType>(storeArrayNameOfHits);
        if (hit != nullptr && pickFunction(hitInformation, hit)) {
          mapFunction(hitInformation, hit);
        }
      }
    }

mapOnHits() [3/4]

void mapOnHits ( const std::string &  storeArrayNameOfHits, std::function< void(RecoHitInformation &, HitType *)> const &  mapFunction  )

inline

Call a function on all hits of the given type in the store array, that are related to this track.

Parameters

storeArrayNameOfHits	The store array the hits should come from.
mapFunction	Call this function for every hit (with its reco hit information)

Definition at line 809 of file RecoTrack.h.

    {
      mapOnHits<HitType>(storeArrayNameOfHits, mapFunction, [](const RecoHitInformation&, const HitType*) -> bool { return true; });
    }

mapOnHits() [4/4]

void mapOnHits ( const std::string &  storeArrayNameOfHits, std::function< void(RecoHitInformation &, HitType *)> const &  mapFunction, std::function< bool(const RecoHitInformation &, const HitType *)> const &  pickFunction  )

inline

Call a function on all hits of the given type in the store array, that are related to this track.

Parameters

storeArrayNameOfHits	The store array the hits should come from.
mapFunction	Call this function for every hit (with its reco hit information)
pickFunction	Use only those hits where the function returns true.

Definition at line 766 of file RecoTrack.h.

    {
      RelationVector<RecoHitInformation> relatedHitInformation = getRelationsTo<RecoHitInformation>
                                                                 (m_storeArrayNameOfRecoHitInformation);
 
      for (RecoHitInformation& hitInformation : relatedHitInformation) {
        HitType* const hit = hitInformation.getRelatedTo<HitType>(storeArrayNameOfHits);
        if (hit != nullptr && pickFunction(hitInformation, hit)) {
          mapFunction(hitInformation, hit);
        }
      }
    }

prune()

void prune

(

)

Prune the genfit track, e.g.

remove all track points with measurements, but the first and the last one. Also, set the flags of the corresponding RecoHitInformation to pruned. Only to be used in the prune module.

Definition at line 375 of file RecoTrack.cc.

{
  // "Delete" all RecoHitInfromation but the first and the last.
  // Copy is intended!
  std::vector<RelationEntry> relatedRecoHitInformations = getRelationsWith<RecoHitInformation>
                                                          (m_storeArrayNameOfRecoHitInformation).relations();
  std::sort(relatedRecoHitInformations.begin(), relatedRecoHitInformations.end(), [](const RelationEntry & lhs,
  const RelationEntry & rhs) {
    return dynamic_cast<RecoHitInformation*>(lhs.object)->getSortingParameter() > dynamic_cast<RecoHitInformation*>
           (rhs.object)->getSortingParameter();
  });
 
  // "Prune" all RecoHitInformation but the first and the last.
  for (unsigned int i = 1; i < relatedRecoHitInformations.size() - 1; ++i) {
    dynamic_cast<RecoHitInformation*>(relatedRecoHitInformations[i].object)->setFlag(RecoHitInformation::RecoHitFlag::c_pruned);
    dynamic_cast<RecoHitInformation*>(relatedRecoHitInformations[i].object)->setCreatedTrackPointID(-1);
  }
 
  // Genfits prune method fails, if the number of hits is too small.
  if (getHitPointsWithMeasurement().size() >= 2) {
    m_genfitTrack.prune("FL");
  }
}

registerRequiredRelations()

void registerRequiredRelations ( StoreArray< RecoTrack > &  recoTracks, std::string const &  pxdHitsStoreArrayName = "", std::string const &  svdHitsStoreArrayName = "", std::string const &  cdcHitsStoreArrayName = "", std::string const &  bklmHitsStoreArrayName = "", std::string const &  eklmHitsStoreArrayName = "", std::string const &  recoHitInformationStoreArrayName = ""  )

static

Convenience method which registers all relations required to fully use a RecoTrack.

If you create a new RecoTrack StoreArray, call this method in the initialize() method of your module. Note that the BKLM and EKLM relations may not be registered because the KLM modules are loaded after tracking; in this case, a second call of this method is required after creation of the BKLM and EKLM hits store arrays.

Parameters

recoTracks	Reference to the store array where the new RecoTrack list is located
pxdHitsStoreArrayName	name of the StoreArray holding the PXDClusters lists
svdHitsStoreArrayName	name of the StoreArray holding the SVDClusters lists
cdcHitsStoreArrayName	name of the StoreArray holding the CDCHits lists
bklmHitsStoreArrayName	name of the StoreArray holding the BKLMHits lists
eklmHitsStoreArrayName	name of the StoreArray holding the EKLMHits lists
recoHitInformationStoreArrayName	name of the StoreArray holding RecoHitInformation lists

Definition at line 53 of file RecoTrack.cc.

{
  StoreArray<RecoHitInformation> recoHitInformations(recoHitInformationStoreArrayName);
  recoHitInformations.registerInDataStore();
  recoTracks.registerRelationTo(recoHitInformations);
 
  StoreArray<RecoHitInformation::UsedPXDHit> pxdHits(pxdHitsStoreArrayName);
  if (pxdHits.isOptional()) {
    pxdHits.registerRelationTo(recoTracks);
    recoHitInformations.registerRelationTo(pxdHits);
  }
 
  StoreArray<RecoHitInformation::UsedSVDHit> svdHits(svdHitsStoreArrayName);
  if (svdHits.isOptional()) {
    svdHits.registerRelationTo(recoTracks);
    recoHitInformations.registerRelationTo(svdHits);
  }
 
  StoreArray<RecoHitInformation::UsedCDCHit> cdcHits(cdcHitsStoreArrayName);
  if (cdcHits.isOptional()) {
    cdcHits.registerRelationTo(recoTracks);
    recoHitInformations.registerRelationTo(cdcHits);
  }
 
  StoreArray<RecoHitInformation::UsedBKLMHit> bklmHits(bklmHitsStoreArrayName);
  if (bklmHits.isOptional()) {
    bklmHits.registerRelationTo(recoTracks);
    recoHitInformations.registerRelationTo(bklmHits);
  }
 
  StoreArray<RecoHitInformation::UsedEKLMHit> eklmHits(eklmHitsStoreArrayName);
  if (eklmHits.isOptional()) {
    eklmHits.registerRelationTo(recoTracks);
    recoHitInformations.registerRelationTo(eklmHits);
  }
}

revertRecoHitInformationSorting()

void revertRecoHitInformationSorting ( )

inline

Revert the sorting order of the RecoHitInformation.

Definition at line 750 of file RecoTrack.h.

    {
      const uint recoHitInformationSize = getRecoHitInformations().size();
      for (auto RecoHitInfo : getRecoHitInformations()) {
        // The "-1" ensures that the sorting parameter still is in range 0...size-1 instead of 1...size
        RecoHitInfo->setSortingParameter(recoHitInformationSize - RecoHitInfo->getSortingParameter() - 1);
      }
    }

set2ndFlipQualityIndicator()

void set2ndFlipQualityIndicator ( const float  qualityIndicator )

inline

Set the 2nd flipping quality attached to this RecoTrack.

Definition at line 870 of file RecoTrack.h.

    {
      m_2ndFlipqualityIndicator = qualityIndicator;
    }

setChargeSeed()

void setChargeSeed ( const short int  chargeSeed )

inline

Set the charge seed stored in the reco track. ATTENTION: This is not the fitted charge.

Definition at line 597 of file RecoTrack.h.

    {
      m_charge = chargeSeed;
      deleteFittedInformation();
    }

setDirtyFlag()

void setDirtyFlag ( const bool &  dirtyFlag = true )

inline

Set to true, if you want to rebuild the measurements and do the fit independent on changes of the hit content.

You can use this setting if you want to use other measurement creators than before (probably non-default settings) or different fitting algorithms.

Definition at line 722 of file RecoTrack.h.

    {
      m_dirtyFlag = dirtyFlag;
      if (dirtyFlag) {
        deleteFittedInformation();
      }
    }

setFlipQualityIndicator()

void setFlipQualityIndicator ( const float  qualityIndicator )

inline

Set the 1st flipping quality attached to this RecoTrack.

Definition at line 859 of file RecoTrack.h.

    {
      m_flipqualityIndicator = qualityIndicator;
    }

setFoundByTrackFinder()

void setFoundByTrackFinder ( const HitType *  hit, OriginTrackFinder  originTrackFinder  )

inline

Set the found by track finder flag or throws an exception of the hit is not related to the track.

Definition at line 372 of file RecoTrack.h.

    {
      RecoHitInformation* recoHitInformation = getRecoHitInformationSafely(hit);
      recoHitInformation->setFoundByTrackFinder(originTrackFinder);
    }

setMatchingStatus()

void setMatchingStatus ( MatchingStatus  matchingStatus )

inline

Set the matching status (used by the TrackMatcher module)

Definition at line 835 of file RecoTrack.h.

    {
      m_matchingStatus = matchingStatus;
    }

setPositionAndMomentum()

void setPositionAndMomentum ( const ROOT::Math::XYZVector &  positionSeed, const ROOT::Math::XYZVector &  momentumSeed  )

inline

Set the position and momentum seed of the reco track. ATTENTION: This is not the fitted position or momentum.

Definition at line 590 of file RecoTrack.h.

    {
      m_genfitTrack.setStateSeed(XYZToTVector(positionSeed), XYZToTVector(momentumSeed));
      deleteFittedInformation();
    }

setQualityIndicator()

void setQualityIndicator ( const float  qualityIndicator )

inline

Set the quality index attached to this RecoTrack. 0 means likely fake.

Definition at line 847 of file RecoTrack.h.

    {
      m_qualityIndicator = qualityIndicator;
    }

setRightLeftInformation()

void setRightLeftInformation ( const HitType *  hit, RightLeftInformation  rightLeftInformation  )

inline

Set the right left information or throws an exception of the hit is not related to the track. Will set the dirty flag!

Definition at line 363 of file RecoTrack.h.

    {
      RecoHitInformation* recoHitInformation = getRecoHitInformationSafely(hit);
      recoHitInformation->setRightLeftInformation(rightLeftInformation);
      setDirtyFlag();
    }

setSeedCovariance()

void setSeedCovariance ( const TMatrixDSym &  seedCovariance )

inline

Set the covariance of the seed. ATTENTION: This is not the fitted covariance.

Definition at line 614 of file RecoTrack.h.

{ m_genfitTrack.setCovSeed(seedCovariance); }

setSortingParameter()

void setSortingParameter ( const HitType *  hit, unsigned int  sortingParameter  )

inline

Set the sorting parameter or throws an exception of the hit is not related to the track. Will set the dirty flag!

Definition at line 380 of file RecoTrack.h.

    {
      RecoHitInformation* recoHitInformation = getRecoHitInformationSafely(hit);
      recoHitInformation->setSortingParameter(sortingParameter);
      setDirtyFlag();
    }

setTimeSeed()

void setTimeSeed ( const double  timeSeed )

inline

Set the time seed. ATTENTION: This is not the fitted time.

Definition at line 604 of file RecoTrack.h.

    {
      m_genfitTrack.setTimeSeed(timeSeed);
      deleteFittedInformation();
    }

swapArmTimes()

void swapArmTimes ( )

inlineprivate

Swap arm times, booleans and nSVDHits.

Definition at line 1058 of file RecoTrack.h.

    {
      std::swap(m_outgoingArmTime, m_ingoingArmTime);
      std::swap(m_hasOutgoingArmTime, m_hasIngoingArmTime);
      std::swap(m_nSVDHitsOfOutgoingArm, m_nSVDHitsOfIngoingArm);
    }

wasFitSuccessful()

bool wasFitSuccessful

(

const genfit::AbsTrackRep *

representation = nullptr

)

const

Returns true if the last fit with the given representation was successful.

Definition at line 336 of file RecoTrack.cc.

{
  checkDirtyFlag();
 
  if (getRepresentations().empty()) {
    return false;
  }
 
  if (not hasTrackFitStatus(representation)) {
    return false;
  }
 
  const genfit::FitStatus* fs = getTrackFitStatus(representation);
  if (not fs) {
    return false;
  }
  if (not fs->isFitConverged()) {
    return false;
  }
 
  // make sure we only consider fitted if the Kalman method was used
  if (not dynamic_cast<const genfit::KalmanFitStatus*>(fs)) {
    return false;
  }
 
  // make sure there is at least one hit with a valid mSoP
  const unsigned int trackSize = m_genfitTrack.getNumPoints();
  for (unsigned int i = 0; i < trackSize; i++) {
    try {
      m_genfitTrack.getFittedState(i, representation);
      return true;
    } catch (const genfit::Exception& exception) {
      B2DEBUG(29, "Can not get mSoP because of: " << exception.what());
    }
  }
 
  return false;
}

Friends And Related Function Documentation

RecoTrackGenfitAccess

friend class RecoTrackGenfitAccess

friend

The RecoTrackGenfitAccess need to access the genfit track (which is intended)!

Definition at line 81 of file RecoTrack.h.

Member Data Documentation

m_2ndFlipqualityIndicator

float m_2ndFlipqualityIndicator = NAN

private

Quality index for flipping.

Definition at line 922 of file RecoTrack.h.

m_cacheArrayIndex

int m_cacheArrayIndex

mutableprivateinherited

Cache of the index in the TClonesArray to which this object belongs.

Definition at line 432 of file RelationsObject.h.

m_cacheDataStoreEntry

DataStore::StoreEntry* m_cacheDataStoreEntry

mutableprivateinherited

Cache of the data store entry to which this object belongs.

Definition at line 429 of file RelationsObject.h.

m_charge

short int m_charge = 1

private

Storage for the charge. All other helix parameters are saved in the genfit::Track.

Definition at line 899 of file RecoTrack.h.

m_dirtyFlag

bool m_dirtyFlag = true

private

Bool is hits were added to track after fitting and the measurements should be recalculated.

will be true after ROOT deserialization, which means the measurements will be recreated

Definition at line 914 of file RecoTrack.h.

m_flipqualityIndicator

float m_flipqualityIndicator = NAN

private

Quality index for flipping.

Definition at line 920 of file RecoTrack.h.

m_genfitTrack

genfit::Track m_genfitTrack

private

Internal storage for the genfit track.

Definition at line 897 of file RecoTrack.h.

m_hasIngoingArmTime

bool m_hasIngoingArmTime = false

private

Internal storage of the final ingoing arm time is set.

Definition at line 934 of file RecoTrack.h.

m_hasOutgoingArmTime

bool m_hasOutgoingArmTime = false

private

Internal storage of the final outgoing arm time is set.

Definition at line 936 of file RecoTrack.h.

m_ingoingArmTime

float m_ingoingArmTime = NAN

private

Track time of the ingoing arm.

Definition at line 928 of file RecoTrack.h.

m_ingoingArmTimeError

float m_ingoingArmTimeError = NAN

private

Error of the track time of the ingoing arm.

Definition at line 930 of file RecoTrack.h.

m_isArmTimeComputed

bool m_isArmTimeComputed = false

private

true if the arms times are already computed, false otherwise

Definition at line 932 of file RecoTrack.h.

m_matchingStatus

MatchingStatus m_matchingStatus = MatchingStatus::c_undefined

private

Flag used in the MCRecoTracksMatcherModule.

Definition at line 916 of file RecoTrack.h.

m_nSVDHitsOfIngoingArm

int m_nSVDHitsOfIngoingArm = 0

private

Number of SVD clusters of the ingoing arm.

Definition at line 940 of file RecoTrack.h.

m_nSVDHitsOfOutgoingArm

int m_nSVDHitsOfOutgoingArm = 0

private

Number of SVD clusters of the outgoing arm.

Definition at line 938 of file RecoTrack.h.

m_outgoingArmTime

float m_outgoingArmTime = NAN

private

Track time of the outgoing arm.

Definition at line 924 of file RecoTrack.h.

m_outgoingArmTimeError

float m_outgoingArmTimeError = NAN

private

Error of the track time of the outgoing arm.

Definition at line 926 of file RecoTrack.h.

m_qualityIndicator

float m_qualityIndicator = NAN

private

Quality index for classification of fake vs. MC-matched Tracks.

Definition at line 918 of file RecoTrack.h.

m_storeArrayNameOfBKLMHits

std::string m_storeArrayNameOfBKLMHits = ""

private

Store array name of added BKLM hits.

Definition at line 907 of file RecoTrack.h.

m_storeArrayNameOfCDCHits

std::string m_storeArrayNameOfCDCHits = ""

private

Store array name of added CDC hits.

Definition at line 905 of file RecoTrack.h.

m_storeArrayNameOfEKLMHits

std::string m_storeArrayNameOfEKLMHits = ""

private

Store array name of added EKLM hits.

Definition at line 909 of file RecoTrack.h.

m_storeArrayNameOfPXDHits

std::string m_storeArrayNameOfPXDHits = ""

private

Store array name of added PXD hits.

Definition at line 901 of file RecoTrack.h.

m_storeArrayNameOfRecoHitInformation

std::string m_storeArrayNameOfRecoHitInformation = ""

private

Store array of added RecoHitInformation.

Definition at line 911 of file RecoTrack.h.

m_storeArrayNameOfSVDHits

std::string m_storeArrayNameOfSVDHits = ""

private

Store array name of added SVD hits.

Definition at line 903 of file RecoTrack.h.

---

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

• tracking/dataobjects/include/RecoTrack.h
• tracking/dataobjects/src/RecoTrack.cc