CompetingPixelClustersOnTrack.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
// CompetingPixelClustersOnTrack.h, (c) ATLAS Detector software
 
#ifndef COMPETINGPIXELCLUSTERSONTRACK_H
#define COMPETINGPIXELCLUSTERSONTRACK_H
 
// Trk
#include "CxxUtils/CachedUniquePtr.h"
#include "InDetRIO_OnTrack/PixelClusterOnTrack.h" // cannot forward declare
#include "TrkCompetingRIOsOnTrack/CompetingRIOsOnTrack.h"
#include <iosfwd>
#include <memory>
#include <utility>
 
class MsgStream;
 
namespace Trk {
class PrepRawData;
class LocalParameters;
class Surface;
}
 
namespace InDet {
 
class CompetingPixelClustersOnTrack : public Trk::CompetingRIOsOnTrack
{
 
public:
  friend class CompetingPixelClustersOnTrackTool;
 
  CompetingPixelClustersOnTrack();
  CompetingPixelClustersOnTrack(const CompetingPixelClustersOnTrack& compROT);
  CompetingPixelClustersOnTrack& operator=(const CompetingPixelClustersOnTrack& compROT);
  CompetingPixelClustersOnTrack& operator=(CompetingPixelClustersOnTrack&& compROT) noexcept;
 
  CompetingPixelClustersOnTrack(std::vector<const InDet::PixelClusterOnTrack*>&& childrots,
                                std::vector<AssignmentProb>&& assgnProb);
 
  virtual ~CompetingPixelClustersOnTrack();
 
  CompetingPixelClustersOnTrack* clone() const;
 
  std::unique_ptr<CompetingPixelClustersOnTrack> uniqueClone() const
  {
    return std::unique_ptr<CompetingPixelClustersOnTrack>(clone());
  }
 
  const Trk::Surface& associatedSurface() const;
 
  const Amg::Vector3D& globalPosition() const;
 
  unsigned int numberOfContainedROTs() const;
 
  const std::vector<const InDet::PixelClusterOnTrack*>& containedROTs() const;
 
  const InDet::PixelClusterOnTrack& rioOnTrack(unsigned int) const;
 
  MsgStream& dump(MsgStream& out) const;
  std::ostream& dump(std::ostream& out) const;
 
private:
  void clearChildRotVector();
 
  CxxUtils::CachedUniquePtr<const Amg::Vector3D> m_globalPosition;
 
  std::vector<const InDet::PixelClusterOnTrack*> m_containedChildRots;
 
  bool ROTsHaveCommonSurface(const bool withNonVanishingAssignProb = true) const;
};
 
inline CompetingPixelClustersOnTrack*
CompetingPixelClustersOnTrack::clone() const
{
  return new InDet::CompetingPixelClustersOnTrack(*this);
}
 
inline const Trk::Surface&
CompetingPixelClustersOnTrack::associatedSurface() const
{
  return ((*(std::as_const(m_containedChildRots).begin()))->associatedSurface());
}
 
inline const std::vector<const InDet::PixelClusterOnTrack*>&
CompetingPixelClustersOnTrack::containedROTs() const
{
  return (m_containedChildRots);
}
 
inline const InDet::PixelClusterOnTrack&
CompetingPixelClustersOnTrack::rioOnTrack(unsigned int indx) const
{
  return *std::as_const(m_containedChildRots)[indx];
}
 
inline unsigned int
CompetingPixelClustersOnTrack::numberOfContainedROTs() const
{
  return m_containedChildRots.size();
}
 
}
 
#endif // COMPETINGPIXELCLUSTERSONTRACK_H