Trk::TrackStateOnSurface Class Reference

represents the track state (measurement, material, fit parameters and quality) at a surface. More...

#include <TrackStateOnSurface.h>

Inheritance diagram for Trk::TrackStateOnSurface:

Collaboration diagram for Trk::TrackStateOnSurface:

Public Types
enum	TrackStateOnSurfaceType {   Measurement = 0 , InertMaterial = 1 , BremPoint = 2 , Scatterer = 3 ,   Perigee = 4 , Outlier = 5 , Hole = 6 , Unknown = 7 ,   CaloDeposit = 8 , Parameter = 9 , FitQuality = 10 , Alignment = 11 ,   NumberOfTrackStateOnSurfaceTypes = 12 }
enum	PersistencyHint {   PartialPersistification = 0 , PersistifyMeasurement = 1 , PersistifyTrackParameters = 2 , PersistifySlimCaloDeposit = 3 ,   NumberOfPersistencyHints = 4 }
enum	Variety { SingleComponent = 0 , MultiComponent = 1 , Align = 2 }

Public Member Functions
	TrackStateOnSurface ()
	Default ctor for POOL.
	TrackStateOnSurface (const FitQualityOnSurface &fitQoS, std::unique_ptr< MeasurementBase > meas, std::unique_ptr< TrackParameters > trackParameters, std::unique_ptr< MaterialEffectsBase > materialEffects=nullptr, std::unique_ptr< AlignmentEffectsOnTrack > alignmentEffectsOnTrack=nullptr)
	Partial constructors.
	TrackStateOnSurface (std::unique_ptr< MeasurementBase > meas, std::unique_ptr< TrackParameters > trackParameters, std::unique_ptr< MaterialEffectsBase > materialEffects=nullptr, std::unique_ptr< AlignmentEffectsOnTrack > alignmentEffectsOnTrack=nullptr)
	TrackStateOnSurface (const FitQualityOnSurface &fitQoS, std::unique_ptr< MeasurementBase > meas, std::unique_ptr< TrackParameters > trackParameters, std::unique_ptr< MaterialEffectsBase > materialEffectsOnTrack, const std::bitset< TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes > &typePattern, std::unique_ptr< AlignmentEffectsOnTrack > alignmentEffectsOnTrack=nullptr)
	Full constructors.
	TrackStateOnSurface (std::unique_ptr< MeasurementBase > meas, std::unique_ptr< TrackParameters > trackParameters, std::unique_ptr< MaterialEffectsBase > materialEffectsOnTrack, const std::bitset< TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes > &typePattern, std::unique_ptr< AlignmentEffectsOnTrack > alignmentEffectsOnTrack=nullptr)
virtual TrackStateOnSurface *	clone () const
	Pseudo-constructor: needed to avoid excessive RTTI.
	TrackStateOnSurface (const TrackStateOnSurface &trackStateOnSurface)
	copy ctor
	TrackStateOnSurface (TrackStateOnSurface &&trackStateOnSurface) noexcept
	Move ctor.
Trk::TrackStateOnSurface &	operator= (const Trk::TrackStateOnSurface &rhs)
Trk::TrackStateOnSurface &	operator= (Trk::TrackStateOnSurface &&rhs) noexcept
virtual	~TrackStateOnSurface ()=default
	destructor
const FitQualityOnSurface &	fitQualityOnSurface () const
	return FitQuality On Surface const overload
FitQualityOnSurface &	fitQualityOnSurface ()
	return FitQuality On Surface non-const overload
const TrackParameters *	trackParameters () const
	return ptr to trackparameters const overload
TrackParameters *	trackParameters ()
	return ptr to trackparameters non-const overload
const MeasurementBase *	measurementOnTrack () const
	returns MeasurementBase const overload
MeasurementBase *	measurementOnTrack ()
	returns MeasurementBase non-const overload
const MaterialEffectsBase *	materialEffectsOnTrack () const
	return material effects const overload
MaterialEffectsBase *	materialEffectsOnTrack ()
	return material effects non-const overload
const AlignmentEffectsOnTrack *	alignmentEffectsOnTrack () const
	return the the alignment effects const overload
AlignmentEffectsOnTrack *	alignmentEffectsOnTrack ()
	return the the alignment effects non-const overload
