Muon::CompetingMuonClustersOnTrack Class Reference

Class for competing MuonClusters, it extends the Trk::CompetingRIOsOnTrack base class. More...

#include <CompetingMuonClustersOnTrack.h>

Inheritance diagram for Muon::CompetingMuonClustersOnTrack:

Collaboration diagram for Muon::CompetingMuonClustersOnTrack:

Public Types
typedef double	AssignmentProb
	Type def of Assignment probability: probability for a certain RIO_OnTrack to be assigned to the track.

Public Member Functions
	CompetingMuonClustersOnTrack ()=default
	Default Constructor for POOL.
	CompetingMuonClustersOnTrack (const CompetingMuonClustersOnTrack &compROT)
	Copy Constructor.
	CompetingMuonClustersOnTrack (CompetingMuonClustersOnTrack &&compROT)=default
	Move constructor.
CompetingMuonClustersOnTrack &	operator= (const CompetingMuonClustersOnTrack &compROT) noexcept
	Assignment operator.
CompetingMuonClustersOnTrack &	operator= (CompetingMuonClustersOnTrack &&compROT) noexcept=default
	CompetingMuonClustersOnTrack (std::vector< std::unique_ptr< const MuonClusterOnTrack > > &&childrots, std::vector< AssignmentProb > &&assgnProb)
	Constructor with all parameters: PLEASE do not use directly, but call Muon::CompetingMuonClustersOnTrackTool, otherwise inconsistency of the data will be very probable.
	CompetingMuonClustersOnTrack (Trk::LocalParameters &&locPars, Amg::MatrixX &&error, const Trk::Surface *assSurf, std::vector< std::unique_ptr< const MuonClusterOnTrack > > &&childrots, std::vector< AssignmentProb > &&assgnProb)
	constructor taking the local parameters + error matrix + associated surface directly, instead of using the base-class to recalculate them
virtual	~CompetingMuonClustersOnTrack ()=default
	Destructor.
CompetingMuonClustersOnTrack *	clone () const
	needed to avoid excessive RTTI
const Trk::Surface &	associatedSurface () const
	returns the surface for the local to global transformation .
const Trk::Surface *	associatedSurfaceRaw () const
const Amg::Vector3D &	globalPosition () const
	Interface method to get the global Position.
unsigned int	numberOfContainedROTs () const
	Number of RIO_OnTracks to be contained by this CompetingRIOsOnTrack.
const std::vector< std::unique_ptr< const MuonClusterOnTrack > > &	containedROTs () const
	returns the vector of SCT_ClusterOnTrack objects .
const MuonClusterOnTrack &	rioOnTrack (unsigned int) const
	returns the RIO_OnTrack (also known as ROT) objects depending on the integer
MsgStream &	dump (MsgStream &out) const
	returns some information about this MeasurementBase/CompetingMuonClustersOnTrack.
std::ostream &	dump (std::ostream &out) const
	returns some information about this MeasurementBase/CompetingMuonClustersOnTrack.
std::unique_ptr< CompetingRIOsOnTrack >	uniqueClone () const
	NVI Clone.
unsigned int	indexOfMaxAssignProb () const
	Index of the ROT with the highest assignment probability.
AssignmentProb	assignmentProbability (unsigned int indx) const
	returns the AssignmentProbability depending on the integer.
virtual void	setLocalParametersAndErrorMatrix ()
	recalculate the LocalParameters and ErrorMatrix
virtual bool	type (MeasurementBaseType::Type type) const override final
	Extended method checking the type.
const LocalParameters &	localParameters () const
	Interface method to get the LocalParameters.
const Amg::MatrixX &	localCovariance () const
	Interface method to get the localError.
const Surface *	surfacePtr ()
	return the ptr we hold useful for tests
const Surface *	release () noexcept
	release ala unique_ptr release
void	destroySurface () noexcept
	destroySurface deletes the ptr if not null and the surface has not a associatedDetectorElement Usefull also for testing

Static Public Member Functions
static const Surface *	cloneHelper (const Surface *input)
	Helper for cloning or not when we need depending on if we have an associatedDetectorElement.

