CombinedVolumeBounds.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

// CombinedVolumeBounds.h, (c) ATLAS Detector software
 
#ifndef TRKVOLUMES_COMBINEDVOLUMEBOUNDS_H
#define TRKVOLUMES_COMBINEDVOLUMEBOUNDS_H
 
// Trk
#include "TrkDetDescrUtils/ObjectsAccessor.h"
#include "TrkVolumes/Volume.h"
#include "TrkVolumes/VolumeBounds.h"
 
// Eigen
#include "GeoPrimitives/GeoPrimitives.h"
//
#include <memory>
 
class MsgStream;
 
namespace Trk {
 
class SurfaceBounds;
class Volume;
class Surface;

 
class CombinedVolumeBounds final : public VolumeBounds {
 public:
  CombinedVolumeBounds();

  CombinedVolumeBounds(std::unique_ptr<Volume> first,
                       std::unique_ptr<Volume> second,
                       bool intersection);

  CombinedVolumeBounds(const CombinedVolumeBounds& bobo);

  virtual ~CombinedVolumeBounds();

  CombinedVolumeBounds& operator=(const CombinedVolumeBounds& bobo);

  virtual CombinedVolumeBounds* clone() const override final;

  virtual bool inside(const Amg::Vector3D&, double tol = 0.) const override final;

  virtual std::vector<std::unique_ptr<Trk::Surface>> decomposeToSurfaces
  (const Amg::Transform3D& transform) override final;

  virtual ObjectAccessor boundarySurfaceAccessor(
      const Amg::Vector3D& gp, const Amg::Vector3D& dir,
      bool forceInside = false) const override final;

  const Volume* first() const;

  const Volume* second() const;

  bool intersection() const;

  const std::vector<bool>& boundsOrientation() const;

  virtual MsgStream& dump(MsgStream& sl) const override final;

  virtual std::ostream& dump(std::ostream& sl) const override final;
 
 private:
  static Trk::Volume* createSubtractedVolume(const Amg::Transform3D& transf,
                                             const Trk::Volume* subtrVol);
 
  std::unique_ptr<Volume> m_first{};
  std::unique_ptr<Volume> m_second{};
  bool m_intersection{};
  EightObjectsAccessor m_objectAccessor{};
  std::vector<bool> m_boundsOrientation{};
};
 
inline CombinedVolumeBounds* CombinedVolumeBounds::clone() const {
  return new CombinedVolumeBounds(*this);
}
 
inline bool CombinedVolumeBounds::inside(const Amg::Vector3D& pos, double tol) const {
  if (m_intersection) {
    return (m_first->inside(pos, tol) && m_second->inside(pos, tol));
  }
  return (m_first->inside(pos, tol) || m_second->inside(pos, tol));
}
 
inline const Volume* CombinedVolumeBounds::first() const {
  return m_first.get();
}
 
inline const Volume* CombinedVolumeBounds::second() const {
  return m_second.get();
}
 
inline bool CombinedVolumeBounds::intersection() const {
  return m_intersection;
}
 
inline ObjectAccessor CombinedVolumeBounds::boundarySurfaceAccessor(
    const Amg::Vector3D&, const Amg::Vector3D&, bool) const {
  return Trk::ObjectAccessor(m_objectAccessor);
}
 
inline const std::vector<bool>& CombinedVolumeBounds::boundsOrientation() const {
  return (m_boundsOrientation);
}
 
}  // namespace Trk
 
#endif  // TRKVOLUMES_COMBINEDVOLUMEBOUNDS_H