bool	type (const TrackStateOnSurfaceType type) const
	Use this method to find out if the TSoS is of a certain type: i.e.
virtual Trk::TrackStateOnSurface::Variety	variety () const
	Use this method to find if this is a Single, Multi or Align TrackStateOnsurface.
std::string	dumpType () const
	returns a string with the expanded type of the object (i.e.
const std::bitset< NumberOfTrackStateOnSurfaceTypes >	types () const
	returns a bitset with the types of this bitset.
void	setHints (const uint8_t hints) const
	Use this method to set persistification hints.
const std::bitset< NumberOfPersistencyHints >	hints () const
	Use this method to get the persistification hints.
const Trk::Surface &	surface () const
	return associated surface
bool	isSane () const

Static Public Member Functions
static unsigned int long	joinBitsets (const std::bitset< NumberOfTrackStateOnSurfaceTypes > &types, const std::bitset< NumberOfPersistencyHints > &hints)
static void	splitToBitsets (const unsigned int long input, std::bitset< NumberOfTrackStateOnSurfaceTypes > &types, std::bitset< NumberOfPersistencyHints > &hints)

Protected Attributes
uint16_t	m_typeFlags {}
std::atomic< uint8_t >	m_hints {}

Private Member Functions
void	setFlags ()
	set sensible default flags

Private Attributes
FitQualityOnSurface	m_fitQualityOnSurface {}
std::unique_ptr< TrackParameters >	m_trackParameters {}
std::unique_ptr< MeasurementBase >	m_measurementOnTrack {}
std::unique_ptr< MaterialEffectsBase >	m_materialEffectsOnTrack {}
std::unique_ptr< AlignmentEffectsOnTrack >	m_alignmentEffectsOnTrack {}

Friends
class	::TrackCollectionCnv
class	::TrackStateOnSurfaceCnv_p3

Detailed Description

represents the track state (measurement, material, fit parameters and quality) at a surface.

As the name suggests TrackStateOnSurface is intended to represent the state of a track at a surface, and will be of particular relevance for track fitting, extrapolating and following (for example it provides a way to store scattering angle information).

The principle is that these objects can contain pointers to other objects. Not all are required to be passed, and so not all will exist. As a rule of thumb, if an object is returned by pointer then you cannot be sure it exists and should check.

The code does not (for speed reasons) enforce contraints on what is placed in a TrackStateOnSurface. What follows are simple guidelines for the use of TrackStateOnSurface.

• DO NOT create separate TrackStateOnSurface for the same surface i.e. put all the information for one surface into the same TrackStateOnSurface (to achieve what you want, have a look at Trk::CompetingRIO_OnTracks). Do not create one TSoS for the parameters, one for the MeasurementBase and one for the scatterer. They should all be together, in the same TSoS, if they exist on the same Trk::Surface.
• An MeasurementBase or MaterialEffectsBase can exist without a matching Trk::TrackParameters e.g. if the Track is meant to be used as input to track fitting. Otherwise and if possible add the matching Trk::TrackParameters and Trk::FitQualityOnSurface.
• A Trk::MaterialEffectsBase must have a matching Trk::TrackParameters. Otherwise information such as the changes in direction is meaningless without the coordinates provided by a Trk::TrackParameters

Author

edwar.nosp@m.d.mo.nosp@m.yse@c.nosp@m.ern..nosp@m.ch

Chistos Anastopoulos Athena MT migration

Definition at line 70 of file TrackStateOnSurface.h.

Member Enumeration Documentation

PersistencyHint

enum Trk::TrackStateOnSurface::PersistencyHint

Enumerator
PartialPersistification
PersistifyMeasurement	Mark the measuremenet for persistification.
PersistifyTrackParameters	Mark track parameters for persisitification.
PersistifySlimCaloDeposit	Mark track parameters for persisitification.
NumberOfPersistencyHints

Definition at line 155 of file TrackStateOnSurface.h.

  {
 
    PartialPersistification = 0,
    PersistifyMeasurement = 1,

    PersistifyTrackParameters = 2,

    PersistifySlimCaloDeposit = 3,
 
    NumberOfPersistencyHints = 4
  };

TrackStateOnSurfaceType

enum Trk::TrackStateOnSurface::TrackStateOnSurfaceType

Enumerator
Measurement	This is a measurement, and will at least contain a Trk::MeasurementBase.
InertMaterial	This represents inert material, and so will contain MaterialEffectsBase.
BremPoint	This represents a brem point on the track, and so will contain TrackParameters and MaterialEffectsBase.
Scatterer	This represents a scattering point on the track, and so will contain TrackParameters and MaterialEffectsBase.
Perigee	This represents a perigee, and so will contain a Perigee object only.
Outlier	This TSoS contains an outlier, that is, it contains a MeasurementBase/RIO_OnTrack which was not used in the track fit.
Hole	A hole on the track - this is defined in the following way. A hole is a missing measurement BETWEEN the first and last actual measurements. i.e. if your track starts in the SCT, you should not consider a missing b-layer hit as a hole.
Unknown	For some reason this does not fall into any of the other categories PLEASE DO NOT USE THIS - DEPRECATED!
CaloDeposit	This TSOS contains a CaloEnergy object.
Parameter	This TSOS contains a Trk::ParameterBase.
FitQuality	This TSOS contains a Trk::FitQualityOnSurface.
Alignment	This TSOS contains a Trk::AlignmentEffectsOnTrack.
NumberOfTrackStateOnSurfaceTypes

Definition at line 97 of file TrackStateOnSurface.h.

  {
    Measurement = 0,

    InertMaterial = 1,

    BremPoint = 2,

    Scatterer = 3,

    Perigee = 4,

    Outlier = 5,

    Hole = 6,

    Unknown = 7,

    CaloDeposit = 8,

    Parameter = 9,

    FitQuality = 10,

    Alignment = 11,
 
    NumberOfTrackStateOnSurfaceTypes = 12
  };

Variety

enum Trk::TrackStateOnSurface::Variety

Enumerator
SingleComponent
MultiComponent
Align

Definition at line 211 of file TrackStateOnSurface.h.

  {
    SingleComponent = 0,
    MultiComponent = 1,
    Align = 2,
  };

Constructor & Destructor Documentation

TrackStateOnSurface() [1/7]

Trk::TrackStateOnSurface::TrackStateOnSurface ( )

default

Default ctor for POOL.

Do not use!

TrackStateOnSurface() [2/7]

Trk::TrackStateOnSurface::TrackStateOnSurface ( const FitQualityOnSurface & fitQoS, std::unique_ptr< MeasurementBase > meas, std::unique_ptr< TrackParameters > trackParameters, std::unique_ptr< MaterialEffectsBase > materialEffects = nullptr, std::unique_ptr< AlignmentEffectsOnTrack > alignmentEffectsOnTrack = nullptr )

explicit

Partial constructors.

The objects passed in belong to the this object, or to the Track to which this FQOS will be assigned.

These ctors will set appropriate flags for all non-null objects passed

Definition at line 15 of file TrackStateOnSurface.cxx.

  : m_fitQualityOnSurface(fitQoS)
  , m_trackParameters(std::move(trackParameters))
  , m_measurementOnTrack(std::move(meas))
  , m_materialEffectsOnTrack(std::move(materialEffects))
  , m_alignmentEffectsOnTrack(std::move(alignmentEffectsOnTrack))
{
  assert(isSane());
  setFlags();
}

TrackStateOnSurface() [3/7]

Trk::TrackStateOnSurface::TrackStateOnSurface ( std::unique_ptr< MeasurementBase > meas, std::unique_ptr< TrackParameters > trackParameters, std::unique_ptr< MaterialEffectsBase > materialEffects = nullptr, std::unique_ptr< AlignmentEffectsOnTrack > alignmentEffectsOnTrack = nullptr )

explicit

Definition at line 31 of file TrackStateOnSurface.cxx.

  : m_fitQualityOnSurface{}
  , m_trackParameters(std::move(trackParameters))
  , m_measurementOnTrack(std::move(meas))
  , m_materialEffectsOnTrack(std::move(materialEffects))
  , m_alignmentEffectsOnTrack(std::move(alignmentEffectsOnTrack))
{
  assert(isSane());
  setFlags();
}

TrackStateOnSurface() [4/7]

Trk::TrackStateOnSurface::TrackStateOnSurface ( const FitQualityOnSurface & fitQoS, std::unique_ptr< MeasurementBase > meas, std::unique_ptr< TrackParameters > trackParameters, std::unique_ptr< MaterialEffectsBase > materialEffectsOnTrack, const std::bitset< TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes > & typePattern, std::unique_ptr< AlignmentEffectsOnTrack > alignmentEffectsOnTrack = nullptr )

explicit

Full constructors.

Parameters

[in]	FitQualityOnSurface	(we provide one without it)
[in]	unique	pointer to a MeasurementBase, or 0 if no object is being passed.
[in]	unigue	trackParameter pointer to a TrackParameters, or 0 if no object is being passed. being passed.
[in]	materialEffectsOnTrack	pointer to a MaterialEffectsBase, or 0 if no object is being passed.
[in]	typePattern	The pattern of 'types' which correspond to this TSoS. You create the bitset as follows:

Definition at line 47 of file TrackStateOnSurface.cxx.

  : m_fitQualityOnSurface(fitQoS)
  , m_trackParameters(std::move(trackParameters))
  , m_measurementOnTrack(std::move(meas))
  , m_materialEffectsOnTrack(std::move(materialEffects))
  , m_alignmentEffectsOnTrack(std::move(alignmentEffectsOnTrack))
  , m_typeFlags(typePattern.to_ulong())
{
  assert(isSane());
}

TrackStateOnSurface() [5/7]

Trk::TrackStateOnSurface::TrackStateOnSurface ( std::unique_ptr< MeasurementBase > meas, std::unique_ptr< TrackParameters > trackParameters, std::unique_ptr< MaterialEffectsBase > materialEffectsOnTrack, const std::bitset< TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes > & typePattern, std::unique_ptr< AlignmentEffectsOnTrack > alignmentEffectsOnTrack = nullptr )

explicit

Definition at line 64 of file TrackStateOnSurface.cxx.

  : m_fitQualityOnSurface{}
  , m_trackParameters(std::move(trackParameters))
  , m_measurementOnTrack(std::move(meas))
  , m_materialEffectsOnTrack(std::move(materialEffects))
  , m_alignmentEffectsOnTrack(std::move(alignmentEffectsOnTrack))
  , m_typeFlags(typePattern.to_ulong())
{
  assert(isSane());
}

TrackStateOnSurface() [6/7]

Trk::TrackStateOnSurface::TrackStateOnSurface

(

const TrackStateOnSurface &

trackStateOnSurface

)

copy ctor

Definition at line 81 of file TrackStateOnSurface.cxx.

    : m_fitQualityOnSurface(rhs.m_fitQualityOnSurface),
      m_trackParameters(rhs.m_trackParameters ? rhs.m_trackParameters->clone()
                                              : nullptr),
      m_measurementOnTrack(rhs.m_measurementOnTrack
                               ? rhs.m_measurementOnTrack->clone()
                               : nullptr),
      m_materialEffectsOnTrack(rhs.m_materialEffectsOnTrack
                                   ? rhs.m_materialEffectsOnTrack->clone()
                                   : nullptr),
      m_alignmentEffectsOnTrack(rhs.m_alignmentEffectsOnTrack
                                    ? std::make_unique<AlignmentEffectsOnTrack>(
                                          *rhs.m_alignmentEffectsOnTrack)
                                    : nullptr),
      m_typeFlags(rhs.m_typeFlags) {}

TrackStateOnSurface() [7/7]

Trk::TrackStateOnSurface::TrackStateOnSurface ( TrackStateOnSurface && trackStateOnSurface )

noexcept

Move ctor.

Definition at line 98 of file TrackStateOnSurface.cxx.

  : m_fitQualityOnSurface(rhs.m_fitQualityOnSurface)
  , m_trackParameters(std::move(rhs.m_trackParameters))
  , m_measurementOnTrack(std::move(rhs.m_measurementOnTrack))
  , m_materialEffectsOnTrack(std::move(rhs.m_materialEffectsOnTrack))
  , m_alignmentEffectsOnTrack(std::move(rhs.m_alignmentEffectsOnTrack))
  , m_typeFlags(rhs.m_typeFlags)
{
}

~TrackStateOnSurface()

virtual Trk::TrackStateOnSurface::~TrackStateOnSurface ( )

virtualdefault

destructor

Member Function Documentation

alignmentEffectsOnTrack() [1/2]

AlignmentEffectsOnTrack * Trk::TrackStateOnSurface::alignmentEffectsOnTrack

(

)

return the the alignment effects non-const overload

alignmentEffectsOnTrack() [2/2]

const AlignmentEffectsOnTrack * Trk::TrackStateOnSurface::alignmentEffectsOnTrack

(

)

const

return the the alignment effects const overload

clone()

virtual TrackStateOnSurface * Trk::TrackStateOnSurface::clone ( ) const

virtual

Pseudo-constructor: needed to avoid excessive RTTI.

Reimplemented in Trk::MultiComponentStateOnSurface.

dumpType()

std::string Trk::TrackStateOnSurface::dumpType

(

)

const

returns a string with the expanded type of the object (i.e.

if it has several type bits set, they all will be returned)

Definition at line 147 of file TrackStateOnSurface.cxx.

{
  std::string type;
  const auto& typesSet = types();
  if (typesSet.test(TrackStateOnSurface::Measurement)) {
    type += "Measurement ";
  }
  if (typesSet.test(TrackStateOnSurface::InertMaterial)) {
    type += "InertMaterial ";
  }
  if (typesSet.test(TrackStateOnSurface::BremPoint)) {
    type += "BremPoint ";
  }
  if (typesSet.test(TrackStateOnSurface::Scatterer)) {
    type += "Scatterer ";
  }
  if (typesSet.test(TrackStateOnSurface::Perigee)) {
    type += "Perigee ";
  }
  if (typesSet.test(TrackStateOnSurface::Outlier)) {
    type += "Outlier ";
  }
  if (typesSet.test(TrackStateOnSurface::Hole)) {
    type += "Hole ";
  }
  if (typesSet.test(TrackStateOnSurface::CaloDeposit)) {
    type += "CaloDeposit ";
  }
  if (typesSet.test(TrackStateOnSurface::Parameter)) {
    type += "Parameter ";
  }
  if (typesSet.test(TrackStateOnSurface::FitQuality)) {
    type += "FitQuality ";
  }
  if (typesSet.test(TrackStateOnSurface::Alignment)) {
    type += "Alignment ";
  }
  return type;
}

fitQualityOnSurface() [1/2]

FitQualityOnSurface & Trk::TrackStateOnSurface::fitQualityOnSurface

(

)

return FitQuality On Surface non-const overload

fitQualityOnSurface() [2/2]

const FitQualityOnSurface & Trk::TrackStateOnSurface::fitQualityOnSurface

(

)

const

return FitQuality On Surface const overload

hints()

const std::bitset< NumberOfPersistencyHints > Trk::TrackStateOnSurface::hints

(

)

const

Use this method to get the persistification hints.

isSane()

bool Trk::TrackStateOnSurface::isSane

(

)

const

Definition at line 203 of file TrackStateOnSurface.cxx.

{
  bool surfacesDiffer =
    not Trk::consistentSurfaces(trackParameters(),
                                measurementOnTrack(),
                                materialEffectsOnTrack());
  if (surfacesDiffer) {
    std::cerr << "TrackStateOnSurface::isSane. With :" << '\n';
    std::cerr << "Types : " << types().to_string() << '\n';
    std::cerr << "Hints " << hints().to_string() << '\n';
    std::cerr << "Surfaces differ! " << std::endl;
    if (m_trackParameters) {
      std::cerr << "ParamSurf: [" << &(m_trackParameters->associatedSurface())
                << "] " << m_trackParameters->associatedSurface() << std::endl;
    }
    if (m_measurementOnTrack) {
      std::cerr << "measSurf: [" << &(m_measurementOnTrack->associatedSurface())
                << "] " << m_measurementOnTrack->associatedSurface()
                << std::endl;
    }
    if (m_materialEffectsOnTrack) {
      std::cerr << "matSurf: ["
                << &(m_materialEffectsOnTrack->associatedSurface()) << "] "
                << m_materialEffectsOnTrack->associatedSurface() << std::endl;
    }
    return false;
  }
 
  return true;
}

joinBitsets()

unsigned int long Trk::TrackStateOnSurface::joinBitsets ( const std::bitset< NumberOfTrackStateOnSurfaceTypes > & types, const std::bitset< NumberOfPersistencyHints > & hints )

inlinestatic

Definition at line 183 of file TrackStateOnSurface.h.

  {
    //put hints in place
    unsigned int long res = hints.to_ulong();
    //shift them up
    res = (res << NumberOfTrackStateOnSurfaceTypes);
    //Add type
    res += types.to_ulong();
    return res;
  }

materialEffectsOnTrack() [1/2]

MaterialEffectsBase * Trk::TrackStateOnSurface::materialEffectsOnTrack

(

)

return material effects non-const overload

materialEffectsOnTrack() [2/2]

const MaterialEffectsBase * Trk::TrackStateOnSurface::materialEffectsOnTrack

(

)

const

return material effects const overload

measurementOnTrack() [1/2]

MeasurementBase * Trk::TrackStateOnSurface::measurementOnTrack

(

)

returns MeasurementBase non-const overload

measurementOnTrack() [2/2]

const MeasurementBase * Trk::TrackStateOnSurface::measurementOnTrack

(

)

const

returns MeasurementBase const overload

operator=() [1/2]

TrackStateOnSurface & Trk::TrackStateOnSurface::operator=

(

const Trk::TrackStateOnSurface &

rhs

)

Definition at line 110 of file TrackStateOnSurface.cxx.

{
  if (this != &rhs) {
    m_fitQualityOnSurface = rhs.m_fitQualityOnSurface;
    m_trackParameters.reset(
        rhs.m_trackParameters ? rhs.m_trackParameters->clone() : nullptr);
    m_measurementOnTrack.reset(
        rhs.m_measurementOnTrack ? rhs.m_measurementOnTrack->clone() : nullptr);
    m_materialEffectsOnTrack.reset(rhs.m_materialEffectsOnTrack
                                       ? rhs.m_materialEffectsOnTrack->clone()
                                       : nullptr);
    m_alignmentEffectsOnTrack = rhs.m_alignmentEffectsOnTrack
                                    ? std::make_unique<AlignmentEffectsOnTrack>(
                                          *rhs.m_alignmentEffectsOnTrack)
                                    : nullptr;
    m_typeFlags = rhs.m_typeFlags;
    assert(isSane());
  }
  return *this;
}

operator=() [2/2]

TrackStateOnSurface & Trk::TrackStateOnSurface::operator= ( Trk::TrackStateOnSurface && rhs )

noexcept

Definition at line 133 of file TrackStateOnSurface.cxx.

{
  if (this != &rhs) {
    m_fitQualityOnSurface = rhs.m_fitQualityOnSurface;
    m_trackParameters = std::move(rhs.m_trackParameters);
    m_measurementOnTrack = std::move(rhs.m_measurementOnTrack);
    m_materialEffectsOnTrack = std::move(rhs.m_materialEffectsOnTrack);
    m_alignmentEffectsOnTrack = std::move(rhs.m_alignmentEffectsOnTrack);
    m_typeFlags = rhs.m_typeFlags;
  }
  return *this;
}

setFlags()

void Trk::TrackStateOnSurface::setFlags ( )

private

set sensible default flags

setHints()

void Trk::TrackStateOnSurface::setHints

(

const uint8_t

hints

)

const

Use this method to set persistification hints.

This can be called only once per TSOS It will set a cached Value which we can not reset But this allows it to be const..

Definition at line 235 of file TrackStateOnSurface.cxx.

{
  // The extra "hidden" bit we save (1<<NumberOfPersistencyHints)
  // is to dissalow repeated calls to setHints(0).
  uint8_t exp = 0;
  if (!m_hints.compare_exchange_strong(
        exp, hints | (1 << NumberOfPersistencyHints))) {
    throw std::runtime_error(
      "TSOS trying to set again already set Persistification Hints");
  }
}

splitToBitsets()

void Trk::TrackStateOnSurface::splitToBitsets ( const unsigned int long input, std::bitset< NumberOfTrackStateOnSurfaceTypes > & types, std::bitset< NumberOfPersistencyHints > & hints )

inlinestatic

Definition at line 196 of file TrackStateOnSurface.h.

  {
    // mask with NumberOfTrackStateOnSurfaceTypes bits set to 1
    constexpr unsigned int long maskTypesSet =
      (1 << NumberOfTrackStateOnSurfaceTypes) - 1;
    //keep just the Type part of the input
    types = std::bitset<NumberOfTrackStateOnSurfaceTypes>(input & maskTypesSet);
    //keep the upper Hints part of the input
    hints = std::bitset<NumberOfPersistencyHints>(
      input >> NumberOfTrackStateOnSurfaceTypes);
  }

surface()

const Surface & Trk::TrackStateOnSurface::surface

(

)

const

return associated surface

Used to perform sanity checks on this object (i.e. all consistuents are on the same surface). Returns 'true' if it seems okay.

Definition at line 188 of file TrackStateOnSurface.cxx.

{
  if (m_trackParameters) {
    return m_trackParameters->associatedSurface();
  }
  if (m_measurementOnTrack) {
    return m_measurementOnTrack->associatedSurface();
  }
  if (m_materialEffectsOnTrack) {
    return m_materialEffectsOnTrack->associatedSurface();
  }
  throw std::runtime_error("TrackStateOnSurface without Surface!");
}

trackParameters() [1/2]

TrackParameters * Trk::TrackStateOnSurface::trackParameters

(

)

return ptr to trackparameters non-const overload

trackParameters() [2/2]

const TrackParameters * Trk::TrackStateOnSurface::trackParameters

(

)

const

return ptr to trackparameters const overload

type()

bool Trk::TrackStateOnSurface::type

(

const TrackStateOnSurfaceType

type

)

const

Use this method to find out if the TSoS is of a certain type: i.e.

if ( tsos->type(TrackStateOnSurface::Measurement) { //etc }

Returns

true if the TrackStateOnSurface is of this type

types()

const std::bitset< NumberOfTrackStateOnSurfaceTypes > Trk::TrackStateOnSurface::types

(

)

const

returns a bitset with the types of this bitset.

As an example of how this is used, see the type( const TrackStateOnSurfaceType& type ) method but a better example would be if you wanted to check several type flags at once.

const bitset<NumberOfTrackStateOnSurfaceTypes> mask;
mask.set(Measurement,true);
mask.set(BremPoint,true);
// loop over lots of TSoS and call:
if (tsos.types() & mask ) { // do something}

variety()

virtual Trk::TrackStateOnSurface::Variety Trk::TrackStateOnSurface::variety ( ) const

virtual

Use this method to find if this is a Single, Multi or Align TrackStateOnsurface.

Reimplemented in Trk::AlignTSOS, and Trk::MultiComponentStateOnSurface.

Friends And Related Symbol Documentation

::TrackCollectionCnv

friend class ::TrackCollectionCnv

friend

Definition at line 72 of file TrackStateOnSurface.h.

::TrackStateOnSurfaceCnv_p3

friend class ::TrackStateOnSurfaceCnv_p3

friend

Definition at line 73 of file TrackStateOnSurface.h.

Member Data Documentation

m_alignmentEffectsOnTrack

std::unique_ptr<AlignmentEffectsOnTrack> Trk::TrackStateOnSurface::m_alignmentEffectsOnTrack {}

private

Definition at line 371 of file TrackStateOnSurface.h.

{};

m_fitQualityOnSurface

FitQualityOnSurface Trk::TrackStateOnSurface::m_fitQualityOnSurface {}

private

Definition at line 367 of file TrackStateOnSurface.h.

{};

m_hints

std::atomic<uint8_t> Trk::TrackStateOnSurface::m_hints {}

mutableprotected

Definition at line 374 of file TrackStateOnSurface.h.

{};

m_materialEffectsOnTrack

std::unique_ptr<MaterialEffectsBase> Trk::TrackStateOnSurface::m_materialEffectsOnTrack {}

private

Definition at line 370 of file TrackStateOnSurface.h.

{};

m_measurementOnTrack

std::unique_ptr<MeasurementBase> Trk::TrackStateOnSurface::m_measurementOnTrack {}

private

Definition at line 369 of file TrackStateOnSurface.h.

{};

m_trackParameters

std::unique_ptr<TrackParameters> Trk::TrackStateOnSurface::m_trackParameters {}

private

Definition at line 368 of file TrackStateOnSurface.h.

{};

m_typeFlags

uint16_t Trk::TrackStateOnSurface::m_typeFlags {}

protected

Definition at line 373 of file TrackStateOnSurface.h.

{};

---

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

• TrackStateOnSurface.h
• TrackStateOnSurface.cxx