Protected Attributes
std::vector< AssignmentProb >	m_assignProb
	assignment probabilities of the ROTs
LocalParameters	m_localParams
Amg::MatrixX	m_localCovariance
const Surface *	m_associatedSurface

Private Member Functions
bool	ROTsHaveCommonSurface (const bool withNonVanishingAssignProb=true) const
	Have all the contained ROTs a common associated surface?

Private Attributes
CxxUtils::CachedUniquePtr< const Amg::Vector3D >	m_globalPosition {}
	The global Position.
std::vector< std::unique_ptr< const MuonClusterOnTrack > >	m_containedChildRots {}
	The vector of contained Muon::MuonClusterOnTrack objects.

Friends
class	CompetingMuonClustersOnTrackTool
	Muon::CompetingMuonClustersOnTrackTool is a friend to allow for updates of the assignment probabilities.

Detailed Description

Class for competing MuonClusters, it extends the Trk::CompetingRIOsOnTrack base class.

This class is used for two use cases:

• by the Deterministic Annealing Filter to handle several MuonClusterOnTrack in one detector element, which compete against each other in being assigned to a track.
• to handle reclustering on ROT level

Author

Niels van Eldik

Definition at line 51 of file CompetingMuonClustersOnTrack.h.

Member Typedef Documentation

AssignmentProb

typedef double Trk::CompetingRIOsOnTrack::AssignmentProb

inherited

Type def of Assignment probability: probability for a certain RIO_OnTrack to be assigned to the track.

Definition at line 69 of file CompetingRIOsOnTrack.h.

Constructor & Destructor Documentation

CompetingMuonClustersOnTrack() [1/5]

Muon::CompetingMuonClustersOnTrack::CompetingMuonClustersOnTrack ( )

default

Default Constructor for POOL.

CompetingMuonClustersOnTrack() [2/5]

Muon::CompetingMuonClustersOnTrack::CompetingMuonClustersOnTrack

(

const CompetingMuonClustersOnTrack &

compROT

)

Copy Constructor.

Definition at line 20 of file CompetingMuonClustersOnTrack.cxx.

                                                                                                     :
   CompetingMuonClustersOnTrack{} {
    (*this) = compROT;
}

CompetingMuonClustersOnTrack() [3/5]

Muon::CompetingMuonClustersOnTrack::CompetingMuonClustersOnTrack ( CompetingMuonClustersOnTrack && compROT )

default

Move constructor.

CompetingMuonClustersOnTrack() [4/5]

Muon::CompetingMuonClustersOnTrack::CompetingMuonClustersOnTrack	(	std::vector< std::unique_ptr< const MuonClusterOnTrack > > &&	childrots,
		std::vector< AssignmentProb > &&	assgnProb )

Constructor with all parameters: PLEASE do not use directly, but call Muon::CompetingMuonClustersOnTrackTool, otherwise inconsistency of the data will be very probable.

• The constructor takes following parameters:

  Parameters

  childrots	a vector of MuonClusterOnTrack objects that form the CompetingMuonClustersOnTrack
  assgnProb	a vector with the assignment probabilities for each of the child ROTs

Definition at line 26 of file CompetingMuonClustersOnTrack.cxx.

  : Trk::CompetingRIOsOnTrack(std::move(assgnProb))
  , m_containedChildRots(std::move(childrots))
{
  setLocalParametersAndErrorMatrix();
}

CompetingMuonClustersOnTrack() [5/5]

Muon::CompetingMuonClustersOnTrack::CompetingMuonClustersOnTrack	(	Trk::LocalParameters &&	locPars,
		Amg::MatrixX &&	error,
		const Trk::Surface *	assSurf,
		std::vector< std::unique_ptr< const MuonClusterOnTrack > > &&	childrots,
		std::vector< AssignmentProb > &&	assgnProb )

constructor taking the local parameters + error matrix + associated surface directly, instead of using the base-class to recalculate them

Parameters

