Acts/Geometry/ConeVolumeBounds.hpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2020 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 http://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(ActsScalar innerAlpha, ActsScalar innerOffsetZ,
0060                    ActsScalar outerAlpha, ActsScalar outerOffsetZ,
0061                    ActsScalar halflengthZ, ActsScalar averagePhi,
0062                    ActsScalar halfPhiSector) noexcept(false);
0063
0064   /// Constructor - for general cylidner-cone setups
0065   ///
0066   /// @param cylinderR The inner radius of the cylinder
0067   /// @param alpha  The opening angle of the cone (0 if no cone)
0068   /// @param offsetZ The tip  z position in of the cone, w.r.t center
0069   /// @param halflengthZ The minimum z value of the inner and outer cones
0070   /// @param averagePhi The phi orientation of the sector (defaulted to 0)
0071   /// @param halfPhiSector The opening angle phi sector
0072   ///
0073   /// @note depending on cylinderR > coneR it is constructing a cone with
0074   /// cylindrical cutout or a cylinder with conical cutout
0075   ConeVolumeBounds(ActsScalar cylinderR, ActsScalar alpha, ActsScalar offsetZ,
0076                    ActsScalar halflengthZ, ActsScalar averagePhi,
0077                    ActsScalar halfPhiSector) noexcept(false);
0078
0079   /// Constructor - from a fixed size array
0080   ///
0081   /// @param values The bound values
0082   ConeVolumeBounds(const std::array<ActsScalar, eSize>& values) noexcept(false)
0083       : m_values(values) {
0084     checkConsistency();
0085     buildSurfaceBounds();
0086   }
0087
0088   ConeVolumeBounds(const ConeVolumeBounds& cobo) = default;
0089   ~ConeVolumeBounds() override = default;
0090   ConeVolumeBounds& operator=(const ConeVolumeBounds& cobo) = default;
0091
0092   VolumeBounds::BoundsType type() const final { return VolumeBounds::eCone; }
0093
0094   /// Return the bound values as dynamically sized vector
0095   ///
0096   /// @return this returns a copy of the internal values
0097   std::vector<ActsScalar> values() const final;
0098
0099   /// This method checks if position in the 3D volume
0100   /// frame is inside the cylinder
0101   ///
0102   /// @param pos is the position in volume frame to be checked
0103   /// @param tol is the absolute tolerance to be applied
0104   bool inside(const Vector3& pos, ActsScalar tol = 0.) const final;
0105
0106   /// Oriented surfaces, i.e. the decomposed boundary surfaces and the
0107   /// according navigation direction into the volume given the normal
0108   /// vector on the surface
0109   ///
0110   /// @param transform is the 3D transform to be applied to the boundary
0111   /// surfaces to position them in 3D space
0112   ///
0113   /// It will throw an exception if the orientation prescription is not adequate
0114   ///
0115   /// @return a vector of surfaces bounding this volume
0116   std::vector<OrientedSurface> orientedSurfaces(
0117       const Transform3& transform = Transform3::Identity()) const final;
0118
0119   /// Construct bounding box for this shape
0120   /// @param trf Optional transform
0121   /// @param envelope Optional envelope to add / subtract from min/max
0122   /// @param entity Entity to associate this bounding box with
0123   /// @return Constructed bounding box
0124   Volume::BoundingBox boundingBox(const Transform3* trf = nullptr,
0125                                   const Vector3& envelope = {0, 0, 0},
0126                                   const Volume* entity = nullptr) const final;
0127
0128   /// Access to the bound values
0129   /// @param bValue the class nested enum for the array access
0130   ActsScalar get(BoundValues bValue) const { return m_values[bValue]; }
0131
0132   // Return the derived innerRmin
0133   ActsScalar innerRmin() const;
0134
0135   // Return the derived innerRmin
0136   ActsScalar innerRmax() const;
0137
0138   // Return the derived inner tan(alpha)
0139   ActsScalar innerTanAlpha() const;
0140
0141   // Return the derived outerRmin
0142   ActsScalar outerRmin() const;
0143
0144   // Return the derived outerRmax
0145   ActsScalar outerRmax() const;
0146
0147   // Return the derived outer tan(alpha)
0148   ActsScalar outerTanAlpha() const;
0149
0150   /// Output Method for std::ostream
0151   ///
0152   /// @param os is ostream operator to be dumped into
0153   std::ostream& toStream(std::ostream& os) const final;
0154
0155  private:
0156   /// Check the input values for consistency,
0157   /// will throw a logic_exception if consistency is not given
0158   void checkConsistency() noexcept(false);
0159
0160   /// Create the surface bounds
0161   void buildSurfaceBounds();
0162
0163   /// The bound values
0164   std::array<ActsScalar, eSize> m_values;
0165   std::shared_ptr<CylinderBounds> m_innerCylinderBounds{nullptr};
0166   std::shared_ptr<ConeBounds> m_innerConeBounds{nullptr};
0167   std::shared_ptr<ConeBounds> m_outerConeBounds{nullptr};
0168   std::shared_ptr<CylinderBounds> m_outerCylinderBounds{nullptr};
0169   std::shared_ptr<RadialBounds> m_negativeDiscBounds{nullptr};
0170   std::shared_ptr<RadialBounds> m_positiveDiscBounds{nullptr};
0171   std::shared_ptr<PlanarBounds> m_sectorBounds{nullptr};
0172
0173   /// Derived values
0174   ActsScalar m_innerRmin = 0.;
0175   ActsScalar m_innerRmax = 0.;
0176   ActsScalar m_innerTanAlpha = 0.;
0177   ActsScalar m_outerRmin = 0.;
0178   ActsScalar m_outerRmax = 0.;
0179   ActsScalar m_outerTanAlpha = 0.;
0180 };
0181
0182 }  // namespace Acts