Acts/Geometry/ConeVolumeBounds.hpp

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
0008
0009 #pragma once
0010
0011 #include "Acts/Definitions/Algebra.hpp"
0012 #include "Acts/Geometry/Volume.hpp"
0013 #include "Acts/Geometry/VolumeBounds.hpp"
0014 #include "Acts/Utilities/BoundingBox.hpp"
0015
0016 #include <array>
0017 #include <iomanip>
0018 #include <memory>
0019 #include <ostream>
0020 #include <vector>
0021
0022 namespace Acts {
0023
0024 class CylinderBounds;
0025 class ConeBounds;
0026 class RadialBounds;
0027 class PlanarBounds;
0028
0029 /// @class ConeVolumeBounds
0030 ///
0031 /// Volume bound class for describing conical volumes
0032 /// either with cylindrical inlay or outer boundary, it also allows
0033 /// for a sectoral description
0034 class ConeVolumeBounds : public VolumeBounds {
0035  public:
0036   /// @enum BoundValues for readability
0037   enum BoundValues : unsigned int {
0038     eInnerAlpha = 0,
0039     eInnerOffsetZ = 1,
0040     eOuterAlpha = 2,
0041     eOuterOffsetZ = 3,
0042     eHalfLengthZ = 4,
0043     eAveragePhi = 5,
0044     eHalfPhiSector = 6,
0045     eSize
0046   };
0047
0048   ConeVolumeBounds() = delete;
0049
0050   /// Constructor - for general cone-cone setups
0051   ///
0052   /// @param innerAlpha The opening angle of the inner cone (0 if no cone)
0053   /// @param innerOffsetZ The tip z position in of the inner cone, w.r.t center
0054   /// @param outerAlpha  The opening angle of the outer cone (0 if no cone)
0055   /// @param outerOffsetZ The tip z position in of the outer cone, w.r.t center
0056   /// @param halflengthZ The minimum z value of the inner and outer cones
0057   /// @param averagePhi The phi orientation of the sector
0058   /// @param halfPhiSector The opening angle phi sector
0059   ConeVolumeBounds(double innerAlpha, double innerOffsetZ, double outerAlpha,
0060                    double outerOffsetZ, double halflengthZ, double averagePhi,
0061                    double halfPhiSector) noexcept(false);
0062
0063   /// Constructor - for general cylidner-cone setups
0064   ///
0065   /// @param cylinderR The inner radius of the cylinder
0066   /// @param alpha  The opening angle of the cone (0 if no cone)
0067   /// @param offsetZ The tip  z position in of the cone, w.r.t center
0068   /// @param halflengthZ The minimum z value of the inner and outer cones
0069   /// @param averagePhi The phi orientation of the sector (defaulted to 0)
0070   /// @param halfPhiSector The opening angle phi sector
0071   ///
0072   /// @note depending on cylinderR > coneR it is constructing a cone with
0073   /// cylindrical cutout or a cylinder with conical cutout
0074   ConeVolumeBounds(double cylinderR, double alpha, double offsetZ,
0075                    double halflengthZ, double averagePhi,
0076                    double halfPhiSector) noexcept(false);
0077
0078   /// Constructor - from a fixed size array
0079   ///
0080   /// @param values The bound values
0081   ConeVolumeBounds(const std::array<double, eSize>& values) noexcept(false)
0082       : m_values(values) {
0083     checkConsistency();
0084     buildSurfaceBounds();
0085   }
0086
0087   ConeVolumeBounds(const ConeVolumeBounds& cobo) = default;
0088   ~ConeVolumeBounds() override = default;
0089   ConeVolumeBounds& operator=(const ConeVolumeBounds& cobo) = default;
0090
0091   VolumeBounds::BoundsType type() const final { return VolumeBounds::eCone; }
0092
0093   /// Return the bound values as dynamically sized vector
0094   ///
0095   /// @return this returns a copy of the internal values
0096   std::vector<double> values() const final;
0097
0098   /// This method checks if position in the 3D volume
0099   /// frame is inside the cylinder
0100   ///
0101   /// @param pos is the position in volume frame to be checked
0102   /// @param tol is the absolute tolerance to be applied
0103   bool inside(const Vector3& pos, double tol = 0.) const final;
0104
0105   /// Oriented surfaces, i.e. the decomposed boundary surfaces and the
0106   /// according navigation direction into the volume given the normal
0107   /// vector on the surface
0108   ///
0109   /// @param transform is the 3D transform to be applied to the boundary
0110   /// surfaces to position them in 3D space
0111   ///
0112   /// It will throw an exception if the orientation prescription is not adequate
0113   ///
0114   /// @return a vector of surfaces bounding this volume
0115   std::vector<OrientedSurface> orientedSurfaces(
0116       const Transform3& transform = Transform3::Identity()) const final;
0117
0118   /// Construct bounding box for this shape
0119   /// @param trf Optional transform
0120   /// @param envelope Optional envelope to add / subtract from min/max
0121   /// @param entity Entity to associate this bounding box with
0122   /// @return Constructed bounding box
0123   Volume::BoundingBox boundingBox(const Transform3* trf = nullptr,
0124                                   const Vector3& envelope = {0, 0, 0},
0125                                   const Volume* entity = nullptr) const final;
0126
0127   /// Access to the bound values
0128   /// @param bValue the class nested enum for the array access
0129   double get(BoundValues bValue) const { return m_values[bValue]; }
0130
0131   // Return the derived innerRmin
0132   double innerRmin() const;
0133
0134   // Return the derived innerRmin
0135   double innerRmax() const;
0136
0137   // Return the derived inner tan(alpha)
0138   double innerTanAlpha() const;
0139
0140   // Return the derived outerRmin
0141   double outerRmin() const;
0142
0143   // Return the derived outerRmax
0144   double outerRmax() const;
0145
0146   // Return the derived outer tan(alpha)
0147   double outerTanAlpha() const;
0148
0149   /// Output Method for std::ostream
0150   ///
0151   /// @param os is ostream operator to be dumped into
0152   std::ostream& toStream(std::ostream& os) const final;
0153
0154  private:
0155   /// Check the input values for consistency,
0156   /// will throw a logic_exception if consistency is not given
0157   void checkConsistency() noexcept(false);
0158
0159   /// Create the surface bounds
0160   void buildSurfaceBounds();
0161
0162   /// The bound values
0163   std::array<double, eSize> m_values;
0164   std::shared_ptr<CylinderBounds> m_innerCylinderBounds{nullptr};
0165   std::shared_ptr<ConeBounds> m_innerConeBounds{nullptr};
0166   std::shared_ptr<ConeBounds> m_outerConeBounds{nullptr};
0167   std::shared_ptr<CylinderBounds> m_outerCylinderBounds{nullptr};
0168   std::shared_ptr<RadialBounds> m_negativeDiscBounds{nullptr};
0169   std::shared_ptr<RadialBounds> m_positiveDiscBounds{nullptr};
0170   std::shared_ptr<PlanarBounds> m_sectorBounds{nullptr};
0171
0172   /// Derived values
0173   double m_innerRmin = 0.;
0174   double m_innerRmax = 0.;
0175   double m_innerTanAlpha = 0.;
0176   double m_outerRmin = 0.;
0177   double m_outerRmax = 0.;
0178   double m_outerTanAlpha = 0.;
0179 };
0180
0181 }  // namespace Acts