locPars	the Trk::LocalParameters of the new CompetingMuonClustersOnTrack
error	the Amg::MatrixX of the new CompetingMuonClustersOnTrack
assSurf	the surface at which the local parameters and erro are expressed
childrots	a vector of MuonClusterOnTrack objects that form the CompetingMuonClustersOnTrack
assgnProb	a vector with the assignment probabilities for each of the child ROTs

Definition at line 35 of file CompetingMuonClustersOnTrack.cxx.

  : Trk::CompetingRIOsOnTrack{std::move(assgnProb)}
  , Trk::SurfacePtrHolderDetEl{assSurf}
  , m_containedChildRots(std::move(childrots))
{
  Trk::MeasurementBase::m_localParams = std::move(locPars);
  Trk::MeasurementBase::m_localCovariance = std::move(error);
}

~CompetingMuonClustersOnTrack()

virtual Muon::CompetingMuonClustersOnTrack::~CompetingMuonClustersOnTrack ( )

virtualdefault

Destructor.

Member Function Documentation

assignmentProbability()

CompetingRIOsOnTrack::AssignmentProb Trk::CompetingRIOsOnTrack::assignmentProbability ( unsigned int indx ) const

inlineinherited

returns the AssignmentProbability depending on the integer.

• extends MeasurementBase

Definition at line 139 of file CompetingRIOsOnTrack.h.

{
  assert(indx < numberOfContainedROTs());
  if (indx < numberOfContainedROTs()) {
    return m_assignProb[indx];
  }
  return 0; // could consider throwing an exception here - EJWM
}

associatedSurface()

const Trk::Surface & Muon::CompetingMuonClustersOnTrack::associatedSurface ( ) const

inlinevirtual

returns the surface for the local to global transformation .

• interface from MeasurementBase

Implements Trk::MeasurementBase.

Definition at line 159 of file CompetingMuonClustersOnTrack.h.

{
  if (m_associatedSurface) {
    return *m_associatedSurface;
  }
  return m_containedChildRots.front()->associatedSurface();
}

associatedSurfaceRaw()

const Trk::Surface * Muon::CompetingMuonClustersOnTrack::associatedSurfaceRaw ( ) const

inline

Definition at line 168 of file CompetingMuonClustersOnTrack.h.

{
  return m_associatedSurface;
}

clone()

CompetingMuonClustersOnTrack * Muon::CompetingMuonClustersOnTrack::clone ( ) const

inlinevirtual

needed to avoid excessive RTTI

Implements Trk::CompetingRIOsOnTrack.

Definition at line 153 of file CompetingMuonClustersOnTrack.h.

{
  return new CompetingMuonClustersOnTrack(*this);
}

cloneHelper()

const Surface * Trk::SurfacePtrHolderImplDetEl< Surface >::cloneHelper ( const Surface * input )

inlinestaticinherited

Helper for cloning or not when we need depending on if we have an associatedDetectorElement.

Definition at line 213 of file SurfaceHolderImpl.h.

  {
    return (input && input->associatedDetectorElement() == nullptr
              ? input->clone()
              : input);
  }

containedROTs()

const std::vector< std::unique_ptr< const MuonClusterOnTrack > > & Muon::CompetingMuonClustersOnTrack::containedROTs ( ) const

inline

returns the vector of SCT_ClusterOnTrack objects .

• specific for this CompetingMuonClustersOnTrack: MuonClusterOnTrack

Definition at line 180 of file CompetingMuonClustersOnTrack.h.

                                                 {
  return m_containedChildRots;
}

destroySurface()

void Trk::SurfacePtrHolderImplDetEl< Surface >::destroySurface ( )

inlinenoexceptinherited

destroySurface deletes the ptr if not null and the surface has not a associatedDetectorElement Usefull also for testing

Definition at line 201 of file SurfaceHolderImpl.h.

  {
    if (m_associatedSurface &&
        m_associatedSurface->associatedDetectorElement() == nullptr) {
      delete m_associatedSurface;
    }
    //
    m_associatedSurface = nullptr;
  }

dump() [1/2]

MsgStream & Muon::CompetingMuonClustersOnTrack::dump ( MsgStream & out ) const

virtual

returns some information about this MeasurementBase/CompetingMuonClustersOnTrack.

Reimplemented from Trk::CompetingRIOsOnTrack.

Definition at line 71 of file CompetingMuonClustersOnTrack.cxx.

{
  out << "Muon::CompetingMuonClustersOnTrack (Muon competingROTs) "
      << std::endl;
  out << "  - it contains   : " << m_containedChildRots.size()
      << " RIO_OnTrack objects" << std::endl;
  out << "  - parameters     : " << std::endl;
  out << "  - parameter key : " << std::endl;
  return out;
}

dump() [2/2]

std::ostream & Muon::CompetingMuonClustersOnTrack::dump ( std::ostream & out ) const

virtual

returns some information about this MeasurementBase/CompetingMuonClustersOnTrack.

Reimplemented from Trk::CompetingRIOsOnTrack.

Definition at line 83 of file CompetingMuonClustersOnTrack.cxx.

{
  out << "Muon::CompetingMuonClustersOnTrack (Muon competingROTs) "
      << std::endl;
  out << "  - it contains   : " << m_containedChildRots.size()
      << " RIO_OnTrack objects" << std::endl;
  out << "  - it contains   : " << numberOfContainedROTs()
      << " RIO_OnTrack objects" << std::endl;
  out << "  - parameters     : " << std::endl;
  out << "  - parameter key : " << std::endl;
  return out;
}

globalPosition()

const Amg::Vector3D & Muon::CompetingMuonClustersOnTrack::globalPosition ( ) const

inlinevirtual

Interface method to get the global Position.

• interface from MeasurementBase

Implements Trk::MeasurementBase.

Definition at line 191 of file CompetingMuonClustersOnTrack.h.

{
  if (not m_globalPosition) {
    m_globalPosition.set(std::make_unique<const Amg::Vector3D>(
      associatedSurface().localToGlobal(localParameters())));
  }
  return (*m_globalPosition);
}

indexOfMaxAssignProb()

unsigned int Trk::CompetingRIOsOnTrack::indexOfMaxAssignProb ( ) const

inherited

Index of the ROT with the highest assignment probability.

• extends MeasurementBase

Definition at line 100 of file CompetingRIOsOnTrack.cxx.

{
  unsigned int index = 0;
  double maxAssgnProb = 0;
  for (unsigned int i = 0; i < numberOfContainedROTs(); i++) {
    if (m_assignProb[i] >= maxAssgnProb) {
      index = i;
      maxAssgnProb = m_assignProb[i];
    }
  }
  return index;
}

localCovariance()

const Amg::MatrixX & Trk::MeasurementBase::localCovariance ( ) const

inlineinherited

Interface method to get the localError.

Definition at line 138 of file MeasurementBase.h.

{
  return m_localCovariance;
}

localParameters()

const Trk::LocalParameters & Trk::MeasurementBase::localParameters ( ) const

inlineinherited

Interface method to get the LocalParameters.

Definition at line 132 of file MeasurementBase.h.

{
  return m_localParams;
}

numberOfContainedROTs()

unsigned int Muon::CompetingMuonClustersOnTrack::numberOfContainedROTs ( ) const

inlinevirtual

Number of RIO_OnTracks to be contained by this CompetingRIOsOnTrack.

Implements Trk::CompetingRIOsOnTrack.

Definition at line 174 of file CompetingMuonClustersOnTrack.h.

{
  return m_containedChildRots.size();
}

operator=() [1/2]

CompetingMuonClustersOnTrack & Muon::CompetingMuonClustersOnTrack::operator= ( CompetingMuonClustersOnTrack && compROT )

defaultnoexcept

operator=() [2/2]

CompetingMuonClustersOnTrack & Muon::CompetingMuonClustersOnTrack::operator= ( const CompetingMuonClustersOnTrack & compROT )

noexcept

Assignment operator.

Definition at line 50 of file CompetingMuonClustersOnTrack.cxx.

{
  if (this != &compROT) {
    // assingment operator of base class
    Trk::CompetingRIOsOnTrack::operator=(compROT);
    Trk::SurfacePtrHolderDetEl::operator=(compROT);
    m_globalPosition.release();
    m_containedChildRots.clear();
    std::ranges::transform(compROT.m_containedChildRots, 
                           std::back_inserter(m_containedChildRots),
                           [](const std::unique_ptr<const MuonClusterOnTrack>& cluster) {
                              return std::unique_ptr<const MuonClusterOnTrack>{cluster->clone()};
                           });
 
  }
  return (*this);
}

release()

const Surface * Trk::SurfacePtrHolderImplDetEl< Surface >::release ( )

inlinenoexceptinherited

release ala unique_ptr release

Definition at line 192 of file SurfaceHolderImpl.h.

  {
    const S* tmp = m_associatedSurface;
    m_associatedSurface = nullptr;
    return tmp;
  }

rioOnTrack()

const MuonClusterOnTrack & Muon::CompetingMuonClustersOnTrack::rioOnTrack ( unsigned int indx ) const

inlinevirtual

returns the RIO_OnTrack (also known as ROT) objects depending on the integer

Implements Trk::CompetingRIOsOnTrack.

Definition at line 185 of file CompetingMuonClustersOnTrack.h.

{
  return *m_containedChildRots.at(indx).get();
}

ROTsHaveCommonSurface()

bool Muon::CompetingMuonClustersOnTrack::ROTsHaveCommonSurface ( const bool withNonVanishingAssignProb = true ) const

privatevirtual

Have all the contained ROTs a common associated surface?

If withNonVanishingAssignProb==true just the ROTs with non-vanishing assignment probabilities are checked.

• interface from CompetingRIOsOnTrack

Implements Trk::CompetingRIOsOnTrack.

Definition at line 98 of file CompetingMuonClustersOnTrack.cxx.

{
  return true;
}

setLocalParametersAndErrorMatrix()

void Trk::CompetingRIOsOnTrack::setLocalParametersAndErrorMatrix ( )

virtualinherited

recalculate the LocalParameters and ErrorMatrix

Reimplemented in InDet::CompetingSCT_ClustersOnTrack, and InDet::CompetingTRT_DriftCirclesOnTrack.

Definition at line 33 of file CompetingRIOsOnTrack.cxx.

{
 
  if (ROTsHaveCommonSurface()) {
    // std::cout << "CompROT - weight matrices: " << std::endl;
    // std::cout << "CompROT - [1] " << rioOnTrack(0).localCovariance() << std::endl;
    Amg::MatrixX meanWeightMatrix =
      assignmentProbability(0) * rioOnTrack(0).localCovariance().inverse();
    for (unsigned int i = 1; i < numberOfContainedROTs(); i++) {
      meanWeightMatrix += assignmentProbability(i) * rioOnTrack(i).localCovariance().inverse();
      // std::cout << "CompROT - ["<< i << "] " << rioOnTrack(i).localCovariance() <<
      // std::endl;
    }
    // limit weight values against values too close to 0, otherwise inversion will fail!
    if (meanWeightMatrix.trace() <= 1.0e-15) {
      meanWeightMatrix = Amg::MatrixX(rioOnTrack(0).localCovariance().rows(),
                                      rioOnTrack(0).localCovariance().cols());
      meanWeightMatrix.setZero();
      for (int i = 0; i < meanWeightMatrix.cols(); ++i) {
        meanWeightMatrix(i, i) = 1.0e-10;
      }
    }
    // std::cout << "CompROT - mean weight: " << meanWeightMatrix << std::endl;
    m_localCovariance = meanWeightMatrix.inverse();
    // std::cout << "CompROT - mean covariance: " << localCovariance() << std::endl;
 
    if (numberOfContainedROTs() == 1) {
      m_localParams = rioOnTrack(0).localParameters();
    } else {
      Amg::MatrixX weight = rioOnTrack(0).localCovariance().inverse();
      Amg::VectorX meanParams =
        assignmentProbability(0) * weight * rioOnTrack(0).localParameters();
      for (unsigned int i = 1; i < numberOfContainedROTs(); i++) {
        weight = rioOnTrack(i).localCovariance().inverse();
        meanParams =
          meanParams + assignmentProbability(i) * weight * rioOnTrack(i).localParameters();
      }
      // std::cout << "CompROT - sum params: " << meanParams << std::endl;
      meanParams = localCovariance() * meanParams;
      // std::cout << "CompROT - mean params: " << meanParams << std::endl;
      int paramKey = rioOnTrack(0).localParameters().parameterKey();
      if (paramKey == 1) {
        Trk::DefinedParameter Par1(meanParams[Trk::loc1], Trk::loc1);
        m_localParams = Trk::LocalParameters(Par1);
      } else if (paramKey == 3) {
        Trk::DefinedParameter Par1(meanParams[Trk::loc1], Trk::loc1);
        Trk::DefinedParameter Par2(meanParams[Trk::loc2], Trk::loc2);
        m_localParams = Trk::LocalParameters(Par1, Par2);
      } else {
        std::cout << "Trk::CompetingRIOsOnTrack: can not handle parameter key " << paramKey
                  << std::endl;
      }
    }
  } else {
    // --------------------------------------------------
    // Warning: effective localParams cannot be calculated when ROTs don't lie on the
    //          associated surface without detector specific knowledge.
    // --------------------------------------------------
    // return 0;
    std::cout
      << "Trk::CompetingRIOsOnTrack: can not handle ROTs in different surfaces without "
         "detector specific knowledge "
      << std::endl;
  }
}

surfacePtr()

const Surface * Trk::SurfacePtrHolderImplDetEl< Surface >::surfacePtr ( )

inlineinherited

return the ptr we hold useful for tests

Definition at line 190 of file SurfaceHolderImpl.h.

{ return m_associatedSurface; }

type()

virtual bool Trk::CompetingRIOsOnTrack::type ( MeasurementBaseType::Type type ) const

inlinefinaloverridevirtualinherited

Extended method checking the type.

Implements Trk::MeasurementBase.

Definition at line 116 of file CompetingRIOsOnTrack.h.

  {
    return (type == MeasurementBaseType::CompetingRIOsOnTrack);
  }

uniqueClone()

std::unique_ptr< CompetingRIOsOnTrack > Trk::CompetingRIOsOnTrack::uniqueClone ( ) const

inlineinherited

NVI Clone.

Definition at line 88 of file CompetingRIOsOnTrack.h.

  {
    return std::unique_ptr<CompetingRIOsOnTrack>(clone());
  }

Friends And Related Symbol Documentation

CompetingMuonClustersOnTrackTool

friend class CompetingMuonClustersOnTrackTool

friend

Muon::CompetingMuonClustersOnTrackTool is a friend to allow for updates of the assignment probabilities.

Definition at line 59 of file CompetingMuonClustersOnTrack.h.

Member Data Documentation

m_assignProb

std::vector<AssignmentProb> Trk::CompetingRIOsOnTrack::m_assignProb

protectedinherited

assignment probabilities of the ROTs

Definition at line 125 of file CompetingRIOsOnTrack.h.

m_associatedSurface

const Surface* Trk::SurfacePtrHolderImplDetEl< Surface >::m_associatedSurface

protectedinherited

Definition at line 221 of file SurfaceHolderImpl.h.

m_containedChildRots

std::vector<std::unique_ptr<const MuonClusterOnTrack> > Muon::CompetingMuonClustersOnTrack::m_containedChildRots {}

private

The vector of contained Muon::MuonClusterOnTrack objects.

Definition at line 141 of file CompetingMuonClustersOnTrack.h.

{};

m_globalPosition

CxxUtils::CachedUniquePtr<const Amg::Vector3D> Muon::CompetingMuonClustersOnTrack::m_globalPosition {}

private

The global Position.

Definition at line 138 of file CompetingMuonClustersOnTrack.h.

{};

m_localCovariance

Amg::MatrixX Trk::MeasurementBase::m_localCovariance

protectedinherited

Definition at line 112 of file MeasurementBase.h.

m_localParams

LocalParameters Trk::MeasurementBase::m_localParams

protectedinherited

Definition at line 111 of file MeasurementBase.h.

---

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

• CompetingMuonClustersOnTrack.h
• CompetingMuonClustersOnTrack.cxx