diff --git a/Core/include/Acts/Geometry/CuboidVolumeBounds.hpp b/Core/include/Acts/Geometry/CuboidVolumeBounds.hpp
index 061ee9a05fb0291ca7e8c4bfeefa35b12c725616..7c9622f3f19c2b83cecb60ddfed8007fff68249d 100644
--- a/Core/include/Acts/Geometry/CuboidVolumeBounds.hpp
+++ b/Core/include/Acts/Geometry/CuboidVolumeBounds.hpp
@@ -127,7 +127,7 @@ class CuboidVolumeBounds : public VolumeBounds {
std::shared_ptr<const RectangleBounds> faceZXRectangleBounds() const;
/// The bound values
- std::vector<TDD_real_t> m_valueStore;
+ std::vector<double> m_values;
std::shared_ptr<const RectangleBounds> m_xyBounds;
std::shared_ptr<const RectangleBounds> m_yzBounds;
std::shared_ptr<const RectangleBounds> m_zxBounds;
@@ -138,21 +138,21 @@ inline CuboidVolumeBounds* CuboidVolumeBounds::clone() const {
}
inline bool CuboidVolumeBounds::inside(const Vector3D& pos, double tol) const {
- return (std::abs(pos.x()) <= m_valueStore.at(bv_halfX) + tol &&
- std::abs(pos.y()) <= m_valueStore.at(bv_halfY) + tol &&
- std::abs(pos.z()) <= m_valueStore.at(bv_halfZ) + tol);
+ return (std::abs(pos.x()) <= m_values.at(bv_halfX) + tol &&
+ std::abs(pos.y()) <= m_values.at(bv_halfY) + tol &&
+ std::abs(pos.z()) <= m_values.at(bv_halfZ) + tol);
}
inline double CuboidVolumeBounds::halflengthX() const {
- return m_valueStore.at(bv_halfX);
+ return m_values.at(bv_halfX);
}
inline double CuboidVolumeBounds::halflengthY() const {
- return m_valueStore.at(bv_halfY);
+ return m_values.at(bv_halfY);
}
inline double CuboidVolumeBounds::halflengthZ() const {
- return m_valueStore.at(bv_halfZ);
+ return m_values.at(bv_halfZ);
}
template <class T>
@@ -160,8 +160,8 @@ T& CuboidVolumeBounds::dumpT(T& dt) const {
dt << std::setiosflags(std::ios::fixed);
dt << std::setprecision(5);
dt << "Acts::CuboidVolumeBounds: (halfX, halfY, halfZ) = ";
- dt << "(" << m_valueStore.at(bv_halfX) << ", " << m_valueStore.at(bv_halfY)
- << ", " << m_valueStore.at(bv_halfZ) << ")";
+ dt << "(" << m_values.at(bv_halfX) << ", " << m_values.at(bv_halfY) << ", "
+ << m_values.at(bv_halfZ) << ")";
return dt;
}
} // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Geometry/CylinderLayer.hpp b/Core/include/Acts/Geometry/CylinderLayer.hpp
index 02a2b9622866b0f5f9934e4301355e2a602512d2..dc9f582341c37d929b5b9a3ecc180f3b92d4e92a 100644
--- a/Core/include/Acts/Geometry/CylinderLayer.hpp
+++ b/Core/include/Acts/Geometry/CylinderLayer.hpp
@@ -11,7 +11,7 @@
///////////////////////////////////////////////////////////////////
#pragma once
-#include <algorithm>
+
#include "Acts/Geometry/CylinderVolumeBounds.hpp"
#include "Acts/Geometry/GeometryContext.hpp"
#include "Acts/Geometry/Layer.hpp"
@@ -19,6 +19,8 @@
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/ThrowAssert.hpp"
+#include <algorithm>
+
namespace Acts {
class CylinderBounds;
@@ -27,9 +29,7 @@ class ApproachDescriptor;
/// @class CylinderLayer
///
/// Class to describe a cylindrical detector layer for tracking, it inhertis
-/// from
-/// both,
-/// Layer base class and CylinderSurface class
+/// from both, Layer base class and CylinderSurface class
///
class CylinderLayer : public CylinderSurface, public Layer {
public:
diff --git a/Core/include/Acts/Geometry/CylinderVolumeBounds.hpp b/Core/include/Acts/Geometry/CylinderVolumeBounds.hpp
index 4239e632aa35a140994a8a05b5cfbb5a97a4c29a..1ed77ae6263438077f4c977db25f25e81f8851a9 100644
--- a/Core/include/Acts/Geometry/CylinderVolumeBounds.hpp
+++ b/Core/include/Acts/Geometry/CylinderVolumeBounds.hpp
@@ -205,7 +205,7 @@ class CylinderVolumeBounds : public VolumeBounds {
std::shared_ptr<const PlanarBounds> sectorPlaneBounds() const;
/// The internal version of the bounds can be float/double
- std::vector<TDD_real_t> m_valueStore;
+ std::vector<double> m_values;
/// numerical stability
/// @todo unify the numerical stability checks
@@ -221,12 +221,12 @@ inline bool CylinderVolumeBounds::inside(const Vector3D& pos,
using VectorHelpers::perp;
using VectorHelpers::phi;
double ros = perp(pos);
- bool insidePhi = cos(phi(pos)) >= cos(m_valueStore[bv_halfPhiSector]) - tol;
- bool insideR = insidePhi ? ((ros >= m_valueStore[bv_innerRadius] - tol) &&
- (ros <= m_valueStore[bv_outerRadius] + tol))
+ bool insidePhi = cos(phi(pos)) >= cos(m_values[bv_halfPhiSector]) - tol;
+ bool insideR = insidePhi ? ((ros >= m_values[bv_innerRadius] - tol) &&
+ (ros <= m_values[bv_outerRadius] + tol))
: false;
bool insideZ =
- insideR ? (std::abs(pos.z()) <= m_valueStore[bv_halfZ] + tol) : false;
+ insideR ? (std::abs(pos.z()) <= m_values[bv_halfZ] + tol) : false;
return (insideZ && insideR && insidePhi);
}
@@ -250,28 +250,27 @@ inline double CylinderVolumeBounds::binningBorder(BinningValue bValue)
}
inline double CylinderVolumeBounds::innerRadius() const {
- return m_valueStore.at(bv_innerRadius);
+ return m_values.at(bv_innerRadius);
}
inline double CylinderVolumeBounds::outerRadius() const {
- return m_valueStore.at(bv_outerRadius);
+ return m_values.at(bv_outerRadius);
}
inline double CylinderVolumeBounds::mediumRadius() const {
- return 0.5 *
- (m_valueStore.at(bv_innerRadius) + m_valueStore.at(bv_outerRadius));
+ return 0.5 * (m_values.at(bv_innerRadius) + m_values.at(bv_outerRadius));
}
inline double CylinderVolumeBounds::deltaRadius() const {
- return (m_valueStore.at(bv_outerRadius) - m_valueStore.at(bv_innerRadius));
+ return (m_values.at(bv_outerRadius) - m_values.at(bv_innerRadius));
}
inline double CylinderVolumeBounds::halfPhiSector() const {
- return m_valueStore.at(bv_halfPhiSector);
+ return m_values.at(bv_halfPhiSector);
}
inline double CylinderVolumeBounds::halflengthZ() const {
- return m_valueStore.at(bv_halfZ);
+ return m_values.at(bv_halfZ);
}
template <class T>
@@ -279,10 +278,9 @@ T& CylinderVolumeBounds::dumpT(T& tstream) const {
tstream << std::setiosflags(std::ios::fixed);
tstream << std::setprecision(5);
tstream << "Acts::CylinderVolumeBounds: (rMin, rMax, halfPhi, halfZ) = ";
- tstream << m_valueStore.at(bv_innerRadius) << ", "
- << m_valueStore.at(bv_outerRadius) << ", "
- << m_valueStore.at(bv_halfPhiSector) << ", "
- << m_valueStore.at(bv_halfZ);
+ tstream << m_values.at(bv_innerRadius) << ", " << m_values.at(bv_outerRadius)
+ << ", " << m_values.at(bv_halfPhiSector) << ", "
+ << m_values.at(bv_halfZ);
return tstream;
}
} // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Geometry/DoubleTrapezoidVolumeBounds.hpp b/Core/include/Acts/Geometry/DoubleTrapezoidVolumeBounds.hpp
index 4d23ab4b348da515fc190e163c9c2511739752f9..3355393eb070bb8f6330d84b8c75ae1810935fb5 100644
--- a/Core/include/Acts/Geometry/DoubleTrapezoidVolumeBounds.hpp
+++ b/Core/include/Acts/Geometry/DoubleTrapezoidVolumeBounds.hpp
@@ -188,7 +188,7 @@ class DoubleTrapezoidVolumeBounds : public VolumeBounds {
/// parallel to local zx plane, positive local y
RectangleBounds* faceZXRectangleBoundsTop() const;
- std::vector<TDD_real_t> m_valueStore; ///< the internal store
+ std::vector<double> m_values; ///< the internal store
};
inline DoubleTrapezoidVolumeBounds* DoubleTrapezoidVolumeBounds::clone() const {
@@ -196,35 +196,35 @@ inline DoubleTrapezoidVolumeBounds* DoubleTrapezoidVolumeBounds::clone() const {
}
inline double DoubleTrapezoidVolumeBounds::minHalflengthX() const {
- return m_valueStore.at(bv_minHalfX);
+ return m_values.at(bv_minHalfX);
}
inline double DoubleTrapezoidVolumeBounds::medHalflengthX() const {
- return m_valueStore.at(bv_medHalfX);
+ return m_values.at(bv_medHalfX);
}
inline double DoubleTrapezoidVolumeBounds::maxHalflengthX() const {
- return m_valueStore.at(bv_maxHalfX);
+ return m_values.at(bv_maxHalfX);
}
inline double DoubleTrapezoidVolumeBounds::halflengthY1() const {
- return m_valueStore.at(bv_halfY1);
+ return m_values.at(bv_halfY1);
}
inline double DoubleTrapezoidVolumeBounds::halflengthY2() const {
- return m_valueStore.at(bv_halfY2);
+ return m_values.at(bv_halfY2);
}
inline double DoubleTrapezoidVolumeBounds::halflengthZ() const {
- return m_valueStore.at(bv_halfZ);
+ return m_values.at(bv_halfZ);
}
inline double DoubleTrapezoidVolumeBounds::alpha1() const {
- return m_valueStore.at(bv_alpha1);
+ return m_values.at(bv_alpha1);
}
inline double DoubleTrapezoidVolumeBounds::alpha2() const {
- return m_valueStore.at(bv_alpha2);
+ return m_values.at(bv_alpha2);
}
template <class T>
@@ -233,10 +233,10 @@ T& DoubleTrapezoidVolumeBounds::dumpT(T& dT) const {
dT << std::setprecision(5);
dT << "Acts::DoubleTrapezoidVolumeBounds: (minhalfX, medhalfX, maxhalfX, "
"halfY1, halfY2, halfZ) = ";
- dT << "(" << m_valueStore.at(bv_minHalfX) << ", "
- << m_valueStore.at(bv_medHalfX) << ", " << m_valueStore.at(bv_maxHalfX);
- dT << ", " << m_valueStore.at(bv_halfY1) << ", " << m_valueStore.at(bv_halfY2)
- << ", " << m_valueStore.at(bv_halfZ) << ")";
+ dT << "(" << m_values.at(bv_minHalfX) << ", " << m_values.at(bv_medHalfX)
+ << ", " << m_values.at(bv_maxHalfX);
+ dT << ", " << m_values.at(bv_halfY1) << ", " << m_values.at(bv_halfY2) << ", "
+ << m_values.at(bv_halfZ) << ")";
return dT;
}
} // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Geometry/TrapezoidVolumeBounds.hpp b/Core/include/Acts/Geometry/TrapezoidVolumeBounds.hpp
index 3540e263d9002c11899836d691ced3b127caad39..eb2320d96f12a9c0bc5446986c7f52cdd2ab2aee 100644
--- a/Core/include/Acts/Geometry/TrapezoidVolumeBounds.hpp
+++ b/Core/include/Acts/Geometry/TrapezoidVolumeBounds.hpp
@@ -170,7 +170,7 @@ class TrapezoidVolumeBounds : public VolumeBounds {
RectangleBounds* faceZXRectangleBoundsTop() const;
/// the bounds values
- std::vector<TDD_real_t> m_valueStore;
+ std::vector<double> m_values;
};
inline TrapezoidVolumeBounds* TrapezoidVolumeBounds::clone() const {
@@ -178,22 +178,22 @@ inline TrapezoidVolumeBounds* TrapezoidVolumeBounds::clone() const {
}
inline double TrapezoidVolumeBounds::minHalflengthX() const {
- return m_valueStore.at(bv_minHalfX);
+ return m_values.at(bv_minHalfX);
}
inline double TrapezoidVolumeBounds::maxHalflengthX() const {
- return m_valueStore.at(bv_maxHalfX);
+ return m_values.at(bv_maxHalfX);
}
inline double TrapezoidVolumeBounds::halflengthY() const {
- return m_valueStore.at(bv_halfY);
+ return m_values.at(bv_halfY);
}
inline double TrapezoidVolumeBounds::halflengthZ() const {
- return m_valueStore.at(bv_halfZ);
+ return m_values.at(bv_halfZ);
}
inline double TrapezoidVolumeBounds::alpha() const {
- return m_valueStore.at(bv_alpha);
+ return m_values.at(bv_alpha);
}
inline double TrapezoidVolumeBounds::beta() const {
- return m_valueStore.at(bv_beta);
+ return m_values.at(bv_beta);
}
template <class T>
@@ -202,10 +202,9 @@ T& TrapezoidVolumeBounds::dumpT(T& dt) const {
dt << std::setprecision(5);
dt << "Acts::TrapezoidVolumeBounds: (minhalfX, halfY, halfZ, alpha, beta) "
"= ";
- dt << "(" << m_valueStore.at(bv_minHalfX) << ", " << m_valueStore.at(bv_halfY)
- << ", " << m_valueStore.at(bv_halfZ);
- dt << ", " << m_valueStore.at(bv_alpha) << ", " << m_valueStore.at(bv_beta)
- << ")";
+ dt << "(" << m_values.at(bv_minHalfX) << ", " << m_values.at(bv_halfY) << ", "
+ << m_values.at(bv_halfZ);
+ dt << ", " << m_values.at(bv_alpha) << ", " << m_values.at(bv_beta) << ")";
return dt;
}
} // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Geometry/VolumeBounds.hpp b/Core/include/Acts/Geometry/VolumeBounds.hpp
index e39dcedffc70301babc1bf5d1272ac01a13271dd..c39a141b9d44371931bd090cc5025a7a0d0c3c2a 100644
--- a/Core/include/Acts/Geometry/VolumeBounds.hpp
+++ b/Core/include/Acts/Geometry/VolumeBounds.hpp
@@ -15,13 +15,13 @@
#include "Acts/Utilities/BoundingBox.hpp"
#include "Acts/Utilities/Definitions.hpp"
-#ifndef VOLUMEBOUNDS_VALUESTORE_FILL
-#define VOLUMEBOUNDS_VALUESTORE_FILL(val) m_valueStore[bv_##val] = val
+#ifndef VOLUMEBOUNDS_boundValues_FILL
+#define VOLUMEBOUNDS_boundValues_FILL(val) m_values[bv_##val] = val
#endif
-#ifndef VOLUMEBOUNDS_VALUESTORE_ACCESS
-#define VOLUMEBOUNDS_VALUESTORE_ACCESS(val) \
- double val() const { return m_valueStore[bv_##val]; }
+#ifndef VOLUMEBOUNDS_boundValues_ACCESS
+#define VOLUMEBOUNDS_boundValues_ACCESS(val) \
+ double val() const { return m_values[bv_##val]; }
#endif
#ifndef VOLUMEBOUNDS_DERIVED_ACCESS
diff --git a/Core/include/Acts/Surfaces/AnnulusBounds.hpp b/Core/include/Acts/Surfaces/AnnulusBounds.hpp
index 6b302da3773c732f88160b8e29838bbb3f1520ef..48de63b0870454daeb1f6dd81b7717183aee0859 100644
--- a/Core/include/Acts/Surfaces/AnnulusBounds.hpp
+++ b/Core/include/Acts/Surfaces/AnnulusBounds.hpp
@@ -13,6 +13,10 @@
#include "Acts/Utilities/ParameterDefinitions.hpp"
#include "Acts/Utilities/detail/periodic.hpp"
+#include <array>
+#include <exception>
+#include <vector>
+
namespace Acts {
/// @brief Class that implements a (potentially asymmetric) bounds with
@@ -29,42 +33,50 @@ class AnnulusBounds : public DiscBounds {
public:
using Transform2D = Eigen::Affine2d;
- /// enumeration for readability
- enum BoundValues {
- bv_minR = 0,
- bv_maxR = 1,
- bv_phiMin = 2,
- bv_phiMax = 3,
- bv_phiAvg = 4,
- bv_originX = 5,
- bv_originY = 6,
- bv_length = 7
+ enum BoundValues : int {
+ eMinR = 0,
+ eMaxR = 1,
+ eMinPhiRel = 2,
+ eMaxPhiRel = 3,
+ eAveragePhi = 4,
+ eOriginX = 5,
+ eOriginY = 6,
+ eSize = 7
};
+ AnnulusBounds() = delete;
+
/// @brief Default constructor from parameters
/// @param minR inner radius, in module system
/// @param maxR outer radius, in module system
- /// @param minPhi right angular edge, in strip system
- /// @param maxPhi left angular edge, in strip system
+ /// @param minPhiRel right angular edge, in strip system, rel to avgOhi
+ /// @param maxPhiRel left angular edge, in strip system, rel to avgPhi
/// @param moduleOrigin The origin offset between the two systems.
/// @param avgPhi (Optional) internal rotation of this bounds object's local
/// frame
- /// @note For @c moduleOrigin you need to actually calculate the cartesian
+ /// @note For @c morigin you need to actually calculate the cartesian
/// offset
- AnnulusBounds(double minR, double maxR, double minPhi, double maxPhi,
- const Vector2D& moduleOrigin = {0, 0}, double avgPhi = 0);
+ AnnulusBounds(double minR, double maxR, double minPhiRel, double maxPhiRel,
+ const Vector2D& moduleOrigin = {0, 0},
+ double avgPhi = 0) noexcept(false)
+ : AnnulusBounds({minR, maxR, minPhiRel, maxPhiRel, avgPhi,
+ moduleOrigin.x(), moduleOrigin.y()}) {}
+
+ /// Constructor - from parameters array
+ ///
+ /// @param values The parameter array
+ AnnulusBounds(const std::array<double, eSize>& values) noexcept(false);
- /// @brief copy constructor
AnnulusBounds(const AnnulusBounds& source) = default;
- /// Virtual constructor
AnnulusBounds* clone() const final;
- /// Bound type
SurfaceBounds::BoundsType type() const final;
- /// This returns the stored values for persisitency
- std::vector<TDD_real_t> valueStore() const final;
+ /// Return the bound values as dynamically sized vector
+ ///
+ /// @return this returns a copy of the internal values
+ std::vector<double> values() const final;
/// Inside check for the bounds object driven by the boundary check directive
/// Each Bounds has a method inside, which checks if a LocalPosition is inside
@@ -87,13 +99,9 @@ class AnnulusBounds : public DiscBounds {
/// @param sl is the ostream to be dumped into
std::ostream& toStream(std::ostream& sl) const final;
- /// @brief Returns inner radial bounds (module system)
- /// @return The inner radius
- double rMin() const;
-
- /// @brief Returns outer radial bounds (module system)
- /// @return The outer radius
- double rMax() const;
+ /// Access to the bound values
+ /// @param bValue the class nested enum for the array access
+ double get(BoundValues bValue) const { return m_values[bValue]; }
/// @brief Returns the right angular edge of the module
/// @return The right side angle
@@ -116,9 +124,9 @@ class AnnulusBounds : public DiscBounds {
/// Return a reference radius for binning
double binningValuePhi() const final;
- /// @brief Returns moduleOrigin, but rotated out, so @c avgPhi is already
+ /// @brief Returns moduleOrigin, but rotated out, so @c averagePhi is already
/// considered. The module origin needs to consider the rotation introduced by
- /// @c avgPhi
+ /// @c averagePhi
/// @return The origin of the local frame
Vector2D moduleOrigin() const;
@@ -134,7 +142,6 @@ class AnnulusBounds : public DiscBounds {
/// i.e. (max R; pos locX), (min R; pos locX), (min R; neg loc X), (max R: neg
/// locX)
///
- ///
/// @param lseg the number of segments used to approximate
/// and eventually curved line
///
@@ -144,11 +151,14 @@ class AnnulusBounds : public DiscBounds {
/// @return vector for vertices in 2D
std::vector<Vector2D> vertices(unsigned int lseg) const;
+ /// This method returns inner radius
+ double rMin() const final;
+
+ /// This method returns outer radius
+ double rMax() const final;
+
private:
- double m_rMin;
- double m_rMax;
- double m_phiMin;
- double m_phiMax;
+ std::array<double, eSize> m_values;
// @TODO: Does this need to be in bound values?
Vector2D m_moduleOrigin;
@@ -174,7 +184,10 @@ class AnnulusBounds : public DiscBounds {
Vector2D m_outRightStripXY;
Vector2D m_inRightStripXY;
- /// Private helper method:
+ /// Check the input values for consistency, will throw a logic_exception
+ /// if consistency is not given
+ void checkConsistency() noexcept(false);
+
/// Inside check for the bounds object driven by the boundary check directive
/// Each Bounds has a method inside, which checks if a LocalPosition is inside
/// the bounds Inside can be called without/with tolerances.
@@ -186,10 +199,14 @@ class AnnulusBounds : public DiscBounds {
virtual bool inside(const Vector2D& lposition, double tolR,
double tolPhi) const final;
- /// Private helper mehtod
+ /// Transform the strip cartesien
+ /// into the module polar system
+ ///
+ /// @param vStripXy the position in the cartesian strip system
+ /// @return the poistion in the module polar coordiante system
Vector2D stripXYToModulePC(const Vector2D& vStripXY) const;
- /// Private helper mehtod
+ /// Private helper method
Vector2D closestOnSegment(const Vector2D& a, const Vector2D& b,
const Vector2D& p,
const Eigen::Matrix<double, 2, 2>& weight) const;
@@ -200,45 +217,66 @@ class AnnulusBounds : public DiscBounds {
};
inline AnnulusBounds* AnnulusBounds::clone() const {
- return new AnnulusBounds(m_rMin, m_rMax, m_phiMin, m_phiMax, m_moduleOrigin,
- m_phiAvg);
+ return new AnnulusBounds(m_values);
}
inline SurfaceBounds::BoundsType AnnulusBounds::type() const {
- return SurfaceBounds::Annulus;
+ return SurfaceBounds::eAnnulus;
}
inline double AnnulusBounds::rMin() const {
- return m_rMin;
+ return get(eMinR);
}
inline double AnnulusBounds::rMax() const {
- return m_rMax;
+ return get(eMaxR);
}
inline double AnnulusBounds::phiMin() const {
- return m_phiMin + m_phiAvg;
+ return get(eMinPhiRel) + get(eAveragePhi);
}
inline double AnnulusBounds::phiMax() const {
- return m_phiMax + m_phiAvg;
+ return get(eMaxPhiRel) + get(eAveragePhi);
}
inline bool AnnulusBounds::coversFullAzimuth() const {
- return (std::abs((m_phiMax - m_phiMin) - M_PI) < s_onSurfaceTolerance);
+ return (std::abs((get(eMinPhiRel) - get(eMaxPhiRel)) - M_PI) <
+ s_onSurfaceTolerance);
}
inline bool AnnulusBounds::insideRadialBounds(double R,
double tolerance) const {
- return ((R + tolerance) > m_rMin and (R - tolerance) < m_rMax);
+ return ((R + tolerance) > get(eMinR) and (R - tolerance) < get(eMaxR));
}
inline double AnnulusBounds::binningValueR() const {
- return 0.5 * (m_rMin + m_rMax);
+ return 0.5 * (get(eMinR) + get(eMaxR));
}
inline double AnnulusBounds::binningValuePhi() const {
- return m_phiAvg;
+ return get(eAveragePhi);
+}
+
+inline std::vector<double> AnnulusBounds::values() const {
+ std::vector<double> valvector;
+ valvector.insert(valvector.begin(), m_values.begin(), m_values.end());
+ return valvector;
+}
+
+inline void AnnulusBounds::checkConsistency() noexcept(false) {
+ if (get(eMinR) < 0. or get(eMaxR) < 0. or get(eMinR) > get(eMaxR) or
+ std::abs(get(eMinR) - get(eMaxR)) < s_epsilon) {
+ throw std::invalid_argument("AnnulusBounds: invalid radial setup.");
+ }
+ if (get(eMinPhiRel) != detail::radian_sym(get(eMinPhiRel)) or
+ get(eMaxPhiRel) != detail::radian_sym(get(eMaxPhiRel)) or
+ get(eMinPhiRel) > get(eMaxPhiRel)) {
+ throw std::invalid_argument("AnnulusBounds: invalid phi boundary setup.");
+ }
+ if (get(eAveragePhi) != detail::radian_sym(get(eAveragePhi))) {
+ throw std::invalid_argument("AnnulusBounds: invalid phi positioning.");
+ }
}
} // namespace Acts
diff --git a/Core/include/Acts/Surfaces/ConeBounds.hpp b/Core/include/Acts/Surfaces/ConeBounds.hpp
index 9f8d4a964edc2af54ed10da04a22229a2b32a044..9446fe4b7b21525b5fcc8fff7ad996c4d6abfba8 100644
--- a/Core/include/Acts/Surfaces/ConeBounds.hpp
+++ b/Core/include/Acts/Surfaces/ConeBounds.hpp
@@ -7,10 +7,13 @@
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#pragma once
-#include <cfloat>
#include "Acts/Surfaces/SurfaceBounds.hpp"
#include "Acts/Utilities/Definitions.hpp"
+#include "Acts/Utilities/detail/periodic.hpp"
+
+#include <array>
+#include <vector>
namespace Acts {
@@ -27,17 +30,15 @@ namespace Acts {
class ConeBounds : public SurfaceBounds {
public:
- /// @enum BoundValues for readablility
- enum BoundValues {
- bv_alpha = 0,
- bv_minZ = 1,
- bv_maxZ = 2,
- bv_averagePhi = 3,
- bv_halfPhiSector = 4,
- bv_length = 5
+ enum BoundValues : int {
+ eAlpha = 0,
+ eMinZ = 1,
+ eMaxZ = 2,
+ eHalfPhiSector = 3,
+ eAveragePhi = 4,
+ eSize = 5
};
- // Deleted default constructor
ConeBounds() = delete;
/// Constructor - open cone with alpha, by default a full cone
@@ -48,31 +49,36 @@ class ConeBounds : public SurfaceBounds {
/// @param halfphi is the half opening angle (default is pi)
/// @param avphi is the phi value around which the bounds are opened
/// (default=0)
- ConeBounds(double alpha, bool symm, double halfphi = M_PI, double avphi = 0.);
+ ConeBounds(double alpha, bool symm, double halfphi = M_PI,
+ double avphi = 0.) noexcept(false);
/// Constructor - open cone with alpha, minz and maxz, by
/// default a full cone but can optionally make it a conical section
///
/// @param alpha is the opening angle of the cone
- /// @param zmin cone expanding from minimal z
- /// @param zmax cone expanding to maximal z
+ /// @param minz cone expanding from minimal z
+ /// @param maxz cone expanding to maximal z
/// @param halfphi is the half opening angle (default is pi)
/// @param avphi is the phi value around which the bounds are opened
/// (default=0)
- ConeBounds(double alpha, double zmin, double zmax, double halfphi = M_PI,
- double avphi = 0.);
+ ConeBounds(double alpha, double minz, double maxz, double halfphi = M_PI,
+ double avphi = 0.) noexcept(false);
+
+ /// Constructor - from parameters array
+ ///
+ /// @param values The parameter array
+ ConeBounds(const std::array<double, eSize>& values) noexcept(false);
- /// Defaulted destructor
~ConeBounds() override = default;
- /// Virtual constructor
ConeBounds* clone() const final;
- /// The type enumeration
BoundsType type() const final;
- /// The value store for persistency
- std::vector<TDD_real_t> valueStore() const final;
+ /// Return the bound values as dynamically sized vector
+ ///
+ /// @return this returns a copy of the internal values
+ std::vector<double> values() const final;
/// inside method for local position
///
@@ -100,38 +106,20 @@ class ConeBounds : public SurfaceBounds {
/// @return is the r value associated with z
double r(double z) const;
- /// Return the average values for the angles
+ /// Return tangent of alpha (pre-computed)
double tanAlpha() const;
- /// Return the average values for the angles
- double sinAlpha() const;
-
- /// Return the average values for the angles
- double cosAlpha() const;
-
- /// Return the average values for the angles
- double alpha() const;
-
- /// This method returns the minimum z value in the local
- /// frame for an unbound symmetric cone, it returns -MAXBOUNDVALUE*/
- double minZ() const;
-
- /// This method returns the maximum z value in the local
- /// frame for an unbound symmetric cone, it returns -MAXBOUNDVALUE*/
- double maxZ() const;
-
- /// This method returns the average phi value
- /// (i.e. the "middle" phi value for the conical sector we are describing)
- double averagePhi() const;
-
- /// This method returns the half-phi width of the sector
- /// (so that averagePhi +/- halfPhiSector gives the phi bounds of the cone)
- double halfPhiSector() const;
+ /// Access to the bound values
+ /// @param bValue the class nested enum for the array access
+ double get(BoundValues bValue) const { return m_values[bValue]; }
private:
- double m_alpha, m_tanAlpha;
- double m_zMin, m_zMax;
- double m_avgPhi, m_halfPhi;
+ std::array<double, eSize> m_values;
+ double m_tanAlpha;
+
+ /// Check the input values for consistency, will throw a logic_exception
+ /// if consistency is not given
+ void checkConsistency() noexcept(false);
/// Private helper functin to shift a local 2D position
///
@@ -147,31 +135,26 @@ inline double ConeBounds::tanAlpha() const {
return m_tanAlpha;
}
-inline double ConeBounds::sinAlpha() const {
- return std::sin(m_alpha);
-}
-
-inline double ConeBounds::cosAlpha() const {
- return std::cos(m_alpha);
-}
-
-inline double ConeBounds::alpha() const {
- return m_alpha;
+inline std::vector<double> ConeBounds::values() const {
+ std::vector<double> valvector;
+ valvector.insert(valvector.begin(), m_values.begin(), m_values.end());
+ return valvector;
}
-inline double ConeBounds::minZ() const {
- return m_zMin;
+inline void ConeBounds::checkConsistency() noexcept(false) {
+ if (get(eAlpha) < 0. or get(eAlpha) >= M_PI) {
+ throw std::invalid_argument("ConeBounds: invalid open angle.");
+ }
+ if (get(eMinZ) > get(eMaxZ) or
+ std::abs(get(eMinZ) - get(eMaxZ)) < s_epsilon) {
+ throw std::invalid_argument("ConeBounds: invalid z range setup.");
+ }
+ if (get(eHalfPhiSector) < 0. or abs(eHalfPhiSector) > M_PI) {
+ throw std::invalid_argument("ConeBounds: invalid phi sector setup.");
+ }
+ if (get(eAveragePhi) != detail::radian_sym(get(eAveragePhi))) {
+ throw std::invalid_argument("ConeBounds: invalid phi positioning.");
+ }
}
-inline double ConeBounds::maxZ() const {
- return m_zMax;
-}
-
-inline double ConeBounds::averagePhi() const {
- return m_avgPhi;
-}
-
-inline double ConeBounds::halfPhiSector() const {
- return m_halfPhi;
-}
} // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Surfaces/ConvexPolygonBounds.hpp b/Core/include/Acts/Surfaces/ConvexPolygonBounds.hpp
index d40b967b19a3cbe9242f423e4a8e06a359500dc9..aef8eff127b625618ca9631bef32be5b7901f590 100644
--- a/Core/include/Acts/Surfaces/ConvexPolygonBounds.hpp
+++ b/Core/include/Acts/Surfaces/ConvexPolygonBounds.hpp
@@ -7,13 +7,14 @@
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#pragma once
-#include <cmath>
#include "Acts/Surfaces/PlanarBounds.hpp"
#include "Acts/Surfaces/RectangleBounds.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include <boost/container/small_vector.hpp>
+#include <cmath>
+#include <exception>
namespace Acts {
@@ -28,9 +29,10 @@ class ConvexPolygonBoundsBase : public PlanarBounds {
/// @param sl is the ostream to be written into
std::ostream& toStream(std::ostream& sl) const final;
- /// Return vector containing defining parameters
- /// @return the parameters
- std::vector<TDD_real_t> valueStore() const final;
+ /// Return the bound values as dynamically sized vector
+ ///
+ /// @return this returns a copy of the internal values
+ std::vector<double> values() const final;
protected:
/// Return a rectangle bounds instance that encloses a set of vertices.
@@ -43,9 +45,9 @@ class ConvexPolygonBoundsBase : public PlanarBounds {
/// generic over the number of vertices, so it's factored out of the concrete
/// classes and into this base class.
/// @param vertices A collection of vertices.
- /// @return Whether the vertices form a convex polygon.
+ /// throws a logic error if this is not the case
template <typename coll_t>
- static bool convex_impl(const coll_t& vertices);
+ static void convex_impl(const coll_t& vertices) noexcept(false);
};
/// This is the actual implementation of the bounds.
@@ -55,39 +57,44 @@ class ConvexPolygonBoundsBase : public PlanarBounds {
/// @tparam N Number of vertices
template <int N>
class ConvexPolygonBounds : public ConvexPolygonBoundsBase {
+ public:
/// Expose number of vertices given as template parameter.
///
static constexpr size_t num_vertices = N;
/// Type that's used to store the vertices, in this case a fixed size array.
///
using vertex_array = std::array<Vector2D, num_vertices>;
+ /// Expose number of parameters as a template parameter
+ ///
+ static constexpr size_t eSize = 2 * N;
+ /// Type that's used to store the vertices, in this case a fixed size array.
+ ///
+ using value_array = std::array<double, eSize>;
- public:
static_assert(N >= 3, "ConvexPolygonBounds needs at least 3 sides.");
- /// Default constructor, deleted
ConvexPolygonBounds() = delete;
/// Constructor from a vector of vertices, to facilitate construction.
/// This will throw if the vector size does not match `num_vertices`.
/// This will throw if the vertices do not form a convex polygon.
/// @param vertices The list of vertices.
- ConvexPolygonBounds(const std::vector<Vector2D>& vertices);
+ ConvexPolygonBounds(const std::vector<Vector2D>& vertices) noexcept(false);
/// Constructor from a fixed size array of vertices.
/// This will throw if the vertices do not form a convex polygon.
/// @param vertices The vertices
- ConvexPolygonBounds(const vertex_array& vertices);
+ ConvexPolygonBounds(const vertex_array& vertices) noexcept(false);
+
+ /// Constructor from a fixed size array of parameters
+ /// This will throw if the vertices do not form a convex polygon.
+ /// @param values The values to build up the vertices
+ ConvexPolygonBounds(const value_array& values) noexcept(false);
- /// Defaulted destructor
~ConvexPolygonBounds() override = default;
- /// Return a copy of this bounds object.
- /// @return The cloned instance
ConvexPolygonBounds<N>* clone() const final;
- /// Return the bounds type of this bounds object.
- /// @return The bounds type
BoundsType type() const final;
/// Return whether a local 2D point lies inside of the bounds defined by this
@@ -118,13 +125,13 @@ class ConvexPolygonBounds : public ConvexPolygonBoundsBase {
/// @return The rectangular bounds
const RectangleBounds& boundingBox() const final;
- /// Return whether this bounds class is in fact convex
- /// @return Whether the bounds are convex.
- bool convex() const;
-
private:
vertex_array m_vertices;
RectangleBounds m_boundingBox;
+
+ /// Return whether this bounds class is in fact convex
+ /// throws a log error if not
+ void checkConsistency() const noexcept(false);
};
/// Tag to trigger specialization of a dynamic polygon
@@ -185,15 +192,13 @@ class ConvexPolygonBounds<PolygonDynamic> : public ConvexPolygonBoundsBase {
///
const RectangleBounds& boundingBox() const final;
- ///
- /// Return whether this bounds class is in fact convex
- /// @return Whether the bounds are convex.
- ///
- bool convex() const;
-
private:
boost::container::small_vector<Vector2D, 10> m_vertices;
RectangleBounds m_boundingBox;
+
+ /// Return whether this bounds class is in fact convex
+ /// thorws a logic error if not
+ void checkConsistency() const noexcept(false);
};
} // namespace Acts
diff --git a/Core/include/Acts/Surfaces/ConvexPolygonBounds.ipp b/Core/include/Acts/Surfaces/ConvexPolygonBounds.ipp
index b7c8eb7c1774fd21fdd4891d47d4d2c2bf1872b6..2c3f1f282561505978c4c442c4805ec2fa121d40 100644
--- a/Core/include/Acts/Surfaces/ConvexPolygonBounds.ipp
+++ b/Core/include/Acts/Surfaces/ConvexPolygonBounds.ipp
@@ -37,8 +37,8 @@ Acts::RectangleBounds Acts::ConvexPolygonBoundsBase::makeBoundingBox(
return {vmin, vmax};
}
-std::vector<TDD_real_t> Acts::ConvexPolygonBoundsBase::valueStore() const {
- std::vector<TDD_real_t> values;
+std::vector<double> Acts::ConvexPolygonBoundsBase::values() const {
+ std::vector<double> values;
for (const auto& vtx : vertices()) {
values.push_back(vtx.x());
values.push_back(vtx.y());
@@ -47,7 +47,8 @@ std::vector<TDD_real_t> Acts::ConvexPolygonBoundsBase::valueStore() const {
}
template <typename coll_t>
-bool Acts::ConvexPolygonBoundsBase::convex_impl(const coll_t& vertices) {
+void Acts::ConvexPolygonBoundsBase::convex_impl(
+ const coll_t& vertices) noexcept(false) {
static_assert(std::is_same<typename coll_t::value_type, Vector2D>::value,
"Must be collection of Vector2D");
@@ -78,29 +79,41 @@ bool Acts::ConvexPolygonBoundsBase::convex_impl(const coll_t& vertices) {
}
if (std::signbit(dot) != ref) {
- return false;
+ throw std::logic_error(
+ "ConvexPolygon: Given vertices do not form convex hull");
}
}
}
- return true;
}
template <int N>
Acts::ConvexPolygonBounds<N>::ConvexPolygonBounds(
- const std::vector<Acts::Vector2D>& vertices)
+ const std::vector<Acts::Vector2D>& vertices) noexcept(false)
: m_vertices(), m_boundingBox(makeBoundingBox(vertices)) {
throw_assert(vertices.size() == N,
"Size and number of given vertices do not match.");
for (size_t i = 0; i < N; i++) {
m_vertices[i] = vertices[i];
}
- throw_assert(convex(), "Given vertices do not form convex hull.");
+ checkConsistency();
}
template <int N>
-Acts::ConvexPolygonBounds<N>::ConvexPolygonBounds(const vertex_array& vertices)
+Acts::ConvexPolygonBounds<N>::ConvexPolygonBounds(
+ const vertex_array& vertices) noexcept(false)
: m_vertices(vertices), m_boundingBox(makeBoundingBox(vertices)) {
- throw_assert(convex(), "Given vertices do not form convex hull.");
+ checkConsistency();
+}
+
+template <int N>
+Acts::ConvexPolygonBounds<N>::ConvexPolygonBounds(
+ const value_array& values) noexcept(false)
+ : m_vertices(), m_boundingBox(0., 0.) {
+ for (size_t i = 0; i < N; i++) {
+ m_vertices[i] = Vector2D(values[2 * i], values[2 * i + 1]);
+ }
+ makeBoundingBox(m_vertices);
+ checkConsistency();
}
template <int N>
@@ -110,7 +123,7 @@ Acts::ConvexPolygonBounds<N>* Acts::ConvexPolygonBounds<N>::clone() const {
template <int N>
Acts::SurfaceBounds::BoundsType Acts::ConvexPolygonBounds<N>::type() const {
- return SurfaceBounds::ConvexPolygon;
+ return SurfaceBounds::eConvexPolygon;
}
template <int N>
@@ -137,8 +150,8 @@ const Acts::RectangleBounds& Acts::ConvexPolygonBounds<N>::boundingBox() const {
}
template <int N>
-bool Acts::ConvexPolygonBounds<N>::convex() const {
- return convex_impl(m_vertices);
+void Acts::ConvexPolygonBounds<N>::checkConsistency() const noexcept(false) {
+ convex_impl(m_vertices);
}
Acts::ConvexPolygonBounds<Acts::PolygonDynamic>::ConvexPolygonBounds(
@@ -152,7 +165,7 @@ Acts::ConvexPolygonBounds<Acts::PolygonDynamic>::clone() const {
Acts::SurfaceBounds::BoundsType
Acts::ConvexPolygonBounds<Acts::PolygonDynamic>::type() const {
- return SurfaceBounds::ConvexPolygon;
+ return SurfaceBounds::eConvexPolygon;
}
bool Acts::ConvexPolygonBounds<Acts::PolygonDynamic>::inside(
@@ -175,6 +188,7 @@ Acts::ConvexPolygonBounds<Acts::PolygonDynamic>::boundingBox() const {
return m_boundingBox;
}
-bool Acts::ConvexPolygonBounds<Acts::PolygonDynamic>::convex() const {
- return convex_impl(m_vertices);
+void Acts::ConvexPolygonBounds<Acts::PolygonDynamic>::checkConsistency() const
+ noexcept(false) {
+ convex_impl(m_vertices);
}
diff --git a/Core/include/Acts/Surfaces/CylinderBounds.hpp b/Core/include/Acts/Surfaces/CylinderBounds.hpp
index 039c04c77a419d796f615e96e2ae9f2387620897..ffc4a545b0e5907fe7ba1a367f4d2980dd0ad424 100644
--- a/Core/include/Acts/Surfaces/CylinderBounds.hpp
+++ b/Core/include/Acts/Surfaces/CylinderBounds.hpp
@@ -7,12 +7,15 @@
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#pragma once
-#include <cmath>
#include "Acts/Surfaces/SurfaceBounds.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/detail/periodic.hpp"
+#include <array>
+#include <cmath>
+#include <vector>
+
namespace Acts {
/// @class CylinderBounds
@@ -28,57 +31,50 @@ namespace Acts {
/// opening angle @f$ 2\cdot\phi_{half}@f$
/// around an average @f$ \phi @f$ angle @f$ \phi_{ave} @f$.
///
-/// @todo update the documentation picture for cylinder segments
-///
-/// @image html CylinderBounds.gif
-
class CylinderBounds : public SurfaceBounds {
public:
- /// @enum BoundValues for readablility
- /// nested enumeration object
- enum BoundValues {
- bv_radius = 0,
- bv_averagePhi = 1,
- bv_halfPhiSector = 2,
- bv_halfZ = 3,
- bv_length = 4
+ enum BoundValues : int {
+ eR = 0,
+ eHalfLengthZ = 1,
+ eHalfPhiSector = 2,
+ eAveragePhi = 3,
+ eSize = 4
};
CylinderBounds() = delete;
/// Constructor - full cylinder
///
- /// @param radius is the radius of the cylinder
- /// @param halez is the half length in z
- CylinderBounds(double radius, double halfZ);
-
- /// Constructor - open cylinder
+ /// @param r The radius of the cylinder
+ /// @param halfZ The half length in z
+ /// @param halfPhi The half opening angle
+ /// @param avgPhi (optional) The phi value from which the opening angle spans
+ CylinderBounds(double r, double halfZ, double halfPhi = M_PI,
+ double avgPhi = 0.) noexcept(false)
+ : m_values({r, halfZ, halfPhi, avgPhi}),
+ m_closed(std::abs(halfPhi - M_PI) < s_epsilon) {
+ checkConsistency();
+ }
+
+ /// Constructor - from fixed size array
///
- /// @param radius is the radius of the cylinder
- /// @param halfPhi is the half opening angle
- /// @param halfZ is the half length in z
- CylinderBounds(double radius, double halfPhi, double halfZ);
+ /// @param values The parameter values
+ CylinderBounds(const std::array<double, eSize>& values) noexcept(false)
+ : m_values(values),
+ m_closed(std::abs(values[eHalfPhiSector] - M_PI) < s_epsilon) {
+ checkConsistency();
+ }
- /// Constructor - open cylinder
- ///
- /// @param radius is the radius of the cylinder
- /// @param avphi is the middle phi position of the segment
- /// @param halfphi is the half opening angle
- /// @param halez is the half length in z
- CylinderBounds(double radius, double averagePhi, double halfPhi,
- double halfZ);
-
- /// Defaulted destructor
~CylinderBounds() override = default;
- /// Virtual constructor
CylinderBounds* clone() const final;
- /// Type enumeration
BoundsType type() const final;
- /// The value store
- std::vector<TDD_real_t> valueStore() const final;
+ /// Return the bound values as dynamically sized vector
+ ///
+ /// @return this returns a copy of the internal values
+ std::vector<double> values() const final;
/// Inside check for the bounds object driven by the boundary check directive
/// Each Bounds has a method inside, which checks if a LocalPosition is inside
@@ -105,52 +101,57 @@ class CylinderBounds : public SurfaceBounds {
/// @return is a signed distance parameter
double distanceToBoundary(const Vector2D& lposition) const final;
- /// Output Method for std::ostream
- std::ostream& toStream(std::ostream& sl) const final;
-
- /// This method returns the radius
- double r() const;
-
- /// This method returns the average phi
- double averagePhi() const;
-
- /// This method returns the halfPhiSector angle
- double halfPhiSector() const;
-
- /// This method returns the halflengthZ
- double halflengthZ() const;
+ /// Access to the bound values
+ /// @param bValue the class nested enum for the array access
+ double get(BoundValues bValue) const { return m_values[bValue]; }
/// Returns true for full phi coverage
bool coversFullAzimuth() const;
+ /// Output Method for std::ostream
+ std::ostream& toStream(std::ostream& sl) const final;
+
private:
- /// the bound radius, average, half phi and half Z
- double m_radius, m_avgPhi, m_halfPhi, m_halfZ;
- /// an indicator if the bounds are closed
- bool m_closed;
+ /// The bound radius, half Z, half phi and average phi
+ std::array<double, eSize> m_values;
+ /// Indicator if the bounds are closed
+ bool m_closed{false};
+
+ /// Check the input values for consistency, will throw a logic_exception
+ /// if consistency is not given
+ void checkConsistency() noexcept(false);
+ /// Helper method to shift into the phi-frame
+ /// @param lposition the polar coordinates in the global frame
Vector2D shifted(const Vector2D& lposition) const;
+
+ /// Return the jacobian into the polar coordinate
ActsSymMatrixD<2> jacobian() const;
};
-inline double CylinderBounds::r() const {
- return m_radius;
+inline std::vector<double> CylinderBounds::values() const {
+ std::vector<double> valvector;
+ valvector.insert(valvector.begin(), m_values.begin(), m_values.end());
+ return valvector;
}
-inline double CylinderBounds::averagePhi() const {
- return m_avgPhi;
-}
-
-inline double CylinderBounds::halfPhiSector() const {
- return m_halfPhi;
-}
-
-inline double CylinderBounds::halflengthZ() const {
- return m_halfZ;
+inline bool CylinderBounds::coversFullAzimuth() const {
+ return m_closed;
}
-inline bool CylinderBounds::coversFullAzimuth() const {
- return (m_halfPhi == M_PI);
+inline void CylinderBounds::checkConsistency() noexcept(false) {
+ if (get(eR) <= 0.) {
+ throw std::invalid_argument("CylinderBounds: invalid radial setup.");
+ }
+ if (get(eHalfLengthZ) <= 0.) {
+ throw std::invalid_argument("CylinderBounds: invalid length setup.");
+ }
+ if (get(eHalfPhiSector) <= 0. or get(eHalfPhiSector) > M_PI) {
+ throw std::invalid_argument("CylinderBounds: invalid phi sector setup.");
+ }
+ if (get(eAveragePhi) != detail::radian_sym(get(eAveragePhi))) {
+ throw std::invalid_argument("CylinderBounds: invalid phi positioning.");
+ }
}
} // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Surfaces/CylinderSurface.hpp b/Core/include/Acts/Surfaces/CylinderSurface.hpp
index c91769264915ca510e12a67b5752796b9619db25..363437029ba585fcdd7546469694828fabf446c3 100644
--- a/Core/include/Acts/Surfaces/CylinderSurface.hpp
+++ b/Core/include/Acts/Surfaces/CylinderSurface.hpp
@@ -35,25 +35,6 @@ class CylinderSurface : public Surface {
friend Surface;
protected:
- /// Constructor from Transform3D, radius and halflength
- ///
- /// @param htrans transform to position the surface, can be nullptr
- /// @note if htrans == nullptr, the cylinder is positioned around (0.,0.,0.)
- /// @param radius is the radius of the cylinder
- /// @param hlength is the half length of the cylinder in z
- CylinderSurface(std::shared_ptr<const Transform3D> htrans, double radius,
- double hlength);
-
- /// Constructor from Transform3D, radius halfphi, and halflength
- ///
- /// @param htrans transform to position the surface, can be nullptr
- /// @note if htrans == nullptr, the cylinder is positioned around (0.,0.,0.)
- /// @param radius is the radius of the cylinder
- /// @param hphi is the half length in phi of the cylinder
- /// @param hlength is the half length of the cylinder in z
- CylinderSurface(std::shared_ptr<const Transform3D> htrans, double radius,
- double hphi, double hlength);
-
/// Constructor from DetectorElementBase: Element proxy
///
/// @param cbounds are the provided cylinder bounds (shared)
@@ -64,6 +45,16 @@ class CylinderSurface : public Surface {
/// Constructor from Transform3D and CylinderBounds
///
/// @param htrans transform to position the surface, can be nullptr
+ /// @param radius The radius of the cylinder
+ /// @param halfz The half length in z
+ /// @param halfphi The half opening angle
+ /// @param avphi The phi value from which the opening angle spans (both sides)
+ CylinderSurface(std::shared_ptr<const Transform3D> htrans, double radius,
+ double halfz, double halfphi = M_PI, double avphi = 0.);
+
+ /// Constructor from Transform3D and CylinderBounds arguments
+ ///
+ /// @param htrans transform to position the surface, can be nullptr
/// @note if htrans == nullptr, the cylinder is positioned around (0.,0.,0.)
/// @param cbounds is a shared pointer to a cylindeer bounds object,
/// it must exist (assert test)
diff --git a/Core/include/Acts/Surfaces/DiamondBounds.hpp b/Core/include/Acts/Surfaces/DiamondBounds.hpp
index b0078dbfc0f542143e91fbdf806942036d2be489..7452cd6f18070650823644e4388eed130b322159 100644
--- a/Core/include/Acts/Surfaces/DiamondBounds.hpp
+++ b/Core/include/Acts/Surfaces/DiamondBounds.hpp
@@ -7,54 +7,69 @@
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#pragma once
-#include <cmath>
#include "Acts/Surfaces/PlanarBounds.hpp"
#include "Acts/Surfaces/RectangleBounds.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/ParameterDefinitions.hpp"
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <vector>
+
namespace Acts {
-///
/// @class DiamondBounds
///
/// Bounds for a double trapezoidal ("diamond"), planar Surface.
-///
class DiamondBounds : public PlanarBounds {
public:
- /// @enum BoundValues for better readability
enum BoundValues {
- bv_x1 = 0,
- bv_x2 = 1,
- bv_x3 = 2,
- bv_y1 = 3,
- bv_y2 = 4,
- bv_length = 5
+ eHalfLengthXnegY = 0,
+ eHalfLengthXzeroY = 1,
+ eHalfLengthXposY = 2,
+ eHalfLengthYneg = 3,
+ eHalfLengthYpos = 4,
+ eSize = 5
};
+ DiamondBounds() = delete;
+
/// Constructor for convex hexagon symmetric about the y axis
///
- /// @param x1 is the halflength in x at minimal y
- /// @param x2 is the halflength in x at y = 0
- /// @param x3 is the halflength in x at maximal y
- /// @param y1 is the halflength into y < 0
- /// @param y2 is the halflength into y > 0
+ /// @param halfXnegY is the halflength in x at minimal y
+ /// @param halfXzeroY is the halflength in x at y = 0
+ /// @param halfXposY is the halflength in x at maximal y
+ /// @param halfYneg is the halflength into y < 0
+ /// @param halfYpos is the halflength into y > 0
+ DiamondBounds(double halfXnegY, double halfXzeroY, double halfXposY,
+ double halfYneg, double halfYpos) noexcept(false)
+ : m_values({halfXnegY, halfXzeroY, halfXposY, halfYneg, halfYpos}),
+ m_boundingBox(*std::max_element(m_values.begin(), m_values.begin() + 2),
+ std::max(halfYneg, halfYpos)) {
+ checkConsistency();
+ }
+
+ /// Constructor - from fixed size array
///
- /// @image html DiamondBounds.svg
- DiamondBounds(double x1, double x2, double x3, double y1, double y2);
+ /// @param values The parameter values
+ DiamondBounds(const std::array<double, eSize>& values) noexcept(false)
+ : m_values(values),
+ m_boundingBox(
+ *std::max_element(values.begin(), values.begin() + 2),
+ std::max(values[eHalfLengthYneg], values[eHalfLengthYpos])) {}
- /// Defaulted desctructor
~DiamondBounds() override = default;
- /// Virtual constructor
DiamondBounds* clone() const final;
- /// Enumeration type
BoundsType type() const final;
- /// The value store for persistency
- std::vector<TDD_real_t> valueStore() const final;
+ /// Return the bound values as dynamically sized vector
+ ///
+ /// @return this returns a copy of the internal values
+ std::vector<double> values() const final;
/// Inside check for the bounds object driven by the boundary check directive
/// Each Bounds has a method inside, which checks if a LocalPosition is inside
@@ -90,48 +105,34 @@ class DiamondBounds : public PlanarBounds {
/// @param sl is the ostream in which it is dumped
std::ostream& toStream(std::ostream& sl) const final;
- /// This method returns the halflength in X at minimal Y
- /// (first coordinate of local surface frame)
- double x1() const;
-
- /// This method returns the (maximal) halflength in X
- /// (first coordinate of local surface frame)
- double x2() const;
-
- /// This method returns the halflength in X at maximal Y
- /// (first coordinate of local surface frame)
- double x3() const;
-
- /// This method returns the halflength in Y of trapezoid at negative Y
- double y1() const;
-
- /// This method returns the halflength in Y of trapezoid at positive Y
- double y2() const;
+ /// Access to the bound values
+ /// @param bValue the class nested enum for the array access
+ double get(BoundValues bValue) const { return m_values[bValue]; }
private:
- double m_x1, m_x2, m_x3;
- double m_y1, m_y2;
+ std::array<double, eSize> m_values;
RectangleBounds m_boundingBox; ///< internal bounding box cache
-};
-
-inline double DiamondBounds::x1() const {
- return m_x1;
-}
-inline double DiamondBounds::x2() const {
- return m_x2;
-}
-
-inline double DiamondBounds::x3() const {
- return m_x3;
-}
+ /// Check the input values for consistency, will throw a logic_exception
+ /// if consistency is not given
+ void checkConsistency() noexcept(false);
+};
-inline double DiamondBounds::y1() const {
- return m_y1;
+inline std::vector<double> DiamondBounds::values() const {
+ std::vector<double> valvector;
+ valvector.insert(valvector.begin(), m_values.begin(), m_values.end());
+ return valvector;
}
-inline double DiamondBounds::y2() const {
- return m_y2;
+inline void DiamondBounds::checkConsistency() noexcept(false) {
+ if (std::any_of(m_values.begin(), m_values.end(),
+ [](auto v) { return v <= 0.; })) {
+ throw std::invalid_argument("DiamondBounds: negative half length.");
+ }
+ if (get(eHalfLengthXnegY) > get(eHalfLengthXzeroY) or
+ get(eHalfLengthXposY) > get(eHalfLengthXzeroY)) {
+ throw std::invalid_argument("DiamondBounds: not a diamond shape.");
+ }
}
} // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Surfaces/DiscBounds.hpp b/Core/include/Acts/Surfaces/DiscBounds.hpp
index 599574fe8e4979e2749379c8899806f146c9f333..5bc16f402effa5862701ac48f5d682eb6dde5907 100644
--- a/Core/include/Acts/Surfaces/DiscBounds.hpp
+++ b/Core/include/Acts/Surfaces/DiscBounds.hpp
@@ -7,6 +7,7 @@
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#pragma once
+
#include "Acts/Surfaces/SurfaceBounds.hpp"
namespace Acts {
diff --git a/Core/include/Acts/Surfaces/DiscTrapezoidBounds.hpp b/Core/include/Acts/Surfaces/DiscTrapezoidBounds.hpp
index 1d9057977c16c648d5fa3f0259d3ae1c2d296629..0a1950fa9308a010c04fc2517e1bb264c67d9d01 100644
--- a/Core/include/Acts/Surfaces/DiscTrapezoidBounds.hpp
+++ b/Core/include/Acts/Surfaces/DiscTrapezoidBounds.hpp
@@ -12,55 +12,63 @@
#include "Acts/Surfaces/DiscBounds.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/ParameterDefinitions.hpp"
+#include "Acts/Utilities/detail/periodic.hpp"
+
+#include <array>
+#include <vector>
namespace Acts {
-///
/// @class DiscTrapezoidBounds
///
/// Class to describe the bounds for a planar DiscSurface.
/// By providing an argument for hphisec, the bounds can
/// be restricted to a phi-range around the center position.
-///
class DiscTrapezoidBounds : public DiscBounds {
public:
- /// @enum BoundValues
- /// enumeration for readability
- enum BoundValues {
- bv_rMin = 0,
- bv_rMax = 1,
- bv_minHalfX = 2,
- bv_maxHalfX = 3,
- bv_averagePhi = 4,
- bv_stereo = 5,
- bv_length = 6
+ enum BoundValues : int {
+ eHalfLengthXminR = 0,
+ eHalfLengthXmaxR = 1,
+ eMinR = 2,
+ eMaxR = 3,
+ eAveragePhi = 4,
+ eStereo = 5,
+ eSize = 6
};
DiscTrapezoidBounds() = delete;
/// Constructor for a symmetric Trapezoid giving min X length, max X length,
/// Rmin and R max
- /// @param minhalfx half length in X at min radius
- /// @param maxhalfx half length in X at maximum radius
+ /// @param halfXminR half length in X at min radius
+ /// @param halfXmaxR half length in X at maximum radius
/// @param minR inner radius
/// @param maxR outer radius
- /// @param avephi average phi value
+ /// @param avgPhi average phi value
/// @param stereo optional stero angle applied
- DiscTrapezoidBounds(double minhalfx, double maxhalfx, double minR,
- double maxR, double avephi = M_PI_2, double stereo = 0.);
+ DiscTrapezoidBounds(double halfXminR, double halfXmaxR, double minR,
+ double maxR, double avgPhi = M_PI_2,
+ double stereo = 0.) noexcept(false);
+
+ /// Constructor - from fixed size array
+ ///
+ /// @param values The parameter values
+ DiscTrapezoidBounds(const std::array<double, eSize>& values) noexcept(false)
+ : m_values(values) {
+ checkConsistency();
+ }
- /// Defaulted Destructor
~DiscTrapezoidBounds() override = default;
- /// Overloaded clone method
DiscTrapezoidBounds* clone() const final;
- /// Type identifier
SurfaceBounds::BoundsType type() const final;
- /// Value store for persistency
- std::vector<TDD_real_t> valueStore() const final;
+ /// Return the bound values as dynamically sized vector
+ ///
+ /// @return this returns a copy of the internal values
+ std::vector<double> values() const final;
/// This method cheks if the radius given in the LocalPosition is inside
/// [rMin,rMax]
@@ -80,14 +88,15 @@ class DiscTrapezoidBounds : public DiscBounds {
/// Output Method for std::ostream
std::ostream& toStream(std::ostream& sl) const final;
+ /// Access to the bound values
+ /// @param bValue the class nested enum for the array access
+ double get(BoundValues bValue) const { return m_values[bValue]; }
+
/// This method returns inner radius
- double rMin() const;
+ double rMin() const final;
/// This method returns outer radius
- double rMax() const;
-
- /// This method returns the average phi
- double averagePhi() const;
+ double rMax() const final;
/// This method returns the center radius
double rCenter() const;
@@ -98,14 +107,8 @@ class DiscTrapezoidBounds : public DiscBounds {
/// This method returns the halfPhiSector which is covered by the disc
double halfPhiSector() const;
- /// This method returns the minimal halflength in X
- double minHalflengthX() const;
-
- /// This method returns the maximal halflength in X
- double maxHalflengthX() const;
-
- /// This method returns the halflength in Y (this is Rmax -Rmin)
- double halflengthY() const;
+ /// This method returns the half length in Y (this is Rmax -Rmin)
+ double halfLengthY() const;
/// Returns true for full phi coverage - obviously false here
bool coversFullAzimuth() const final;
@@ -132,9 +135,13 @@ class DiscTrapezoidBounds : public DiscBounds {
std::vector<Vector2D> vertices(unsigned int lseg) const;
private:
- double m_rMin, m_rMax, m_minHalfX, m_maxHalfX, m_avgPhi;
+ std::array<double, eSize> m_values;
double m_stereo; // TODO 2017-04-09 msmk: what is this good for?
+ /// Check the input values for consistency, will throw a logic_exception
+ /// if consistency is not given
+ void checkConsistency() noexcept(false);
+
/// Private helper method to convert a local postion
/// into its Cartesian representation
///
@@ -149,23 +156,11 @@ class DiscTrapezoidBounds : public DiscBounds {
};
inline double DiscTrapezoidBounds::rMin() const {
- return m_rMin;
+ return get(eMinR);
}
inline double DiscTrapezoidBounds::rMax() const {
- return m_rMax;
-}
-
-inline double DiscTrapezoidBounds::minHalflengthX() const {
- return m_minHalfX;
-}
-
-inline double DiscTrapezoidBounds::maxHalflengthX() const {
- return m_maxHalfX;
-}
-
-inline double DiscTrapezoidBounds::averagePhi() const {
- return m_avgPhi;
+ return get(eMaxR);
}
inline double DiscTrapezoidBounds::stereo() const {
@@ -173,21 +168,29 @@ inline double DiscTrapezoidBounds::stereo() const {
}
inline double DiscTrapezoidBounds::halfPhiSector() const {
- auto minHalfPhi = std::asin(m_minHalfX / m_rMin);
- auto maxHalfPhi = std::asin(m_maxHalfX / m_rMax);
+ auto minHalfPhi = std::asin(get(eHalfLengthXminR) / get(eMinR));
+ auto maxHalfPhi = std::asin(get(eHalfLengthXmaxR) / get(eMaxR));
return std::max(minHalfPhi, maxHalfPhi);
}
inline double DiscTrapezoidBounds::rCenter() const {
- auto hmin = std::sqrt(m_rMin * m_rMin - m_minHalfX * m_minHalfX);
- auto hmax = std::sqrt(m_rMax * m_rMax - m_maxHalfX * m_maxHalfX);
- return (hmin + hmax) / 2.0;
+ double rmin = get(eMinR);
+ double rmax = get(eMaxR);
+ double hxmin = get(eHalfLengthXminR);
+ double hxmax = get(eHalfLengthXmaxR);
+ auto hmin = std::sqrt(rmin * rmin - hxmin * hxmin);
+ auto hmax = std::sqrt(rmax * rmax - hxmax * hxmax);
+ return 0.5 * (hmin + hmax);
}
-inline double DiscTrapezoidBounds::halflengthY() const {
- auto hmin = std::sqrt(m_rMin * m_rMin - m_minHalfX * m_minHalfX);
- auto hmax = std::sqrt(m_rMax * m_rMax - m_maxHalfX * m_maxHalfX);
- return (hmax - hmin) / 2.0;
+inline double DiscTrapezoidBounds::halfLengthY() const {
+ double rmin = get(eMinR);
+ double rmax = get(eMaxR);
+ double hxmin = get(eHalfLengthXminR);
+ double hxmax = get(eHalfLengthXmaxR);
+ auto hmin = std::sqrt(rmin * rmin - hxmin * hxmin);
+ auto hmax = std::sqrt(rmax * rmax - hxmax * hxmax);
+ return 0.5 * (hmax - hmin);
}
inline bool DiscTrapezoidBounds::coversFullAzimuth() const {
@@ -196,15 +199,34 @@ inline bool DiscTrapezoidBounds::coversFullAzimuth() const {
inline bool DiscTrapezoidBounds::insideRadialBounds(double R,
double tolerance) const {
- return (R + tolerance > m_rMin and R - tolerance < m_rMax);
+ return (R + tolerance > get(eMinR) and R - tolerance < get(eMaxR));
}
inline double DiscTrapezoidBounds::binningValueR() const {
- return 0.5 * (m_rMin + m_rMax);
+ return 0.5 * (get(eMinR) + get(eMaxR));
}
inline double DiscTrapezoidBounds::binningValuePhi() const {
- return m_avgPhi;
+ return get(eAveragePhi);
+}
+
+inline std::vector<double> DiscTrapezoidBounds::values() const {
+ std::vector<double> valvector;
+ valvector.insert(valvector.begin(), m_values.begin(), m_values.end());
+ return valvector;
+}
+
+inline void DiscTrapezoidBounds::checkConsistency() noexcept(false) {
+ if (get(eMinR) < 0. or get(eMaxR) <= 0. or get(eMinR) > get(eMaxR)) {
+ throw std::invalid_argument("DiscTrapezoidBounds: invalid radial setup.");
+ }
+ if (get(eHalfLengthXminR) < 0. or get(eHalfLengthXmaxR) <= 0.) {
+ throw std::invalid_argument("DiscTrapezoidBounds: negative length given.");
+ }
+ if (get(eAveragePhi) != detail::radian_sym(get(eAveragePhi))) {
+ throw std::invalid_argument(
+ "DiscTrapezoidBounds: invalid phi positioning.");
+ }
}
} // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Surfaces/EllipseBounds.hpp b/Core/include/Acts/Surfaces/EllipseBounds.hpp
index be5999e0288ead8efbda4c7cf8bfcbb0629d20ec..e2edb55a4321a2d878e9c4cd7944ce4040060ad0 100644
--- a/Core/include/Acts/Surfaces/EllipseBounds.hpp
+++ b/Core/include/Acts/Surfaces/EllipseBounds.hpp
@@ -7,12 +7,17 @@
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#pragma once
-#include <cmath>
-#include <cstdlib>
#include "Acts/Surfaces/PlanarBounds.hpp"
#include "Acts/Surfaces/RectangleBounds.hpp"
#include "Acts/Utilities/Definitions.hpp"
+#include "Acts/Utilities/detail/periodic.hpp"
+
+#include <array>
+#include <cmath>
+#include <cstdlib>
+#include <exception>
+#include <vector>
namespace Acts {
@@ -20,50 +25,56 @@ namespace Acts {
///
/// Class to describe the bounds for a planar ellispoid
/// surface.
+///
/// By providing an argument for hphisec, the bounds can
/// be restricted to a phi-range around the center position.
-///
-/// @image html EllipseBounds.png
-///
class EllipseBounds : public PlanarBounds {
public:
- /// @brief constants for readability
enum BoundValues {
- bv_rMinX = 0,
- bv_rMinY = 1,
- bv_rMaxX = 2,
- bv_rMaxY = 3,
- bv_averagePhi = 4,
- bv_halfPhiSector = 5,
- bv_length = 6
+ eMinR0 = 0,
+ eMaxR0 = 1,
+ eMinR1 = 2,
+ eMaxR1 = 3,
+ eHalfPhiSector = 4,
+ eAveragePhi = 5,
+ eSize = 6
};
- /// Deleted default constructor
EllipseBounds() = delete;
/// Constructor for full of an ellipsoid disc
///
- /// @param minRadius0 is the minimum radius along coordinate 0
- /// @param minRadius1 is the minimum radius along coorindate 1
- /// @param maxRadius0 is the minimum radius at coorindate 0
- /// @param maxRadius1 is the minimum radius at coorindate 1
+ /// @param minR0 is the minimum radius along coordinate 0
+ /// @param maxR0 is the minimum radius at coorindate 0
+ /// @param minR1 is the minimum radius along coorindate 1
+ /// @param maxR1 is the minimum radius at coorindate 1
+ /// @param halfPhi spanning phi sector (is set to pi as default)
/// @param averagePhi average phi (is set to 0. as default)
- /// @param halfPhi spanning phi sector (is set to pi as default)
- EllipseBounds(double minRadius0, double minRadius1, double maxRadius0,
- double maxRadius1, double averagePhi = 0.,
- double halfPhi = M_PI);
+ EllipseBounds(double minR0, double maxR0, double minR1, double maxR1,
+ double halfPhi = M_PI, double averagePhi = 0.) noexcept(false)
+ : m_values({minR0, maxR0, minR1, maxR1, halfPhi, averagePhi}),
+ m_boundingBox(m_values[eMaxR0], m_values[eMaxR1]) {
+ checkConsistency();
+ }
+
+ /// Constructor - from fixed size array
+ ///
+ /// @param values The parameter values
+ EllipseBounds(const std::array<double, eSize>& values) noexcept(false)
+ : m_values(values), m_boundingBox(values[eMaxR0], values[eMaxR1]) {
+ checkConsistency();
+ }
- /// Defaulted destructor
~EllipseBounds() override = default;
- /// Clone method for surface cloning
EllipseBounds* clone() const final;
- /// Type enumeration
BoundsType type() const final;
- /// Complete value store for persistency
- std::vector<TDD_real_t> valueStore() const final;
+ /// Return the bound values as dynamically sized vector
+ ///
+ /// @return this returns a copy of the internal values
+ std::vector<double> values() const final;
/// This method checks if the point given in the local coordinates is between
/// two ellipsoids if only tol0 is given and additional in the phi sector is
@@ -98,51 +109,38 @@ class EllipseBounds : public PlanarBounds {
/// Output Method for std::ostream
std::ostream& toStream(std::ostream& sl) const final;
- /// This method returns first inner radius
- double rMinX() const;
-
- /// This method returns second inner radius
- double rMinY() const;
-
- /// This method returns first outer radius
- double rMaxX() const;
-
- /// This method returns second outer radius
- double rMaxY() const;
-
- /// This method returns the average phi
- double averagePhi() const;
-
- /// This method returns the halfPhiSector which is covered by the disc
- double halfPhiSector() const;
+ /// Access to the bound values
+ /// @param bValue the class nested enum for the array access
+ double get(BoundValues bValue) const { return m_values[bValue]; }
private:
- double m_rMinX, m_rMinY, m_rMaxX, m_rMaxY, m_avgPhi, m_halfPhi;
+ std::array<double, eSize> m_values;
RectangleBounds m_boundingBox;
-};
-
-inline double EllipseBounds::rMinX() const {
- return m_rMinX;
-}
-inline double EllipseBounds::rMinY() const {
- return m_rMinY;
-}
-
-inline double EllipseBounds::rMaxX() const {
- return m_rMaxX;
-}
-
-inline double EllipseBounds::rMaxY() const {
- return m_rMaxY;
-}
+ /// Check the input values for consistency, will throw a logic_exception
+ /// if consistency is not given
+ void checkConsistency() noexcept(false);
+};
-inline double EllipseBounds::averagePhi() const {
- return m_avgPhi;
+inline std::vector<double> EllipseBounds::values() const {
+ std::vector<double> valvector;
+ valvector.insert(valvector.begin(), m_values.begin(), m_values.end());
+ return valvector;
}
-inline double EllipseBounds::halfPhiSector() const {
- return m_halfPhi;
+inline void EllipseBounds::checkConsistency() noexcept(false) {
+ if (get(eMinR0) <= 0. or get(eMaxR0) <= 0. or get(eMinR0) > get(eMaxR0)) {
+ throw std::invalid_argument("EllipseBounds: invalid first coorindate.");
+ }
+ if (get(eMinR1) <= 0. or get(eMaxR1) <= 0. or get(eMinR1) > get(eMaxR1)) {
+ throw std::invalid_argument("EllipseBounds: invalid second coorindate.");
+ }
+ if (get(eHalfPhiSector) < 0. or get(eHalfPhiSector) > M_PI) {
+ throw std::invalid_argument("EllipseBounds: invalid phi sector setup.");
+ }
+ if (get(eAveragePhi) != detail::radian_sym(get(eAveragePhi))) {
+ throw std::invalid_argument("EllipseBounds: invalid phi positioning.");
+ }
}
} // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Surfaces/InfiniteBounds.hpp b/Core/include/Acts/Surfaces/InfiniteBounds.hpp
index cb3dde3a4cd7254fbb8197aea1bfa051fa3f3235..19cf58bcaa49917e9b607336fce31534e0bb7727 100644
--- a/Core/include/Acts/Surfaces/InfiniteBounds.hpp
+++ b/Core/include/Acts/Surfaces/InfiniteBounds.hpp
@@ -20,15 +20,16 @@ namespace Acts {
class InfiniteBounds : public SurfaceBounds {
public:
InfiniteBounds() = default;
+
~InfiniteBounds() override = default;
InfiniteBounds* clone() const final { return new InfiniteBounds(); }
SurfaceBounds::BoundsType type() const final {
- return SurfaceBounds::Boundless;
+ return SurfaceBounds::eBoundless;
}
- std::vector<TDD_real_t> valueStore() const final { return {}; }
+ std::vector<double> values() const final { return {}; }
/// Method inside() returns true for any case
///
diff --git a/Core/include/Acts/Surfaces/LineBounds.hpp b/Core/include/Acts/Surfaces/LineBounds.hpp
index 3636317887819ff45178575dcb5cd98db9f3db71..8f67aeef2cd2d6048259785367f02f1137119914 100644
--- a/Core/include/Acts/Surfaces/LineBounds.hpp
+++ b/Core/include/Acts/Surfaces/LineBounds.hpp
@@ -7,39 +7,50 @@
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#pragma once
+
#include "Acts/Surfaces/SurfaceBounds.hpp"
#include "Acts/Utilities/Definitions.hpp"
+#include <array>
+#include <vector>
+
namespace Acts {
/// @class LineBounds
///
/// Bounds for a LineSurface.
-///
-
class LineBounds : public SurfaceBounds {
public:
- /// @enum BoundValues for readablility
- /// nested enumeration object
- enum BoundValues { bv_radius = 0, bv_halfZ = 1, bv_length = 2 };
+ enum BoundValues : int { eR = 0, eHalfLengthZ = 1, eSize = 2 };
+
+ LineBounds() = delete;
/// Constructor
///
- /// @param radius is the radius of the cylinder, default = 0.
- /// @param halez is the half length in z, defualt = 0.
- LineBounds(double radius = 0., double halez = 0.);
+ /// @param r is the radius of the cylinder, default = 0.
+ /// @param halfZ is the half length in z, defualt = 0.
+ LineBounds(double r, double halfZ) noexcept(false) : m_values({r, halfZ}) {
+ checkConsistency();
+ }
+
+ /// Constructor - from fixed size array
+ ///
+ /// @param values The parameter values
+ LineBounds(const std::array<double, eSize>& values) noexcept(false)
+ : m_values(values) {
+ checkConsistency();
+ }
- /// Defaulted destructor
~LineBounds() override = default;
- /// Virtual constructor
LineBounds* clone() const final;
- /// Type enumeration
BoundsType type() const final;
- /// Return the intrinsic values
- std::vector<TDD_real_t> valueStore() const final;
+ /// Return the bound values as dynamically sized vector
+ ///
+ /// @return this returns a copy of the internal values
+ std::vector<double> values() const final;
/// Inside check for the bounds object driven by the boundary check directive
/// Each Bounds has a method inside, which checks if a LocalPosition is inside
@@ -59,27 +70,36 @@ class LineBounds : public SurfaceBounds {
/// @return is a signed distance parameter
double distanceToBoundary(const Vector2D& lposition) const final;
- /// This method returns the radius
- virtual double r() const;
-
- /// This method returns the halflengthZ
- double halflengthZ() const;
-
/// Output Method for std::ostream
///
/// @param sl is the ostream to be dumped into
std::ostream& toStream(std::ostream& sl) const final;
+ /// Access to the bound values
+ /// @param bValue the class nested enum for the array access
+ double get(BoundValues bValue) const { return m_values[bValue]; }
+
private:
- double m_radius, m_halfZ;
+ std::array<double, eSize> m_values;
+
+ /// Check the input values for consistency, will throw a logic_exception
+ /// if consistency is not given
+ void checkConsistency() noexcept(false);
};
-inline double LineBounds::r() const {
- return m_radius;
+inline std::vector<double> LineBounds::values() const {
+ std::vector<double> valvector;
+ valvector.insert(valvector.begin(), m_values.begin(), m_values.end());
+ return valvector;
}
-inline double LineBounds::halflengthZ() const {
- return m_halfZ;
+inline void LineBounds::checkConsistency() noexcept(false) {
+ if (get(eR) < 0.) {
+ throw std::invalid_argument("LineBounds: zero radius.");
+ }
+ if (get(eHalfLengthZ) <= 0.) {
+ throw std::invalid_argument("LineBounds: zero/negative length.");
+ }
}
} // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Surfaces/PlanarBounds.hpp b/Core/include/Acts/Surfaces/PlanarBounds.hpp
index 8fafc816ce46e672d29453dd5ea45bd3106af9f1..c596ce163a23ef96d726e674779a3a996d037879 100644
--- a/Core/include/Acts/Surfaces/PlanarBounds.hpp
+++ b/Core/include/Acts/Surfaces/PlanarBounds.hpp
@@ -7,9 +7,11 @@
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#pragma once
-#include <vector>
#include "Acts/Surfaces/SurfaceBounds.hpp"
+
+#include <vector>
+
namespace Acts {
/// Forward declare rectangle bounds as boundary box
diff --git a/Core/include/Acts/Surfaces/RadialBounds.hpp b/Core/include/Acts/Surfaces/RadialBounds.hpp
index c5192452ab859ee447a67e3206c2811b4a9b4f1c..072aa0d859631e02d556eb05a01a57f32ce2f302 100644
--- a/Core/include/Acts/Surfaces/RadialBounds.hpp
+++ b/Core/include/Acts/Surfaces/RadialBounds.hpp
@@ -7,13 +7,15 @@
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#pragma once
-#include <cmath>
#include "Acts/Surfaces/DiscBounds.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/ParameterDefinitions.hpp"
#include "Acts/Utilities/detail/periodic.hpp"
+#include <array>
+#include <vector>
+
namespace Acts {
/// @class RadialBounds
@@ -22,50 +24,48 @@ namespace Acts {
/// By providing an argument for hphisec, the bounds can
/// be restricted to a phi-range around the center position.
///
-/// @image html RadialBounds.gif
-
class RadialBounds : public DiscBounds {
public:
- /// enumeration for readability
enum BoundValues {
- bv_rMin = 0,
- bv_rMax = 1,
- bv_averagePhi = 2,
- bv_halfPhiSector = 3,
- bv_length = 4
+ eMinR = 0,
+ eMaxR = 1,
+ eHalfPhiSector = 2,
+ eAveragePhi = 3,
+ eSize = 4
};
- /// Default contructor
RadialBounds() = delete;
/// Constructor for full disc of symmetric disc around phi=0
///
- /// @param minrad is the inner radius of the disc (0 for full disc)
- /// @param maxrad is the outer radius of the disc
- /// @param hphisec is the half opening angle of the disc (Pi for full angular
- /// coverage)
- RadialBounds(double minrad, double maxrad, double hphisec = M_PI);
-
- /// Constructor for full disc of symmetric disc around phi!=0
+ /// @param minR The inner radius (0 for full disc)
+ /// @param maxR The outer radius
+ /// @param halfPhi The half opening angle (Pi for full angular coverage)
+ /// @param avgPhi The average phi for the disc/ring sector
+ RadialBounds(double minR, double maxR, double halfPhi = M_PI,
+ double avgPhi = 0.) noexcept(false)
+ : m_values({minR, maxR, halfPhi, avgPhi}) {
+ checkConsistency();
+ }
+
+ /// Constructor from array values
///
- /// @param minrad is the inner radius of the disc (0 for full disc)
- /// @param maxrad is the outer radius of the disc
- /// @param avephi is the phi value of the local x-axis in the local 3D frame
- /// @param hphisec is the half opening angle of the disc (Pi for full angular
- /// coverage)
- RadialBounds(double minrad, double maxrad, double avephi, double hphisec);
-
- /// Defaulted Destructor
+ /// @param values The bound values
+ RadialBounds(const std::array<double, eSize>& values) noexcept(false)
+ : m_values(values) {
+ checkConsistency();
+ }
+
~RadialBounds() override = default;
- /// Virtual constructor
RadialBounds* clone() const final;
- /// Return the type enumerator
SurfaceBounds::BoundsType type() const final;
- /// Value store to be written out
- std::vector<TDD_real_t> valueStore() const final;
+ /// Return the bound values as dynamically sized vector
+ ///
+ /// @return this returns a copy of the internal values
+ std::vector<double> values() const final;
/// For disc surfaces the local position in (r,phi) is checked
///
@@ -94,12 +94,9 @@ class RadialBounds : public DiscBounds {
/// Return method for outer Radius
double rMax() const;
- /// Return method for the central phi value
- ///(i.e. phi value of x-axis of local 3D frame)
- double averagePhi() const;
-
- /// Return method for the half phi span
- double halfPhiSector() const;
+ /// Access to the bound values
+ /// @param bValue the class nested enum for the array access
+ double get(BoundValues bValue) const { return m_values[bValue]; }
/// Returns true for full phi coverage
bool coversFullAzimuth() const final;
@@ -115,7 +112,11 @@ class RadialBounds : public DiscBounds {
double binningValuePhi() const final;
private:
- double m_rMin, m_rMax, m_avgPhi, m_halfPhi;
+ std::array<double, eSize> m_values;
+
+ /// Check the input values for consistency, will throw a logic_exception
+ /// if consistency is not given
+ void checkConsistency() noexcept(false);
/// Private helper method to shift a local position
/// within the bounds
@@ -137,35 +138,45 @@ class RadialBounds : public DiscBounds {
};
inline double RadialBounds::rMin() const {
- return m_rMin;
+ return get(eMinR);
}
inline double RadialBounds::rMax() const {
- return m_rMax;
-}
-
-inline double RadialBounds::averagePhi() const {
- return m_avgPhi;
-}
-
-inline double RadialBounds::halfPhiSector() const {
- return m_halfPhi;
+ return get(eMaxR);
}
inline bool RadialBounds::coversFullAzimuth() const {
- return (m_halfPhi == M_PI);
+ return (get(eHalfPhiSector) == M_PI);
}
inline bool RadialBounds::insideRadialBounds(double R, double tolerance) const {
- return (R + tolerance > m_rMin and R - tolerance < m_rMax);
+ return (R + tolerance > get(eMinR) and R - tolerance < get(eMaxR));
}
inline double RadialBounds::binningValueR() const {
- return 0.5 * (m_rMin + m_rMax);
+ return 0.5 * (get(eMinR) + get(eMaxR));
}
inline double RadialBounds::binningValuePhi() const {
- return m_avgPhi;
+ return get(eAveragePhi);
+}
+
+inline std::vector<double> RadialBounds::values() const {
+ std::vector<double> valvector;
+ valvector.insert(valvector.begin(), m_values.begin(), m_values.end());
+ return valvector;
+}
+
+inline void RadialBounds::checkConsistency() noexcept(false) {
+ if (get(eMinR) < 0. or get(eMaxR) <= 0. or get(eMinR) > get(eMaxR)) {
+ throw std::invalid_argument("RadialBounds: invalid radial setup");
+ }
+ if (get(eHalfPhiSector) < 0. or get(eHalfPhiSector) > M_PI) {
+ throw std::invalid_argument("CylinderBounds: invalid phi sector setup.");
+ }
+ if (get(eAveragePhi) != detail::radian_sym(get(eAveragePhi))) {
+ throw std::invalid_argument("CylinderBounds: invalid phi positioning.");
+ }
}
} // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Surfaces/RectangleBounds.hpp b/Core/include/Acts/Surfaces/RectangleBounds.hpp
index 95b13be8757fe943e0de58389f92248d3b9aa037..428078b6b2770abe656003352f53b753c0d80a28 100644
--- a/Core/include/Acts/Surfaces/RectangleBounds.hpp
+++ b/Core/include/Acts/Surfaces/RectangleBounds.hpp
@@ -7,39 +7,58 @@
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#pragma once
+
#include "Acts/Surfaces/PlanarBounds.hpp"
#include "Acts/Utilities/Definitions.hpp"
+#include <array>
+#include <vector>
+
namespace Acts {
/// @class RectangleBounds
///
-/// Bounds for a rectangular, planar surface.
-/// The two local coordinates Acts::eLOC_X, Acts::eLOC_Y are for legacy reasons
-/// also called @f$ phi @f$ respectively @f$ eta @f$. The orientation
-/// with respect to the local surface framce can be seen in the attached
-/// illustration.
-///
-/// @image html RectangularBounds.gif
-
+/// Bounds for a rectangular, planar surface - it can be used to for
+/// rectangles that are symetrically centered around (0./0.) and for
+/// generic shifted rectangles
class RectangleBounds : public PlanarBounds {
public:
- /// @enum BoundValues for readability
- enum BoundValues { bv_halfX = 0, bv_halfY = 1, bv_length = 2 };
+ enum BoundValues : int {
+ eMinX = 0,
+ eMinY = 1,
+ eMaxX = 2,
+ eMaxY = 3,
+ eSize = 4
+ };
RectangleBounds() = delete;
- /// Constructor with halflength in x and y
+ /// Constructor with halflength in x and y - symmetric
///
- /// @param halex halflength in X
- /// @param haley halflength in Y
- RectangleBounds(double halex, double haley);
-
- /// Constructor with explicit min and max vertex
+ /// @param halfX halflength in X
+ /// @param halfY halflength in Y
+ RectangleBounds(double halfX, double halfY) noexcept(false)
+ : m_min({-halfX, -halfY}), m_max({halfX, halfY}) {
+ checkConsistency();
+ }
+
+ /// Constructor - from fixed size array - generic
+ ///
+ /// @param values The parameter values
+ RectangleBounds(const std::array<double, eSize>& values) noexcept(false)
+ : m_min({values[eMinX], values[eMinY]}),
+ m_max({values[eMaxX], values[eMaxY]}) {
+ checkConsistency();
+ }
+
+ /// Constructor - from min/max - generic
///
- /// @param vmin Minimum vertex
- /// @param vmax Maximum vertex
- RectangleBounds(const Vector2D& vmin, const Vector2D& vmax);
+ /// @param min The left bottom corner
+ /// @param max The right top corning
+ RectangleBounds(const Vector2D& min, const Vector2D& max) noexcept(false)
+ : m_min(min), m_max(max) {
+ checkConsistency();
+ }
~RectangleBounds() override = default;
@@ -47,7 +66,7 @@ class RectangleBounds : public PlanarBounds {
BoundsType type() const final;
- std::vector<TDD_real_t> valueStore() const final;
+ std::vector<double> values() const final;
/// Inside check for the bounds object driven by the boundary check directive
/// Each Bounds has a method inside, which checks if a LocalPosition is inside
@@ -83,11 +102,15 @@ class RectangleBounds : public PlanarBounds {
/// @param sl is the ostream for the dump
std::ostream& toStream(std::ostream& sl) const final;
- /// Return method for the half length in X
- double halflengthX() const;
+ /// Access to the bound values
+ /// @param bValue the class nested enum for the array access
+ double get(BoundValues bValue) const;
- /// Return method for the half length in Y
- double halflengthY() const;
+ /// Access to the half length in X
+ double halfLengthX() const;
+
+ /// Access to the half length in Y
+ double halfLengthY() const;
/// Get the min vertex defining the bounds
/// @return The min vertex
@@ -100,18 +123,14 @@ class RectangleBounds : public PlanarBounds {
private:
Vector2D m_min;
Vector2D m_max;
-};
-inline double RectangleBounds::halflengthX() const {
- return std::abs(m_max.x() - m_min.x()) * 0.5;
-}
-
-inline double RectangleBounds::halflengthY() const {
- return std::abs(m_max.y() - m_min.y()) * 0.5;
-}
+ /// Check the input values for consistency, will throw a logic_exception
+ /// if consistency is not given
+ void checkConsistency() noexcept(false);
+};
inline SurfaceBounds::BoundsType RectangleBounds::type() const {
- return SurfaceBounds::Rectangle;
+ return SurfaceBounds::eRectangle;
}
inline const Vector2D& RectangleBounds::min() const {
@@ -122,4 +141,37 @@ inline const Vector2D& RectangleBounds::max() const {
return m_max;
}
+inline double RectangleBounds::halfLengthX() const {
+ return 0.5 * (m_max.x() - m_min.x());
+}
+
+inline double RectangleBounds::halfLengthY() const {
+ return 0.5 * (m_max.y() - m_min.y());
+}
+
+inline std::vector<double> RectangleBounds::values() const {
+ return {m_min.x(), m_min.y(), m_max.x(), m_max.y()};
+}
+
+inline double RectangleBounds::get(BoundValues bValue) const {
+ switch (bValue) {
+ case eMinX:
+ return m_min.x();
+ case eMinY:
+ return m_min.y();
+ case eMaxX:
+ return m_max.x();
+ }
+ return m_max.y();
+}
+
+inline void RectangleBounds::checkConsistency() noexcept(false) {
+ if (get(eMinX) > get(eMaxX)) {
+ throw std::invalid_argument("RectangleBounds: invalid local x setup");
+ }
+ if (get(eMinY) > get(eMaxY)) {
+ throw std::invalid_argument("RectangleBounds: invalid local y setup");
+ }
+}
+
} // namespace Acts
diff --git a/Core/include/Acts/Surfaces/Surface.hpp b/Core/include/Acts/Surfaces/Surface.hpp
index 6287c0cf04557951d47421299df441ec6aa9bac1..168ac50bc2fdb57610276d2c89c6edd4d1ee0885 100644
--- a/Core/include/Acts/Surfaces/Surface.hpp
+++ b/Core/include/Acts/Surfaces/Surface.hpp
@@ -94,7 +94,6 @@ class Surface : public virtual GeometryObject,
const Transform3D& shift);
public:
- /// Destructor
virtual ~Surface();
/// Factory for producing memory managed instances of Surface.
diff --git a/Core/include/Acts/Surfaces/SurfaceBounds.hpp b/Core/include/Acts/Surfaces/SurfaceBounds.hpp
index 7a58c5aab8ad032bd650d9ef1b2a68c770a91ad4..75a72e7846ce732a5e2555c5847375fd37b65196 100644
--- a/Core/include/Acts/Surfaces/SurfaceBounds.hpp
+++ b/Core/include/Acts/Surfaces/SurfaceBounds.hpp
@@ -27,25 +27,22 @@ class SurfaceBounds {
public:
/// @enum BoundsType
///
- /// This enumerator simplifies the persistency,
- /// by saving a dynamic_cast to happen.
- ///
- enum BoundsType {
- Cone = 0,
- Cylinder = 1,
- Diamond = 2,
- Disc = 3,
- Ellipse = 5,
- Line = 6,
- Rectangle = 7,
- RotatedTrapezoid = 8,
- Trapezoid = 9,
- Triangle = 10,
- DiscTrapezoidal = 11,
- ConvexPolygon = 12,
- Annulus = 13,
- Boundless = 14,
- Other = 15
+ /// This enumerator simplifies the persistency and bounds identification
+ enum BoundsType : int {
+ eCone = 0,
+ eCylinder = 1,
+ eDiamond = 2,
+ eDisc = 3,
+ eEllipse = 5,
+ eLine = 6,
+ eRectangle = 7,
+ eTrapezoid = 8,
+ eTriangle = 9,
+ eDiscTrapezoid = 10,
+ eConvexPolygon = 11,
+ eAnnulus = 12,
+ eBoundless = 13,
+ eOther = 14
};
virtual ~SurfaceBounds() = default;
@@ -61,10 +58,11 @@ class SurfaceBounds {
/// @return is a BoundsType enum
virtual BoundsType type() const = 0;
- /// Access method for bound variable store
+ /// Access method for bound values, this is a dynamically sized
+ /// vector containing the parameters needed to describe these bounds
///
- /// @return of the stored values for the boundary object
- virtual std::vector<TDD_real_t> valueStore() const = 0;
+ /// @return of the stored values for this SurfaceBounds object
+ virtual std::vector<double> values() const = 0;
/// Inside check for the bounds object driven by the boundary check directive
/// Each Bounds has a method inside, which checks if a LocalPosition is inside
@@ -92,7 +90,7 @@ inline bool operator==(const SurfaceBounds& lhs, const SurfaceBounds& rhs) {
if (&lhs == &rhs) {
return true;
}
- return (lhs.type() == rhs.type()) && (lhs.valueStore() == rhs.valueStore());
+ return (lhs.type() == rhs.type()) && (lhs.values() == rhs.values());
}
inline bool operator!=(const SurfaceBounds& lhs, const SurfaceBounds& rhs) {
diff --git a/Core/include/Acts/Surfaces/TrapezoidBounds.hpp b/Core/include/Acts/Surfaces/TrapezoidBounds.hpp
index 42e87c1ece3e0462387502f9402ff522b53a4b4a..ee4242c8cb04a00fea0f517baf842f9dafd55f3c 100644
--- a/Core/include/Acts/Surfaces/TrapezoidBounds.hpp
+++ b/Core/include/Acts/Surfaces/TrapezoidBounds.hpp
@@ -26,23 +26,37 @@ namespace Acts {
class TrapezoidBounds : public PlanarBounds {
public:
- /// @enum BoundValues - for readability
enum BoundValues {
- bv_minHalfX = 0,
- bv_maxHalfX = 1,
- bv_halfY = 2,
- bv_length = 3
+ eHalfLengthXnegY = 0,
+ eHalfLengthXposY = 1,
+ eHalfLengthY = 2,
+ eSize = 3
};
- /// Trapezoid bounds default constructor is forbidden
TrapezoidBounds() = delete;
/// Constructor for symmetric Trapezoid
///
- /// @param minhalex minimal half length X, definition at negative halflength Y
- /// @param maxhalex maximal half length X, definition at maximum halflength Y
- /// @param haley half length Y - defined at x=0
- TrapezoidBounds(double minhalex, double maxhalex, double haley);
+ /// @param halfXnegY minimal half length X, definition at negative Y
+ /// @param halfXposY maximal half length X, definition at positive Y
+ /// @param halfY half length Y - defined at x=0
+ TrapezoidBounds(double halfXnegY, double halfXposY,
+ double halfY) noexcept(false)
+ : m_values({halfXnegY, halfXposY, halfY}),
+ m_boundingBox(std::max(halfXnegY, halfXposY), halfY) {
+ checkConsistency();
+ }
+
+ /// Constructor for symmetric Trapezoid - from fixed size array
+ ///
+ /// @param values the values to be stream in
+ TrapezoidBounds(const std::array<double, eSize>& values) noexcept(false)
+ : m_values(values),
+ m_boundingBox(
+ std::max(values[eHalfLengthXnegY], values[eHalfLengthXposY]),
+ values[eHalfLengthY]) {
+ checkConsistency();
+ }
~TrapezoidBounds() override;
@@ -50,7 +64,7 @@ class TrapezoidBounds : public PlanarBounds {
BoundsType type() const final;
- std::vector<TDD_real_t> valueStore() const final;
+ std::vector<double> values() const final;
/// The orientation of the Trapezoid is according to the figure above,
/// in words: the shorter of the two parallel sides of the trapezoid
@@ -70,8 +84,7 @@ class TrapezoidBounds : public PlanarBounds {
/// (3) the local position is inside @f$ y @f$ bounds AND inside minimum @f$ x
/// @f$ bounds <br>
/// (4) the local position is inside @f$ y @f$ bounds AND inside maximum @f$ x
- /// @f$ bounds, so that
- /// it depends on the @f$ eta @f$ coordinate
+ /// @f$ bounds, so that it depends on the @f$ eta @f$ coordinate
/// (5) the local position fails test of (4) <br>
///
/// The inside check is done using single equations of straight lines and one
@@ -95,6 +108,7 @@ class TrapezoidBounds : public PlanarBounds {
///
/// @param lposition Local position (assumed to be in right surface frame)
/// @param bcheck boundary check directive
+ ///
/// @return boolean indicator for the success of this operation
bool inside(const Vector2D& lposition,
const BoundaryCheck& bcheck) const final;
@@ -123,35 +137,32 @@ class TrapezoidBounds : public PlanarBounds {
/// @param sl is the ostream to be dumped into
std::ostream& toStream(std::ostream& sl) const final;
- /// This method returns the minimal halflength in X
- /// (first coordinate of local surface frame)
- double minHalflengthX() const;
-
- /// This method returns the maximal halflength in X
- /// (first coordinate of local surface frame)
- double maxHalflengthX() const;
-
- /// This method returns the halflength in Y
- /// (second coordinate of local surface frame)
- double halflengthY() const;
+ /// Access to the bound values
+ /// @param bValue the class nested enum for the array access
+ double get(BoundValues bValue) const { return m_values[bValue]; }
private:
- double m_minHalfX;
- double m_maxHalfX;
- double m_halfY;
+ std::array<double, eSize> m_values;
RectangleBounds m_boundingBox;
-};
-inline double TrapezoidBounds::minHalflengthX() const {
- return m_minHalfX;
-}
+ /// Check the input values for consistency, will throw a logic_exception
+ /// if consistency is not given
+ void checkConsistency() noexcept(false);
+};
-inline double TrapezoidBounds::maxHalflengthX() const {
- return m_maxHalfX;
+inline std::vector<double> TrapezoidBounds::values() const {
+ std::vector<double> valvector;
+ valvector.insert(valvector.begin(), m_values.begin(), m_values.end());
+ return valvector;
}
-inline double TrapezoidBounds::halflengthY() const {
- return m_halfY;
+inline void TrapezoidBounds::checkConsistency() noexcept(false) {
+ if (get(eHalfLengthXnegY) <= 0. or get(eHalfLengthXposY) <= 0.) {
+ throw std::invalid_argument("TrapezoidBounds: invalid local x setup");
+ }
+ if (get(eHalfLengthY) <= 0.) {
+ throw std::invalid_argument("TrapezoidBounds: invalid local y setup");
+ }
}
} // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Surfaces/TriangleBounds.hpp b/Core/include/Acts/Surfaces/TriangleBounds.hpp
deleted file mode 100644
index 204ea0d8697fd770a604fd785142aab54dc762bc..0000000000000000000000000000000000000000
--- a/Core/include/Acts/Surfaces/TriangleBounds.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-///////////////////////////////////////////////////////////////////
-// TriangleBounds.h, Acts project
-///////////////////////////////////////////////////////////////////
-
-#pragma once
-#include <array>
-#include <utility>
-
-#include "Acts/Surfaces/PlanarBounds.hpp"
-#include "Acts/Surfaces/RectangleBounds.hpp"
-#include "Acts/Utilities/Definitions.hpp"
-#include "Acts/Utilities/ParameterDefinitions.hpp"
-
-namespace Acts {
-
-/// @class TriangleBounds
-///
-/// Bounds for a triangular, planar surface.
-///
-/// @image html TriangularBounds.gif
-
-class TriangleBounds : public PlanarBounds {
- public:
- // @enum BoundValues for readability
- enum BoundValues {
- bv_x1 = 0,
- bv_y1 = 1,
- bv_x2 = 2,
- bv_y2 = 3,
- bv_x3 = 4,
- bv_y3 = 5,
- bv_length = 6
- };
-
- TriangleBounds() = delete;
-
- /// Constructor with coordinates of vertices
- ///
- /// @param vertices is the vector of vertices
- TriangleBounds(const std::array<Vector2D, 3>& vertices);
-
- ~TriangleBounds() override;
-
- TriangleBounds* clone() const final;
-
- BoundsType type() const final;
-
- std::vector<TDD_real_t> valueStore() const final;
-
- /// This method checks if the provided local coordinates are inside the
- /// surface bounds
- ///
- /// @param lposition local position in 2D local Cartesian frame
- /// @param bcheck is the boundary check directive
- /// @return boolean indicator for the success of this operation
- bool inside(const Vector2D& lposition,
- const BoundaryCheck& bcheck) const final;
-
- /// Minimal distance to boundary ( > 0 if outside and <=0 if inside)
- ///
- /// @param lposition is the local position to check for the distance
- /// @return is a signed distance parameter
- double distanceToBoundary(const Vector2D& lposition) const final;
-
- /// Return the vertices
- ///
- /// @param lseg the number of segments used to approximate
- /// and eventually curved line
- ///
- /// @note the number of segements is ignored in this representation
- ///
- /// @return vector for vertices in 2D
- std::vector<Vector2D> vertices(unsigned int lseg = 1) const final;
-
- // Bounding box representation
- const RectangleBounds& boundingBox() const final;
-
- /// Output Method for std::ostream
- ///
- /// @param sl is the ostream to be dumped into
- std::ostream& toStream(std::ostream& sl) const final;
-
- private:
- std::array<Vector2D, 3> m_vertices;
- RectangleBounds m_boundingBox; ///< internal bounding box cache
-};
-
-} // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Surfaces/detail/CylinderSurface.ipp b/Core/include/Acts/Surfaces/detail/CylinderSurface.ipp
index c3f6a8a6bd343b95e64a1d5e1d29dce259addd02..4fa3c318fc0a5d8a7f13444b0dccc71745525dee 100644
--- a/Core/include/Acts/Surfaces/detail/CylinderSurface.ipp
+++ b/Core/include/Acts/Surfaces/detail/CylinderSurface.ipp
@@ -20,7 +20,7 @@ inline detail::RealQuadraticEquation CylinderSurface::intersectionSolver(
const Transform3D& transform, const Vector3D& position,
const Vector3D& direction) const {
// Solve for radius R
- double R = bounds().r();
+ double R = bounds().get(CylinderBounds::eR);
// Get the transformation matrtix
const auto& tMatrix = transform.matrix();
@@ -105,7 +105,7 @@ inline SurfaceIntersection CylinderSurface::intersect(
const Vector3D vecLocal(solution - tMatrix.block<3, 1>(0, 3));
double cZ = vecLocal.dot(tMatrix.block<3, 1>(0, 2));
double tolerance = s_onSurfaceTolerance + bcheck.tolerance()[eLOC_Z];
- double hZ = cBounds.halflengthZ() + tolerance;
+ double hZ = cBounds.get(CylinderBounds::eHalfLengthZ) + tolerance;
return (cZ * cZ < hZ * hZ) ? status : Intersection::Status::missed;
}
return (isOnSurface(gctx, solution, direction, bcheck)
diff --git a/Core/include/Acts/Surfaces/detail/LineSurface.ipp b/Core/include/Acts/Surfaces/detail/LineSurface.ipp
index b120eb18cbc370bf656f240192b21a77eb3ff99a..7d27e86f676d55001c9a5ee4b124dc82234f217d 100644
--- a/Core/include/Acts/Surfaces/detail/LineSurface.ipp
+++ b/Core/include/Acts/Surfaces/detail/LineSurface.ipp
@@ -121,9 +121,11 @@ inline Intersection LineSurface::intersectionEstimate(
// At closest approach: check inside R or and inside Z
const Vector3D vecLocal(result - mb);
double cZ = vecLocal.dot(eb);
- double hZ = m_bounds->halflengthZ() + s_onSurfaceTolerance;
- if ((cZ * cZ > hZ * hZ) or ((vecLocal - cZ * eb).norm() >
- m_bounds->r() + s_onSurfaceTolerance)) {
+ double hZ =
+ m_bounds->get(LineBounds::eHalfLengthZ) + s_onSurfaceTolerance;
+ if ((cZ * cZ > hZ * hZ) or
+ ((vecLocal - cZ * eb).norm() >
+ m_bounds->get(LineBounds::eR) + s_onSurfaceTolerance)) {
status = Intersection::Status::missed;
}
}
diff --git a/Core/include/Acts/Utilities/BinAdjustment.hpp b/Core/include/Acts/Utilities/BinAdjustment.hpp
index 011620157598ea31be5ea5f6fe1d986c19716e3c..9e95aaf860336f861fbcd98c532d98bd795c7cfd 100644
--- a/Core/include/Acts/Utilities/BinAdjustment.hpp
+++ b/Core/include/Acts/Utilities/BinAdjustment.hpp
@@ -31,10 +31,12 @@ BinUtility adjustBinUtility(const BinUtility& bu, const RadialBounds& rBounds) {
// Default constructor
BinUtility uBinUtil;
// The parameters from the cylinder bounds
- double minR = rBounds.rMin();
- double maxR = rBounds.rMax();
- double minPhi = rBounds.averagePhi() - rBounds.halfPhiSector();
- double maxPhi = rBounds.averagePhi() + rBounds.halfPhiSector();
+ double minR = rBounds.get(RadialBounds::eMinR);
+ double maxR = rBounds.get(RadialBounds::eMaxR);
+ double minPhi = rBounds.get(RadialBounds::eAveragePhi) -
+ rBounds.get(RadialBounds::eHalfPhiSector);
+ double maxPhi = rBounds.get(RadialBounds::eAveragePhi) +
+ rBounds.get(RadialBounds::eHalfPhiSector);
// Retrieve the binning data
const std::vector<BinningData>& bData = bu.binningData();
// Loop over the binning data and adjust the dimensions
@@ -76,10 +78,13 @@ BinUtility adjustBinUtility(const BinUtility& bu,
// Default constructor
BinUtility uBinUtil;
// The parameters from the cylinder bounds
- double cR = cBounds.r();
- double cHz = cBounds.halflengthZ();
- double minPhi = cBounds.averagePhi() - cBounds.halfPhiSector();
- double maxPhi = cBounds.averagePhi() + cBounds.halfPhiSector();
+ double cR = cBounds.get(CylinderBounds::eR);
+ double cHz = cBounds.get(CylinderBounds::eHalfLengthZ);
+ double avgPhi = cBounds.get(CylinderBounds::eAveragePhi);
+ double halfPhi = cBounds.get(CylinderBounds::eHalfPhiSector);
+ double minPhi = avgPhi - halfPhi;
+ double maxPhi = avgPhi + halfPhi;
+ ;
// Retrieve the binning data
const std::vector<BinningData>& bData = bu.binningData();
// Loop over the binning data and adjust the dimensions
diff --git a/Core/include/Acts/Utilities/Definitions.hpp b/Core/include/Acts/Utilities/Definitions.hpp
index 7dbb61af0439c95dd26589225bbd78b2b40c3fb6..45a3f3fb1a591f72c645fe13015a7142dd4301d0 100644
--- a/Core/include/Acts/Utilities/Definitions.hpp
+++ b/Core/include/Acts/Utilities/Definitions.hpp
@@ -18,16 +18,11 @@
#include <Eigen/Dense>
#endif
-#ifdef TRKDETDESCR_USEFLOATPRECISON
-using TDD_real_t = float;
-#else
-using TDD_real_t = double;
-#endif
-
-#define TDD_max_bound_value 10e10
-
namespace Acts {
+/// Tolerance for bein numerical equal for geometry building
+static constexpr double s_epsilon = 3 * std::numeric_limits<double>::epsilon();
+
/// Tolerance for being on Surface
///
/// @note This is intentionally given w/o an explicit unit to avoid having
diff --git a/Core/src/Geometry/CuboidVolumeBounds.cpp b/Core/src/Geometry/CuboidVolumeBounds.cpp
index 125b3f4d31d4c0c7ce237804339ba4a630979dda..219c233efa070a52e59c5dc263679b614bffdbdf 100644
--- a/Core/src/Geometry/CuboidVolumeBounds.cpp
+++ b/Core/src/Geometry/CuboidVolumeBounds.cpp
@@ -15,18 +15,18 @@
#include "Acts/Utilities/BoundingBox.hpp"
Acts::CuboidVolumeBounds::CuboidVolumeBounds()
- : VolumeBounds(), m_valueStore(bv_length, 0.) {}
+ : VolumeBounds(), m_values(bv_length, 0.) {}
Acts::CuboidVolumeBounds::CuboidVolumeBounds(double halex, double haley,
double halez)
: VolumeBounds(),
- m_valueStore(bv_length, 0.),
+ m_values(bv_length, 0.),
m_xyBounds(nullptr),
m_yzBounds(nullptr),
m_zxBounds(nullptr) {
- m_valueStore.at(bv_halfX) = halex;
- m_valueStore.at(bv_halfY) = haley;
- m_valueStore.at(bv_halfZ) = halez;
+ m_values.at(bv_halfX) = halex;
+ m_values.at(bv_halfY) = haley;
+ m_values.at(bv_halfZ) = halez;
m_xyBounds = faceXYRectangleBounds();
m_yzBounds = faceYZRectangleBounds();
@@ -35,7 +35,7 @@ Acts::CuboidVolumeBounds::CuboidVolumeBounds(double halex, double haley,
Acts::CuboidVolumeBounds::CuboidVolumeBounds(const CuboidVolumeBounds& bobo)
: VolumeBounds(),
- m_valueStore(bobo.m_valueStore),
+ m_values(bobo.m_values),
m_xyBounds(bobo.m_xyBounds),
m_yzBounds(bobo.m_yzBounds),
m_zxBounds(bobo.m_zxBounds) {}
@@ -45,7 +45,7 @@ Acts::CuboidVolumeBounds::~CuboidVolumeBounds() = default;
Acts::CuboidVolumeBounds& Acts::CuboidVolumeBounds::operator=(
const CuboidVolumeBounds& bobo) {
if (this != &bobo) {
- m_valueStore = bobo.m_valueStore;
+ m_values = bobo.m_values;
m_xyBounds = bobo.m_xyBounds;
m_yzBounds = bobo.m_yzBounds;
m_zxBounds = bobo.m_zxBounds;
@@ -113,20 +113,20 @@ Acts::SurfacePtrVector Acts::CuboidVolumeBounds::decomposeToSurfaces(
std::shared_ptr<const Acts::RectangleBounds>
Acts::CuboidVolumeBounds::faceXYRectangleBounds() const {
- return std::make_shared<const RectangleBounds>(m_valueStore.at(bv_halfX),
- m_valueStore.at(bv_halfY));
+ return std::make_shared<const RectangleBounds>(m_values.at(bv_halfX),
+ m_values.at(bv_halfY));
}
std::shared_ptr<const Acts::RectangleBounds>
Acts::CuboidVolumeBounds::faceYZRectangleBounds() const {
- return std::make_shared<const RectangleBounds>(m_valueStore.at(bv_halfY),
- m_valueStore.at(bv_halfZ));
+ return std::make_shared<const RectangleBounds>(m_values.at(bv_halfY),
+ m_values.at(bv_halfZ));
}
std::shared_ptr<const Acts::RectangleBounds>
Acts::CuboidVolumeBounds::faceZXRectangleBounds() const {
- return std::make_shared<const RectangleBounds>(m_valueStore.at(bv_halfZ),
- m_valueStore.at(bv_halfX));
+ return std::make_shared<const RectangleBounds>(m_values.at(bv_halfZ),
+ m_values.at(bv_halfX));
}
// ostream operator overload
diff --git a/Core/src/Geometry/CutoutCylinderVolumeBounds.cpp b/Core/src/Geometry/CutoutCylinderVolumeBounds.cpp
index e777b74ea06e960ac3f4a0fb0646b8c055982a4c..81d89b835e9ff279bf186d23f43949cba670cb28 100644
--- a/Core/src/Geometry/CutoutCylinderVolumeBounds.cpp
+++ b/Core/src/Geometry/CutoutCylinderVolumeBounds.cpp
@@ -65,11 +65,13 @@ Acts::CutoutCylinderVolumeBounds::decomposeToSurfaces(
}
// outer cylinder envelope
- auto outer = Surface::makeShared<CylinderSurface>(trf, m_rmax, m_dz1);
+ auto outerBounds = std::make_shared<CylinderBounds>(m_rmax, m_dz1);
+ auto outer = Surface::makeShared<CylinderSurface>(trf, outerBounds);
surfaces.at(tubeOuterCover) = outer;
// inner (small) cylinder envelope
- auto ctr_inner = Surface::makeShared<CylinderSurface>(trf, m_rmed, m_dz2);
+ auto ctr_innerBounds = std::make_shared<CylinderBounds>(m_rmed, m_dz2);
+ auto ctr_inner = Surface::makeShared<CylinderSurface>(trf, ctr_innerBounds);
surfaces.at(tubeInnerCover) = ctr_inner;
// z position of the pos and neg choke points
diff --git a/Core/src/Geometry/CylinderVolumeBounds.cpp b/Core/src/Geometry/CylinderVolumeBounds.cpp
index c90f71a4a4862b5296a7cc84f2ac9bffc9879c93..6e0dd1c2287405443c9cae28a029557de968f206 100644
--- a/Core/src/Geometry/CylinderVolumeBounds.cpp
+++ b/Core/src/Geometry/CylinderVolumeBounds.cpp
@@ -25,63 +25,63 @@
const double Acts::CylinderVolumeBounds::s_numericalStable = 10e-2;
Acts::CylinderVolumeBounds::CylinderVolumeBounds()
- : VolumeBounds(), m_valueStore(4, 0.) {}
+ : VolumeBounds(), m_values(4, 0.) {}
Acts::CylinderVolumeBounds::CylinderVolumeBounds(double radius, double halez)
- : VolumeBounds(), m_valueStore(4, 0.) {
- m_valueStore.at(bv_innerRadius) = 0.;
- m_valueStore.at(bv_outerRadius) = std::abs(radius);
- m_valueStore.at(bv_halfPhiSector) = M_PI;
- m_valueStore.at(bv_halfZ) = std::abs(halez);
+ : VolumeBounds(), m_values(4, 0.) {
+ m_values.at(bv_innerRadius) = 0.;
+ m_values.at(bv_outerRadius) = std::abs(radius);
+ m_values.at(bv_halfPhiSector) = M_PI;
+ m_values.at(bv_halfZ) = std::abs(halez);
}
Acts::CylinderVolumeBounds::CylinderVolumeBounds(double rinner, double router,
double halez)
- : VolumeBounds(), m_valueStore(4, 0.) {
- m_valueStore.at(bv_innerRadius) = std::abs(rinner);
- m_valueStore.at(bv_outerRadius) = std::abs(router);
- m_valueStore.at(bv_halfPhiSector) = M_PI;
- m_valueStore.at(bv_halfZ) = std::abs(halez);
+ : VolumeBounds(), m_values(4, 0.) {
+ m_values.at(bv_innerRadius) = std::abs(rinner);
+ m_values.at(bv_outerRadius) = std::abs(router);
+ m_values.at(bv_halfPhiSector) = M_PI;
+ m_values.at(bv_halfZ) = std::abs(halez);
}
Acts::CylinderVolumeBounds::CylinderVolumeBounds(double rinner, double router,
double haphi, double halez)
- : VolumeBounds(), m_valueStore(4, 0.) {
- m_valueStore.at(bv_innerRadius) = std::abs(rinner);
- m_valueStore.at(bv_outerRadius) = std::abs(router);
- m_valueStore.at(bv_halfPhiSector) = std::abs(haphi);
- m_valueStore.at(bv_halfZ) = std::abs(halez);
+ : VolumeBounds(), m_values(4, 0.) {
+ m_values.at(bv_innerRadius) = std::abs(rinner);
+ m_values.at(bv_outerRadius) = std::abs(router);
+ m_values.at(bv_halfPhiSector) = std::abs(haphi);
+ m_values.at(bv_halfZ) = std::abs(halez);
}
Acts::CylinderVolumeBounds::CylinderVolumeBounds(const CylinderBounds& cBounds,
double thickness)
- : VolumeBounds(), m_valueStore(4, 0.) {
- double cR = cBounds.r();
- m_valueStore.at(bv_innerRadius) = cR - 0.5 * thickness;
- m_valueStore.at(bv_outerRadius) = cR + 0.5 * thickness;
- m_valueStore.at(bv_halfPhiSector) = cBounds.halfPhiSector();
- m_valueStore.at(bv_halfZ) = cBounds.halflengthZ();
+ : VolumeBounds(), m_values(4, 0.) {
+ double cR = cBounds.get(CylinderBounds::eR);
+ m_values.at(bv_innerRadius) = cR - 0.5 * thickness;
+ m_values.at(bv_outerRadius) = cR + 0.5 * thickness;
+ m_values.at(bv_halfPhiSector) = cBounds.get(CylinderBounds::eHalfPhiSector);
+ m_values.at(bv_halfZ) = cBounds.get(CylinderBounds::eHalfLengthZ);
}
Acts::CylinderVolumeBounds::CylinderVolumeBounds(const RadialBounds& rBounds,
double thickness)
- : VolumeBounds(), m_valueStore(4, 0.) {
- m_valueStore.at(bv_innerRadius) = rBounds.rMin();
- m_valueStore.at(bv_outerRadius) = rBounds.rMax();
- m_valueStore.at(bv_halfPhiSector) = rBounds.halfPhiSector();
- m_valueStore.at(bv_halfZ) = 0.5 * thickness;
+ : VolumeBounds(), m_values(4, 0.) {
+ m_values.at(bv_innerRadius) = rBounds.get(RadialBounds::eMinR);
+ m_values.at(bv_outerRadius) = rBounds.get(RadialBounds::eMaxR);
+ m_values.at(bv_halfPhiSector) = rBounds.get(RadialBounds::eHalfPhiSector);
+ m_values.at(bv_halfZ) = 0.5 * thickness;
}
Acts::CylinderVolumeBounds::CylinderVolumeBounds(
const CylinderVolumeBounds& cylbo)
- : VolumeBounds(), m_valueStore(cylbo.m_valueStore) {}
+ : VolumeBounds(), m_values(cylbo.m_values) {}
Acts::CylinderVolumeBounds::~CylinderVolumeBounds() = default;
Acts::CylinderVolumeBounds& Acts::CylinderVolumeBounds::operator=(
const CylinderVolumeBounds& cylbo) {
if (this != &cylbo) {
- m_valueStore = cylbo.m_valueStore;
+ m_values = cylbo.m_values;
}
return *this;
}
@@ -146,30 +146,30 @@ Acts::CylinderVolumeBounds::decomposeToSurfaces(
std::shared_ptr<const Acts::CylinderBounds>
Acts::CylinderVolumeBounds::innerCylinderBounds() const {
- return std::make_shared<const CylinderBounds>(
- m_valueStore.at(bv_innerRadius), m_valueStore.at(bv_halfPhiSector),
- m_valueStore.at(bv_halfZ));
+ return std::make_shared<const CylinderBounds>(m_values.at(bv_innerRadius),
+ m_values.at(bv_halfZ),
+ m_values.at(bv_halfPhiSector));
}
std::shared_ptr<const Acts::CylinderBounds>
Acts::CylinderVolumeBounds::outerCylinderBounds() const {
- return std::make_shared<const CylinderBounds>(
- m_valueStore.at(bv_outerRadius), m_valueStore.at(bv_halfPhiSector),
- m_valueStore.at(bv_halfZ));
+ return std::make_shared<const CylinderBounds>(m_values.at(bv_outerRadius),
+ m_values.at(bv_halfZ),
+ m_values.at(bv_halfPhiSector));
}
std::shared_ptr<const Acts::DiscBounds> Acts::CylinderVolumeBounds::discBounds()
const {
- return std::shared_ptr<const DiscBounds>(new RadialBounds(
- m_valueStore.at(bv_innerRadius), m_valueStore.at(bv_outerRadius),
- m_valueStore.at(bv_halfPhiSector)));
+ return std::shared_ptr<const DiscBounds>(
+ new RadialBounds(m_values.at(bv_innerRadius), m_values.at(bv_outerRadius),
+ m_values.at(bv_halfPhiSector)));
}
std::shared_ptr<const Acts::PlanarBounds>
Acts::CylinderVolumeBounds::sectorPlaneBounds() const {
return std::shared_ptr<const PlanarBounds>(new RectangleBounds(
- 0.5 * (m_valueStore.at(bv_outerRadius) - m_valueStore.at(bv_innerRadius)),
- m_valueStore.at(bv_halfZ)));
+ 0.5 * (m_values.at(bv_outerRadius) - m_values.at(bv_innerRadius)),
+ m_values.at(bv_halfZ)));
}
std::ostream& Acts::CylinderVolumeBounds::toStream(std::ostream& sl) const {
diff --git a/Core/src/Geometry/CylinderVolumeBuilder.cpp b/Core/src/Geometry/CylinderVolumeBuilder.cpp
index 0c9f79e85d99098dc43699d158ef34d1d08c151f..e7c017bf633a944d2a3bf32a12e28ef53c0c821c 100644
--- a/Core/src/Geometry/CylinderVolumeBuilder.cpp
+++ b/Core/src/Geometry/CylinderVolumeBuilder.cpp
@@ -496,11 +496,14 @@ Acts::VolumeConfig Acts::CylinderVolumeBuilder::analyzeContent(
if (cLayer != nullptr) {
// now we have access to all the information
double rMinC =
- cLayer->surfaceRepresentation().bounds().r() - 0.5 * thickness;
+ cLayer->surfaceRepresentation().bounds().get(CylinderBounds::eR) -
+ 0.5 * thickness;
double rMaxC =
- cLayer->surfaceRepresentation().bounds().r() + 0.5 * thickness;
+ cLayer->surfaceRepresentation().bounds().get(CylinderBounds::eR) +
+ 0.5 * thickness;
- double hZ = cLayer->surfaceRepresentation().bounds().halflengthZ();
+ double hZ = cLayer->surfaceRepresentation().bounds().get(
+ CylinderBounds::eHalfLengthZ);
takeSmaller(lConfig.rMin, rMinC - m_cfg.layerEnvelopeR.first);
takeBigger(lConfig.rMax, rMaxC + m_cfg.layerEnvelopeR.second);
takeSmaller(lConfig.zMin, center.z() - hZ - m_cfg.layerEnvelopeZ);
diff --git a/Core/src/Geometry/CylinderVolumeHelper.cpp b/Core/src/Geometry/CylinderVolumeHelper.cpp
index d4899289249d133024719f88c4cd1d317c59282c..c0e14aa79bf1631403ea3ef403bee9ec3da03c0f 100644
--- a/Core/src/Geometry/CylinderVolumeHelper.cpp
+++ b/Core/src/Geometry/CylinderVolumeHelper.cpp
@@ -443,13 +443,13 @@ bool Acts::CylinderVolumeHelper::estimateAndCheckDimension(
if (cylBounds != nullptr) {
radial = true;
// get the raw data
- double currentR = cylBounds->r();
+ double currentR = cylBounds->get(CylinderBounds::eR);
double centerZ = (layerIter->surfaceRepresentation()).center(gctx).z();
// check for min/max in the cylinder bounds case
currentRmin = currentR - (0.5 * (layerIter)->thickness());
currentRmax = currentR + (0.5 * (layerIter)->thickness());
- currentZmin = centerZ - cylBounds->halflengthZ();
- currentZmax = centerZ + cylBounds->halflengthZ();
+ currentZmin = centerZ - cylBounds->get(CylinderBounds::eHalfLengthZ);
+ currentZmax = centerZ + cylBounds->get(CylinderBounds::eHalfLengthZ);
}
// dynamic cast to the DiscBounds
const RadialBounds* discBounds = dynamic_cast<const RadialBounds*>(
@@ -789,9 +789,10 @@ void Acts::CylinderVolumeHelper::glueTrackingVolumes(
// 2 cases: r-Binning and zBinning
if (faceOne == cylinderCover || faceOne == tubeOuterCover) {
// (1) create the Boundary CylinderSurface
+ auto cBounds =
+ std::make_shared<CylinderBounds>(rGlueMin, 0.5 * (zMax - zMin));
std::shared_ptr<const Surface> cSurface =
- Surface::makeShared<CylinderSurface>(transform, rGlueMin,
- 0.5 * (zMax - zMin));
+ Surface::makeShared<CylinderSurface>(transform, cBounds);
ACTS_VERBOSE(
" creating a new cylindrical boundary surface "
"with bounds = "
diff --git a/Core/src/Geometry/DoubleTrapezoidVolumeBounds.cpp b/Core/src/Geometry/DoubleTrapezoidVolumeBounds.cpp
index 99394f8640b2217396138c3a90d879caea3dc7db..9df847635b2aab3cd87e89b4f98bddb0adf0995a 100644
--- a/Core/src/Geometry/DoubleTrapezoidVolumeBounds.cpp
+++ b/Core/src/Geometry/DoubleTrapezoidVolumeBounds.cpp
@@ -20,36 +20,36 @@
#include "Acts/Surfaces/RectangleBounds.hpp"
Acts::DoubleTrapezoidVolumeBounds::DoubleTrapezoidVolumeBounds()
- : VolumeBounds(), m_valueStore(bv_length, 0.) {}
+ : VolumeBounds(), m_values(bv_length, 0.) {}
Acts::DoubleTrapezoidVolumeBounds::DoubleTrapezoidVolumeBounds(
double minhalex, double medhalex, double maxhalex, double haley1,
double haley2, double halez)
- : VolumeBounds(), m_valueStore(bv_length, 0.) {
- m_valueStore.at(bv_minHalfX) = minhalex;
- m_valueStore.at(bv_medHalfX) = medhalex;
- m_valueStore.at(bv_maxHalfX) = maxhalex;
- m_valueStore.at(bv_halfY1) = haley1;
- m_valueStore.at(bv_halfY2) = haley2;
- m_valueStore.at(bv_halfZ) = halez;
- m_valueStore.at(bv_alpha1) =
- atan2(m_valueStore.at(bv_medHalfX) - m_valueStore.at(bv_minHalfX),
- 2. * m_valueStore.at(bv_halfY1));
- m_valueStore.at(bv_alpha2) =
- atan2(m_valueStore.at(bv_medHalfX) - m_valueStore.at(bv_maxHalfX),
- 2. * m_valueStore.at(bv_halfY2));
+ : VolumeBounds(), m_values(bv_length, 0.) {
+ m_values.at(bv_minHalfX) = minhalex;
+ m_values.at(bv_medHalfX) = medhalex;
+ m_values.at(bv_maxHalfX) = maxhalex;
+ m_values.at(bv_halfY1) = haley1;
+ m_values.at(bv_halfY2) = haley2;
+ m_values.at(bv_halfZ) = halez;
+ m_values.at(bv_alpha1) =
+ atan2(m_values.at(bv_medHalfX) - m_values.at(bv_minHalfX),
+ 2. * m_values.at(bv_halfY1));
+ m_values.at(bv_alpha2) =
+ atan2(m_values.at(bv_medHalfX) - m_values.at(bv_maxHalfX),
+ 2. * m_values.at(bv_halfY2));
}
Acts::DoubleTrapezoidVolumeBounds::DoubleTrapezoidVolumeBounds(
const Acts::DoubleTrapezoidVolumeBounds& trabo)
- : VolumeBounds(), m_valueStore(trabo.m_valueStore) {}
+ : VolumeBounds(), m_values(trabo.m_values) {}
Acts::DoubleTrapezoidVolumeBounds::~DoubleTrapezoidVolumeBounds() = default;
Acts::DoubleTrapezoidVolumeBounds& Acts::DoubleTrapezoidVolumeBounds::operator=(
const Acts::DoubleTrapezoidVolumeBounds& trabo) {
if (this != &trabo) {
- m_valueStore = trabo.m_valueStore;
+ m_values = trabo.m_values;
}
return *this;
}
@@ -97,7 +97,7 @@ Acts::DoubleTrapezoidVolumeBounds::decomposeToSurfaces(
AngleAxis3D(0.5 * M_PI, Vector3D(0., 0., 1.)));
RectangleBounds* faceAlpha1Bounds = faceAlpha1RectangleBounds();
Vector3D faceAlpha1Position(A + alpha1Rotation.col(0) *
- faceAlpha1Bounds->halflengthX());
+ faceAlpha1Bounds->halfLengthX());
tTransform =
new Transform3D(Translation3D(faceAlpha1Position) * alpha1Rotation);
rSurfaces.push_back(Surface::makeShared<PlaneSurface>(
@@ -112,7 +112,7 @@ Acts::DoubleTrapezoidVolumeBounds::decomposeToSurfaces(
AngleAxis3D(0.5 * M_PI, Vector3D(0., 0., 1.)));
RectangleBounds* faceBeta1Bounds = faceBeta1RectangleBounds();
Vector3D faceBeta1Position(B + beta1Rotation.col(0) *
- faceBeta1Bounds->halflengthX());
+ faceBeta1Bounds->halfLengthX());
tTransform =
new Transform3D(Translation3D(faceBeta1Position) * beta1Rotation);
rSurfaces.push_back(Surface::makeShared<PlaneSurface>(
@@ -130,7 +130,7 @@ Acts::DoubleTrapezoidVolumeBounds::decomposeToSurfaces(
AngleAxis3D(-0.5 * M_PI, Vector3D(0., 0., 1.)));
RectangleBounds* faceAlpha2Bounds = faceAlpha2RectangleBounds();
Vector3D faceAlpha2Position(AA + alpha2Rotation.col(0) *
- faceAlpha2Bounds->halflengthX());
+ faceAlpha2Bounds->halfLengthX());
tTransform =
new Transform3D(Translation3D(faceAlpha2Position) * alpha2Rotation);
rSurfaces.push_back(Surface::makeShared<PlaneSurface>(
@@ -146,7 +146,7 @@ Acts::DoubleTrapezoidVolumeBounds::decomposeToSurfaces(
AngleAxis3D(-0.5 * M_PI, Vector3D(0., 0., 1.)));
RectangleBounds* faceBeta2Bounds = faceBeta2RectangleBounds();
Vector3D faceBeta2Position(BB + beta2Rotation.col(0) *
- faceBeta2Bounds->halflengthX());
+ faceBeta2Bounds->halfLengthX());
tTransform =
new Transform3D(Translation3D(faceBeta2Position) * beta2Rotation);
rSurfaces.push_back(Surface::makeShared<PlaneSurface>(
@@ -177,61 +177,58 @@ Acts::DoubleTrapezoidVolumeBounds::decomposeToSurfaces(
// faces in xy
Acts::DiamondBounds* Acts::DoubleTrapezoidVolumeBounds::faceXYDiamondBounds()
const {
- return new DiamondBounds(
- m_valueStore.at(bv_minHalfX), m_valueStore.at(bv_medHalfX),
- m_valueStore.at(bv_maxHalfX), 2 * m_valueStore.at(bv_halfY1),
- 2 * m_valueStore.at(bv_halfY2));
+ return new DiamondBounds(m_values.at(bv_minHalfX), m_values.at(bv_medHalfX),
+ m_values.at(bv_maxHalfX), 2 * m_values.at(bv_halfY1),
+ 2 * m_values.at(bv_halfY2));
}
Acts::RectangleBounds*
Acts::DoubleTrapezoidVolumeBounds::faceAlpha1RectangleBounds() const {
return new RectangleBounds(
- m_valueStore.at(bv_halfY1) / cos(m_valueStore.at(bv_alpha1)),
- m_valueStore.at(bv_halfZ));
+ m_values.at(bv_halfY1) / cos(m_values.at(bv_alpha1)),
+ m_values.at(bv_halfZ));
}
Acts::RectangleBounds*
Acts::DoubleTrapezoidVolumeBounds::faceAlpha2RectangleBounds() const {
return new RectangleBounds(
- m_valueStore.at(bv_halfY2) / cos(m_valueStore.at(bv_alpha2)),
- m_valueStore.at(bv_halfZ));
+ m_values.at(bv_halfY2) / cos(m_values.at(bv_alpha2)),
+ m_values.at(bv_halfZ));
}
Acts::RectangleBounds*
Acts::DoubleTrapezoidVolumeBounds::faceBeta1RectangleBounds() const {
return new RectangleBounds(
- m_valueStore.at(bv_halfY1) / cos(m_valueStore.at(bv_alpha1)),
- m_valueStore.at(bv_halfZ));
+ m_values.at(bv_halfY1) / cos(m_values.at(bv_alpha1)),
+ m_values.at(bv_halfZ));
}
Acts::RectangleBounds*
Acts::DoubleTrapezoidVolumeBounds::faceBeta2RectangleBounds() const {
return new RectangleBounds(
- m_valueStore.at(bv_halfY2) / cos(m_valueStore.at(bv_alpha2)),
- m_valueStore.at(bv_halfZ));
+ m_values.at(bv_halfY2) / cos(m_values.at(bv_alpha2)),
+ m_values.at(bv_halfZ));
}
Acts::RectangleBounds*
Acts::DoubleTrapezoidVolumeBounds::faceZXRectangleBoundsBottom() const {
- return new RectangleBounds(m_valueStore.at(bv_halfZ),
- m_valueStore.at(bv_minHalfX));
+ return new RectangleBounds(m_values.at(bv_halfZ), m_values.at(bv_minHalfX));
}
Acts::RectangleBounds*
Acts::DoubleTrapezoidVolumeBounds::faceZXRectangleBoundsTop() const {
- return new RectangleBounds(m_valueStore.at(bv_halfZ),
- m_valueStore.at(bv_maxHalfX));
+ return new RectangleBounds(m_values.at(bv_halfZ), m_values.at(bv_maxHalfX));
}
bool Acts::DoubleTrapezoidVolumeBounds::inside(const Vector3D& pos,
double tol) const {
- if (std::abs(pos.z()) > m_valueStore.at(bv_halfZ) + tol) {
+ if (std::abs(pos.z()) > m_values.at(bv_halfZ) + tol) {
return false;
}
- if (pos.y() < -2 * m_valueStore.at(bv_halfY1) - tol) {
+ if (pos.y() < -2 * m_values.at(bv_halfY1) - tol) {
return false;
}
- if (pos.y() > 2 * m_valueStore.at(bv_halfY2) - tol) {
+ if (pos.y() > 2 * m_values.at(bv_halfY2) - tol) {
return false;
}
DiamondBounds* faceXYBounds = faceXYDiamondBounds();
diff --git a/Core/src/Geometry/LayerArrayCreator.cpp b/Core/src/Geometry/LayerArrayCreator.cpp
index 8cf79aa5e208182b034dcddca2ce62bbe5ec8ad4..607e8c4bfec98c86c1505edeb0e56faa300e878c 100644
--- a/Core/src/Geometry/LayerArrayCreator.cpp
+++ b/Core/src/Geometry/LayerArrayCreator.cpp
@@ -213,16 +213,18 @@ std::shared_ptr<Acts::Surface> Acts::LayerArrayCreator::createNavigationSurface(
// get the bounds
const CylinderBounds* cBounds =
dynamic_cast<const CylinderBounds*>(&(layerSurface.bounds()));
- double navigationR = cBounds->r() + offset;
- double halflengthZ = cBounds->halflengthZ();
+ double navigationR = cBounds->get(CylinderBounds::eR) + offset;
+ double halflengthZ = cBounds->get(CylinderBounds::eHalfLengthZ);
// create the new layer surface
std::shared_ptr<const Transform3D> navTrasform =
(!layerSurface.transform(gctx).isApprox(s_idTransform))
? std::make_shared<const Transform3D>(layerSurface.transform(gctx))
: nullptr;
// new navigation layer
- navigationSurface = Surface::makeShared<CylinderSurface>(
- navTrasform, navigationR, halflengthZ);
+ auto cylinderBounds =
+ std::make_shared<CylinderBounds>(navigationR, halflengthZ);
+ navigationSurface =
+ Surface::makeShared<CylinderSurface>(navTrasform, cylinderBounds);
}
return navigationSurface;
}
diff --git a/Core/src/Geometry/ProtoLayer.cpp b/Core/src/Geometry/ProtoLayer.cpp
index 9694dfab4f48a0302a31358b4a81e6abe2909c76..457993909db435a7f48184271152f79ccf0ed454 100644
--- a/Core/src/Geometry/ProtoLayer.cpp
+++ b/Core/src/Geometry/ProtoLayer.cpp
@@ -169,7 +169,7 @@ void ProtoLayer::measure(const GeometryContext& gctx,
}
// set envelopes to half radius
- double cylBoundsR = cylSurface->bounds().r();
+ double cylBoundsR = cylSurface->bounds().get(CylinderBounds::eR);
double env = cylBoundsR / 2.;
envX = {env, env};
envY = {env, env};
@@ -192,11 +192,11 @@ void ProtoLayer::measure(const GeometryContext& gctx,
dynamic_cast<const AnnulusBounds*>(&(sf->bounds()));
if (cBounds != nullptr) {
- double r = cBounds->r();
+ double r = cBounds->get(CylinderBounds::eR);
double z = sf->center(gctx).z();
- double hZ = cBounds->halflengthZ();
- double phi = cBounds->averagePhi();
- double hPhi = cBounds->halfPhiSector();
+ double hZ = cBounds->get(CylinderBounds::eHalfLengthZ);
+ double phi = cBounds->get(CylinderBounds::eAveragePhi);
+ double hPhi = cBounds->get(CylinderBounds::eHalfPhiSector);
maxX = r;
minX = -r;
diff --git a/Core/src/Geometry/TrapezoidVolumeBounds.cpp b/Core/src/Geometry/TrapezoidVolumeBounds.cpp
index b8ba8b8d086817740fdf769dd9848a28dce65a3d..564a85450185153b2d49340f6cc6b6b9263c3ef1 100644
--- a/Core/src/Geometry/TrapezoidVolumeBounds.cpp
+++ b/Core/src/Geometry/TrapezoidVolumeBounds.cpp
@@ -22,47 +22,47 @@
#include "Acts/Utilities/BoundingBox.hpp"
Acts::TrapezoidVolumeBounds::TrapezoidVolumeBounds()
- : VolumeBounds(), m_valueStore(bv_length, 0.) {}
+ : VolumeBounds(), m_values(bv_length, 0.) {}
Acts::TrapezoidVolumeBounds::TrapezoidVolumeBounds(double minhalex,
double maxhalex,
double haley, double halez)
- : VolumeBounds(), m_valueStore(bv_length, 0.) {
- m_valueStore.at(bv_minHalfX) = minhalex;
- m_valueStore.at(bv_maxHalfX) = maxhalex;
- m_valueStore.at(bv_halfY) = haley;
- m_valueStore.at(bv_halfZ) = halez;
- m_valueStore.at(bv_alpha) =
- atan((m_valueStore.at(bv_maxHalfX) - m_valueStore.at(bv_minHalfX)) / 2 /
- m_valueStore.at(bv_halfY)) +
+ : VolumeBounds(), m_values(bv_length, 0.) {
+ m_values.at(bv_minHalfX) = minhalex;
+ m_values.at(bv_maxHalfX) = maxhalex;
+ m_values.at(bv_halfY) = haley;
+ m_values.at(bv_halfZ) = halez;
+ m_values.at(bv_alpha) =
+ atan((m_values.at(bv_maxHalfX) - m_values.at(bv_minHalfX)) / 2 /
+ m_values.at(bv_halfY)) +
0.5 * M_PI;
- m_valueStore.at(bv_beta) = m_valueStore.at(bv_alpha);
+ m_values.at(bv_beta) = m_values.at(bv_alpha);
}
Acts::TrapezoidVolumeBounds::TrapezoidVolumeBounds(double minhalex,
double haley, double halez,
double alpha, double beta)
- : VolumeBounds(), m_valueStore(bv_length, 0.) {
- m_valueStore.at(bv_minHalfX) = minhalex;
- m_valueStore.at(bv_halfY) = haley;
- m_valueStore.at(bv_halfZ) = halez;
- m_valueStore.at(bv_alpha) = alpha;
- m_valueStore.at(bv_beta) = beta;
+ : VolumeBounds(), m_values(bv_length, 0.) {
+ m_values.at(bv_minHalfX) = minhalex;
+ m_values.at(bv_halfY) = haley;
+ m_values.at(bv_halfZ) = halez;
+ m_values.at(bv_alpha) = alpha;
+ m_values.at(bv_beta) = beta;
// now calculate the remaining max half X
double gamma = (alpha > beta) ? (alpha - 0.5 * M_PI) : (beta - 0.5 * M_PI);
- m_valueStore.at(bv_maxHalfX) = minhalex + (2. * haley) * tan(gamma);
+ m_values.at(bv_maxHalfX) = minhalex + (2. * haley) * tan(gamma);
}
Acts::TrapezoidVolumeBounds::TrapezoidVolumeBounds(
const TrapezoidVolumeBounds& trabo)
- : VolumeBounds(), m_valueStore(trabo.m_valueStore) {}
+ : VolumeBounds(), m_values(trabo.m_values) {}
Acts::TrapezoidVolumeBounds::~TrapezoidVolumeBounds() = default;
Acts::TrapezoidVolumeBounds& Acts::TrapezoidVolumeBounds::operator=(
const TrapezoidVolumeBounds& trabo) {
if (this != &trabo) {
- m_valueStore = trabo.m_valueStore;
+ m_values = trabo.m_values;
}
return *this;
}
@@ -163,47 +163,44 @@ Acts::TrapezoidVolumeBounds::decomposeToSurfaces(
Acts::TrapezoidBounds* Acts::TrapezoidVolumeBounds::faceXYTrapezoidBounds()
const {
- return new TrapezoidBounds(m_valueStore.at(bv_minHalfX),
- m_valueStore.at(bv_maxHalfX),
- m_valueStore.at(bv_halfY));
+ return new TrapezoidBounds(m_values.at(bv_minHalfX), m_values.at(bv_maxHalfX),
+ m_values.at(bv_halfY));
}
Acts::RectangleBounds* Acts::TrapezoidVolumeBounds::faceAlphaRectangleBounds()
const {
return new RectangleBounds(
- m_valueStore.at(bv_halfY) / cos(m_valueStore.at(bv_alpha) - 0.5 * M_PI),
- m_valueStore.at(bv_halfZ));
+ m_values.at(bv_halfY) / cos(m_values.at(bv_alpha) - 0.5 * M_PI),
+ m_values.at(bv_halfZ));
}
Acts::RectangleBounds* Acts::TrapezoidVolumeBounds::faceBetaRectangleBounds()
const {
return new RectangleBounds(
- m_valueStore.at(bv_halfY) / cos(m_valueStore.at(bv_beta) - 0.5 * M_PI),
- m_valueStore.at(bv_halfZ));
+ m_values.at(bv_halfY) / cos(m_values.at(bv_beta) - 0.5 * M_PI),
+ m_values.at(bv_halfZ));
}
Acts::RectangleBounds*
Acts::TrapezoidVolumeBounds::faceZXRectangleBoundsBottom() const {
- return new RectangleBounds(m_valueStore.at(bv_halfZ),
- m_valueStore.at(bv_minHalfX));
+ return new RectangleBounds(m_values.at(bv_halfZ), m_values.at(bv_minHalfX));
}
Acts::RectangleBounds* Acts::TrapezoidVolumeBounds::faceZXRectangleBoundsTop()
const {
- // double delta = (m_valueStore.at(bv_alpha) < m_valueStore.at(bv_beta)) ?
- // m_valueStore.at(bv_alpha) - M_PI/2. : m_valueStore.at(bv_beta) - M_PI/2.;
- // return new RectangleBounds(m_valueStore.at(bv_halfZ),
- // 0.5*(m_valueStore.at(bv_minHalfX)+m_valueStore.at(bv_minHalfX)+2.*m_valueStore.at(bv_halfY)/cos(delta)));
- return new RectangleBounds(m_valueStore.at(bv_halfZ),
- m_valueStore.at(bv_maxHalfX));
+ // double delta = (m_values.at(bv_alpha) < m_values.at(bv_beta)) ?
+ // m_values.at(bv_alpha) - M_PI/2. : m_values.at(bv_beta) - M_PI/2.;
+ // return new RectangleBounds(m_values.at(bv_halfZ),
+ // 0.5*(m_values.at(bv_minHalfX)+m_values.at(bv_minHalfX)+2.*m_values.at(bv_halfY)/cos(delta)));
+ return new RectangleBounds(m_values.at(bv_halfZ), m_values.at(bv_maxHalfX));
}
bool Acts::TrapezoidVolumeBounds::inside(const Vector3D& pos,
double tol) const {
- if (std::abs(pos.z()) > m_valueStore.at(bv_halfZ) + tol) {
+ if (std::abs(pos.z()) > m_values.at(bv_halfZ) + tol) {
return false;
}
- if (std::abs(pos.y()) > m_valueStore.at(bv_halfY) + tol) {
+ if (std::abs(pos.y()) > m_values.at(bv_halfY) + tol) {
return false;
}
TrapezoidBounds* faceXYBounds = faceXYTrapezoidBounds();
diff --git a/Core/src/Surfaces/AnnulusBounds.cpp b/Core/src/Surfaces/AnnulusBounds.cpp
index 1ef13638fc0042d2928628016e47837e1c98ec7a..bb22976ec537446ee76df8ccf36a1f80552cb817 100644
--- a/Core/src/Surfaces/AnnulusBounds.cpp
+++ b/Core/src/Surfaces/AnnulusBounds.cpp
@@ -15,16 +15,13 @@
#include <iomanip>
#include <iostream>
-Acts::AnnulusBounds::AnnulusBounds(double minR, double maxR, double minPhi,
- double maxPhi, const Vector2D& moduleOrigin,
- double avgPhi)
- : m_rMin(std::min(minR, maxR)),
- m_rMax(std::max(minR, maxR)),
- m_phiMin(std::min(minPhi, maxPhi)),
- m_phiMax(std::max(minPhi, maxPhi)),
- m_moduleOrigin(moduleOrigin),
- m_phiAvg(detail::radian_sym(avgPhi)) {
- m_rotationStripPC = Eigen::Translation<double, 2>(Vector2D(0, -m_phiAvg));
+Acts::AnnulusBounds::AnnulusBounds(
+ const std::array<double, eSize>& values) noexcept(false)
+ : m_values(values), m_moduleOrigin({values[eOriginX], values[eOriginY]}) {
+ checkConsistency();
+
+ m_rotationStripPC =
+ Eigen::Translation<double, 2>(Vector2D(0, -get(eAveragePhi)));
m_translation = Eigen::Translation<double, 2>(m_moduleOrigin);
m_shiftXY = m_moduleOrigin * -1;
@@ -65,14 +62,14 @@ Acts::AnnulusBounds::AnnulusBounds(double minR, double maxR, double minPhi,
};
// calculate corners in STRIP XY, keep them we need them for minDistance()
- m_outLeftStripXY =
- circIx(m_moduleOrigin[eLOC_X], m_moduleOrigin[eLOC_Y], m_rMax, m_phiMax);
- m_inLeftStripXY =
- circIx(m_moduleOrigin[eLOC_X], m_moduleOrigin[eLOC_Y], m_rMin, m_phiMax);
- m_outRightStripXY =
- circIx(m_moduleOrigin[eLOC_X], m_moduleOrigin[eLOC_Y], m_rMax, m_phiMin);
- m_inRightStripXY =
- circIx(m_moduleOrigin[eLOC_X], m_moduleOrigin[eLOC_Y], m_rMin, m_phiMin);
+ m_outLeftStripXY = circIx(m_moduleOrigin[eLOC_X], m_moduleOrigin[eLOC_Y],
+ get(eMaxR), get(eMaxPhiRel));
+ m_inLeftStripXY = circIx(m_moduleOrigin[eLOC_X], m_moduleOrigin[eLOC_Y],
+ get(eMinR), get(eMaxPhiRel));
+ m_outRightStripXY = circIx(m_moduleOrigin[eLOC_X], m_moduleOrigin[eLOC_Y],
+ get(eMaxR), get(eMinPhiRel));
+ m_inRightStripXY = circIx(m_moduleOrigin[eLOC_X], m_moduleOrigin[eLOC_Y],
+ get(eMinR), get(eMinPhiRel));
m_outLeftStripPC = {m_outLeftStripXY.norm(),
VectorHelpers::phi(m_outLeftStripXY)};
@@ -89,18 +86,6 @@ Acts::AnnulusBounds::AnnulusBounds(double minR, double maxR, double minPhi,
m_inRightModulePC = stripXYToModulePC(m_inRightStripXY);
}
-std::vector<TDD_real_t> Acts::AnnulusBounds::valueStore() const {
- std::vector<TDD_real_t> values(AnnulusBounds::bv_length);
- values[AnnulusBounds::bv_minR] = rMin();
- values[AnnulusBounds::bv_maxR] = rMax();
- values[AnnulusBounds::bv_phiMin] = phiMin();
- values[AnnulusBounds::bv_phiMax] = phiMax();
- values[AnnulusBounds::bv_phiAvg] = 0.5 * (phiMin() + phiMax());
- values[AnnulusBounds::bv_originX] = m_moduleOrigin.x();
- values[AnnulusBounds::bv_originY] = m_moduleOrigin.y();
- return values;
-}
-
std::vector<Acts::Vector2D> Acts::AnnulusBounds::corners() const {
auto rot = m_rotationStripPC.inverse();
@@ -127,15 +112,15 @@ std::vector<Acts::Vector2D> Acts::AnnulusBounds::vertices(
for (unsigned int iseg = 0; iseg < phisInner.size() - 1; ++iseg) {
int addon = (iseg == phisInner.size() - 2) ? 1 : 0;
detail::VerticesHelper::createSegment<Vector2D, Eigen::Affine2d>(
- rvertices, {rMin(), rMin()}, phisInner[iseg], phisInner[iseg + 1], lseg,
- addon);
+ rvertices, {get(eMinR), get(eMinR)}, phisInner[iseg],
+ phisInner[iseg + 1], lseg, addon);
}
// Upper bow from phi_min -> phi_max
for (unsigned int iseg = 0; iseg < phisOuter.size() - 1; ++iseg) {
int addon = (iseg == phisOuter.size() - 2) ? 1 : 0;
detail::VerticesHelper::createSegment<Vector2D, Eigen::Affine2d>(
- rvertices, {rMax(), rMax()}, phisOuter[iseg], phisOuter[iseg + 1], lseg,
- addon);
+ rvertices, {get(eMaxR), get(eMaxR)}, phisOuter[iseg],
+ phisOuter[iseg + 1], lseg, addon);
}
return rvertices;
@@ -149,7 +134,8 @@ bool Acts::AnnulusBounds::inside(const Vector2D& lposition, double tolR,
double phiLoc = locpo_rotated[eLOC_PHI];
double rLoc = locpo_rotated[eLOC_R];
- if (phiLoc < (m_phiMin - tolPhi) || phiLoc > (m_phiMax + tolPhi)) {
+ if (phiLoc < (get(eMinPhiRel) - tolPhi) ||
+ phiLoc > (get(eMaxPhiRel) + tolPhi)) {
return false;
}
@@ -160,7 +146,7 @@ bool Acts::AnnulusBounds::inside(const Vector2D& lposition, double tolR,
m_shiftPC[eLOC_R] * m_shiftPC[eLOC_R] + rLoc * rLoc +
2 * m_shiftPC[eLOC_R] * rLoc * cos(phiLoc - m_shiftPC[eLOC_PHI]);
- if (r_mod2 < m_rMin * m_rMin || r_mod2 > m_rMax * m_rMax) {
+ if (r_mod2 < get(eMinR) * get(eMinR) || r_mod2 > get(eMaxR) * get(eMaxR)) {
return false;
}
} else {
@@ -169,7 +155,7 @@ bool Acts::AnnulusBounds::inside(const Vector2D& lposition, double tolR,
sqrt(m_shiftPC[eLOC_R] * m_shiftPC[eLOC_R] + rLoc * rLoc +
2 * m_shiftPC[eLOC_R] * rLoc * cos(phiLoc - m_shiftPC[eLOC_PHI]));
- if (r_mod < (m_rMin - tolR) || r_mod > (m_rMax + tolR)) {
+ if (r_mod < (get(eMinR) - tolR) || r_mod > (get(eMaxR) + tolR)) {
return false;
}
}
@@ -355,7 +341,6 @@ double Acts::AnnulusBounds::distanceToBoundary(
Vector2D closestStripPC;
double minDist = std::numeric_limits<double>::max();
- ;
double curDist;
// for rmin
@@ -363,7 +348,7 @@ double Acts::AnnulusBounds::distanceToBoundary(
phiMod < m_inLeftModulePC[eLOC_PHI]) {
// is inside phi bounds, to comparison to rmin and r max
// r min
- curDist = std::abs(m_rMin - rMod);
+ curDist = std::abs(get(eMinR) - rMod);
if (curDist < minDist) {
minDist = curDist;
}
@@ -383,9 +368,9 @@ double Acts::AnnulusBounds::distanceToBoundary(
}
}
- if (m_phiMin <= phiStrip && phiStrip < m_phiMax) {
+ if (get(eMinPhiRel) <= phiStrip && phiStrip < get(eMaxPhiRel)) {
// r max
- curDist = std::abs(m_rMax - rMod);
+ curDist = std::abs(get(eMaxR) - rMod);
if (curDist < minDist) {
minDist = curDist;
}
@@ -457,8 +442,8 @@ std::ostream& Acts::AnnulusBounds::toStream(std::ostream& sl) const {
sl << std::setiosflags(std::ios::fixed);
sl << std::setprecision(7);
sl << "Acts::AnnulusBounds: (innerRadius, outerRadius, minPhi, maxPhi) = ";
- sl << "(" << rMin() << ", " << rMax() << ", " << phiMin() << ", " << phiMax()
- << ")" << '\n';
+ sl << "(" << get(eMinR) << ", " << get(eMaxR) << ", " << phiMin() << ", "
+ << phiMax() << ")" << '\n';
sl << " - shift xy = " << m_shiftXY.x() << ", " << m_shiftXY.y() << '\n';
;
sl << " - shift pc = " << m_shiftPC.x() << ", " << m_shiftPC.y() << '\n';
diff --git a/Core/src/Surfaces/CMakeLists.txt b/Core/src/Surfaces/CMakeLists.txt
index 8a1a0822d93533b4053f2a2aba22d1253e9fe721..117279f72341cfd13a247483f2c43c858cb3fa27 100644
--- a/Core/src/Surfaces/CMakeLists.txt
+++ b/Core/src/Surfaces/CMakeLists.txt
@@ -20,5 +20,4 @@ target_sources_local(
Surface.cpp
SurfaceArray.cpp
TrapezoidBounds.cpp
- TriangleBounds.cpp
)
diff --git a/Core/src/Surfaces/ConeBounds.cpp b/Core/src/Surfaces/ConeBounds.cpp
index 2b523d7e260daca920a3c6878fcf02fe77b4314f..03ffd611e050bcae4da06defc2fa0aeffd9353c8 100644
--- a/Core/src/Surfaces/ConeBounds.cpp
+++ b/Core/src/Surfaces/ConeBounds.cpp
@@ -13,38 +13,33 @@
#include <iostream>
#include <limits>
-#include "Acts/Utilities/detail/periodic.hpp"
-
Acts::ConeBounds::ConeBounds(double alpha, bool symm, double halfphi,
- double avphi)
- : ConeBounds(alpha, symm ? -std::numeric_limits<double>::infinity() : 0,
- std::numeric_limits<double>::infinity(), halfphi, avphi) {}
+ double avphi) noexcept(false)
+ : m_values({alpha, symm ? -std::numeric_limits<double>::infinity() : 0,
+ std::numeric_limits<double>::infinity(), halfphi, avphi}),
+ m_tanAlpha(std::tan(alpha)) {
+ checkConsistency();
+}
-Acts::ConeBounds::ConeBounds(double alpha, double zmin, double zmax,
- double halfphi, double avphi)
- : m_alpha(alpha),
- m_tanAlpha(std::tan(alpha)),
- m_zMin(zmin),
- m_zMax(zmax),
- m_avgPhi(detail::radian_sym(avphi)),
- m_halfPhi(std::abs(halfphi)) {}
+Acts::ConeBounds::ConeBounds(double alpha, double minz, double maxz,
+ double halfphi, double avphi) noexcept(false)
+ : m_values({alpha, minz, maxz, halfphi, avphi}),
+ m_tanAlpha(std::tan(alpha)) {
+ checkConsistency();
+}
+
+Acts::ConeBounds::ConeBounds(const std::array<double, eSize>& values) noexcept(
+ false)
+ : m_values(values), m_tanAlpha(std::tan(values[eAlpha])) {
+ checkConsistency();
+}
Acts::ConeBounds* Acts::ConeBounds::clone() const {
return new ConeBounds(*this);
}
Acts::SurfaceBounds::BoundsType Acts::ConeBounds::type() const {
- return SurfaceBounds::Cone;
-}
-
-std::vector<TDD_real_t> Acts::ConeBounds::valueStore() const {
- std::vector<TDD_real_t> values(ConeBounds::bv_length);
- values[ConeBounds::bv_alpha] = alpha();
- values[ConeBounds::bv_minZ] = minZ();
- values[ConeBounds::bv_maxZ] = maxZ();
- values[ConeBounds::bv_averagePhi] = averagePhi();
- values[ConeBounds::bv_halfPhiSector] = halfPhiSector();
- return values;
+ return SurfaceBounds::eCone;
}
/// Shift r-phi coordinate to be centered around the average phi.
@@ -57,33 +52,33 @@ Acts::Vector2D Acts::ConeBounds::shifted(
shifted[eLOC_Z] = lposition[eLOC_Z];
shifted[eLOC_RPHI] =
std::isnormal(x)
- ? (x * radian_sym((lposition[eLOC_RPHI] / x) - averagePhi()))
+ ? (x * radian_sym((lposition[eLOC_RPHI] / x) - get(eAveragePhi)))
: lposition[eLOC_RPHI];
return shifted;
}
bool Acts::ConeBounds::inside(const Acts::Vector2D& lposition,
const Acts::BoundaryCheck& bcheck) const {
- auto rphiHalf = r(lposition[eLOC_Z]) * halfPhiSector();
- return bcheck.isInside(shifted(lposition), Vector2D(-rphiHalf, minZ()),
- Vector2D(rphiHalf, maxZ()));
+ auto rphiHalf = r(lposition[eLOC_Z]) * get(eHalfPhiSector);
+ return bcheck.isInside(shifted(lposition), Vector2D(-rphiHalf, get(eMinZ)),
+ Vector2D(rphiHalf, get(eMaxZ)));
}
double Acts::ConeBounds::distanceToBoundary(
const Acts::Vector2D& lposition) const {
- auto rphiHalf = r(lposition[eLOC_Z]) * halfPhiSector();
+ auto rphiHalf = r(lposition[eLOC_Z]) * get(eHalfPhiSector);
return BoundaryCheck(true).distance(shifted(lposition),
- Vector2D(-rphiHalf, minZ()),
- Vector2D(rphiHalf, maxZ()));
+ Vector2D(-rphiHalf, get(eMinZ)),
+ Vector2D(rphiHalf, get(eMaxZ)));
}
std::ostream& Acts::ConeBounds::toStream(std::ostream& sl) const {
sl << std::setiosflags(std::ios::fixed);
sl << std::setprecision(7);
- sl << "Acts::ConeBounds: (tanAlpha, minZ, maxZ, averagePhi, halfPhiSector) "
+ sl << "Acts::ConeBounds: (tanAlpha, minZ, maxZ, halfPhiSector, averagePhi) "
"= ";
- sl << "(" << m_tanAlpha << ", " << m_zMin << ", " << m_zMax << ", "
- << m_avgPhi << ", " << m_halfPhi << ")";
+ sl << "(" << m_tanAlpha << ", " << get(eMinZ) << ", " << get(eMaxZ) << ", "
+ << get(eHalfPhiSector) << ", " << get(eAveragePhi) << ")";
sl << std::setprecision(-1);
return sl;
}
diff --git a/Core/src/Surfaces/ConeSurface.cpp b/Core/src/Surfaces/ConeSurface.cpp
index 3da3084424b34231afc97ae307abbc959e434dce..1bf3f6bec906bc57321fe0716ec921eae62becdc 100644
--- a/Core/src/Surfaces/ConeSurface.cpp
+++ b/Core/src/Surfaces/ConeSurface.cpp
@@ -140,8 +140,9 @@ double Acts::ConeSurface::pathCorrection(const GeometryContext& gctx,
m_transform ? transform(gctx).inverse() * position : position;
double phi = VectorHelpers::phi(posLocal);
double sgn = posLocal.z() > 0. ? -1. : +1.;
- Vector3D normalC(cos(phi) * bounds().cosAlpha(),
- sin(phi) * bounds().cosAlpha(), sgn * bounds().sinAlpha());
+ double cosAlpha = std::cos(bounds().get(ConeBounds::eAlpha));
+ double sinAlpha = std::sin(bounds().get(ConeBounds::eAlpha));
+ Vector3D normalC(cos(phi) * cosAlpha, sin(phi) * cosAlpha, sgn * sinAlpha);
if (m_transform) {
normalC = transform(gctx) * normalC;
}
@@ -170,9 +171,10 @@ const Acts::Vector3D Acts::ConeSurface::normal(
double phi =
lposition[Acts::eLOC_RPHI] / (bounds().r(lposition[Acts::eLOC_Z])),
sgn = lposition[Acts::eLOC_Z] > 0 ? -1. : +1.;
- Vector3D localNormal(cos(phi) * bounds().cosAlpha(),
- sin(phi) * bounds().cosAlpha(),
- sgn * bounds().sinAlpha());
+ double cosAlpha = std::cos(bounds().get(ConeBounds::eAlpha));
+ double sinAlpha = std::sin(bounds().get(ConeBounds::eAlpha));
+ Vector3D localNormal(cos(phi) * cosAlpha, sin(phi) * cosAlpha,
+ sgn * sinAlpha);
return m_transform ? Vector3D(transform(gctx).linear() * localNormal)
: localNormal;
}
@@ -201,25 +203,27 @@ Acts::Polyhedron Acts::ConeSurface::polyhedronRepresentation(
std::vector<Polyhedron::Face> faces;
std::vector<Polyhedron::Face> triangularMesh;
- if (bounds().minZ() == -std::numeric_limits<double>::infinity() or
- bounds().maxZ() == std::numeric_limits<double>::infinity()) {
+ double minZ = bounds().get(ConeBounds::eMinZ);
+ double maxZ = bounds().get(ConeBounds::eMaxZ);
+
+ if (minZ == -std::numeric_limits<double>::infinity() or
+ maxZ == std::numeric_limits<double>::infinity()) {
throw std::domain_error(
"Polyhedron repr of boundless surface not possible");
}
auto ctransform = transform(gctx);
- // The tip - created only once and only
- // if the we don't have a cut-off cone
+ // The tip - created only once and only, if the it's not a cut-off cone
bool tipExists = false;
- if (bounds().minZ() * bounds().maxZ() <= s_onSurfaceTolerance) {
+ if (minZ * maxZ <= s_onSurfaceTolerance) {
vertices.push_back(ctransform * Vector3D(0., 0., 0.));
tipExists = true;
}
// Cone parameters
- double hPhiSec = bounds().halfPhiSector();
- double avgPhi = bounds().averagePhi();
+ double hPhiSec = bounds().get(ConeBounds::eHalfPhiSector);
+ double avgPhi = bounds().get(ConeBounds::eAveragePhi);
bool fullCone = (hPhiSec == M_PI);
// Get the phi segments from the helper
@@ -229,11 +233,11 @@ Acts::Polyhedron Acts::ConeSurface::polyhedronRepresentation(
// Negative cone if exists
std::vector<double> coneSides;
- if (std::abs(bounds().minZ()) > s_onSurfaceTolerance) {
- coneSides.push_back(bounds().minZ());
+ if (std::abs(minZ) > s_onSurfaceTolerance) {
+ coneSides.push_back(minZ);
}
- if (std::abs(bounds().maxZ()) > s_onSurfaceTolerance) {
- coneSides.push_back(bounds().maxZ());
+ if (std::abs(maxZ) > s_onSurfaceTolerance) {
+ coneSides.push_back(maxZ);
}
for (auto& z : coneSides) {
// Remember the first vertex
diff --git a/Core/src/Surfaces/CylinderBounds.cpp b/Core/src/Surfaces/CylinderBounds.cpp
index 063c145c9c0af4992f48f61bd171e2ed500ac478..977b5b9cfb8491d3be83442b258a120bfe01e4ed 100644
--- a/Core/src/Surfaces/CylinderBounds.cpp
+++ b/Core/src/Surfaces/CylinderBounds.cpp
@@ -7,67 +7,33 @@
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#include "Acts/Surfaces/CylinderBounds.hpp"
+#include "Acts/Utilities/Helpers.hpp"
#include <cmath>
#include <iomanip>
#include <iostream>
-#include "Acts/Utilities/Helpers.hpp"
-#include "Acts/Utilities/detail/periodic.hpp"
-
using Acts::VectorHelpers::perp;
using Acts::VectorHelpers::phi;
-Acts::CylinderBounds::CylinderBounds(double radius, double halfZ)
- : CylinderBounds(radius, 0, M_PI, halfZ) {
- m_closed = true;
-}
-
-Acts::CylinderBounds::CylinderBounds(double radius, double halfPhi,
- double halfZ)
- : CylinderBounds(radius, 0, halfPhi, halfZ) {}
-
-Acts::CylinderBounds::CylinderBounds(double radius, double averagePhi,
- double halfPhi, double halfZ)
- : m_radius(std::abs(radius)),
- m_avgPhi(detail::radian_sym(averagePhi)),
- m_halfPhi(std::abs(halfPhi)),
- m_halfZ(std::abs(halfZ)),
- m_closed(false) {
- if (halfPhi == M_PI) {
- m_closed = true;
- }
-}
-
Acts::CylinderBounds* Acts::CylinderBounds::clone() const {
return new CylinderBounds(*this);
}
Acts::SurfaceBounds::BoundsType Acts::CylinderBounds::type() const {
- return SurfaceBounds::Cylinder;
-}
-
-std::vector<TDD_real_t> Acts::CylinderBounds::valueStore() const {
- std::vector<TDD_real_t> values(CylinderBounds::bv_length);
- values[CylinderBounds::bv_radius] = m_radius;
- values[CylinderBounds::bv_averagePhi] = m_avgPhi;
- values[CylinderBounds::bv_halfPhiSector] = m_halfPhi;
- values[CylinderBounds::bv_halfZ] = m_halfZ;
- return values;
+ return SurfaceBounds::eCylinder;
}
-// Convert from (r*phi,z) to (phi,z) centered around phi0
Acts::Vector2D Acts::CylinderBounds::shifted(
const Acts::Vector2D& lposition) const {
- return {Acts::detail::radian_sym((lposition[Acts::eLOC_RPHI] / m_radius) -
- m_avgPhi),
+ return {Acts::detail::radian_sym((lposition[Acts::eLOC_RPHI] / get(eR)) -
+ get(eAveragePhi)),
lposition[Acts::eLOC_Z]};
}
-// Jacobian from (r*phi,z) to (phi,z)
Acts::ActsSymMatrixD<2> Acts::CylinderBounds::jacobian() const {
ActsSymMatrixD<2> j;
- j(0, eLOC_RPHI) = 1 / m_radius;
+ j(0, eLOC_RPHI) = 1 / get(eR);
j(0, eLOC_Z) = 0;
j(1, eLOC_RPHI) = 0;
j(1, eLOC_Z) = 1;
@@ -77,8 +43,9 @@ Acts::ActsSymMatrixD<2> Acts::CylinderBounds::jacobian() const {
bool Acts::CylinderBounds::inside(const Vector2D& lposition,
const BoundaryCheck& bcheck) const {
return bcheck.transformed(jacobian())
- .isInside(shifted(lposition), Vector2D(-m_halfPhi, -m_halfZ),
- Vector2D(m_halfPhi, m_halfZ));
+ .isInside(shifted(lposition),
+ Vector2D(-get(eHalfPhiSector), -get(eHalfLengthZ)),
+ Vector2D(get(eHalfPhiSector), get(eHalfLengthZ)));
}
bool Acts::CylinderBounds::inside3D(const Vector3D& position,
@@ -92,34 +59,34 @@ bool Acts::CylinderBounds::inside3D(const Vector3D& position,
double addToleranceZ = checkAbsolute ? bcheck.m_tolerance[1] : 0.;
// check if the position compatible with the radius
if ((s_onSurfaceTolerance + addToleranceR) <=
- std::abs(perp(position) - m_radius)) {
+ std::abs(perp(position) - get(eR))) {
return false;
} else if (checkAbsolute && m_closed) {
- return ((s_onSurfaceTolerance + addToleranceZ + m_halfZ) >=
+ return ((s_onSurfaceTolerance + addToleranceZ + get(eHalfLengthZ)) >=
std::abs(position.z()));
}
// detailed, but slower check
- Vector2D lpos(detail::radian_sym(phi(position) - m_avgPhi), position.z());
+ Vector2D lpos(detail::radian_sym(phi(position) - get(eAveragePhi)),
+ position.z());
return bcheck.transformed(jacobian())
- .isInside(lpos, Vector2D(-m_halfPhi, -m_halfZ),
- Vector2D(m_halfPhi, m_halfZ));
+ .isInside(lpos, Vector2D(-get(eHalfPhiSector), -get(eHalfLengthZ)),
+ Vector2D(get(eHalfPhiSector), get(eHalfLengthZ)));
}
double Acts::CylinderBounds::distanceToBoundary(
const Acts::Vector2D& lposition) const {
- return BoundaryCheck(true).distance(shifted(lposition),
- Vector2D(-m_halfPhi, -m_halfZ),
- Vector2D(m_halfPhi, m_halfZ));
+ return BoundaryCheck(true).distance(
+ shifted(lposition), Vector2D(-get(eHalfPhiSector), -get(eHalfLengthZ)),
+ Vector2D(get(eHalfPhiSector), get(eHalfLengthZ)));
}
-// ostream operator overload
std::ostream& Acts::CylinderBounds::toStream(std::ostream& sl) const {
sl << std::setiosflags(std::ios::fixed);
sl << std::setprecision(7);
- sl << "Acts::CylinderBounds: (radius, averagePhi, halfPhiSector, "
- "halflengthInZ) = ";
- sl << "(" << m_radius << ", " << m_avgPhi << ", ";
- sl << m_halfPhi << ", " << m_halfZ << ")";
+ sl << "Acts::CylinderBounds: (radius, halfLengthZ, halfPhiSector, "
+ "averagePhi) = ";
+ sl << "(" << get(eR) << ", " << get(eHalfLengthZ) << ", ";
+ sl << get(eHalfPhiSector) << ", " << get(eAveragePhi) << ")";
sl << std::setprecision(-1);
return sl;
}
diff --git a/Core/src/Surfaces/CylinderSurface.cpp b/Core/src/Surfaces/CylinderSurface.cpp
index cd7ebd3e2cad3a681c239531a6104a60f38789fc..cdc871268fd4c3aec7523cbab4b51f5855a94e9e 100644
--- a/Core/src/Surfaces/CylinderSurface.cpp
+++ b/Core/src/Surfaces/CylinderSurface.cpp
@@ -31,17 +31,11 @@ Acts::CylinderSurface::CylinderSurface(const GeometryContext& gctx,
m_bounds(other.m_bounds) {}
Acts::CylinderSurface::CylinderSurface(
- std::shared_ptr<const Transform3D> htrans, double radius, double hlength)
- : GeometryObject(),
- Surface(std::move(htrans)),
- m_bounds(std::make_shared<const CylinderBounds>(radius, hlength)) {}
-
-Acts::CylinderSurface::CylinderSurface(
- std::shared_ptr<const Transform3D> htrans, double radius, double hphi,
- double hlength)
- : GeometryObject(),
- Surface(std::move(htrans)),
- m_bounds(std::make_shared<const CylinderBounds>(radius, hphi, hlength)) {}
+ std::shared_ptr<const Transform3D> htrans, double radius, double halfz,
+ double halfphi, double avphi)
+ : Surface(std::move(htrans)),
+ m_bounds(std::make_shared<const CylinderBounds>(radius, halfz, halfphi,
+ avphi)) {}
Acts::CylinderSurface::CylinderSurface(
std::shared_ptr<const CylinderBounds> cbounds,
@@ -73,8 +67,8 @@ const Acts::Vector3D Acts::CylinderSurface::binningPosition(
const Acts::Vector3D& sfCenter = center(gctx);
// special binning type for R-type methods
if (bValue == Acts::binR || bValue == Acts::binRPhi) {
- double R = bounds().r();
- double phi = m_bounds ? m_bounds->averagePhi() : 0.;
+ double R = bounds().get(CylinderBounds::eR);
+ double phi = bounds().get(CylinderBounds::eAveragePhi);
return Vector3D(sfCenter.x() + R * cos(phi), sfCenter.y() + R * sin(phi),
sfCenter.z());
}
@@ -112,7 +106,7 @@ void Acts::CylinderSurface::localToGlobal(const GeometryContext& gctx,
const Vector3D& /*unused*/,
Vector3D& position) const {
// create the position in the local 3d frame
- double r = bounds().r();
+ double r = bounds().get(CylinderBounds::eR);
double phi = lposition[Acts::eLOC_RPHI] / r;
position = Vector3D(r * cos(phi), r * sin(phi), lposition[Acts::eLOC_Z]);
position = transform(gctx) * position;
@@ -127,7 +121,7 @@ bool Acts::CylinderSurface::globalToLocal(const GeometryContext& gctx,
// transform it to the globalframe: CylinderSurfaces are allowed to have 0
// pointer transform
double radius = 0.;
- double inttol = bounds().r() * 0.0001;
+ double inttol = bounds().get(CylinderBounds::eR) * 0.0001;
if (inttol < 0.01) {
inttol = 0.01;
}
@@ -135,10 +129,13 @@ bool Acts::CylinderSurface::globalToLocal(const GeometryContext& gctx,
const Transform3D& sfTransform = transform(gctx);
Transform3D inverseTrans(sfTransform.inverse());
Vector3D loc3Dframe(inverseTrans * position);
- lposition = Vector2D(bounds().r() * phi(loc3Dframe), loc3Dframe.z());
+ lposition = Vector2D(bounds().get(CylinderBounds::eR) * phi(loc3Dframe),
+ loc3Dframe.z());
radius = perp(loc3Dframe);
// return true or false
- return ((std::abs(radius - bounds().r()) > inttol) ? false : true);
+ return ((std::abs(radius - bounds().get(CylinderBounds::eR)) > inttol)
+ ? false
+ : true);
}
std::string Acts::CylinderSurface::name() const {
@@ -157,7 +154,7 @@ Acts::CylinderSurface* Acts::CylinderSurface::clone_impl(
const Acts::Vector3D Acts::CylinderSurface::normal(
const GeometryContext& gctx, const Acts::Vector2D& lposition) const {
- double phi = lposition[Acts::eLOC_RPHI] / m_bounds->r();
+ double phi = lposition[Acts::eLOC_RPHI] / m_bounds->get(CylinderBounds::eR);
Vector3D localNormal(cos(phi), sin(phi), 0.);
return Vector3D(transform(gctx).matrix().block<3, 3>(0, 0) * localNormal);
}
@@ -195,13 +192,14 @@ Acts::Polyhedron Acts::CylinderSurface::polyhedronRepresentation(
auto ctrans = transform(gctx);
bool fullCylinder = bounds().coversFullAzimuth();
+ double avgPhi = bounds().get(CylinderBounds::eAveragePhi);
+ double halfPhi = bounds().get(CylinderBounds::eHalfPhiSector);
+
// Get the phi segments from the helper - ensures extra points
auto phiSegs = fullCylinder
? detail::VerticesHelper::phiSegments()
: detail::VerticesHelper::phiSegments(
- bounds().averagePhi() - bounds().halfPhiSector(),
- bounds().averagePhi() + bounds().halfPhiSector(),
- {bounds().averagePhi()});
+ avgPhi - halfPhi, avgPhi + halfPhi, {avgPhi});
// Write the two bows/circles on either side
std::vector<int> sides = {-1, 1};
@@ -210,9 +208,11 @@ Acts::Polyhedron Acts::CylinderSurface::polyhedronRepresentation(
int addon = (iseg == phiSegs.size() - 2 and not fullCylinder) ? 1 : 0;
/// Helper method to create the segment
detail::VerticesHelper::createSegment(
- vertices, {bounds().r(), bounds().r()}, phiSegs[iseg],
- phiSegs[iseg + 1], lseg, addon,
- Vector3D(0., 0., side * bounds().halflengthZ()), ctrans);
+ vertices,
+ {bounds().get(CylinderBounds::eR), bounds().get(CylinderBounds::eR)},
+ phiSegs[iseg], phiSegs[iseg + 1], lseg, addon,
+ Vector3D(0., 0., side * bounds().get(CylinderBounds::eHalfLengthZ)),
+ ctrans);
}
}
auto facesMesh =
diff --git a/Core/src/Surfaces/DiamondBounds.cpp b/Core/src/Surfaces/DiamondBounds.cpp
index b110452e0fd3a2cc12db957b91ad71cdc384e3ef..66a1f0071efd4d2754e65e86c962fd47ece7ba63 100644
--- a/Core/src/Surfaces/DiamondBounds.cpp
+++ b/Core/src/Surfaces/DiamondBounds.cpp
@@ -9,38 +9,15 @@
#include "Acts/Surfaces/DiamondBounds.hpp"
#include "Acts/Utilities/ThrowAssert.hpp"
-#include <cmath>
#include <iomanip>
#include <iostream>
-Acts::DiamondBounds::DiamondBounds(double x1, double x2, double x3, double y1,
- double y2)
- : m_x1(std::abs(x1)),
- m_x2(std::abs(x2)),
- m_x3(std::abs(x3)),
- m_y1(std::abs(y1)),
- m_y2(std::abs(y2)),
- m_boundingBox(std::max(std::max(x1, x2), x3), std::max(y1, y2)) {
- throw_assert((x1 <= x2), "Hexagon must be a convex polygon");
- throw_assert((x3 <= x2), "Hexagon must be a convex polygon");
-}
-
Acts::DiamondBounds* Acts::DiamondBounds::clone() const {
return new DiamondBounds(*this);
}
Acts::SurfaceBounds::BoundsType Acts::DiamondBounds::type() const {
- return SurfaceBounds::Diamond;
-}
-
-std::vector<TDD_real_t> Acts::DiamondBounds::valueStore() const {
- std::vector<TDD_real_t> values(DiamondBounds::bv_length);
- values[DiamondBounds::bv_x1] = x1();
- values[DiamondBounds::bv_x2] = x2();
- values[DiamondBounds::bv_x3] = x3();
- values[DiamondBounds::bv_y1] = y1();
- values[DiamondBounds::bv_y2] = y2();
- return values;
+ return SurfaceBounds::eDiamond;
}
bool Acts::DiamondBounds::inside(const Acts::Vector2D& lposition,
@@ -57,22 +34,29 @@ std::vector<Acts::Vector2D> Acts::DiamondBounds::vertices(
unsigned int /*lseg*/) const {
// Vertices starting at lower left (min rel. phi)
// counter-clockwise
- return {{-x1(), -y1()}, {x1(), -y1()}, {x2(), 0.},
- {x3(), y2()}, {-x3(), y2()}, {-x2(), 0.}};
+ double x1 = get(DiamondBounds::eHalfLengthXnegY);
+ double y1 = get(DiamondBounds::eHalfLengthYneg);
+ double x2 = get(DiamondBounds::eHalfLengthXzeroY);
+ double y2 = 0.;
+ double x3 = get(DiamondBounds::eHalfLengthXposY);
+ double y3 = get(DiamondBounds::eHalfLengthYpos);
+ return {{-x1, -y1}, {x1, -y1}, {x2, y2}, {x3, y3}, {-x3, y3}, {-x2, y2}};
}
const Acts::RectangleBounds& Acts::DiamondBounds::boundingBox() const {
return m_boundingBox;
}
-// ostream operator overload
std::ostream& Acts::DiamondBounds::toStream(std::ostream& sl) const {
sl << std::setiosflags(std::ios::fixed);
sl << std::setprecision(7);
- sl << "Acts::DiamondBounds: (x1, x2, x3, "
- "y1, y2 ) = ";
- sl << "(" << x1() << ", " << x2() << ", " << x3() << ", " << y1() << ", "
- << y2() << ")";
+ sl << "Acts::DiamondBounds: (halfXatYneg, halfXatYzero, halfXatYpos, "
+ "halfYneg, halfYpos) = ";
+ sl << "(" << get(DiamondBounds::eHalfLengthXnegY) << ", "
+ << get(DiamondBounds::eHalfLengthXzeroY) << ", "
+ << get(DiamondBounds::eHalfLengthXposY) << ", "
+ << get(DiamondBounds::eHalfLengthYneg) << ", "
+ << get(DiamondBounds::eHalfLengthYpos) << ")";
sl << std::setprecision(-1);
return sl;
}
diff --git a/Core/src/Surfaces/DiscSurface.cpp b/Core/src/Surfaces/DiscSurface.cpp
index 9c1ea9e3900d4601470335fbc875e794a6e4e85e..1b6a1df0a291b09496a73a98be7da8f91e895c15 100644
--- a/Core/src/Surfaces/DiscSurface.cpp
+++ b/Core/src/Surfaces/DiscSurface.cpp
@@ -102,7 +102,7 @@ const Acts::Vector2D Acts::DiscSurface::localPolarToLocalCartesian(
dynamic_cast<const Acts::DiscTrapezoidBounds*>(&(bounds()));
if (dtbo != nullptr) {
double rMedium = dtbo->rCenter();
- double phi = dtbo->averagePhi();
+ double phi = dtbo->get(DiscTrapezoidBounds::eAveragePhi);
Vector2D polarCenter(rMedium, phi);
Vector2D cartCenter = localPolarToCartesian(polarCenter);
@@ -173,7 +173,7 @@ Acts::Polyhedron Acts::DiscSurface::polyhedronRepresentation(
}
// These are convex shapes, use the helper method
// For rings there's a sweet spot when this stops working
- if (m_bounds->type() == SurfaceBounds::DiscTrapezoidal or toCenter or
+ if (m_bounds->type() == SurfaceBounds::eDiscTrapezoid or toCenter or
not fullDisc) {
// Transformt hem into the vertex frame
wCenter *= 1. / vertices.size();
diff --git a/Core/src/Surfaces/DiscTrapezoidBounds.cpp b/Core/src/Surfaces/DiscTrapezoidBounds.cpp
index f6197d0a6afc814cf84063265d28908a75fa2936..6764972c214c7775eeebd858ea4b4384a23f8254 100644
--- a/Core/src/Surfaces/DiscTrapezoidBounds.cpp
+++ b/Core/src/Surfaces/DiscTrapezoidBounds.cpp
@@ -12,48 +12,33 @@
#include <iomanip>
#include <iostream>
-#include "Acts/Utilities/detail/periodic.hpp"
-
-Acts::DiscTrapezoidBounds::DiscTrapezoidBounds(double minhalfx, double maxhalfx,
- double minR, double maxR,
- double avephi, double stereo)
- : m_rMin(std::min(std::abs(minR), std::abs(maxR))),
- m_rMax(std::max(std::abs(minR), std::abs(maxR))),
- m_minHalfX(std::abs(minhalfx)),
- m_maxHalfX(std::abs(maxhalfx)),
- m_avgPhi(detail::radian_sym(avephi)),
- m_stereo(stereo) {}
+Acts::DiscTrapezoidBounds::DiscTrapezoidBounds(double halfXminR,
+ double halfXmaxR, double minR,
+ double maxR, double avgPhi,
+ double stereo) noexcept(false)
+ : m_values({halfXminR, halfXmaxR, minR, maxR, avgPhi, stereo}) {
+ checkConsistency();
+}
Acts::DiscTrapezoidBounds* Acts::DiscTrapezoidBounds::clone() const {
return new DiscTrapezoidBounds(*this);
}
Acts::SurfaceBounds::BoundsType Acts::DiscTrapezoidBounds::type() const {
- return SurfaceBounds::DiscTrapezoidal;
-}
-
-std::vector<TDD_real_t> Acts::DiscTrapezoidBounds::valueStore() const {
- std::vector<TDD_real_t> values(DiscTrapezoidBounds::bv_length);
- values[bv_rMin] = rMin();
- values[bv_rMax] = rMax();
- values[bv_minHalfX] = minHalflengthX();
- values[bv_maxHalfX] = maxHalflengthX();
- values[bv_averagePhi] = averagePhi();
- values[bv_stereo] = m_stereo;
- return values;
+ return SurfaceBounds::eDiscTrapezoid;
}
Acts::Vector2D Acts::DiscTrapezoidBounds::toLocalCartesian(
const Acts::Vector2D& lposition) const {
- return {lposition[eLOC_R] * std::sin(lposition[eLOC_PHI] - m_avgPhi),
- lposition[eLOC_R] * std::cos(lposition[eLOC_PHI] - m_avgPhi)};
+ return {lposition[eLOC_R] * std::sin(lposition[eLOC_PHI] - get(eAveragePhi)),
+ lposition[eLOC_R] * std::cos(lposition[eLOC_PHI] - get(eAveragePhi))};
}
Acts::ActsMatrixD<2, 2> Acts::DiscTrapezoidBounds::jacobianToLocalCartesian(
const Acts::Vector2D& lposition) const {
ActsMatrixD<2, 2> jacobian;
- jacobian(0, eLOC_R) = std::sin(lposition[eLOC_PHI] - m_avgPhi);
- jacobian(1, eLOC_R) = std::cos(lposition[eLOC_PHI] - m_avgPhi);
+ jacobian(0, eLOC_R) = std::sin(lposition[eLOC_PHI] - get(eAveragePhi));
+ jacobian(1, eLOC_R) = std::cos(lposition[eLOC_PHI] - get(eAveragePhi));
jacobian(0, eLOC_PHI) = lposition[eLOC_R] * std::cos(lposition[eLOC_PHI]);
jacobian(1, eLOC_PHI) = lposition[eLOC_R] * -std::sin(lposition[eLOC_PHI]);
return jacobian;
@@ -61,10 +46,10 @@ Acts::ActsMatrixD<2, 2> Acts::DiscTrapezoidBounds::jacobianToLocalCartesian(
bool Acts::DiscTrapezoidBounds::inside(
const Acts::Vector2D& lposition, const Acts::BoundaryCheck& bcheck) const {
- Vector2D vertices[] = {{minHalflengthX(), rMin()},
- {maxHalflengthX(), rMax()},
- {-maxHalflengthX(), rMax()},
- {-minHalflengthX(), rMin()}};
+ Vector2D vertices[] = {{get(eHalfLengthXminR), get(eMinR)},
+ {get(eHalfLengthXmaxR), get(eMaxR)},
+ {-get(eHalfLengthXmaxR), get(eMaxR)},
+ {-get(eHalfLengthXminR), get(eMinR)}};
auto jacobian = jacobianToLocalCartesian(lposition);
return bcheck.transformed(jacobian).isInside(toLocalCartesian(lposition),
vertices);
@@ -72,31 +57,35 @@ bool Acts::DiscTrapezoidBounds::inside(
double Acts::DiscTrapezoidBounds::distanceToBoundary(
const Acts::Vector2D& lposition) const {
- Vector2D vertices[] = {{minHalflengthX(), rMin()},
- {maxHalflengthX(), rMax()},
- {-maxHalflengthX(), rMax()},
- {-minHalflengthX(), rMin()}};
+ Vector2D vertices[] = {{get(eHalfLengthXminR), get(eMinR)},
+ {get(eHalfLengthXmaxR), get(eMaxR)},
+ {-get(eHalfLengthXmaxR), get(eMaxR)},
+ {-get(eHalfLengthXminR), get(eMinR)}};
return BoundaryCheck(true).distance(toLocalCartesian(lposition), vertices);
}
std::vector<Acts::Vector2D> Acts::DiscTrapezoidBounds::vertices(
unsigned int /*lseg*/) const {
- Vector2D cAxis(std::cos(m_avgPhi), std::sin(m_avgPhi));
+ Vector2D cAxis(std::cos(get(eAveragePhi)), std::sin(get(eAveragePhi)));
Vector2D nAxis(cAxis.y(), -cAxis.x());
- return {
- m_rMin * cAxis - m_minHalfX * nAxis, m_rMin * cAxis + m_minHalfX * nAxis,
- m_rMax * cAxis + m_maxHalfX * nAxis, m_rMax * cAxis - m_maxHalfX * nAxis};
+ return {get(eMinR) * cAxis - get(eHalfLengthXminR) * nAxis,
+ get(eMinR) * cAxis + get(eHalfLengthXminR) * nAxis,
+ get(eMaxR) * cAxis + get(eHalfLengthXmaxR) * nAxis,
+ get(eMaxR) * cAxis - get(eHalfLengthXmaxR) * nAxis};
}
// ostream operator overload
std::ostream& Acts::DiscTrapezoidBounds::toStream(std::ostream& sl) const {
sl << std::setiosflags(std::ios::fixed);
sl << std::setprecision(7);
- sl << "Acts::DiscTrapezoidBounds: (innerRadius, outerRadius, hMinX, "
- "hMaxX, hlengthY, hPhiSector, averagePhi, rCenter, stereo) = ";
- sl << "(" << rMin() << ", " << rMax() << ", " << minHalflengthX() << ", "
- << maxHalflengthX() << ", " << halflengthY() << ", " << halfPhiSector()
- << ", " << averagePhi() << ", " << rCenter() << ", " << stereo() << ")";
+ sl << "Acts::DiscTrapezoidBounds: (innerRadius, outerRadius, "
+ "halfLengthXminR, "
+ "halfLengthXmaxR, halfLengthY, halfPhiSector, averagePhi, rCenter, "
+ "stereo) = ";
+ sl << "(" << get(eMinR) << ", " << get(eMaxR) << ", " << get(eHalfLengthXminR)
+ << ", " << get(eHalfLengthXmaxR) << ", " << halfLengthY() << ", "
+ << halfPhiSector() << ", " << get(eAveragePhi) << ", " << rCenter() << ", "
+ << stereo() << ")";
sl << std::setprecision(-1);
return sl;
}
diff --git a/Core/src/Surfaces/EllipseBounds.cpp b/Core/src/Surfaces/EllipseBounds.cpp
index 7d4f06d691f68cb91d8b89ffeb4993ba506690b5..929ef8426a0580d84bbce516a6a03aeacf3a1616 100644
--- a/Core/src/Surfaces/EllipseBounds.cpp
+++ b/Core/src/Surfaces/EllipseBounds.cpp
@@ -8,46 +8,21 @@
#include "Acts/Surfaces/EllipseBounds.hpp"
#include "Acts/Surfaces/detail/VerticesHelper.hpp"
+#include "Acts/Utilities/Helpers.hpp"
#include <cmath>
#include <iomanip>
#include <iostream>
-#include "Acts/Utilities/Helpers.hpp"
-#include "Acts/Utilities/detail/periodic.hpp"
-
using Acts::VectorHelpers::perp;
using Acts::VectorHelpers::phi;
-Acts::EllipseBounds::EllipseBounds(double minRadius0, double minRadius1,
- double maxRadius0, double maxRadius1,
- double averagePhi, double halfPhi)
- : m_rMinX(std::abs(minRadius0)),
- m_rMinY(std::abs(minRadius1)),
- m_rMaxX(std::abs(maxRadius0)),
- m_rMaxY(std::abs(maxRadius1)),
- m_avgPhi(detail::radian_sym(averagePhi)),
- m_halfPhi(std::abs(halfPhi)),
- m_boundingBox(std::max(minRadius0, maxRadius0),
- std::max(minRadius1, maxRadius1)) {}
-
Acts::EllipseBounds* Acts::EllipseBounds::clone() const {
return new EllipseBounds(*this);
}
Acts::SurfaceBounds::BoundsType Acts::EllipseBounds::type() const {
- return SurfaceBounds::Ellipse;
-}
-
-std::vector<TDD_real_t> Acts::EllipseBounds::valueStore() const {
- std::vector<TDD_real_t> values(EllipseBounds::bv_length);
- values[EllipseBounds::bv_rMinX] = m_rMinX;
- values[EllipseBounds::bv_rMinY] = m_rMinY;
- values[EllipseBounds::bv_rMaxX] = m_rMaxX;
- values[EllipseBounds::bv_rMaxY] = m_rMaxY;
- values[EllipseBounds::bv_averagePhi] = m_avgPhi;
- values[EllipseBounds::bv_halfPhiSector] = m_halfPhi;
- return values;
+ return SurfaceBounds::eEllipse;
}
static inline double square(double x) {
@@ -55,42 +30,45 @@ static inline double square(double x) {
}
/// @warning This **only** works for tolerance-based checks
-bool Acts::EllipseBounds::inside(const Acts::Vector2D& lposition,
- const Acts::BoundaryCheck& bcheck) const {
+bool Acts::EllipseBounds::inside(const Vector2D& lposition,
+ const BoundaryCheck& bcheck) const {
double tol0 = bcheck.m_tolerance[0];
double tol1 = bcheck.m_tolerance[1];
- double phi = detail::radian_sym(VectorHelpers::phi(lposition) - averagePhi());
- double phiHalf = halfPhiSector() + tol1;
+ double phi =
+ detail::radian_sym(VectorHelpers::phi(lposition) - get(eAveragePhi));
+ double phiHalf = get(eHalfPhiSector) + tol1;
bool insidePhi = (-phiHalf <= phi) && (phi < phiHalf);
- bool insideInner = (rMinX() <= tol0) || (rMinY() <= tol0) ||
- (1 < (square(lposition[Acts::eLOC_X] / (rMinX() - tol0)) +
- square(lposition[Acts::eLOC_Y] / (rMinY() - tol0))));
- bool insideOuter = ((square(lposition[Acts::eLOC_X] / (rMaxX() + tol0)) +
- square(lposition[Acts::eLOC_Y] / (rMaxY() + tol0))) < 1);
+ bool insideInner =
+ (get(eMinR0) <= tol0) || (get(eMinR1) <= tol0) ||
+ (1 < (square(lposition[Acts::eLOC_X] / (get(eMinR0) - tol0)) +
+ square(lposition[Acts::eLOC_Y] / (get(eMinR1) - tol0))));
+ bool insideOuter =
+ ((square(lposition[Acts::eLOC_X] / (get(eMaxR0) + tol0)) +
+ square(lposition[Acts::eLOC_Y] / (get(eMaxR1) + tol0))) < 1);
return (insidePhi && insideInner && insideOuter);
}
// For ellipse bound this is only approximation which is valid
-// only if m_valueStore.at(EllipseBounds::bv_rMinX) ~=
-// m_valueStore.at(EllipseBounds::bv_rMinY)
-// and m_valueStore.at(EllipseBounds::bv_rMaxX) ~=
-// m_valueStore.at(EllipseBounds::bv_rMaxY)
+// only if m_values.at(EllipseBounds::bv_rMinX) ~=
+// m_values.at(EllipseBounds::bv_rMinY)
+// and m_values.at(EllipseBounds::bv_rMaxX) ~=
+// m_values.at(EllipseBounds::bv_rMaxY)
//
double Acts::EllipseBounds::distanceToBoundary(
const Vector2D& lposition) const {
double r = perp(lposition);
if (r == 0) {
- return std::min(rMinX(), rMinY());
+ return std::min(get(eMinR0), get(eMinR1));
}
double sn = lposition[eLOC_X] / r;
double cs = lposition[eLOC_Y] / r;
- double dF = detail::radian_sym(phi(lposition) - m_avgPhi);
+ double dF = detail::radian_sym(phi(lposition) - get(eAveragePhi));
double sf = 0.;
- if (m_halfPhi < M_PI) {
- double df = std::abs(dF) - m_halfPhi;
+ if (get(eHalfPhiSector) < M_PI) {
+ double df = std::abs(dF) - get(eHalfPhiSector);
sf = r * std::sin(df);
if (df > 0.) {
r *= std::cos(df);
@@ -100,14 +78,14 @@ double Acts::EllipseBounds::distanceToBoundary(
}
if (sf <= 0.) {
- double a = cs / m_rMaxX;
- double b = sn / m_rMaxY;
+ double a = cs / get(eMaxR0);
+ double b = sn / get(eMaxR1);
double sr0 = r - 1. / std::hypot(a, b);
if (sr0 >= 0.) {
return sr0;
}
- a = cs / m_rMinX;
- b = sn / m_rMinY;
+ a = cs / get(eMinR0);
+ b = sn / get(eMinR1);
double sr1 = 1. / std::hypot(a, b) - r;
if (sr1 >= 0.) {
return sr1;
@@ -122,17 +100,18 @@ double Acts::EllipseBounds::distanceToBoundary(
}
double fb;
- fb = (dF > 0.) ? (m_avgPhi + m_halfPhi) : (m_avgPhi - m_halfPhi);
+ fb = (dF > 0.) ? (get(eAveragePhi) + get(eHalfPhiSector))
+ : (get(eAveragePhi) - get(eHalfPhiSector));
sn = sin(fb);
cs = cos(fb);
- double a = cs / m_rMaxX;
- double b = sn / m_rMaxY;
+ double a = cs / get(eMaxR0);
+ double b = sn / get(eMaxR1);
double sr0 = r - 1. / std::hypot(a, b);
if (sr0 >= 0.) {
return std::hypot(sr0, sf);
}
- a = cs / m_rMinX;
- b = sn / m_rMinY;
+ a = cs / get(eMinR0);
+ b = sn / get(eMinR1);
double sr1 = (1. / std::hypot(a, b)) - r;
if (sr1 >= 0.) {
return std::hypot(sr1, sf);
@@ -143,7 +122,8 @@ double Acts::EllipseBounds::distanceToBoundary(
std::vector<Acts::Vector2D> Acts::EllipseBounds::vertices(
unsigned int lseg) const {
return detail::VerticesHelper::ellispoidVertices(
- m_rMinX, m_rMinY, m_rMaxX, m_rMaxY, m_avgPhi, m_halfPhi, lseg);
+ get(eMinR0), get(eMinR1), get(eMaxR0), get(eMaxR1), get(eAveragePhi),
+ get(eHalfPhiSector), lseg);
}
const Acts::RectangleBounds& Acts::EllipseBounds::boundingBox() const {
@@ -154,10 +134,11 @@ const Acts::RectangleBounds& Acts::EllipseBounds::boundingBox() const {
std::ostream& Acts::EllipseBounds::toStream(std::ostream& sl) const {
sl << std::setiosflags(std::ios::fixed);
sl << std::setprecision(7);
- sl << "Acts::EllipseBounds: (innerRadiusX, innerRadiusY, outerRadiusX, "
- "outerRadiusY, hPhiSector) = ";
- sl << "(" << rMinX() << ", " << rMinY() << ", " << rMaxX() << ", " << rMaxY()
- << ", " << averagePhi() << ", " << halfPhiSector() << ")";
+ sl << "Acts::EllipseBounds: (innerRadius0, outerRadius0, innerRadius1, "
+ "outerRadius1, hPhiSector, averagePhi) = ";
+ sl << "(" << get(eMinR0) << ", " << get(eMaxR0) << ", " << get(eMinR1) << ", "
+ << get(eMaxR1) << ", " << get(eAveragePhi) << ", " << get(eHalfPhiSector)
+ << ", " << get(eAveragePhi) << ")";
sl << std::setprecision(-1);
return sl;
}
diff --git a/Core/src/Surfaces/LineBounds.cpp b/Core/src/Surfaces/LineBounds.cpp
index fe29188e66412ee27b2a29ca4d146ae74ad1a05c..d9336e16842a4b565c0af4484f452659bcf08832 100644
--- a/Core/src/Surfaces/LineBounds.cpp
+++ b/Core/src/Surfaces/LineBounds.cpp
@@ -11,28 +11,20 @@
#include <iomanip>
#include <iostream>
-Acts::LineBounds::LineBounds(double radius, double halez)
- : m_radius(std::abs(radius)), m_halfZ(std::abs(halez)) {}
-
Acts::LineBounds* Acts::LineBounds::clone() const {
return new LineBounds(*this);
}
Acts::SurfaceBounds::BoundsType Acts::LineBounds::type() const {
- return SurfaceBounds::Line;
-}
-
-std::vector<TDD_real_t> Acts::LineBounds::valueStore() const {
- std::vector<TDD_real_t> values(LineBounds::bv_length);
- values[LineBounds::bv_radius] = r();
- values[LineBounds::bv_halfZ] = halflengthZ();
- return values;
+ return SurfaceBounds::eLine;
}
bool Acts::LineBounds::inside(const Acts::Vector2D& lposition,
const Acts::BoundaryCheck& bcheck) const {
- return bcheck.isInside(lposition, Vector2D(-r(), -halflengthZ()),
- Vector2D(r(), halflengthZ()));
+ double r = get(LineBounds::eR);
+ double halfLengthZ = get(LineBounds::eHalfLengthZ);
+ return bcheck.isInside(lposition, Vector2D(-r, -halfLengthZ),
+ Vector2D(r, halfLengthZ));
}
double Acts::LineBounds::distanceToBoundary(
@@ -46,7 +38,8 @@ std::ostream& Acts::LineBounds::toStream(std::ostream& sl) const {
sl << std::setiosflags(std::ios::fixed);
sl << std::setprecision(7);
sl << "Acts::LineBounds: (radius, halflengthInZ) = ";
- sl << "(" << r() << ", " << halflengthZ() << ")";
+ sl << "(" << get(LineBounds::eR) << ", " << get(LineBounds::eHalfLengthZ)
+ << ")";
sl << std::setprecision(-1);
return sl;
}
diff --git a/Core/src/Surfaces/PlaneSurface.cpp b/Core/src/Surfaces/PlaneSurface.cpp
index c55d3fa8ae96b37f26b518afad128a1a3ef98159..1c5c00d9a98a30d691185241b082461a8187c0c6 100644
--- a/Core/src/Surfaces/PlaneSurface.cpp
+++ b/Core/src/Surfaces/PlaneSurface.cpp
@@ -132,15 +132,14 @@ Acts::Polyhedron Acts::PlaneSurface::polyhedronRepresentation(
for (const auto& v2D : vertices2D) {
vertices.push_back(transform(gctx) * Vector3D(v2D.x(), v2D.y(), 0.));
}
- bool isEllipse = bounds().type() == SurfaceBounds::Ellipse;
+ bool isEllipse = bounds().type() == SurfaceBounds::eEllipse;
bool innerExists = false, coversFull = false;
if (isEllipse) {
- auto vStore = bounds().valueStore();
- innerExists = std::abs(vStore[EllipseBounds::BoundValues::bv_rMinX]) <
- s_onSurfaceTolerance;
- coversFull =
- std::abs(vStore[EllipseBounds::BoundValues::bv_halfPhiSector]) <
- M_PI - s_onSurfaceTolerance;
+ auto vStore = bounds().values();
+ innerExists =
+ std::abs(vStore[EllipseBounds::eMaxR0]) < s_onSurfaceTolerance;
+ coversFull = std::abs(vStore[EllipseBounds::eHalfPhiSector]) <
+ M_PI - s_onSurfaceTolerance;
}
// All of those can be described as convex
// @todo same as for Discs: coversFull is not the right criterium
diff --git a/Core/src/Surfaces/RadialBounds.cpp b/Core/src/Surfaces/RadialBounds.cpp
index c4952f24e04d9e276826e1f534c194e72d4e6edd..ff2deb3fca3f4638c12c90f7e4017d90daca13a6 100644
--- a/Core/src/Surfaces/RadialBounds.cpp
+++ b/Core/src/Surfaces/RadialBounds.cpp
@@ -14,67 +14,49 @@
#include <iomanip>
#include <iostream>
-Acts::RadialBounds::RadialBounds(double minrad, double maxrad, double hphisec)
- : RadialBounds(minrad, maxrad, 0, hphisec) {}
-
-Acts::RadialBounds::RadialBounds(double minrad, double maxrad, double avephi,
- double hphisec)
- : m_rMin(std::min(minrad, maxrad)),
- m_rMax(std::max(minrad, maxrad)),
- m_avgPhi(detail::radian_sym(avephi)),
- m_halfPhi(std::abs(hphisec)) {}
-
Acts::RadialBounds* Acts::RadialBounds::clone() const {
return new RadialBounds(*this);
}
Acts::SurfaceBounds::BoundsType Acts::RadialBounds::type() const {
- return SurfaceBounds::Disc;
-}
-
-std::vector<TDD_real_t> Acts::RadialBounds::valueStore() const {
- std::vector<TDD_real_t> values(RadialBounds::bv_length);
- values[RadialBounds::bv_rMin] = rMin();
- values[RadialBounds::bv_rMax] = rMax();
- values[RadialBounds::bv_averagePhi] = averagePhi();
- values[RadialBounds::bv_halfPhiSector] = halfPhiSector();
- return values;
+ return SurfaceBounds::eDisc;
}
Acts::Vector2D Acts::RadialBounds::shifted(
const Acts::Vector2D& lposition) const {
Vector2D tmp;
tmp[eLOC_R] = lposition[eLOC_R];
- tmp[eLOC_PHI] = detail::radian_sym(lposition[eLOC_PHI] - averagePhi());
+ tmp[eLOC_PHI] = detail::radian_sym(lposition[eLOC_PHI] - get(eAveragePhi));
return tmp;
}
bool Acts::RadialBounds::inside(const Acts::Vector2D& lposition,
const Acts::BoundaryCheck& bcheck) const {
- return bcheck.isInside(shifted(lposition), Vector2D(rMin(), -halfPhiSector()),
- Vector2D(rMax(), halfPhiSector()));
+ return bcheck.isInside(shifted(lposition),
+ Vector2D(get(eMinR), -get(eHalfPhiSector)),
+ Vector2D(get(eMaxR), get(eHalfPhiSector)));
}
double Acts::RadialBounds::distanceToBoundary(
const Acts::Vector2D& lposition) const {
- return BoundaryCheck(true).distance(shifted(lposition),
- Vector2D(rMin(), -halfPhiSector()),
- Vector2D(rMax(), halfPhiSector()));
+ return BoundaryCheck(true).distance(
+ shifted(lposition), Vector2D(get(eMinR), -get(eHalfPhiSector)),
+ Vector2D(get(eMaxR), get(eHalfPhiSector)));
}
std::vector<Acts::Vector2D> Acts::RadialBounds::vertices(
unsigned int lseg) const {
- return detail::VerticesHelper::circularVertices(m_rMin, m_rMax, m_avgPhi,
- m_halfPhi, lseg);
+ return detail::VerticesHelper::circularVertices(
+ get(eMinR), get(eMaxR), get(eAveragePhi), get(eHalfPhiSector), lseg);
}
-// ostream operator overload
std::ostream& Acts::RadialBounds::toStream(std::ostream& sl) const {
sl << std::setiosflags(std::ios::fixed);
sl << std::setprecision(7);
- sl << "Acts::RadialBounds: (innerRadius, outerRadius, hPhiSector) = ";
- sl << "(" << rMin() << ", " << rMax() << ", " << averagePhi() << ", "
- << halfPhiSector() << ")";
+ sl << "Acts::RadialBounds: (innerRadius, outerRadius, hPhiSector, "
+ "averagePhi) = ";
+ sl << "(" << get(eMinR) << ", " << get(eMaxR) << ", " << get(eHalfPhiSector)
+ << ", " << get(eAveragePhi) << ")";
sl << std::setprecision(-1);
return sl;
}
diff --git a/Core/src/Surfaces/RectangleBounds.cpp b/Core/src/Surfaces/RectangleBounds.cpp
index abca4abcbd00d26b9712640f8c6eaa32d3bc3a4a..5734cfad5eea3e60730f7e79ed8cc97b29a9244a 100644
--- a/Core/src/Surfaces/RectangleBounds.cpp
+++ b/Core/src/Surfaces/RectangleBounds.cpp
@@ -13,23 +13,10 @@
#include <iomanip>
#include <iostream>
-Acts::RectangleBounds::RectangleBounds(double halex, double haley)
- : m_min(-halex, -haley), m_max(halex, haley) {}
-
-Acts::RectangleBounds::RectangleBounds(const Vector2D& vmin,
- const Vector2D& vmax)
- : m_min(vmin), m_max(vmax) {}
-
Acts::RectangleBounds* Acts::RectangleBounds::clone() const {
return new RectangleBounds(*this);
}
-std::vector<TDD_real_t> Acts::RectangleBounds::valueStore() const {
- std::vector<TDD_real_t> values(RectangleBounds::bv_length);
- values = {m_min.x(), m_min.y(), m_max.x(), m_max.y()};
- return values;
-}
-
bool Acts::RectangleBounds::inside(const Acts::Vector2D& lposition,
const Acts::BoundaryCheck& bcheck) const {
return bcheck.isInside(lposition, m_min, m_max);
@@ -37,7 +24,7 @@ bool Acts::RectangleBounds::inside(const Acts::Vector2D& lposition,
double Acts::RectangleBounds::distanceToBoundary(
const Acts::Vector2D& lposition) const {
- return BoundaryCheck(true).distance(lposition, m_min, m_max);
+ return BoundaryCheck(true).distance(lposition, min(), max());
}
std::vector<Acts::Vector2D> Acts::RectangleBounds::vertices(
@@ -55,9 +42,10 @@ std::ostream& Acts::RectangleBounds::toStream(std::ostream& sl) const {
sl << std::setiosflags(std::ios::fixed);
sl << std::setprecision(7);
sl << "Acts::RectangleBounds: (hlX, hlY) = "
- << "(" << halflengthX() << ", " << halflengthY() << ")";
+ << "(" << 0.5 * (get(eMaxX) - get(eMinX)) << ", "
+ << 0.5 * (get(eMaxY) - get(eMinY)) << ")";
sl << "\n(lower left, upper right):\n";
- sl << m_min.transpose() << "\n" << m_max.transpose();
+ sl << min().transpose() << "\n" << max().transpose();
sl << std::setprecision(-1);
return sl;
}
diff --git a/Core/src/Surfaces/StrawSurface.cpp b/Core/src/Surfaces/StrawSurface.cpp
index 91a3dce097184de378f3ba18bdc7a51ae98f9211..d2718a4269f8cc9dc2c80d6395a599287d0234c2 100644
--- a/Core/src/Surfaces/StrawSurface.cpp
+++ b/Core/src/Surfaces/StrawSurface.cpp
@@ -65,6 +65,7 @@ Acts::Polyhedron Acts::StrawSurface::polyhedronRepresentation(
const Transform3D& ctransform = transform(gctx);
// Draw the bounds if more than one segment are chosen
if (lseg > 1) {
+ double r = m_bounds->get(LineBounds::eR);
auto phiSegs = detail::VerticesHelper::phiSegments();
// Write the two bows/circles on either side
std::vector<int> sides = {-1, 1};
@@ -73,9 +74,9 @@ Acts::Polyhedron Acts::StrawSurface::polyhedronRepresentation(
int addon = (iseg == phiSegs.size() - 2) ? 1 : 0;
/// Helper method to create the segment
detail::VerticesHelper::createSegment(
- vertices, {m_bounds->r(), m_bounds->r()}, phiSegs[iseg],
- phiSegs[iseg + 1], lseg, addon,
- Vector3D(0., 0., side * m_bounds->halflengthZ()), ctransform);
+ vertices, {r, r}, phiSegs[iseg], phiSegs[iseg + 1], lseg, addon,
+ Vector3D(0., 0., side * m_bounds->get(LineBounds::eHalfLengthZ)),
+ ctransform);
}
}
auto facesMesh = detail::FacesHelper::cylindricalFaceMesh(vertices);
@@ -84,8 +85,8 @@ Acts::Polyhedron Acts::StrawSurface::polyhedronRepresentation(
}
size_t bvertices = vertices.size();
- Vector3D left(0, 0, -m_bounds->halflengthZ());
- Vector3D right(0, 0, m_bounds->halflengthZ());
+ Vector3D left(0, 0, -m_bounds->get(LineBounds::eHalfLengthZ));
+ Vector3D right(0, 0, m_bounds->get(LineBounds::eHalfLengthZ));
// The central wire/straw
vertices.push_back(ctransform * left);
vertices.push_back(ctransform * right);
diff --git a/Core/src/Surfaces/TrapezoidBounds.cpp b/Core/src/Surfaces/TrapezoidBounds.cpp
index 8f6e1cb23e95a166f2c3cbf62052adcf56f62ad2..3d4861ff908c27abc10b59b46937604a292c8f3e 100644
--- a/Core/src/Surfaces/TrapezoidBounds.cpp
+++ b/Core/src/Surfaces/TrapezoidBounds.cpp
@@ -12,13 +12,6 @@
#include <iomanip>
#include <iostream>
-Acts::TrapezoidBounds::TrapezoidBounds(double minhalex, double maxhalex,
- double haley)
- : m_minHalfX(std::abs(minhalex)),
- m_maxHalfX(std::abs(maxhalex)),
- m_halfY(std::abs(haley)),
- m_boundingBox(std::max(minhalex, maxhalex), haley) {}
-
Acts::TrapezoidBounds::~TrapezoidBounds() = default;
Acts::TrapezoidBounds* Acts::TrapezoidBounds::clone() const {
@@ -26,15 +19,7 @@ Acts::TrapezoidBounds* Acts::TrapezoidBounds::clone() const {
}
Acts::SurfaceBounds::BoundsType Acts::TrapezoidBounds::type() const {
- return SurfaceBounds::Trapezoid;
-}
-
-std::vector<TDD_real_t> Acts::TrapezoidBounds::valueStore() const {
- std::vector<TDD_real_t> values(TrapezoidBounds::bv_length);
- values[TrapezoidBounds::bv_minHalfX] = minHalflengthX();
- values[TrapezoidBounds::bv_maxHalfX] = maxHalflengthX();
- values[TrapezoidBounds::bv_halfY] = halflengthY();
- return values;
+ return SurfaceBounds::eTrapezoid;
}
bool Acts::TrapezoidBounds::inside(const Acts::Vector2D& lposition,
@@ -49,11 +34,10 @@ double Acts::TrapezoidBounds::distanceToBoundary(
std::vector<Acts::Vector2D> Acts::TrapezoidBounds::vertices(
unsigned int /*lseg*/) const {
- // counter-clockwise from bottom-right corner
- return {{minHalflengthX(), -halflengthY()},
- {maxHalflengthX(), halflengthY()},
- {-maxHalflengthX(), halflengthY()},
- {-minHalflengthX(), -halflengthY()}};
+ double minhx = get(TrapezoidBounds::eHalfLengthXnegY);
+ double maxhx = get(TrapezoidBounds::eHalfLengthXposY);
+ double hy = get(TrapezoidBounds::eHalfLengthY);
+ return {{-minhx, -hy}, {minhx, -hy}, {maxhx, hy}, {-maxhx, hy}};
}
const Acts::RectangleBounds& Acts::TrapezoidBounds::boundingBox() const {
@@ -63,9 +47,9 @@ const Acts::RectangleBounds& Acts::TrapezoidBounds::boundingBox() const {
std::ostream& Acts::TrapezoidBounds::toStream(std::ostream& sl) const {
sl << std::setiosflags(std::ios::fixed);
sl << std::setprecision(7);
- sl << "Acts::TrapezoidBounds: (minHlengthX, maxHlengthX, hlengthY) = "
- << "(" << minHalflengthX() << ", " << maxHalflengthX() << ", "
- << halflengthY() << ")";
+ sl << "Acts::TrapezoidBounds: (halfXnegY, halfXposY, halfY) = "
+ << "(" << get(eHalfLengthXnegY) << ", " << get(eHalfLengthXposY) << ", "
+ << get(eHalfLengthY) << ")";
sl << std::setprecision(-1);
return sl;
}
diff --git a/Core/src/Surfaces/TriangleBounds.cpp b/Core/src/Surfaces/TriangleBounds.cpp
deleted file mode 100644
index a9e9e09013bbf7d66ca03141f5a618454326dba2..0000000000000000000000000000000000000000
--- a/Core/src/Surfaces/TriangleBounds.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 2016-2020 CERN for the benefit of the Acts project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include "Acts/Surfaces/TriangleBounds.hpp"
-
-#include <iomanip>
-#include <iostream>
-
-Acts::TriangleBounds::TriangleBounds(const std::array<Vector2D, 3>& vertices)
- : m_vertices(vertices), m_boundingBox(0, 0) {
- double mx = 0;
- double my = 0;
- for (auto& v : vertices) {
- mx = std::max(mx, std::abs(v.x()));
- my = std::max(my, std::abs(v.y()));
- }
- m_boundingBox = RectangleBounds(mx, my);
-}
-
-Acts::TriangleBounds::~TriangleBounds() = default;
-
-Acts::TriangleBounds* Acts::TriangleBounds::clone() const {
- return new TriangleBounds(*this);
-}
-
-Acts::SurfaceBounds::BoundsType Acts::TriangleBounds::type() const {
- return SurfaceBounds::Triangle;
-}
-
-std::vector<TDD_real_t> Acts::TriangleBounds::valueStore() const {
- std::vector<TDD_real_t> values(TriangleBounds::bv_length);
- values[TriangleBounds::bv_x1] = m_vertices[0].x();
- values[TriangleBounds::bv_y1] = m_vertices[0].y();
- values[TriangleBounds::bv_x2] = m_vertices[1].x();
- values[TriangleBounds::bv_y2] = m_vertices[1].y();
- values[TriangleBounds::bv_x3] = m_vertices[2].x();
- values[TriangleBounds::bv_y3] = m_vertices[2].y();
- return values;
-}
-
-bool Acts::TriangleBounds::inside(const Acts::Vector2D& lposition,
- const Acts::BoundaryCheck& bcheck) const {
- return bcheck.isInside(lposition, m_vertices);
-}
-
-double Acts::TriangleBounds::distanceToBoundary(
- const Acts::Vector2D& lposition) const {
- return BoundaryCheck(true).distance(lposition, m_vertices);
-}
-
-std::vector<Acts::Vector2D> Acts::TriangleBounds::vertices(
- unsigned int /*lseg*/) const {
- return {std::begin(m_vertices), std::end(m_vertices)};
-}
-
-const Acts::RectangleBounds& Acts::TriangleBounds::boundingBox() const {
- return m_boundingBox;
-}
-
-// ostream operator overload
-std::ostream& Acts::TriangleBounds::toStream(std::ostream& sl) const {
- sl << std::setiosflags(std::ios::fixed);
- sl << std::setprecision(7);
- sl << "Acts::TriangleBounds: generating vertices (X, Y)";
- sl << "(" << m_vertices[0].x() << " , " << m_vertices[1].y() << ") " << '\n';
- sl << "(" << m_vertices[1].x() << " , " << m_vertices[1].y() << ") " << '\n';
- sl << "(" << m_vertices[2].x() << " , " << m_vertices[2].y() << ") ";
- sl << std::setprecision(-1);
- return sl;
-}
diff --git a/Plugins/DD4hep/include/Acts/Plugins/DD4hep/ActsExtension.hpp b/Plugins/DD4hep/include/Acts/Plugins/DD4hep/ActsExtension.hpp
index 69c359c4c6135639865025370e754bcff63bf772..2dc04a8ced8fa6c818ad6a217164c8b291ccf0ae 100644
--- a/Plugins/DD4hep/include/Acts/Plugins/DD4hep/ActsExtension.hpp
+++ b/Plugins/DD4hep/include/Acts/Plugins/DD4hep/ActsExtension.hpp
@@ -115,7 +115,7 @@ class ActsExtension {
std::map<std::string, std::string> m_flagStore;
/// Unique value store for doubles
- std::map<std::string, double> m_valueStore;
+ std::map<std::string, double> m_values;
};
// Templated helper method to get from the value/type store
diff --git a/Plugins/DD4hep/src/ActsExtension.cpp b/Plugins/DD4hep/src/ActsExtension.cpp
index eeda30f01aa3ce9290ab47c4e6292820816cb32c..1ab694d81e350bd0a455685e4c58fd3526a647e2 100644
--- a/Plugins/DD4hep/src/ActsExtension.cpp
+++ b/Plugins/DD4hep/src/ActsExtension.cpp
@@ -14,22 +14,22 @@ Acts::ActsExtension::ActsExtension(const std::string& axes) {
Acts::ActsExtension::ActsExtension(const ActsExtension& ext,
const dd4hep::DetElement& /*elem*/)
- : m_flagStore(ext.m_flagStore), m_valueStore(ext.m_valueStore) {}
+ : m_flagStore(ext.m_flagStore), m_values(ext.m_values) {}
double Acts::ActsExtension::getValue(const std::string& tag,
const std::string& category) const
noexcept(false) {
- return getT(m_valueStore, tag, category);
+ return getT(m_values, tag, category);
}
void Acts::ActsExtension::addValue(double value, const std::string& tag,
const std::string& category) {
- addT(m_valueStore, value, tag, category, 0.0);
+ addT(m_values, value, tag, category, 0.0);
}
bool Acts::ActsExtension::hasValue(const std::string& tag,
const std::string& category) const {
- return hasT(m_valueStore, tag, category);
+ return hasT(m_values, tag, category);
}
bool Acts::ActsExtension::hasType(const std::string& type,
@@ -63,7 +63,7 @@ std::string Acts::ActsExtension::toString() const {
}
rString += "- value store: ";
rString += '\n';
- for (auto const& [key, value] : m_valueStore) {
+ for (auto const& [key, value] : m_values) {
rString += key;
rString += " : ";
rString += std::to_string(value);
diff --git a/Plugins/Digitization/include/Acts/Plugins/Digitization/CartesianSegmentation.hpp b/Plugins/Digitization/include/Acts/Plugins/Digitization/CartesianSegmentation.hpp
index 277dd27b9f5e60ddd96a264b65259c426c45d864..08ff4f1f820087422deb5dde8f6cbd664458e64b 100644
--- a/Plugins/Digitization/include/Acts/Plugins/Digitization/CartesianSegmentation.hpp
+++ b/Plugins/Digitization/include/Acts/Plugins/Digitization/CartesianSegmentation.hpp
@@ -138,7 +138,7 @@ inline DigitizationCell CartesianSegmentation::cell(
inline std::pair<double, double> CartesianSegmentation::pitch() const {
auto boundingBox = m_activeBounds->boundingBox();
- auto values = boundingBox.valueStore();
+ auto values = boundingBox.values();
double pitchX = 2. * values[0] / m_binUtility->bins(0);
double pitchY = 2. * values[1] / m_binUtility->bins(1);
return std::pair<double, double>(pitchX, pitchY);
diff --git a/Plugins/Digitization/src/CartesianSegmentation.cpp b/Plugins/Digitization/src/CartesianSegmentation.cpp
index 41bc1b5befc9441b2b263e682ff3fbe121d78d08..0fdd24ecf9319159116b8b73dd39c6a51e622147 100644
--- a/Plugins/Digitization/src/CartesianSegmentation.cpp
+++ b/Plugins/Digitization/src/CartesianSegmentation.cpp
@@ -22,11 +22,11 @@ Acts::CartesianSegmentation::CartesianSegmentation(
size_t numCellsY)
: m_activeBounds(mBounds), m_binUtility(nullptr) {
auto mutableBinUtility = std::make_shared<BinUtility>(
- numCellsX, -mBounds->boundingBox().halflengthX(),
- mBounds->boundingBox().halflengthX(), Acts::open, Acts::binX);
+ numCellsX, -mBounds->boundingBox().halfLengthX(),
+ mBounds->boundingBox().halfLengthX(), Acts::open, Acts::binX);
(*mutableBinUtility) +=
- BinUtility(numCellsY, -mBounds->boundingBox().halflengthY(),
- mBounds->boundingBox().halflengthY(), Acts::open, Acts::binY);
+ BinUtility(numCellsY, -mBounds->boundingBox().halfLengthY(),
+ mBounds->boundingBox().halfLengthY(), Acts::open, Acts::binY);
m_binUtility = std::const_pointer_cast<const BinUtility>(mutableBinUtility);
}
@@ -58,8 +58,7 @@ void Acts::CartesianSegmentation::createSegmentationSurfaces(
// - they share the RectangleBounds only if the lorentzAngle is 0
// otherwise only the readout surface has full length bounds like the module
std::shared_ptr<const PlanarBounds> moduleBounds(
- new RectangleBounds(m_activeBounds->boundingBox().halflengthX(),
- m_activeBounds->boundingBox().halflengthY()));
+ new RectangleBounds(m_activeBounds->boundingBox()));
// - they are separated by half a thickness in z
auto mutableReadoutPlaneTransform =
std::make_shared<Transform3D>(Transform3D::Identity());
@@ -80,10 +79,10 @@ void Acts::CartesianSegmentation::createSegmentationSurfaces(
} else {
// lorentz reduced Bounds
double lorentzReducedHalfX =
- m_activeBounds->boundingBox().halflengthX() - fabs(lorentzPlaneShiftX);
+ m_activeBounds->boundingBox().halfLengthX() - fabs(lorentzPlaneShiftX);
std::shared_ptr<const PlanarBounds> lorentzReducedBounds(
new RectangleBounds(lorentzReducedHalfX,
- m_activeBounds->boundingBox().halflengthY()));
+ m_activeBounds->boundingBox().halfLengthY()));
counterPlaneBounds = lorentzReducedBounds;
// now we shift the counter plane in position - this depends on lorentz
// angle
@@ -106,12 +105,12 @@ void Acts::CartesianSegmentation::createSegmentationSurfaces(
// -----------------------------------------------------------
// easy stuff first, constant pitch size and
double pitchX =
- 2. * m_activeBounds->boundingBox().halflengthX() / m_binUtility->bins(0);
+ 2. * m_activeBounds->boundingBox().halfLengthX() / m_binUtility->bins(0);
// now, let's create the shared bounds of all surfaces marking x bins - choice
// fixes orientation of the matrix
std::shared_ptr<const PlanarBounds> xBinBounds(new RectangleBounds(
- m_activeBounds->boundingBox().halflengthY(), halfThickness));
+ m_activeBounds->boundingBox().halfLengthY(), halfThickness));
// now, let's create the shared bounds of all surfaces marking lorentz planes
double lorentzPlaneHalfX = std::abs(halfThickness / cos(lorentzAngle));
// the bounds of the lorentz plane
@@ -119,7 +118,7 @@ void Acts::CartesianSegmentation::createSegmentationSurfaces(
(lorentzAngle == 0.)
? xBinBounds
: std::shared_ptr<const PlanarBounds>(
- new RectangleBounds(m_activeBounds->boundingBox().halflengthY(),
+ new RectangleBounds(m_activeBounds->boundingBox().halfLengthY(),
lorentzPlaneHalfX));
// now the rotation matrix for the xBins
@@ -141,7 +140,7 @@ void Acts::CartesianSegmentation::createSegmentationSurfaces(
for (size_t ibinx = 0; ibinx <= m_binUtility->bins(0); ++ibinx) {
// the current step x position
double cPosX =
- -m_activeBounds->boundingBox().halflengthX() + ibinx * pitchX;
+ -m_activeBounds->boundingBox().halfLengthX() + ibinx * pitchX;
// (i) this is the low/high boundary --- ( ibin == 0/m_binUtility->bins(0) )
if ((ibinx == 0u) || ibinx == m_binUtility->bins(0)) {
// check if it a straight boundary or not: always straight for no lorentz
@@ -192,17 +191,17 @@ void Acts::CartesianSegmentation::createSegmentationSurfaces(
yBinRotationMatrix.col(2) = Vector3D(0., -1., 0.);
// easy stuff first, constant pitch in Y
double pitchY =
- 2. * m_activeBounds->boundingBox().halflengthY() / m_binUtility->bins(1);
+ 2. * m_activeBounds->boundingBox().halfLengthY() / m_binUtility->bins(1);
// let's create the shared bounds of all surfaces marking y bins
std::shared_ptr<const PlanarBounds> yBinBounds(new RectangleBounds(
- m_activeBounds->boundingBox().halflengthX(), halfThickness));
+ m_activeBounds->boundingBox().halfLengthX(), halfThickness));
// reserve, it's always (number of bins-1) as the boundaries are within the
// boundarySurfaces
segmentationSurfacesY.reserve(m_binUtility->bins(1));
for (size_t ibiny = 0; ibiny <= m_binUtility->bins(1); ++ibiny) {
// the position of the bin surface
double binPosY =
- -m_activeBounds->boundingBox().halflengthY() + ibiny * pitchY;
+ -m_activeBounds->boundingBox().halfLengthY() + ibiny * pitchY;
Vector3D binSurfaceCenter(0., binPosY, 0.);
// the binning transform
auto binTransform = std::make_shared<const Transform3D>(
diff --git a/Plugins/Json/src/JsonGeometryConverter.cpp b/Plugins/Json/src/JsonGeometryConverter.cpp
index 45f40f816ffad082b0f5f12a246522265076f2ff..7d2ec45f43e527f11bfdf0556964bc0b2527b605 100644
--- a/Plugins/Json/src/JsonGeometryConverter.cpp
+++ b/Plugins/Json/src/JsonGeometryConverter.cpp
@@ -600,9 +600,10 @@ void Acts::JsonGeometryConverter::addSurfaceToJson(json& sjson,
}
if (cylinderBounds != nullptr) {
sjson[m_cfg.surfacetypekey] = "Cylinder";
- sjson[m_cfg.surfacepositionkey] = cylinderBounds->r();
- sjson[m_cfg.surfacerangekey] = {-1 * cylinderBounds->halflengthZ(),
- cylinderBounds->halflengthZ()};
+ sjson[m_cfg.surfacepositionkey] = cylinderBounds->get(CylinderBounds::eR);
+ sjson[m_cfg.surfacerangekey] = {
+ -1 * cylinderBounds->get(CylinderBounds::eHalfLengthZ),
+ cylinderBounds->get(CylinderBounds::eHalfLengthZ)};
}
if (annulusBounds != nullptr) {
sjson[m_cfg.surfacetypekey] = "Annulus";
@@ -665,24 +666,31 @@ Acts::BinUtility Acts::JsonGeometryConverter::DefaultBin(
dynamic_cast<const Acts::AnnulusBounds*>(&surfaceBounds);
if (radialBounds != nullptr) {
- bUtility += BinUtility(
- 1, radialBounds->averagePhi() - radialBounds->halfPhiSector(),
- radialBounds->averagePhi() + radialBounds->halfPhiSector(),
- Acts::closed, Acts::binPhi);
+ bUtility += BinUtility(1,
+ radialBounds->get(RadialBounds::eAveragePhi) -
+ radialBounds->get(RadialBounds::eHalfPhiSector),
+ radialBounds->get(RadialBounds::eAveragePhi) +
+ radialBounds->get(RadialBounds::eHalfPhiSector),
+ Acts::closed, Acts::binPhi);
bUtility += BinUtility(1, radialBounds->rMin(), radialBounds->rMax(),
Acts::open, Acts::binR);
}
if (cylinderBounds != nullptr) {
- bUtility += BinUtility(
- 1, cylinderBounds->averagePhi() - cylinderBounds->halfPhiSector(),
- cylinderBounds->averagePhi() + cylinderBounds->halfPhiSector(),
- Acts::closed, Acts::binPhi);
bUtility +=
- BinUtility(1, -1 * cylinderBounds->halflengthZ(),
- cylinderBounds->halflengthZ(), Acts::open, Acts::binZ);
+ BinUtility(1,
+ cylinderBounds->get(CylinderBounds::eAveragePhi) -
+ cylinderBounds->get(CylinderBounds::eHalfPhiSector),
+ cylinderBounds->get(CylinderBounds::eAveragePhi) +
+ cylinderBounds->get(CylinderBounds::eHalfPhiSector),
+ Acts::closed, Acts::binPhi);
+ bUtility +=
+ BinUtility(1, -1 * cylinderBounds->get(CylinderBounds::eHalfLengthZ),
+ cylinderBounds->get(CylinderBounds::eHalfLengthZ),
+ Acts::open, Acts::binZ);
}
if (annulusBounds != nullptr) {
- bUtility += BinUtility(1, annulusBounds->phiMin(), annulusBounds->phiMax(),
+ bUtility += BinUtility(1, annulusBounds->get(AnnulusBounds::eMinPhiRel),
+ annulusBounds->get(AnnulusBounds::eMaxPhiRel),
Acts::closed, Acts::binPhi);
bUtility += BinUtility(1, annulusBounds->rMin(), annulusBounds->rMax(),
Acts::open, Acts::binR);
diff --git a/Tests/IntegrationTests/PropagationTestBase.hpp b/Tests/IntegrationTests/PropagationTestBase.hpp
index 8714d26f17ebb8fe97008d7ac0deb226105131a6..b084fbe34ef5fbbb6878f0a804199ccac45e347d 100644
--- a/Tests/IntegrationTests/PropagationTestBase.hpp
+++ b/Tests/IntegrationTests/PropagationTestBase.hpp
@@ -69,21 +69,24 @@ BOOST_DATA_TEST_CASE(propagation_to_cylinder_,
// just make sure we can reach it
double r = pfrac * std::abs(pT / Bz);
r = (r > 2.5_m) ? 2.5_m : r;
- // check atlas stepper
- auto a_at_cylinder = to_cylinder(apropagator, pT, phi, theta, charge, r,
- rand1, rand2, rand3, covtpr, debug);
- // check eigen stepper
- auto e_at_cylinder = to_cylinder(epropagator, pT, phi, theta, charge, r,
- rand1, rand2, rand3, covtpr, debug);
- CHECK_CLOSE_ABS(e_at_cylinder.first, a_at_cylinder.first, 10_um);
-
- // check without charge
- auto s_at_cylinder = to_cylinder(spropagator, pT, phi, theta, 0., r, rand1,
- rand2, rand3, covtpr, debug);
- e_at_cylinder = to_cylinder(epropagator, pT, phi, theta, 0., r, rand1, rand2,
- rand3, covtpr, debug);
-
- CHECK_CLOSE_ABS(s_at_cylinder.first, e_at_cylinder.first, 1_um);
+
+ if (r > 0.) {
+ // check atlas stepper
+ auto a_at_cylinder = to_cylinder(apropagator, pT, phi, theta, charge, r,
+ rand1, rand2, rand3, covtpr, debug);
+ // check eigen stepper
+ auto e_at_cylinder = to_cylinder(epropagator, pT, phi, theta, charge, r,
+ rand1, rand2, rand3, covtpr, debug);
+ CHECK_CLOSE_ABS(e_at_cylinder.first, a_at_cylinder.first, 10_um);
+
+ // check without charge
+ auto s_at_cylinder = to_cylinder(spropagator, pT, phi, theta, 0., r, rand1,
+ rand2, rand3, covtpr, debug);
+ e_at_cylinder = to_cylinder(epropagator, pT, phi, theta, 0., r, rand1,
+ rand2, rand3, covtpr, debug);
+
+ CHECK_CLOSE_ABS(s_at_cylinder.first, e_at_cylinder.first, 1_um);
+ }
}
/// test consistency of propagators to a plane
diff --git a/Tests/UnitTests/Core/EventData/BoundParametersTests.cpp b/Tests/UnitTests/Core/EventData/BoundParametersTests.cpp
index 1b5529f9c7327b53106b1b478f06b2c61d91de6b..423b79037767e8f3f173a8d6b2f32526270e2db8 100644
--- a/Tests/UnitTests/Core/EventData/BoundParametersTests.cpp
+++ b/Tests/UnitTests/Core/EventData/BoundParametersTests.cpp
@@ -279,9 +279,9 @@ BOOST_DATA_TEST_CASE(
Vector3D mom = p * direction;
// 3D position in local frame
- const double phi_l = pars_array[0] / bounds->r();
- Vector3D pos = (bounds->r() * cos(phi_l)) * rot.col(0) +
- (bounds->r() * sin(phi_l)) * rot.col(1) +
+ double r = bounds->get(CylinderBounds::eR);
+ const double phi_l = pars_array[0] / r;
+ Vector3D pos = (r * cos(phi_l)) * rot.col(0) + (r * sin(phi_l)) * rot.col(1) +
(pars_array[1]) * rot.col(2) + center;
// constructor from parameter vector
diff --git a/Tests/UnitTests/Core/EventData/MeasurementHelpersTests.cpp b/Tests/UnitTests/Core/EventData/MeasurementHelpersTests.cpp
index 3b424e4fa12930eb9e454b9132573a6f4dc2dcc3..6ee55462c38f3e25f5510a780bddcd21d154ce78 100644
--- a/Tests/UnitTests/Core/EventData/MeasurementHelpersTests.cpp
+++ b/Tests/UnitTests/Core/EventData/MeasurementHelpersTests.cpp
@@ -25,8 +25,11 @@ using MeasurementType = Measurement<SourceLink, params...>;
using FittableMeasurement = FittableMeasurement<SourceLink>;
BOOST_AUTO_TEST_CASE(getSurface_test) {
- auto cylinder = Surface::makeShared<CylinderSurface>(nullptr, 3, 10);
- auto cylinder2 = Surface::makeShared<CylinderSurface>(nullptr, 3, 10);
+ auto cylinderBounds = std::make_shared<CylinderBounds>(3, 10);
+
+ auto cylinder = Surface::makeShared<CylinderSurface>(nullptr, cylinderBounds);
+ auto cylinder2 =
+ Surface::makeShared<CylinderSurface>(nullptr, cylinderBounds);
ActsSymMatrixD<2> cov;
cov << 0.04, 0, 0, 0.1;
diff --git a/Tests/UnitTests/Core/Geometry/DiscLayerTests.cpp b/Tests/UnitTests/Core/Geometry/DiscLayerTests.cpp
index 8156e4c9143c4443a9510051f2f11b412e7c53de..87af9d55fe4cd72783b9e9f7ac847c736bf34328 100644
--- a/Tests/UnitTests/Core/Geometry/DiscLayerTests.cpp
+++ b/Tests/UnitTests/Core/Geometry/DiscLayerTests.cpp
@@ -44,9 +44,9 @@ BOOST_AUTO_TEST_CASE(DiscLayerConstruction) {
// RadialBounds) to construct
Translation3D translation{0., 1., 2.};
auto pTransform = std::make_shared<const Transform3D>(translation);
- const double minRad(10.), maxRad(5.); // 20 x 10 disc
+ const double minRad(5.), maxRad(10.); // 20 x 10 disc
auto pDisc = std::make_shared<const RadialBounds>(minRad, maxRad);
- auto pDiscLayer = DiscLayer::create(pTransform, pDisc);
+ auto pDiscLayer = DiscLayer::create(pTransform, pDisc, nullptr, 1.);
BOOST_CHECK_EQUAL(pDiscLayer->layerType(), LayerType::passive);
// next level: need an array of Surfaces;
// bounds object, rectangle type
@@ -57,7 +57,8 @@ BOOST_AUTO_TEST_CASE(DiscLayerConstruction) {
Surface::makeShared<PlaneSurface>(pNullTransform, rBounds),
Surface::makeShared<PlaneSurface>(pNullTransform, rBounds)};
const double thickness(1.0);
- auto pDiscLayerFromSurfaces = DiscLayer::create(pTransform, pDisc, nullptr);
+ auto pDiscLayerFromSurfaces =
+ DiscLayer::create(pTransform, pDisc, nullptr, 1.);
BOOST_CHECK_EQUAL(pDiscLayerFromSurfaces->layerType(), LayerType::passive);
// construct with thickness:
auto pDiscLayerWithThickness =
@@ -81,9 +82,9 @@ BOOST_AUTO_TEST_CASE(DiscLayerConstruction) {
BOOST_AUTO_TEST_CASE(DiscLayerProperties /*, *utf::expected_failures(1)*/) {
Translation3D translation{0., 1., 2.};
auto pTransform = std::make_shared<const Transform3D>(translation);
- const double minRad(10.), maxRad(5.); // 20 x 10 disc
+ const double minRad(5.), maxRad(10.); // 20 x 10 disc
auto pDisc = std::make_shared<const RadialBounds>(minRad, maxRad);
- auto pDiscLayer = DiscLayer::create(pTransform, pDisc);
+ auto pDiscLayer = DiscLayer::create(pTransform, pDisc, nullptr, 1.);
// auto planeSurface = pDiscLayer->surfaceRepresentation();
BOOST_CHECK_EQUAL(pDiscLayer->surfaceRepresentation().name(),
std::string("Acts::DiscSurface"));
diff --git a/Tests/UnitTests/Core/Geometry/LayerCreatorTests.cpp b/Tests/UnitTests/Core/Geometry/LayerCreatorTests.cpp
index 88e04677c85875f15ae9cb64a9afb756a3e1fb7f..e0103c717ee34a8688411f7581c8b985e71e5412 100644
--- a/Tests/UnitTests/Core/Geometry/LayerCreatorTests.cpp
+++ b/Tests/UnitTests/Core/Geometry/LayerCreatorTests.cpp
@@ -252,8 +252,8 @@ BOOST_FIXTURE_TEST_CASE(LayerCreator_createCylinderLayer, LayerCreatorFixture) {
CHECK_CLOSE_REL(layer->thickness(), (rMax - rMin) + 2 * envR, 1e-3);
const CylinderBounds* bounds = &layer->bounds();
- CHECK_CLOSE_REL(bounds->r(), (rMax + rMin) / 2., 1e-3);
- CHECK_CLOSE_REL(bounds->halflengthZ(), 14 + envZ, 1e-3);
+ CHECK_CLOSE_REL(bounds->get(CylinderBounds::eR), (rMax + rMin) / 2., 1e-3);
+ CHECK_CLOSE_REL(bounds->get(CylinderBounds::eHalfLengthZ), 14 + envZ, 1e-3);
BOOST_CHECK(checkBinning(tgContext, *layer->surfaceArray()));
auto axes = layer->surfaceArray()->getAxes();
BOOST_CHECK_EQUAL(axes.at(0)->getNBins(), 30u);
@@ -272,8 +272,8 @@ BOOST_FIXTURE_TEST_CASE(LayerCreator_createCylinderLayer, LayerCreatorFixture) {
p_LC->cylinderLayer(tgContext, srf, 30, 7, pl2));
CHECK_CLOSE_REL(layer->thickness(), (rMax - rMin) + 2 * envR, 1e-3);
bounds = &layer->bounds();
- CHECK_CLOSE_REL(bounds->r(), (rMax + rMin) / 2., 1e-3);
- CHECK_CLOSE_REL(bounds->halflengthZ(), 14 + envZ, 1e-3);
+ CHECK_CLOSE_REL(bounds->get(CylinderBounds::eR), (rMax + rMin) / 2., 1e-3);
+ CHECK_CLOSE_REL(bounds->get(CylinderBounds::eHalfLengthZ), 14 + envZ, 1e-3);
BOOST_CHECK(checkBinning(tgContext, *layer->surfaceArray()));
axes = layer->surfaceArray()->getAxes();
BOOST_CHECK_EQUAL(axes.at(0)->getNBins(), 30u);
@@ -287,8 +287,8 @@ BOOST_FIXTURE_TEST_CASE(LayerCreator_createCylinderLayer, LayerCreatorFixture) {
p_LC->cylinderLayer(tgContext, srf, 13, 3, pl2));
CHECK_CLOSE_REL(layer->thickness(), (rMax - rMin) + 2 * envR, 1e-3);
bounds = &layer->bounds();
- CHECK_CLOSE_REL(bounds->r(), (rMax + rMin) / 2., 1e-3);
- CHECK_CLOSE_REL(bounds->halflengthZ(), 14 + envZ, 1e-3);
+ CHECK_CLOSE_REL(bounds->get(CylinderBounds::eR), (rMax + rMin) / 2., 1e-3);
+ CHECK_CLOSE_REL(bounds->get(CylinderBounds::eHalfLengthZ), 14 + envZ, 1e-3);
// this succeeds despite sub-optimal binning
// since we now have multientry bins
BOOST_CHECK(checkBinning(tgContext, *layer->surfaceArray()));
@@ -310,8 +310,8 @@ BOOST_FIXTURE_TEST_CASE(LayerCreator_createCylinderLayer, LayerCreatorFixture) {
p_LC->cylinderLayer(tgContext, srf, equidistant, equidistant, pl3));
CHECK_CLOSE_REL(layer->thickness(), 19, 1e-3);
bounds = &layer->bounds();
- CHECK_CLOSE_REL(bounds->r(), 10.5, 1e-3);
- CHECK_CLOSE_REL(bounds->halflengthZ(), 25, 1e-3);
+ CHECK_CLOSE_REL(bounds->get(CylinderBounds::eR), 10.5, 1e-3);
+ CHECK_CLOSE_REL(bounds->get(CylinderBounds::eHalfLengthZ), 25, 1e-3);
// this should fail, b/c it's a completely inconvenient binning
// but it succeeds despite sub-optimal binning
diff --git a/Tests/UnitTests/Core/Geometry/TrackingGeometryClosureTests.cpp b/Tests/UnitTests/Core/Geometry/TrackingGeometryClosureTests.cpp
index 1a6a466e43a125ba1a1054412ad5c95c3bb8c79e..977c29e9e12cd4f73a885c4dd265007507294e2c 100644
--- a/Tests/UnitTests/Core/Geometry/TrackingGeometryClosureTests.cpp
+++ b/Tests/UnitTests/Core/Geometry/TrackingGeometryClosureTests.cpp
@@ -39,47 +39,46 @@ double layerEnvelope = 0.5_mm;
double volumeEnvelope = 10_mm;
// inner inner volume definitions
-double iiv_surfaceRadius = 25_mm;
-double iiv_volumeRadius =
- iiv_surfaceRadius + 0.5 * surfaceRstagger + layerEnvelope + volumeEnvelope;
+double iiv_surfaceR = 25_mm;
+double iiv_volumeR =
+ iiv_surfaceR + 0.5 * surfaceRstagger + layerEnvelope + volumeEnvelope;
/// inner outer volume defininitions
-double iov_surfaceRadius = 100_mm;
-double iov_volumeRadius =
- iov_surfaceRadius + 0.5 * surfaceRstagger + layerEnvelope + volumeEnvelope;
+double iov_surfaceR = 100_mm;
+double iov_volumeR =
+ iov_surfaceR + 0.5 * surfaceRstagger + layerEnvelope + volumeEnvelope;
/// inner inner volume
auto iiVolume = constructCylinderVolume(
- tgContext, surfaceHalfLengthZ, iiv_surfaceRadius, surfaceRstagger,
- surfaceZoverlap, layerEnvelope, volumeEnvelope, 0., iiv_volumeRadius,
+ tgContext, surfaceHalfLengthZ, iiv_surfaceR, surfaceRstagger,
+ surfaceZoverlap, layerEnvelope, volumeEnvelope, 0., iiv_volumeR,
"InnerInnerVolume");
/// inner outer volume
auto ioVolume = constructCylinderVolume(
- tgContext, surfaceHalfLengthZ, iov_surfaceRadius, surfaceRstagger,
- surfaceZoverlap, layerEnvelope, volumeEnvelope, iiv_volumeRadius,
- iov_volumeRadius, "InnerOuterVolume");
+ tgContext, surfaceHalfLengthZ, iov_surfaceR, surfaceRstagger,
+ surfaceZoverlap, layerEnvelope, volumeEnvelope, iiv_volumeR, iov_volumeR,
+ "InnerOuterVolume");
// now create the Inner Container volume
double volumeHalfZ =
(4 * surfaceHalfLengthZ - surfaceZoverlap) + volumeEnvelope;
/// the inner volume
-auto iVolume =
- constructContainerVolume(tgContext, iiVolume, ioVolume, iov_volumeRadius,
- volumeHalfZ, "InnerVolume");
+auto iVolume = constructContainerVolume(
+ tgContext, iiVolume, ioVolume, iov_volumeR, volumeHalfZ, "InnerVolume");
// outer volume definitions
-double ov_surfaceRadius = 150_mm;
-double ov_volumeRadius =
- ov_surfaceRadius + 0.5 * surfaceRstagger + layerEnvelope + volumeEnvelope;
+double ov_surfaceR = 150_mm;
+double ov_volumeR =
+ ov_surfaceR + 0.5 * surfaceRstagger + layerEnvelope + volumeEnvelope;
/// inner outer volume
auto oVolume = constructCylinderVolume(
- tgContext, surfaceHalfLengthZ, ov_surfaceRadius, surfaceRstagger,
- surfaceZoverlap, layerEnvelope, volumeEnvelope, iov_volumeRadius,
- ov_volumeRadius, "OuterVolume");
+ tgContext, surfaceHalfLengthZ, ov_surfaceR, surfaceRstagger,
+ surfaceZoverlap, layerEnvelope, volumeEnvelope, iov_volumeR, ov_volumeR,
+ "OuterVolume");
/// the inner volume
-auto volume = constructContainerVolume(
- tgContext, iVolume, oVolume, ov_volumeRadius, volumeHalfZ, "WorldVolume");
+auto volume = constructContainerVolume(tgContext, iVolume, oVolume, ov_volumeR,
+ volumeHalfZ, "WorldVolume");
// creating a TrackingGeometry
// -> closs the geometry, this should set the GeometryID
diff --git a/Tests/UnitTests/Core/Geometry/TrackingGeometryGeoIDTests.cpp b/Tests/UnitTests/Core/Geometry/TrackingGeometryGeoIDTests.cpp
index c27a2da6d8c7095107f173f764783650e7355c5a..756a4cb88e35f0eab2a252ef5035358c375d4c61 100644
--- a/Tests/UnitTests/Core/Geometry/TrackingGeometryGeoIDTests.cpp
+++ b/Tests/UnitTests/Core/Geometry/TrackingGeometryGeoIDTests.cpp
@@ -24,28 +24,28 @@ GeometryContext tgContext = GeometryContext();
/// create three cylinder surfaces
/// the surface radius (will also be the layer radius)
double iVsurfaceHalfLengthZ = 50_mm;
-double iVsurfaceRadius = 25_mm;
+double iVsurfaceR = 25_mm;
double iVsurfaceRstagger = 5_mm;
double iVsurfaceZoverlap = 10_mm;
double iVlayerEnvelope = 0.5_mm;
double iVvolumeEnvelope = 10_mm;
-double iVvolumeRadius = iVsurfaceRadius + 0.5 * iVsurfaceRstagger +
- iVlayerEnvelope + iVvolumeEnvelope;
+double iVvolumeR =
+ iVsurfaceR + 0.5 * iVsurfaceRstagger + iVlayerEnvelope + iVvolumeEnvelope;
/// the surface radius (will also be the layer radius)
double oVsurfaceHalfLengthZ = 50_mm;
-double oVsurfaceRadius = 100_mm;
+double oVsurfaceR = 100_mm;
double oVsurfaceRstagger = 5_mm;
double oVsurfaceZoverlap = 10_mm;
double oVlayerEnvelope = 0.5_mm;
double oVvolumeEnvelope = 10_mm;
-double oVvolumeRadius = oVsurfaceRadius + 0.5 * oVsurfaceRstagger +
- oVlayerEnvelope + oVvolumeEnvelope;
+double oVvolumeR =
+ oVsurfaceR + 0.5 * oVsurfaceRstagger + oVlayerEnvelope + oVvolumeEnvelope;
/// inner volume
auto iVolume = constructCylinderVolume(
- tgContext, iVsurfaceHalfLengthZ, iVsurfaceRadius, iVsurfaceRstagger,
- iVsurfaceZoverlap, iVlayerEnvelope, iVvolumeEnvelope, 0., iVvolumeRadius,
+ tgContext, iVsurfaceHalfLengthZ, iVsurfaceR, iVsurfaceRstagger,
+ iVsurfaceZoverlap, iVlayerEnvelope, iVvolumeEnvelope, 0., iVvolumeR,
"InnerVolume");
BOOST_AUTO_TEST_CASE(GeometryID_innervolume_test) {
@@ -69,9 +69,9 @@ BOOST_AUTO_TEST_CASE(GeometryID_innervolume_test) {
/// outer volume
auto oVolume = constructCylinderVolume(
- tgContext, oVsurfaceHalfLengthZ, oVsurfaceRadius, oVsurfaceRstagger,
- oVsurfaceZoverlap, oVlayerEnvelope, oVvolumeEnvelope, iVvolumeRadius,
- oVvolumeRadius, "OuterVolume");
+ tgContext, oVsurfaceHalfLengthZ, oVsurfaceR, oVsurfaceRstagger,
+ oVsurfaceZoverlap, oVlayerEnvelope, oVvolumeEnvelope, iVvolumeR, oVvolumeR,
+ "OuterVolume");
BOOST_AUTO_TEST_CASE(GeometryID_outervolume_test) {
BOOST_CHECK_EQUAL(0ul, oVolume->geoID().value());
@@ -95,8 +95,8 @@ BOOST_AUTO_TEST_CASE(GeometryID_outervolume_test) {
double oVvolumeHalfZ =
(4 * oVsurfaceHalfLengthZ - oVsurfaceZoverlap) + oVvolumeEnvelope;
// now create the container volume
-auto hVolume = constructContainerVolume(
- tgContext, iVolume, oVolume, oVvolumeRadius, oVvolumeHalfZ, "Container");
+auto hVolume = constructContainerVolume(tgContext, iVolume, oVolume, oVvolumeR,
+ oVvolumeHalfZ, "Container");
/// pre-check on GeometryID
BOOST_AUTO_TEST_CASE(GeometryID_containervolume_test) {
diff --git a/Tests/UnitTests/Core/Geometry/TrackingVolumeCreation.hpp b/Tests/UnitTests/Core/Geometry/TrackingVolumeCreation.hpp
index 06a76eff553473bc4f13e2a5ecc3cac2daeb4cdd..156f2881b58955392abba8b9ab3a57f40b14e7cc 100644
--- a/Tests/UnitTests/Core/Geometry/TrackingVolumeCreation.hpp
+++ b/Tests/UnitTests/Core/Geometry/TrackingVolumeCreation.hpp
@@ -21,10 +21,10 @@ namespace Acts {
/// helper function to create a cylinder
TrackingVolumePtr constructCylinderVolume(
- const GeometryContext& gctx, double surfaceHalfLengthZ,
- double surfaceRadius, double surfaceRstagger, double surfaceZoverlap,
- double layerEnvelope, double volumeEnvelope, double innerVolumeR,
- double outerVolumeR, const std::string& name) {
+ const GeometryContext& gctx, double surfaceHalfLengthZ, double surfaceR,
+ double surfaceRstagger, double surfaceZoverlap, double layerEnvelope,
+ double volumeEnvelope, double innerVolumeR, double outerVolumeR,
+ const std::string& name) {
/// the surface transforms
auto sfnPosition =
Vector3D(0., 0., -3 * surfaceHalfLengthZ - surfaceZoverlap);
@@ -35,12 +35,15 @@ TrackingVolumePtr constructCylinderVolume(
auto sfpTransform =
std::make_shared<const Transform3D>(Translation3D(sfpPosition));
/// the surfaces
- auto sfn = Surface::makeShared<CylinderSurface>(
- sfnTransform, surfaceRadius - 0.5 * surfaceRstagger, surfaceHalfLengthZ);
- auto sfc = Surface::makeShared<CylinderSurface>(
- sfcTransform, surfaceRadius + 0.5 * surfaceRstagger, surfaceHalfLengthZ);
- auto sfp = Surface::makeShared<CylinderSurface>(
- sfpTransform, surfaceRadius - 0.5 * surfaceRstagger, surfaceHalfLengthZ);
+ auto sfnBounds = std::make_shared<CylinderBounds>(
+ surfaceR - 0.5 * surfaceRstagger, surfaceHalfLengthZ);
+ auto sfn = Surface::makeShared<CylinderSurface>(sfnTransform, sfnBounds);
+ auto sfcBounds = std::make_shared<CylinderBounds>(
+ surfaceR + 0.5 * surfaceRstagger, surfaceHalfLengthZ);
+ auto sfc = Surface::makeShared<CylinderSurface>(sfcTransform, sfcBounds);
+ auto sfpBounds = std::make_shared<CylinderBounds>(
+ surfaceR - 0.5 * surfaceRstagger, surfaceHalfLengthZ);
+ auto sfp = Surface::makeShared<CylinderSurface>(sfpTransform, sfpBounds);
/// prepare the surfaces
@@ -66,8 +69,7 @@ TrackingVolumePtr constructCylinderVolume(
auto bArray = std::make_unique<SurfaceArray>(std::move(sl), surfaces_only);
/// now create the Layer
- auto layer0bounds =
- std::make_shared<const CylinderBounds>(surfaceRadius, bUmax);
+ auto layer0bounds = std::make_shared<const CylinderBounds>(surfaceR, bUmax);
auto layer0 = CylinderLayer::create(nullptr, layer0bounds, std::move(bArray),
surfaceRstagger + 2 * layerEnvelope);
std::unique_ptr<const LayerArray> layerArray =
@@ -87,7 +89,7 @@ TrackingVolumePtr constructCylinderVolume(
MutableTrackingVolumePtr constructContainerVolume(const GeometryContext& gctx,
TrackingVolumePtr iVolume,
TrackingVolumePtr oVolume,
- double hVolumeRadius,
+ double hVolumeR,
double hVolumeHalflength,
const std::string& name) {
/// create the volume array
@@ -96,10 +98,10 @@ MutableTrackingVolumePtr constructContainerVolume(const GeometryContext& gctx,
{oVolume, oVolume->binningPosition(gctx, binR)}};
/// the bounds for the container
auto hVolumeBounds = std::make_shared<const CylinderVolumeBounds>(
- 0., hVolumeRadius, hVolumeHalflength);
+ 0., hVolumeR, hVolumeHalflength);
/// create the BinUtility & the BinnedArray
auto vUtility = std::make_unique<const BinUtility>(volumes.size(), 0.,
- hVolumeRadius, open, binR);
+ hVolumeR, open, binR);
std::shared_ptr<const TrackingVolumeArray> vArray =
std::make_shared<const BinnedArrayXD<TrackingVolumePtr>>(
volumes, std::move(vUtility));
diff --git a/Tests/UnitTests/Core/Propagator/NavigatorTests.cpp b/Tests/UnitTests/Core/Propagator/NavigatorTests.cpp
index e20fa82aa82bcd3a2b5f8b1a34a18776d666c234..1b25a14ba3b51a45d78137eb412869dffccfe2ed 100644
--- a/Tests/UnitTests/Core/Propagator/NavigatorTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/NavigatorTests.cpp
@@ -282,11 +282,9 @@ BOOST_AUTO_TEST_CASE(Navigator_methods) {
BOOST_CHECK(state.navigation.navLayerIter ==
state.navigation.navLayers.begin());
// Cache the beam pipe radius
- double beamPipeRadius =
- perp(state.navigation.navLayerIter->intersection.position);
+ double beamPipeR = perp(state.navigation.navLayerIter->intersection.position);
// step size has been updated
- CHECK_CLOSE_ABS(state.stepping.stepSize, beamPipeRadius,
- s_onSurfaceTolerance);
+ CHECK_CLOSE_ABS(state.stepping.stepSize, beamPipeR, s_onSurfaceTolerance);
if (debug) {
std::cout << "<<< Test 1a >>> initialize at "
<< toString(state.stepping.pos) << std::endl;
diff --git a/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp b/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp
index d690f011c3c35351c2545595f01ebb45259d0f3c..7d1e08c753f40b6146556ff62cdf783858a58d93 100644
--- a/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp
+++ b/Tests/UnitTests/Core/Propagator/PropagatorTests.cpp
@@ -119,8 +119,10 @@ BFieldType bField(0, 0, Bz);
EigenStepperType estepper(bField);
EigenPropagatorType epropagator(std::move(estepper));
-auto mSurface = Surface::makeShared<CylinderSurface>(nullptr, 10., 1000_mm);
-auto cSurface = Surface::makeShared<CylinderSurface>(nullptr, 150., 1000_mm);
+auto mCylinder = std::make_shared<CylinderBounds>(10_mm, 1000_mm);
+auto mSurface = Surface::makeShared<CylinderSurface>(nullptr, mCylinder);
+auto cCylinder = std::make_shared<CylinderBounds>(150_mm, 1000_mm);
+auto cSurface = Surface::makeShared<CylinderSurface>(nullptr, cCylinder);
const int ntests = 5;
diff --git a/Tests/UnitTests/Core/Surfaces/AnnulusBoundsTests.cpp b/Tests/UnitTests/Core/Surfaces/AnnulusBoundsTests.cpp
index 6f5193eec60311412010e505d73723bfcfc00dc5..04eb2337ab152a57fe2f0949505741925d9a5932 100644
--- a/Tests/UnitTests/Core/Surfaces/AnnulusBoundsTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/AnnulusBoundsTests.cpp
@@ -32,15 +32,45 @@ double maxPhi = 1.33970;
Vector2D offset(-2., 2.);
-/// Unit tests for AnnulusBounds constrcuctors
+// Unit tests for AnnulusBounds constrcuctors
BOOST_AUTO_TEST_CASE(AnnulusBoundsConstruction) {
- //
- /// Test construction with radii and default sector
+ // Test construction with radii and default sector
auto original = AnnulusBounds(minRadius, maxRadius, minPhi, maxPhi, offset);
- BOOST_CHECK_EQUAL(original.type(), SurfaceBounds::Annulus);
-
AnnulusBounds copied(original);
- BOOST_CHECK_EQUAL(copied.type(), SurfaceBounds::Annulus);
+ BOOST_CHECK_EQUAL(original, copied);
+}
+
+// Unit tests for AnnulusBounds recreation
+BOOST_AUTO_TEST_CASE(AnnulusBoundsRecreation) {
+ // Test construction with radii and default sector
+ auto original = AnnulusBounds(minRadius, maxRadius, minPhi, maxPhi, offset);
+ auto valvector = original.values();
+ std::array<double, AnnulusBounds::eSize> values;
+ std::copy_n(valvector.begin(), AnnulusBounds::eSize, values.begin());
+ AnnulusBounds recreated(values);
+ BOOST_CHECK_EQUAL(original, recreated);
+}
+
+// Unit tests for AnnulusBounds exception throwing
+BOOST_AUTO_TEST_CASE(AnnulusBoundsExcpetion) {
+ // Exception for negative inenr radius
+ BOOST_CHECK_THROW(AnnulusBounds(-1., maxRadius, minPhi, maxPhi, offset),
+ std::logic_error);
+ // Exception for negative outer radius
+ BOOST_CHECK_THROW(AnnulusBounds(minRadius, -1., minPhi, maxPhi, offset),
+ std::logic_error);
+ // Exception for swapped radii
+ BOOST_CHECK_THROW(AnnulusBounds(maxRadius, minRadius, minPhi, maxPhi, offset),
+ std::logic_error);
+ // Exception for out of range min phi
+ BOOST_CHECK_THROW(AnnulusBounds(minRadius, maxRadius, -4., maxPhi, offset),
+ std::logic_error);
+ // Exception for out of range max phi
+ BOOST_CHECK_THROW(AnnulusBounds(minRadius, maxRadius, minPhi, 4., offset),
+ std::logic_error);
+ // Exception for out of range max phi
+ BOOST_CHECK_THROW(AnnulusBounds(minRadius, maxRadius, maxPhi, minPhi, offset),
+ std::logic_error);
}
/// Unit tests for AnnulusBounds properties
@@ -54,7 +84,7 @@ BOOST_AUTO_TEST_CASE(AnnulusBoundsProperties) {
delete pClonedAnnulusBounds;
//
/// Test type() (redundant; already used in constructor confirmation)
- BOOST_CHECK_EQUAL(aBounds.type(), SurfaceBounds::Annulus);
+ BOOST_CHECK_EQUAL(aBounds.type(), SurfaceBounds::eAnnulus);
/// Test positions inside/outside
// - start from cartesian (from test drawing)
@@ -79,21 +109,19 @@ BOOST_AUTO_TEST_CASE(AnnulusBoundsProperties) {
BOOST_CHECK(!aBounds.inside(toStripFrame(outsideXY3), BoundaryCheck(true)));
BOOST_CHECK(!aBounds.inside(toStripFrame(outsideXY4), BoundaryCheck(true)));
- /// Check radial inside
+ // Check radial inside
BOOST_CHECK(!aBounds.insideRadialBounds(0.5));
BOOST_CHECK(aBounds.insideRadialBounds(9.));
BOOST_CHECK(!aBounds.insideRadialBounds(18.));
- /// Test rMin
- BOOST_CHECK_EQUAL(aBounds.rMin(), minRadius);
- //
- /// Test rMax
- BOOST_CHECK_EQUAL(aBounds.rMax(), maxRadius);
- /// Test phiMin
- BOOST_CHECK_EQUAL(aBounds.rMin(), minRadius);
- //
- /// Test phiMax
- BOOST_CHECK_EQUAL(aBounds.rMax(), maxRadius);
+ // Test rMin
+ BOOST_CHECK_EQUAL(aBounds.get(AnnulusBounds::eMinR), minRadius);
+ // Test rMax
+ BOOST_CHECK_EQUAL(aBounds.get(AnnulusBounds::eMaxR), maxRadius);
+ // Test phiMin
+ BOOST_CHECK_EQUAL(aBounds.get(AnnulusBounds::eMinPhiRel), minPhi);
+ // Test phiMax
+ BOOST_CHECK_EQUAL(aBounds.get(AnnulusBounds::eMaxPhiRel), maxPhi);
}
BOOST_AUTO_TEST_SUITE_END()
diff --git a/Tests/UnitTests/Core/Surfaces/CMakeLists.txt b/Tests/UnitTests/Core/Surfaces/CMakeLists.txt
index fcc253d910a9f041da85ad5332e485d8de9d9af9..c16dfed6adb4518024cfa4a4cc4144835007ded3 100644
--- a/Tests/UnitTests/Core/Surfaces/CMakeLists.txt
+++ b/Tests/UnitTests/Core/Surfaces/CMakeLists.txt
@@ -22,4 +22,3 @@ add_unittest(SurfaceBoundsTests SurfaceBoundsTests.cpp)
add_unittest(SurfaceIntersectionTests SurfaceIntersectionTests.cpp)
add_unittest(SurfaceTests SurfaceTests.cpp)
add_unittest(TrapezoidBoundsTests TrapezoidBoundsTests.cpp)
-add_unittest(TriangleBoundsTests TriangleBoundsTests.cpp)
diff --git a/Tests/UnitTests/Core/Surfaces/ConeBoundsTests.cpp b/Tests/UnitTests/Core/Surfaces/ConeBoundsTests.cpp
index 94bb31b14bd3f7bc6627a72f462a23cd5ccfddc8..8b14f8cdc00ac30fb5042af866ec0da90ba8f1b1 100644
--- a/Tests/UnitTests/Core/Surfaces/ConeBoundsTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/ConeBoundsTests.cpp
@@ -30,6 +30,7 @@ namespace Acts {
namespace Test {
BOOST_AUTO_TEST_SUITE(Surfaces)
+
/// Unit test for creating compliant/non-compliant ConeBounds object
BOOST_AUTO_TEST_CASE(ConeBoundsConstruction) {
// test default construction
@@ -39,17 +40,18 @@ BOOST_AUTO_TEST_CASE(ConeBoundsConstruction) {
const bool symmetric(false);
BOOST_TEST_CHECKPOINT("Four parameter constructor (last two at default)");
ConeBounds defaultConeBounds(alpha, symmetric);
- BOOST_CHECK_EQUAL(defaultConeBounds.type(), SurfaceBounds::Cone);
+ BOOST_CHECK_EQUAL(defaultConeBounds.type(), SurfaceBounds::eCone);
BOOST_TEST_CHECKPOINT("Four parameter constructor");
ConeBounds fourParameterConstructed(alpha, symmetric, halfPhi, averagePhi);
- BOOST_CHECK_EQUAL(fourParameterConstructed.type(), SurfaceBounds::Cone);
+ BOOST_CHECK_EQUAL(fourParameterConstructed.type(), SurfaceBounds::eCone);
BOOST_TEST_CHECKPOINT("Five parameter constructor (last two at default)");
ConeBounds defaulted5ParamConeBounds(alpha, zMin, zMax);
- BOOST_CHECK_EQUAL(defaulted5ParamConeBounds.type(), SurfaceBounds::Cone);
+ BOOST_CHECK_EQUAL(defaulted5ParamConeBounds.type(), SurfaceBounds::eCone);
BOOST_TEST_CHECKPOINT("Five parameter constructor)");
ConeBounds fiveParamConstructedConeBounds(alpha, zMin, zMax, halfPhi,
averagePhi);
- BOOST_CHECK_EQUAL(fiveParamConstructedConeBounds.type(), SurfaceBounds::Cone);
+ BOOST_CHECK_EQUAL(fiveParamConstructedConeBounds.type(),
+ SurfaceBounds::eCone);
BOOST_TEST_CHECKPOINT("Copy constructor");
ConeBounds copyConstructedConeBounds(fiveParamConstructedConeBounds);
BOOST_CHECK_EQUAL(copyConstructedConeBounds, fiveParamConstructedConeBounds);
@@ -57,6 +59,42 @@ BOOST_AUTO_TEST_CASE(ConeBoundsConstruction) {
BOOST_CHECK_EQUAL(*pClonedConeBounds, fiveParamConstructedConeBounds);
delete pClonedConeBounds;
}
+
+// Streaning and recreation test
+BOOST_AUTO_TEST_CASE(ConeBoundsRecreation) {
+ double alpha(M_PI / 8.0), zMin(3.), zMax(6.), halfPhi(M_PI / 4.0),
+ averagePhi(0.);
+ // const bool symmetric(false);
+ ConeBounds original(alpha, zMin, zMax, halfPhi, averagePhi);
+ auto valvector = original.values();
+ std::array<double, ConeBounds::eSize> values;
+ std::copy_n(valvector.begin(), ConeBounds::eSize, values.begin());
+ ConeBounds recreated(values);
+ BOOST_CHECK_EQUAL(recreated, original);
+}
+
+// Unit tests for AnnulusBounds exception throwing
+BOOST_AUTO_TEST_CASE(ConeBoundsExceptions) {
+ double alpha(M_PI / 8.0), zMin(3.), zMax(6.), halfPhi(M_PI / 4.0),
+ averagePhi(0.);
+
+ // Exception for opening angle smaller 0
+ BOOST_CHECK_THROW(ConeBounds(-alpha, zMin, zMax, halfPhi, averagePhi),
+ std::logic_error);
+ // Exception for opening angle bigger M_PI
+ BOOST_CHECK_THROW(ConeBounds(M_PI, zMin, zMax, halfPhi, averagePhi),
+ std::logic_error);
+ // Exception for swapped zMin and zMax
+ BOOST_CHECK_THROW(ConeBounds(alpha, zMax, zMin, halfPhi, averagePhi),
+ std::logic_error);
+ // Exception for negative half sector phi
+ BOOST_CHECK_THROW(ConeBounds(alpha, zMin, zMax, -halfPhi, averagePhi),
+ std::logic_error);
+ // Exception for out of range phi positioning
+ BOOST_CHECK_THROW(ConeBounds(alpha, zMin, zMax, halfPhi, 2 * M_PI),
+ std::logic_error);
+}
+
/// Unit tests for properties of ConeBounds object
BOOST_AUTO_TEST_CASE(ConeBoundsProperties) {
double alpha(M_PI / 8.0), zMin(3.), zMax(6.), halfPhi(M_PI / 4.0),
@@ -67,7 +105,7 @@ BOOST_AUTO_TEST_CASE(ConeBoundsProperties) {
ConeBounds coneBoundsObject(alpha, zMin, zMax, halfPhi, averagePhi);
//
/// test for type (redundant)
- BOOST_CHECK_EQUAL(coneBoundsObject.type(), SurfaceBounds::Cone);
+ BOOST_CHECK_EQUAL(coneBoundsObject.type(), SurfaceBounds::eCone);
//
/// test for inside
BOOST_CHECK(!coneBoundsObject.inside(origin));
@@ -81,32 +119,27 @@ BOOST_AUTO_TEST_CASE(ConeBoundsProperties) {
/// test for tanAlpha
CHECK_CLOSE_REL(coneBoundsObject.tanAlpha(), std::tan(alpha), 1e-6);
//
- /// test for sinAlpha
- CHECK_CLOSE_REL(coneBoundsObject.sinAlpha(), std::sin(alpha), 1e-6);
- //
- /// test for cosAlpha
- CHECK_CLOSE_REL(coneBoundsObject.cosAlpha(), std::cos(alpha), 1e-6);
- //
/// test for alpha
- CHECK_CLOSE_REL(coneBoundsObject.alpha(), alpha, 1e-6);
+ CHECK_CLOSE_REL(coneBoundsObject.get(ConeBounds::eAlpha), alpha, 1e-6);
//
/// test for minZ
- CHECK_CLOSE_REL(coneBoundsObject.minZ(), zMin, 1e-6);
+ CHECK_CLOSE_REL(coneBoundsObject.get(ConeBounds::eMinZ), zMin, 1e-6);
//
/// test for maxZ
- CHECK_CLOSE_REL(coneBoundsObject.maxZ(), zMax, 1e-6);
+ CHECK_CLOSE_REL(coneBoundsObject.get(ConeBounds::eMaxZ), zMax, 1e-6);
//
/// test for averagePhi
- CHECK_CLOSE_REL(coneBoundsObject.halfPhiSector(), halfPhi, 1e-6);
- //
+ CHECK_CLOSE_REL(coneBoundsObject.get(ConeBounds::eHalfPhiSector), halfPhi,
+ 1e-6);
/// test for dump
boost::test_tools::output_test_stream dumpOuput;
coneBoundsObject.toStream(dumpOuput);
BOOST_CHECK(dumpOuput.is_equal(
- "Acts::ConeBounds: (tanAlpha, minZ, maxZ, averagePhi, halfPhiSector) = "
- "(0.4142136, 3.0000000, 6.0000000, 0.0000000, 0.7853982)"));
+ "Acts::ConeBounds: (tanAlpha, minZ, maxZ, halfPhiSector, averagePhi) = "
+ "(0.4142136, 3.0000000, 6.0000000, 0.7853982, 0.0000000)"));
}
-/// Unit test for testing ConeBounds assignment
+
+// Unit test for testing ConeBounds assignment
BOOST_AUTO_TEST_CASE(ConeBoundsAssignment) {
double alpha(M_PI / 8.0), zMin(3.), zMax(6.), halfPhi(M_PI / 4.0),
averagePhi(0.);
diff --git a/Tests/UnitTests/Core/Surfaces/ConeSurfaceTests.cpp b/Tests/UnitTests/Core/Surfaces/ConeSurfaceTests.cpp
index 8e563ccffa16767f85ab837ff16b2fe3440b0270..0aa45819af424ed6a6ad50b6514be2c1bd0b30e4 100644
--- a/Tests/UnitTests/Core/Surfaces/ConeSurfaceTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/ConeSurfaceTests.cpp
@@ -134,7 +134,7 @@ BOOST_AUTO_TEST_CASE(ConeSurfaceProperties) {
1e-6);
//
/// Test bounds
- BOOST_CHECK_EQUAL(coneSurfaceObject->bounds().type(), SurfaceBounds::Cone);
+ BOOST_CHECK_EQUAL(coneSurfaceObject->bounds().type(), SurfaceBounds::eCone);
//
/// Test localToGlobal
Vector2D localPosition{1.0, M_PI / 2.0};
diff --git a/Tests/UnitTests/Core/Surfaces/ConvexPolygonBoundsTests.cpp b/Tests/UnitTests/Core/Surfaces/ConvexPolygonBoundsTests.cpp
index 3912bd0bed54cbf1c3dc997098cbb16489299b52..b279d5748e0e477ea4414c6ce4f8e3954fdf31ed 100644
--- a/Tests/UnitTests/Core/Surfaces/ConvexPolygonBoundsTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/ConvexPolygonBoundsTests.cpp
@@ -25,43 +25,34 @@ namespace Test {
BOOST_AUTO_TEST_SUITE(Surfaces)
-BOOST_AUTO_TEST_CASE(convexity_test) {
+BOOST_AUTO_TEST_CASE(ConvexPolygonBoundsConvexity) {
std::vector<vec2> vertices;
vertices = {{0, 0}, {1, 0}, {0.2, 0.2}, {0, 1}};
- { BOOST_CHECK_THROW(poly<4> quad(vertices), AssertionFailureException); }
+ { BOOST_CHECK_THROW(poly<4> quad(vertices), std::logic_error); }
vertices = {{0, 0}, {1, 0}, {0.8, 0.8}, {0, 1}};
{
// wrong number of vertices
BOOST_CHECK_THROW(poly<3> trip{vertices}, AssertionFailureException);
}
- {
- poly<4> quad = {vertices};
- BOOST_CHECK(quad.convex());
- }
+ { poly<4> quad = {vertices}; }
// this one is self intersecting
vertices = {{0, 0}, {1, 0}, {0.5, 1}, {0.9, 1.2}};
- { BOOST_CHECK_THROW(poly<4> quad{vertices}, AssertionFailureException); }
+ { BOOST_CHECK_THROW(poly<4> quad{vertices}, std::logic_error); }
// this one is not
vertices = {{0, 0}, {1, 0}, {0.9, 1.2}, {0.5, 1}};
- {
- poly<4> quad = {vertices};
- BOOST_CHECK(quad.convex());
- }
+ { poly<4> quad = {vertices}; }
vertices = {{0, 0}, {1, 0}, {0.8, 0.5}, {1, 1}, {0, 1}};
- { BOOST_CHECK_THROW(poly<5> pent(vertices), AssertionFailureException); }
+ { BOOST_CHECK_THROW(poly<5> pent(vertices), std::logic_error); }
vertices = {{0, 0}, {1, 0}, {1.1, 0.5}, {1, 1}, {0, 1}};
- {
- poly<5> pent{vertices};
- BOOST_CHECK(pent.convex());
- }
+ { poly<5> pent{vertices}; }
}
-BOOST_AUTO_TEST_CASE(construction_test) {
+BOOST_AUTO_TEST_CASE(ConvexPolygonBoundsConstruction) {
std::vector<vec2> vertices;
// triangle
@@ -103,7 +94,19 @@ BOOST_AUTO_TEST_CASE(construction_test) {
CHECK_CLOSE_ABS(quad.distanceToBoundary({0.3, -0.2}), 0.2, 1e-6);
}
-BOOST_AUTO_TEST_CASE(construction_test_dynamic) {
+BOOST_AUTO_TEST_CASE(ConvexPolygonBoundsRecreation) {
+ // rectangular poly
+ std::vector<vec2> vertices = {{0, 0}, {1, 0}, {0.9, 1.2}, {0.5, 1}};
+ poly<4> original(vertices);
+
+ auto valvector = original.values();
+ std::array<double, poly<4>::eSize> values;
+ std::copy_n(valvector.begin(), poly<4>::eSize, values.begin());
+ poly<4> recreated(values);
+ BOOST_CHECK_EQUAL(original, recreated);
+}
+
+BOOST_AUTO_TEST_CASE(ConvexPolygonBoundsDynamicTest) {
using poly = ConvexPolygonBounds<PolygonDynamic>;
std::vector<vec2> vertices;
diff --git a/Tests/UnitTests/Core/Surfaces/CylinderBoundsTests.cpp b/Tests/UnitTests/Core/Surfaces/CylinderBoundsTests.cpp
index 1f31d8b544bd34b6af1013776df8f4bf21ac20aa..ecbe1c3c6fb283fe00bd0e8b1dafb96132eda679 100644
--- a/Tests/UnitTests/Core/Surfaces/CylinderBoundsTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/CylinderBoundsTests.cpp
@@ -21,22 +21,59 @@ namespace Acts {
namespace Test {
BOOST_AUTO_TEST_SUITE(Surfaces)
/// Unit test for creating compliant/non-compliant CylinderBounds object
+
BOOST_AUTO_TEST_CASE(CylinderBoundsConstruction) {
/// test default construction
// CylinderBounds defaultConstructedCylinderBounds; // deleted
double radius(0.5), halfz(10.), halfphi(M_PI / 2.0), averagePhi(M_PI / 2.0);
BOOST_CHECK_EQUAL(CylinderBounds(radius, halfz).type(),
- SurfaceBounds::Cylinder);
- BOOST_CHECK_EQUAL(CylinderBounds(radius, halfphi, halfz).type(),
- SurfaceBounds::Cylinder);
- BOOST_CHECK_EQUAL(CylinderBounds(radius, averagePhi, halfphi, halfz).type(),
- SurfaceBounds::Cylinder);
+ SurfaceBounds::eCylinder);
+ BOOST_CHECK_EQUAL(CylinderBounds(radius, halfz, halfphi).type(),
+ SurfaceBounds::eCylinder);
+ BOOST_CHECK_EQUAL(CylinderBounds(radius, halfz, halfphi, averagePhi).type(),
+ SurfaceBounds::eCylinder);
//
/// test copy construction;
CylinderBounds cylinderBounds(radius, halfz);
CylinderBounds copyConstructedCylinderBounds(cylinderBounds);
- BOOST_CHECK_EQUAL(copyConstructedCylinderBounds.type(),
- SurfaceBounds::Cylinder);
+ BOOST_CHECK_EQUAL(copyConstructedCylinderBounds, cylinderBounds);
+}
+
+BOOST_AUTO_TEST_CASE(CylinderBoundsRecreation) {
+ /// test default construction
+ // CylinderBounds defaultConstructedCylinderBounds; // deleted
+ double radius(0.5), halfz(10.);
+ // Test construction with radii and default sector
+ auto original = CylinderBounds(radius, halfz);
+ auto valvector = original.values();
+ std::array<double, CylinderBounds::eSize> values;
+ std::copy_n(valvector.begin(), CylinderBounds::eSize, values.begin());
+ CylinderBounds recreated(values);
+ BOOST_CHECK_EQUAL(original, recreated);
+}
+
+BOOST_AUTO_TEST_CASE(CylinderBoundsException) {
+ double radius(0.5), halfz(10.), halfphi(M_PI / 2.0), averagePhi(M_PI / 2.0);
+
+ // Negative radius
+ BOOST_CHECK_THROW(CylinderBounds(-radius, halfz, halfphi, averagePhi),
+ std::logic_error);
+
+ // Negative half length in z
+ BOOST_CHECK_THROW(CylinderBounds(radius, -halfz, halfphi, averagePhi),
+ std::logic_error);
+
+ // Negative half sector in phi
+ BOOST_CHECK_THROW(CylinderBounds(radius, halfz, -halfphi, averagePhi),
+ std::logic_error);
+
+ // Half sector in phi out of bounds
+ BOOST_CHECK_THROW(CylinderBounds(radius, halfz, 4., averagePhi),
+ std::logic_error);
+
+ // Phi position out of bounds
+ BOOST_CHECK_THROW(CylinderBounds(radius, halfz, halfphi, 4.),
+ std::logic_error);
}
/// Unit tests for CylinderBounds properties
@@ -45,18 +82,19 @@ BOOST_AUTO_TEST_CASE(CylinderBoundsProperties) {
// CylinderBounds object of radius 0.5 and halfz 20
double nominalRadius{0.5};
double nominalHalfLength{20.};
- double averagePhi(0.0);
double halfphi(M_PI / 4.0);
+ double averagePhi(0.0);
CylinderBounds cylinderBoundsObject(nominalRadius, nominalHalfLength);
- CylinderBounds cylinderBoundsSegment(nominalRadius, averagePhi, halfphi,
- nominalHalfLength);
+ CylinderBounds cylinderBoundsSegment(nominalRadius, nominalHalfLength,
+ halfphi, averagePhi);
+
/// test for clone
auto pCylinderBoundsClone = cylinderBoundsObject.clone();
BOOST_CHECK_NE(pCylinderBoundsClone, nullptr);
delete pCylinderBoundsClone;
/// test for type()
- BOOST_CHECK_EQUAL(cylinderBoundsObject.type(), SurfaceBounds::Cylinder);
+ BOOST_CHECK_EQUAL(cylinderBoundsObject.type(), SurfaceBounds::eCylinder);
/// test for inside(), 2D coords are r or phi ,z? : needs clarification
const Vector2D origin{0., 0.};
@@ -90,25 +128,28 @@ BOOST_AUTO_TEST_CASE(CylinderBoundsProperties) {
1e-6); // fail
/// test for r()
- CHECK_CLOSE_REL(cylinderBoundsObject.r(), nominalRadius, 1e-6);
+ CHECK_CLOSE_REL(cylinderBoundsObject.get(CylinderBounds::eR), nominalRadius,
+ 1e-6);
/// test for averagePhi
- CHECK_CLOSE_REL(cylinderBoundsObject.averagePhi(), averagePhi, 1e-6);
+ CHECK_CLOSE_REL(cylinderBoundsObject.get(CylinderBounds::eAveragePhi),
+ averagePhi, 1e-6);
/// test for halfPhiSector
- CHECK_CLOSE_REL(cylinderBoundsSegment.halfPhiSector(), halfphi,
+ CHECK_CLOSE_REL(cylinderBoundsSegment.get(CylinderBounds::eHalfPhiSector),
+ halfphi,
1e-6); // fail
/// test for halflengthZ (NOTE: Naming violation)
- CHECK_CLOSE_REL(cylinderBoundsObject.halflengthZ(), nominalHalfLength, 1e-6);
+ CHECK_CLOSE_REL(cylinderBoundsObject.get(CylinderBounds::eHalfLengthZ),
+ nominalHalfLength, 1e-6);
/// test for dump
boost::test_tools::output_test_stream dumpOuput;
cylinderBoundsObject.toStream(dumpOuput);
- BOOST_CHECK(
- dumpOuput.is_equal("Acts::CylinderBounds: (radius, averagePhi, "
- "halfPhiSector, halflengthInZ) = (0.5000000, "
- "0.0000000, 3.1415927, 20.0000000)"));
+ BOOST_CHECK(dumpOuput.is_equal(
+ "Acts::CylinderBounds: (radius, halfLengthZ, halfPhiSector, "
+ "averagePhi) = (0.5000000, 20.0000000, 3.1415927, 0.0000000)"));
}
/// Unit test for testing CylinderBounds assignment
BOOST_AUTO_TEST_CASE(CylinderBoundsAssignment) {
@@ -117,7 +158,8 @@ BOOST_AUTO_TEST_CASE(CylinderBoundsAssignment) {
CylinderBounds cylinderBoundsObject(nominalRadius, nominalHalfLength);
CylinderBounds assignedCylinderBounds(10.5, 6.6);
assignedCylinderBounds = cylinderBoundsObject;
- BOOST_CHECK_EQUAL(assignedCylinderBounds.r(), cylinderBoundsObject.r());
+ BOOST_CHECK_EQUAL(assignedCylinderBounds.get(CylinderBounds::eR),
+ cylinderBoundsObject.get(CylinderBounds::eR));
BOOST_CHECK_EQUAL(assignedCylinderBounds, cylinderBoundsObject);
}
diff --git a/Tests/UnitTests/Core/Surfaces/CylinderSurfaceTests.cpp b/Tests/UnitTests/Core/Surfaces/CylinderSurfaceTests.cpp
index 96648dec4e3d81fc7e6a1e79342bbd9b21968072..b79d87828988589893c89549084aa681a7865902 100644
--- a/Tests/UnitTests/Core/Surfaces/CylinderSurfaceTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/CylinderSurfaceTests.cpp
@@ -49,7 +49,7 @@ BOOST_AUTO_TEST_CASE(CylinderSurfaceConstruction) {
//
/// Constructor with transform pointer, radius, halfZ and halfPhiSector
BOOST_CHECK_EQUAL(Surface::makeShared<CylinderSurface>(pTransform, radius,
- halfPhiSector, halfZ)
+ halfZ, halfPhiSector)
->type(),
Surface::Cylinder);
@@ -149,7 +149,7 @@ BOOST_AUTO_TEST_CASE(CylinderSurfaceProperties) {
//
/// Test bounds
BOOST_CHECK_EQUAL(cylinderSurfaceObject->bounds().type(),
- SurfaceBounds::Cylinder);
+ SurfaceBounds::eCylinder);
//
/// Test localToGlobal
Vector2D localPosition{0., 0.};
@@ -211,7 +211,7 @@ BOOST_AUTO_TEST_CASE(CylinderSurfaceProperties) {
Rotation: colX = (1.000000, 0.000000, 0.000000)\n\
colY = (0.000000, 1.000000, 0.000000)\n\
colZ = (0.000000, 0.000000, 1.000000)\n\
- Bounds : Acts::CylinderBounds: (radius, averagePhi, halfPhiSector, halflengthInZ) = (1.0000000, 0.0000000, 3.1415927, 10.0000000)"));
+ Bounds : Acts::CylinderBounds: (radius, halfLengthZ, halfPhiSector, averagePhi) = (1.0000000, 10.0000000, 3.1415927, 0.0000000)"));
}
BOOST_AUTO_TEST_CASE(EqualityOperators) {
diff --git a/Tests/UnitTests/Core/Surfaces/DiamondBoundsTests.cpp b/Tests/UnitTests/Core/Surfaces/DiamondBoundsTests.cpp
index 20cdcdc8249f2dc1d29dbe3026a6f18e134148f2..e19714c0e72dae3f94c3068c45044de17dc2e40f 100644
--- a/Tests/UnitTests/Core/Surfaces/DiamondBoundsTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/DiamondBoundsTests.cpp
@@ -31,20 +31,20 @@ BOOST_AUTO_TEST_CASE(DiamondBoundsConstruction) {
// DiamondBounds d(minHalfX, midHalfX, maxHalfX, halfY1, halfY2);
BOOST_CHECK_EQUAL(
DiamondBounds(minHalfX, midHalfX, maxHalfX, halfY1, halfY2).type(),
- SurfaceBounds::Diamond);
+ SurfaceBounds::eDiamond);
//
/// Copy constructor
DiamondBounds original(minHalfX, midHalfX, maxHalfX, halfY1, halfY2);
DiamondBounds copied(original);
- BOOST_CHECK_EQUAL(copied.type(), SurfaceBounds::Diamond);
+ BOOST_CHECK_EQUAL(copied.type(), SurfaceBounds::eDiamond);
// invalid inputs
BOOST_CHECK_THROW(
DiamondBounds db(midHalfX, minHalfX, maxHalfX, halfY1, halfY2),
- AssertionFailureException);
+ std::logic_error);
BOOST_CHECK_THROW(
DiamondBounds db(minHalfX, maxHalfX, midHalfX, halfY1, halfY2),
- AssertionFailureException);
+ std::logic_error);
}
/// Unit tests for DiamondBounds properties
BOOST_AUTO_TEST_CASE(DiamondBoundsProperties) {
@@ -57,23 +57,28 @@ BOOST_AUTO_TEST_CASE(DiamondBoundsProperties) {
delete pClonedDiamondBoundsObject;
//
/// Test type() (redundant; already used in constructor confirmation)
- BOOST_CHECK_EQUAL(diamondBoundsObject.type(), SurfaceBounds::Diamond);
+ BOOST_CHECK_EQUAL(diamondBoundsObject.type(), SurfaceBounds::eDiamond);
// //redundant test
//
- /// Test minHalflengthX() NOTE: Naming violation
- BOOST_CHECK_EQUAL(diamondBoundsObject.x1(), minHalfX);
+ /// Test the half length at negative y
+ BOOST_CHECK_EQUAL(diamondBoundsObject.get(DiamondBounds::eHalfLengthXnegY),
+ minHalfX);
//
- /// Test medHalflengthX() NOTE: Naming violation
- BOOST_CHECK_EQUAL(diamondBoundsObject.x2(), midHalfX);
+ /// Test the half length at the x axis
+ BOOST_CHECK_EQUAL(diamondBoundsObject.get(DiamondBounds::eHalfLengthXzeroY),
+ midHalfX);
//
- /// Test maxHalflengthX() NOTE: Naming violation
- BOOST_CHECK_EQUAL(diamondBoundsObject.x3(), maxHalfX);
+ /// Test the half length at positive y
+ BOOST_CHECK_EQUAL(diamondBoundsObject.get(DiamondBounds::eHalfLengthXposY),
+ maxHalfX);
//
- /// Test halflengthY1() NOTE: Naming violation
- BOOST_CHECK_EQUAL(diamondBoundsObject.y1(), halfY1);
+ /// Test half length into the negative side
+ BOOST_CHECK_EQUAL(diamondBoundsObject.get(DiamondBounds::eHalfLengthYneg),
+ halfY1);
//
- /// Test halflengthY2() NOTE: Naming violation
- BOOST_CHECK_EQUAL(diamondBoundsObject.y2(), halfY2);
+ /// Test half length into the positive side
+ BOOST_CHECK_EQUAL(diamondBoundsObject.get(DiamondBounds::eHalfLengthYpos),
+ halfY2);
//
/// Test boundingBox
BOOST_CHECK_EQUAL(diamondBoundsObject.boundingBox(),
@@ -98,8 +103,8 @@ BOOST_AUTO_TEST_CASE(DiamondBoundsProperties) {
boost::test_tools::output_test_stream dumpOuput;
diamondBoundsObject.toStream(dumpOuput);
BOOST_CHECK(
- dumpOuput.is_equal("Acts::DiamondBounds: (x1, x2, "
- "x3, y1, y2 ) = (10.0000000, "
+ dumpOuput.is_equal("Acts::DiamondBounds: (halfXatYneg, halfXatYzero, "
+ "halfXatYpos, halfYneg, halfYpos) = (10.0000000, "
"50.0000000, 30.0000000, 10.0000000, 20.0000000)"));
//
/// Test inside
@@ -129,7 +134,8 @@ BOOST_AUTO_TEST_CASE(DiamondBoundsAssignment) {
similarlyConstructeDiamondBoundsObject);
//
/// Test assignment
- DiamondBounds assignedDiamondBoundsObject(0, 0, 0, 0, 0); // invalid
+ DiamondBounds assignedDiamondBoundsObject(
+ 2 * minHalfX, 2 * midHalfX, 2 * maxHalfX, 2 * halfY1, 2 * halfY2);
// object, in some sense
assignedDiamondBoundsObject = diamondBoundsObject;
BOOST_CHECK_EQUAL(assignedDiamondBoundsObject, diamondBoundsObject);
diff --git a/Tests/UnitTests/Core/Surfaces/DiscSurfaceTests.cpp b/Tests/UnitTests/Core/Surfaces/DiscSurfaceTests.cpp
index 4557d176e29938b7bf5e23a880fa2e89068f9f13..7317ab01fa2053d51477519f99a2a72587e0d5ed 100644
--- a/Tests/UnitTests/Core/Surfaces/DiscSurfaceTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/DiscSurfaceTests.cpp
@@ -99,7 +99,7 @@ BOOST_AUTO_TEST_CASE(DiscSurface_properties_test, *utf::expected_failures(2)) {
origin3D);
//
/// Test bounds
- BOOST_CHECK_EQUAL(discSurfaceObject->bounds().type(), SurfaceBounds::Disc);
+ BOOST_CHECK_EQUAL(discSurfaceObject->bounds().type(), SurfaceBounds::eDisc);
//
Vector3D ignoredMomentum{0., 0., 0.};
/// Test isOnSurface()
@@ -136,9 +136,9 @@ BOOST_AUTO_TEST_CASE(DiscSurface_properties_test, *utf::expected_failures(2)) {
BOOST_CHECK(discSurfaceObject->globalToLocal(
tgContext, point3DNotInSector, ignoredMomentum, returnedLocalPosition));
//
- Vector3D pointOutsideRadius{0.0, 100., 0};
+ Vector3D pointOutsideR{0.0, 100., 0};
BOOST_CHECK(discSurfaceObject->globalToLocal(
- tgContext, pointOutsideRadius, ignoredMomentum, returnedLocalPosition));
+ tgContext, pointOutsideR, ignoredMomentum, returnedLocalPosition));
//
/// Test localPolarToCartesian
Vector2D rPhi1_1{std::sqrt(2.), M_PI / 4.};
diff --git a/Tests/UnitTests/Core/Surfaces/DiscTrapezoidBoundsTests.cpp b/Tests/UnitTests/Core/Surfaces/DiscTrapezoidBoundsTests.cpp
index fec8a40f19eb02760ef368deb0f040c504eb163b..b4384c3bb0a50cd31ead9ba42a36a1bd200acbe7 100644
--- a/Tests/UnitTests/Core/Surfaces/DiscTrapezoidBoundsTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/DiscTrapezoidBoundsTests.cpp
@@ -20,6 +20,7 @@ namespace Acts {
namespace Test {
BOOST_AUTO_TEST_SUITE(Surfaces)
+
/// Unit tests for DiscTrapezoidBounds constrcuctors
BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsConstruction) {
double minHalfX(1.0), maxHalfX(5.0), rMin(2.0), rMax(6.0), averagePhi(0.0),
@@ -31,18 +32,73 @@ BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsConstruction) {
/// Test construction with dimensions and default stereo
BOOST_CHECK_EQUAL(
DiscTrapezoidBounds(minHalfX, maxHalfX, rMin, rMax, averagePhi).type(),
- SurfaceBounds::DiscTrapezoidal);
+ SurfaceBounds::eDiscTrapezoid);
//
/// Test construction with all dimensions
BOOST_CHECK_EQUAL(
DiscTrapezoidBounds(minHalfX, maxHalfX, rMin, rMax, averagePhi, stereo)
.type(),
- SurfaceBounds::DiscTrapezoidal);
+ SurfaceBounds::eDiscTrapezoid);
//
/// Copy constructor
DiscTrapezoidBounds original(minHalfX, maxHalfX, rMin, rMax, averagePhi);
DiscTrapezoidBounds copied(original);
- BOOST_CHECK_EQUAL(copied.type(), SurfaceBounds::DiscTrapezoidal);
+ BOOST_CHECK_EQUAL(copied.type(), SurfaceBounds::eDiscTrapezoid);
+}
+
+// Streaning and recreation test
+BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsRecreation) {
+ double minHalfX(1.0), maxHalfX(5.0), rMin(2.0), rMax(6.0), averagePhi(0.0),
+ stereo(0.1);
+
+ DiscTrapezoidBounds original(minHalfX, maxHalfX, rMin, rMax, averagePhi,
+ stereo);
+ auto valvector = original.values();
+ std::array<double, DiscTrapezoidBounds::eSize> values;
+ std::copy_n(valvector.begin(), DiscTrapezoidBounds::eSize, values.begin());
+ DiscTrapezoidBounds recreated(values);
+ BOOST_CHECK_EQUAL(recreated, original);
+}
+
+// Unit tests for AnnulusBounds exception throwing
+BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsExceptions) {
+ double minHalfX(1.0), maxHalfX(5.0), rMin(2.0), rMax(6.0), averagePhi(0.0),
+ stereo(0.1);
+
+ // Exception for opening neg min half x < 0
+ BOOST_CHECK_THROW(
+ DiscTrapezoidBounds(-minHalfX, maxHalfX, rMin, rMax, averagePhi, stereo),
+ std::logic_error);
+
+ // Exception for opening neg max half x < 0
+ BOOST_CHECK_THROW(
+ DiscTrapezoidBounds(minHalfX, -maxHalfX, rMin, rMax, averagePhi, stereo),
+ std::logic_error);
+
+ // Exception for opening neg min and max half x < 0
+ BOOST_CHECK_THROW(
+ DiscTrapezoidBounds(-minHalfX, -maxHalfX, rMin, rMax, averagePhi, stereo),
+ std::logic_error);
+
+ // Exception for opening neg r min
+ BOOST_CHECK_THROW(
+ DiscTrapezoidBounds(minHalfX, maxHalfX, -rMin, rMax, averagePhi, stereo),
+ std::logic_error);
+
+ // Exception for opening neg r max
+ BOOST_CHECK_THROW(
+ DiscTrapezoidBounds(minHalfX, maxHalfX, rMin, -rMax, averagePhi, stereo),
+ std::logic_error);
+
+ // Exception for opening neg r min and r max
+ BOOST_CHECK_THROW(
+ DiscTrapezoidBounds(minHalfX, maxHalfX, -rMin, -rMax, averagePhi, stereo),
+ std::logic_error);
+
+ // Exception for out of bound average phi
+ BOOST_CHECK_THROW(
+ DiscTrapezoidBounds(minHalfX, maxHalfX, rMin, rMax, 4., stereo),
+ std::logic_error);
}
/// Unit tests for DiscTrapezoidBounds properties
@@ -58,7 +114,7 @@ BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsProperties) {
//
/// Test type() (redundant; already used in constructor confirmation)
BOOST_CHECK_EQUAL(DiscTrapezoidBoundsObject.type(),
- SurfaceBounds::DiscTrapezoidal);
+ SurfaceBounds::eDiscTrapezoid);
//
/// Test distanceToBoundary
Vector2D origin(0., 0.);
@@ -73,8 +129,9 @@ BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsProperties) {
boost::test_tools::output_test_stream dumpOuput;
DiscTrapezoidBoundsObject.toStream(dumpOuput);
BOOST_CHECK(dumpOuput.is_equal(
- "Acts::DiscTrapezoidBounds: (innerRadius, outerRadius, hMinX, "
- "hMaxX, hlengthY, hPhiSector, averagePhi, rCenter, stereo) = "
+ "Acts::DiscTrapezoidBounds: (innerRadius, outerRadius, halfLengthXminR, "
+ "halfLengthXmaxR, halfLengthY, halfPhiSector, averagePhi, rCenter, "
+ "stereo) = "
"(2.0000000, 6.0000000, 1.0000000, 5.0000000, 0.7922870, 0.9851108, "
"0.0000000, 2.5243378, 0.0000000)"));
//
@@ -89,7 +146,8 @@ BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsProperties) {
CHECK_CLOSE_REL(DiscTrapezoidBoundsObject.rMax(), rMax, 1e-6);
//
/// Test averagePhi
- CHECK_SMALL(DiscTrapezoidBoundsObject.averagePhi(), 1e-9);
+ CHECK_SMALL(DiscTrapezoidBoundsObject.get(DiscTrapezoidBounds::eAveragePhi),
+ 1e-9);
//
/// Test rCenter (redundant; not configurable)
CHECK_CLOSE_REL(DiscTrapezoidBoundsObject.rCenter(), 2.524337798, 1e-6);
@@ -98,13 +156,17 @@ BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsProperties) {
CHECK_SMALL(DiscTrapezoidBoundsObject.stereo(), 1e-6);
//
/// Test minHalflengthX
- CHECK_CLOSE_REL(DiscTrapezoidBoundsObject.minHalflengthX(), minHalfX, 1e-6);
+ CHECK_CLOSE_REL(
+ DiscTrapezoidBoundsObject.get(DiscTrapezoidBounds::eHalfLengthXminR),
+ minHalfX, 1e-6);
//
/// Test maxHalflengthX
- CHECK_CLOSE_REL(DiscTrapezoidBoundsObject.maxHalflengthX(), maxHalfX, 1e-6);
+ CHECK_CLOSE_REL(
+ DiscTrapezoidBoundsObject.get(DiscTrapezoidBounds::eHalfLengthXmaxR),
+ maxHalfX, 1e-6);
//
/// Test halflengthY
- CHECK_CLOSE_REL(DiscTrapezoidBoundsObject.halflengthY(), 0.792286991, 1e-6);
+ CHECK_CLOSE_REL(DiscTrapezoidBoundsObject.halfLengthY(), 0.792286991, 1e-6);
}
/// Unit test for testing DiscTrapezoidBounds assignment
BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsAssignment) {
@@ -115,8 +177,8 @@ BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsAssignment) {
// operator == not implemented in this class
//
/// Test assignment
- DiscTrapezoidBounds assignedDiscTrapezoidBoundsObject(2.1, 6.6, 3.4, 4.2,
- 33.);
+ DiscTrapezoidBounds assignedDiscTrapezoidBoundsObject(2.1, 6.6, 3.4, 4.2, 0.3,
+ 0.);
assignedDiscTrapezoidBoundsObject = DiscTrapezoidBoundsObject;
BOOST_CHECK_EQUAL(assignedDiscTrapezoidBoundsObject,
DiscTrapezoidBoundsObject);
diff --git a/Tests/UnitTests/Core/Surfaces/DiscTrapezoidalBoundsTests.cpp b/Tests/UnitTests/Core/Surfaces/DiscTrapezoidalBoundsTests.cpp
deleted file mode 100644
index 82deb4d79d28fb46213abda4777f73bcf82d69d8..0000000000000000000000000000000000000000
--- a/Tests/UnitTests/Core/Surfaces/DiscTrapezoidalBoundsTests.cpp
+++ /dev/null
@@ -1,129 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 2017-2018 CERN for the benefit of the Acts project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include <boost/test/data/test_case.hpp>
-#include <boost/test/tools/output_test_stream.hpp>
-#include <boost/test/unit_test.hpp>
-
-#include <limits>
-
-#include "Acts/Surfaces/DiscTrapezoidBounds.hpp"
-#include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
-#include "Acts/Utilities/Definitions.hpp"
-
-namespace Acts {
-
-namespace Test {
-BOOST_AUTO_TEST_SUITE(Surfaces)
-/// Unit tests for DiscTrapezoidBounds constrcuctors
-BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsConstruction) {
- double minHalfX(1.0), maxHalfX(5.0), rMin(2.0), rMax(6.0), averagePhi(0.0),
- stereo(0.1);
- // test default construction
- // DiscTrapezoidBounds defaultConstructedDiscTrapezoidBounds; should be
- // deleted
- //
- /// Test construction with dimensions and default stereo
- BOOST_CHECK_EQUAL(
- DiscTrapezoidBounds(minHalfX, maxHalfX, rMin, rMax, averagePhi).type(),
- SurfaceBounds::DiscTrapezoidal);
- //
- /// Test construction with all dimensions
- BOOST_CHECK_EQUAL(
- DiscTrapezoidBounds(minHalfX, maxHalfX, rMin, rMax, averagePhi, stereo)
- .type(),
- SurfaceBounds::DiscTrapezoidal);
- //
- /// Copy constructor
- DiscTrapezoidBounds original(minHalfX, maxHalfX, rMin, rMax, averagePhi);
- DiscTrapezoidBounds copied(original);
- BOOST_CHECK_EQUAL(copied.type(), SurfaceBounds::DiscTrapezoidal);
-}
-
-/// Unit tests for DiscTrapezoidBounds properties
-BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsProperties) {
- double minHalfX(1.0), maxHalfX(5.0), rMin(2.0), rMax(6.0),
- averagePhi(0.0) /*, stereo(0.1)*/;
- /// Test clone
- DiscTrapezoidBounds discTrapezoidBoundsObject(minHalfX, maxHalfX, rMin, rMax,
- averagePhi);
- auto pClonedDiscTrapezoidBounds = discTrapezoidBoundsObject.clone();
- BOOST_CHECK_NE(pClonedDiscTrapezoidBounds, nullptr);
- delete pClonedDiscTrapezoidBounds;
- //
- /// Test type() (redundant; already used in constructor confirmation)
- BOOST_CHECK_EQUAL(discTrapezoidBoundsObject.type(),
- SurfaceBounds::DiscTrapezoidal);
- //
- /// Test distanceToBoundary
- Vector2D origin(0., 0.);
- Vector2D outside(30., 0.);
- Vector2D inSurface(2., 0.0);
- CHECK_CLOSE_REL(discTrapezoidBoundsObject.distanceToBoundary(origin), 2.0,
- 1e-6);
- CHECK_CLOSE_REL(discTrapezoidBoundsObject.distanceToBoundary(outside), 24.0,
- 1e-6);
- //
- /// Test dump
- boost::test_tools::output_test_stream dumpOuput;
- discTrapezoidBoundsObject.toStream(dumpOuput);
- BOOST_CHECK(dumpOuput.is_equal(
- "Acts::DiscTrapezoidBounds: (innerRadius, outerRadius, hMinX, "
- "hMaxX, hlengthY, hPhiSector, averagePhi, rCenter, stereo) = "
- "(2.0000000, 6.0000000, 1.0000000, 5.0000000, 0.7922870, 0.9851108, "
- "0.0000000, 2.5243378, 0.0000000)"));
- //
- /// Test inside
- BOOST_CHECK(discTrapezoidBoundsObject.inside(inSurface, BoundaryCheck(true)));
- BOOST_CHECK(!discTrapezoidBoundsObject.inside(outside, BoundaryCheck(true)));
- //
- /// Test rMin
- CHECK_CLOSE_REL(discTrapezoidBoundsObject.rMin(), rMin, 1e-6);
- //
- /// Test rMax
- CHECK_CLOSE_REL(discTrapezoidBoundsObject.rMax(), rMax, 1e-6);
- //
- /// Test averagePhi
- CHECK_SMALL(discTrapezoidBoundsObject.averagePhi(), 1e-9);
- //
- /// Test rCenter (redundant; not configurable)
- CHECK_CLOSE_REL(discTrapezoidBoundsObject.rCenter(), 2.524337798, 1e-6);
- //
- /// Test halfPhiSector (redundant; not configurable)
- CHECK_SMALL(discTrapezoidBoundsObject.stereo(), 1e-6);
- //
- /// Test minHalflengthX
- CHECK_CLOSE_REL(discTrapezoidBoundsObject.minHalflengthX(), minHalfX, 1e-6);
- //
- /// Test maxHalflengthX
- CHECK_CLOSE_REL(discTrapezoidBoundsObject.maxHalflengthX(), maxHalfX, 1e-6);
- //
- /// Test halflengthY
- CHECK_CLOSE_REL(discTrapezoidBoundsObject.halflengthY(), 0.792286991, 1e-6);
-}
-/// Unit test for testing DiscTrapezoidBounds assignment
-BOOST_AUTO_TEST_CASE(DiscTrapezoidBoundsAssignment) {
- double minHalfX(1.0), maxHalfX(5.0), rMin(2.0), rMax(6.0), averagePhi(0.0),
- stereo(0.1);
- DiscTrapezoidBounds discTrapezoidBoundsObject(minHalfX, maxHalfX, rMin, rMax,
- averagePhi, stereo);
- // operator == not implemented in this class
- //
- /// Test assignment
- DiscTrapezoidBounds assignedDiscTrapezoidBoundsObject(2.1, 6.6, 3.4, 4.2,
- 33.);
- assignedDiscTrapezoidBoundsObject = discTrapezoidBoundsObject;
- BOOST_CHECK_EQUAL(assignedDiscTrapezoidBoundsObject,
- discTrapezoidBoundsObject);
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-} // namespace Test
-
-} // namespace Acts
diff --git a/Tests/UnitTests/Core/Surfaces/EllipseBoundsTests.cpp b/Tests/UnitTests/Core/Surfaces/EllipseBoundsTests.cpp
index a6b384ceac230db0b25ba43eb8d6e4e536da0ecb..9dc42f1821100ac6165385fe6e30f2613fcb4ffb 100644
--- a/Tests/UnitTests/Core/Surfaces/EllipseBoundsTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/EllipseBoundsTests.cpp
@@ -20,66 +20,128 @@ namespace Acts {
namespace Test {
BOOST_AUTO_TEST_SUITE(Surfaces)
+
/// Unit test for creating compliant/non-compliant EllipseBounds object
BOOST_AUTO_TEST_CASE(EllipseBoundsConstruction) {
- double minRad1(10.), minRad2(15.), maxRad1(15.), maxRad2(20.), averagePhi(0.),
- phiSector(M_PI / 2.);
+ double minRad0(10.), maxRad0(15.), minRad1(25.), maxRad1(30.),
+ phiSector(M_PI / 2.), averagePhi(0.);
// test default construction
// EllipseBounds defaultConstructedEllipseBounds; //deleted
//
/// Test construction with dimensions
BOOST_CHECK_EQUAL(
- EllipseBounds(minRad1, minRad2, maxRad1, maxRad2, averagePhi, phiSector)
+ EllipseBounds(minRad0, maxRad0, minRad1, maxRad1, phiSector, averagePhi)
.type(),
- SurfaceBounds::Ellipse);
+ SurfaceBounds::eEllipse);
//
/// Copy constructor
- EllipseBounds original(minRad1, minRad2, maxRad1, maxRad2, averagePhi,
- phiSector);
+ EllipseBounds original(minRad0, maxRad0, minRad1, maxRad1, phiSector,
+ averagePhi);
EllipseBounds copied(original);
- BOOST_CHECK_EQUAL(copied.type(), SurfaceBounds::Ellipse);
+ BOOST_CHECK_EQUAL(copied, original);
+}
+
+// Streaning and recreation test
+BOOST_AUTO_TEST_CASE(EllipseBoundsRecreation) {
+ double minRad0(10.), maxRad0(15.), minRad1(25.), maxRad1(30.),
+ phiSector(M_PI / 2.), averagePhi(0.);
+ // const bool symmetric(false);
+ EllipseBounds original(minRad0, maxRad0, minRad1, maxRad1, phiSector,
+ averagePhi);
+ auto valvector = original.values();
+ std::array<double, EllipseBounds::eSize> values;
+ std::copy_n(valvector.begin(), EllipseBounds::eSize, values.begin());
+ EllipseBounds recreated(values);
+ BOOST_CHECK_EQUAL(recreated, original);
+}
+
+// Unit tests for AnnulusBounds exception throwing
+BOOST_AUTO_TEST_CASE(ConeBoundsExceptions) {
+ double minRad0(10.), maxRad0(15.), minRad1(25.), maxRad1(30.),
+ phiSector(M_PI / 2.), averagePhi(0.);
+ // Exception for opening minR0 < 0
+ BOOST_CHECK_THROW(
+ EllipseBounds(-minRad0, maxRad0, minRad1, maxRad1, phiSector, averagePhi),
+ std::logic_error);
+ // Exception for opening maxR0 < 0
+ BOOST_CHECK_THROW(
+ EllipseBounds(minRad0, -maxRad0, minRad1, maxRad1, phiSector, averagePhi),
+ std::logic_error);
+ // Exception for opening minR0 and maxR0 < 0
+ BOOST_CHECK_THROW(EllipseBounds(-minRad0, -maxRad0, minRad1, maxRad1,
+ phiSector, averagePhi),
+ std::logic_error);
+ // Exception for swapped minR0/maxR0
+ BOOST_CHECK_THROW(
+ EllipseBounds(maxRad0, minRad0, minRad1, maxRad1, phiSector, averagePhi),
+ std::logic_error);
+ // Exception for opening minR1 < 0
+ BOOST_CHECK_THROW(
+ EllipseBounds(minRad0, maxRad0, -minRad1, maxRad1, phiSector, averagePhi),
+ std::logic_error);
+ // Exception for opening maxR1 < 0
+ BOOST_CHECK_THROW(
+ EllipseBounds(minRad0, maxRad0, minRad1, -maxRad1, phiSector, averagePhi),
+ std::logic_error);
+ // Exception for opening maxR1 < 0
+ BOOST_CHECK_THROW(EllipseBounds(minRad0, maxRad0, -minRad1, -maxRad1,
+ phiSector, averagePhi),
+ std::logic_error);
+ // Exception for swapped minR1/maxR1
+ BOOST_CHECK_THROW(
+ EllipseBounds(minRad0, maxRad0, maxRad1, minRad1, phiSector, averagePhi),
+ std::logic_error);
+ // Exception for negative phiSector
+ BOOST_CHECK_THROW(
+ EllipseBounds(minRad0, maxRad0, minRad1, maxRad1, -phiSector, averagePhi),
+ std::logic_error);
+ // Exception for average phi out of bound
+ BOOST_CHECK_THROW(
+ EllipseBounds(minRad0, maxRad0, minRad1, maxRad1, phiSector, 4.),
+ std::logic_error);
}
/// Unit tests for EllipseBounds properties
BOOST_AUTO_TEST_CASE_EXPECTED_FAILURES(CylinderBoundsProperties, 1)
BOOST_AUTO_TEST_CASE(EllipseBoundsProperties) {
- double minRad1(10.), minRad2(15.), maxRad1(15.), maxRad2(20.), averagePhi(0.),
+ double minRad0(10.), minRad1(15.), maxRad0(15.), maxRad1(20.), averagePhi(0.),
phiSector(M_PI / 2.);
/// Test clone
- EllipseBounds ellipseBoundsObject(minRad1, minRad2, maxRad1, maxRad2,
- averagePhi, phiSector);
+ EllipseBounds ellipseBoundsObject(minRad0, maxRad0, minRad1, maxRad1,
+ phiSector, averagePhi);
auto pClonedEllipseBoundsObject = ellipseBoundsObject.clone();
BOOST_CHECK_NE(pClonedEllipseBoundsObject, nullptr);
delete pClonedEllipseBoundsObject;
//
/// Test type() (redundant; already used in constructor confirmation)
- BOOST_CHECK_EQUAL(ellipseBoundsObject.type(), SurfaceBounds::Ellipse);
+ BOOST_CHECK_EQUAL(ellipseBoundsObject.type(), SurfaceBounds::eEllipse);
//
// clone already tested
//
/// Test distanceToBoundary
Vector2D origin(0., 0.);
- Vector2D outsideBy10(0., 30.);
+ Vector2D outsideBy15(0., 30.);
Vector2D inRectangle(17., 11.);
CHECK_CLOSE_REL(ellipseBoundsObject.distanceToBoundary(origin), 10.,
1e-6); // makes sense
- CHECK_CLOSE_REL(ellipseBoundsObject.distanceToBoundary(outsideBy10), 10.,
+ CHECK_CLOSE_REL(ellipseBoundsObject.distanceToBoundary(outsideBy15), 15.,
1e-6); // fails, not clear why
//
/// Test rMinX
- BOOST_CHECK_EQUAL(ellipseBoundsObject.rMinX(), minRad1);
+ BOOST_CHECK_EQUAL(ellipseBoundsObject.get(EllipseBounds::eMinR0), minRad0);
//
/// Test rMinY
- BOOST_CHECK_EQUAL(ellipseBoundsObject.rMinY(), minRad2);
+ BOOST_CHECK_EQUAL(ellipseBoundsObject.get(EllipseBounds::eMinR1), minRad1);
//
/// Test rMaxX
- BOOST_CHECK_EQUAL(ellipseBoundsObject.rMaxX(), maxRad1);
+ BOOST_CHECK_EQUAL(ellipseBoundsObject.get(EllipseBounds::eMaxR0), maxRad0);
//
/// Test rMaxY
- BOOST_CHECK_EQUAL(ellipseBoundsObject.rMaxY(), maxRad2);
+ BOOST_CHECK_EQUAL(ellipseBoundsObject.get(EllipseBounds::eMaxR1), maxRad1);
//
/// Test averagePhi
- BOOST_CHECK_EQUAL(ellipseBoundsObject.averagePhi(), averagePhi);
+ BOOST_CHECK_EQUAL(ellipseBoundsObject.get(EllipseBounds::eAveragePhi),
+ averagePhi);
//
/// Test vertices
// std::vector<Vector2D> expectedVertices{{15, 0}, {0, 20}, {-15, 0}, {0,
@@ -94,29 +156,31 @@ BOOST_AUTO_TEST_CASE(EllipseBoundsProperties) {
RectangleBounds(15., 20.));
//
/// Test halfPhiSector
- BOOST_CHECK_EQUAL(ellipseBoundsObject.halfPhiSector(), M_PI / 2.);
+ BOOST_CHECK_EQUAL(ellipseBoundsObject.get(EllipseBounds::eHalfPhiSector),
+ M_PI / 2.);
//
/// Test dump
boost::test_tools::output_test_stream dumpOuput;
ellipseBoundsObject.toStream(dumpOuput);
BOOST_CHECK(dumpOuput.is_equal(
- "Acts::EllipseBounds: (innerRadiusX, innerRadiusY, outerRadiusX, "
- "outerRadiusY, hPhiSector) = (10.0000000, 15.0000000, 15.0000000, "
- "20.0000000, 0.0000000, 1.5707963)"));
+ "Acts::EllipseBounds: (innerRadius0, outerRadius0, innerRadius1, "
+ "outerRadius1, hPhiSector, averagePhi) = (10.0000000, 15.0000000, "
+ "15.0000000, "
+ "20.0000000, 0.0000000, 1.5707963, 0.0000000)"));
//
/// Test inside
BOOST_CHECK(!ellipseBoundsObject.inside(inRectangle, BoundaryCheck(true)));
// dont understand why this is so:
- BOOST_CHECK(!ellipseBoundsObject.inside(outsideBy10, BoundaryCheck(true)));
+ BOOST_CHECK(!ellipseBoundsObject.inside(outsideBy15, BoundaryCheck(true)));
}
/// Unit test for testing EllipseBounds assignment
BOOST_AUTO_TEST_CASE(EllipseBoundsAssignment) {
- double minRad1(10.), minRad2(15.), maxRad1(15.), maxRad2(20.), averagePhi(0.),
+ double minRad0(10.), minRad1(15.), maxRad0(15.), maxRad1(20.), averagePhi(0.),
phiSector(M_PI / 2.);
- EllipseBounds ellipseBoundsObject(minRad1, minRad2, maxRad1, maxRad2,
+ EllipseBounds ellipseBoundsObject(minRad0, minRad1, maxRad0, maxRad1,
averagePhi, phiSector);
EllipseBounds similarlyConstructeEllipseBoundsObject(
- minRad1, minRad2, maxRad1, maxRad2, averagePhi, phiSector);
+ minRad0, minRad1, maxRad0, maxRad1, averagePhi, phiSector);
/// Test operator ==
BOOST_CHECK_EQUAL(ellipseBoundsObject,
similarlyConstructeEllipseBoundsObject);
diff --git a/Tests/UnitTests/Core/Surfaces/InfiniteBoundsTests.cpp b/Tests/UnitTests/Core/Surfaces/InfiniteBoundsTests.cpp
index 79db24051f65da487b1cab1543249ea9a59ec784..35abc70db414bdb5531f3786a3f1c86443314482 100644
--- a/Tests/UnitTests/Core/Surfaces/InfiniteBoundsTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/InfiniteBoundsTests.cpp
@@ -20,17 +20,17 @@ BOOST_AUTO_TEST_SUITE(Surfaces)
/// Unit test for creating compliant/non-compliant InfiniteBounds object
BOOST_AUTO_TEST_CASE(InfiniteBoundsConstruction) {
InfiniteBounds u;
- BOOST_CHECK_EQUAL(u.type(), SurfaceBounds::Boundless);
+ BOOST_CHECK_EQUAL(u.type(), SurfaceBounds::eBoundless);
// InfiniteBounds s(1); // would act as size_t cast to InfiniteBounds
// InfiniteBounds t(s);
InfiniteBounds v(u); // implicit
- BOOST_CHECK_EQUAL(v.type(), SurfaceBounds::Boundless);
+ BOOST_CHECK_EQUAL(v.type(), SurfaceBounds::eBoundless);
}
/// Unit tests for InfiniteBounds properties
BOOST_AUTO_TEST_CASE(InfiniteBoundsProperties) {
InfiniteBounds infiniteBoundsObject;
/// test for type()
- BOOST_CHECK_EQUAL(infiniteBoundsObject.type(), SurfaceBounds::Boundless);
+ BOOST_CHECK_EQUAL(infiniteBoundsObject.type(), SurfaceBounds::eBoundless);
/// test for inside()
const Vector2D anyVector{0., 1.};
diff --git a/Tests/UnitTests/Core/Surfaces/LineBoundsTests.cpp b/Tests/UnitTests/Core/Surfaces/LineBoundsTests.cpp
index 25c3c7f215e5a7f0197f989ff66f39d8ca1b1ea7..95983f4cbc26799ac25becdd12c9bfdf8deaf0d4 100644
--- a/Tests/UnitTests/Core/Surfaces/LineBoundsTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/LineBoundsTests.cpp
@@ -20,18 +20,50 @@ namespace Test {
BOOST_AUTO_TEST_SUITE(Surfaces)
/// Unit test for creating compliant/non-compliant LineBounds object
BOOST_AUTO_TEST_CASE(LineBoundsConstruction) {
- /// test default construction
- LineBounds defaultConstructedLineBounds; // implicit
- BOOST_CHECK_EQUAL(defaultConstructedLineBounds.type(), SurfaceBounds::Line);
/// test LineBounds(double, double)
double radius(0.5), halfz(10.);
- BOOST_CHECK_EQUAL(LineBounds(radius, halfz).type(), SurfaceBounds::Line);
- //
- LineBounds s(1); // would act as size_t cast to LineBounds
+ LineBounds lineBounds(radius, halfz);
+ BOOST_CHECK_EQUAL(lineBounds.type(), SurfaceBounds::eLine);
/// test copy construction;
- LineBounds copyConstructedLineBounds(
- defaultConstructedLineBounds); // implicit
- BOOST_CHECK_EQUAL(copyConstructedLineBounds.type(), SurfaceBounds::Line);
+ LineBounds copyConstructedLineBounds(lineBounds); // implicit
+ BOOST_CHECK_EQUAL(copyConstructedLineBounds.type(), SurfaceBounds::eLine);
+}
+
+/// Unit test for testing LineBounds recreation from streaming
+BOOST_AUTO_TEST_CASE(LineBoundsRecreation) {
+ double nominalRadius{0.5};
+ double nominalHalfLength{20.};
+ LineBounds original(nominalRadius, nominalHalfLength);
+ LineBounds recreated(original);
+ auto valvector = original.values();
+ std::array<double, LineBounds::eSize> values;
+ std::copy_n(valvector.begin(), LineBounds::eSize, values.begin());
+ BOOST_CHECK_EQUAL(original, recreated);
+}
+
+/// Unit test for testing LineBounds exceptions
+BOOST_AUTO_TEST_CASE(LineBoundsExceptions) {
+ double nominalRadius{0.5};
+ double nominalHalfLength{20.};
+ // Negative radius
+ BOOST_CHECK_THROW(LineBounds(-nominalRadius, nominalHalfLength),
+ std::logic_error);
+ // Negative half length
+ BOOST_CHECK_THROW(LineBounds(nominalRadius, -nominalHalfLength),
+ std::logic_error);
+
+ // Negative radius and half length
+ BOOST_CHECK_THROW(LineBounds(-nominalRadius, -nominalHalfLength),
+ std::logic_error);
+}
+
+/// Unit test for testing LineBounds assignment
+BOOST_AUTO_TEST_CASE(LineBoundsAssignment) {
+ double nominalRadius{0.5};
+ double nominalHalfLength{20.};
+ LineBounds lineBoundsObject(nominalRadius, nominalHalfLength);
+ LineBounds assignedLineBounds = lineBoundsObject;
+ BOOST_CHECK_EQUAL(assignedLineBounds, lineBoundsObject);
}
/// Unit tests for LineBounds properties
@@ -47,7 +79,7 @@ BOOST_AUTO_TEST_CASE(LineBoundsProperties) {
delete pLineBoundsClone;
/// test for type()
- BOOST_CHECK_EQUAL(lineBoundsObject.type(), SurfaceBounds::Line);
+ BOOST_CHECK_EQUAL(lineBoundsObject.type(), SurfaceBounds::eLine);
/// test for inside()
const Vector2D origin{0., 0.};
@@ -76,10 +108,11 @@ BOOST_AUTO_TEST_CASE(LineBoundsProperties) {
1e-6); // why?
/// test for r()
- BOOST_CHECK_EQUAL(lineBoundsObject.r(), nominalRadius);
+ BOOST_CHECK_EQUAL(lineBoundsObject.get(LineBounds::eR), nominalRadius);
/// test for halflengthZ (NOTE: Naming violation)
- BOOST_CHECK_EQUAL(lineBoundsObject.halflengthZ(), nominalHalfLength);
+ BOOST_CHECK_EQUAL(lineBoundsObject.get(LineBounds::eHalfLengthZ),
+ nominalHalfLength);
/// test for dump
boost::test_tools::output_test_stream dumpOuput;
@@ -87,17 +120,7 @@ BOOST_AUTO_TEST_CASE(LineBoundsProperties) {
BOOST_CHECK(dumpOuput.is_equal(
"Acts::LineBounds: (radius, halflengthInZ) = (0.5000000, 20.0000000)"));
}
-/// Unit test for testing LineBounds assignment
-BOOST_AUTO_TEST_CASE(LineBoundsAssignment) {
- double nominalRadius{0.5};
- double nominalHalfLength{20.};
- LineBounds lineBoundsObject(nominalRadius, nominalHalfLength);
- LineBounds assignedLineBounds;
- assignedLineBounds = lineBoundsObject;
- BOOST_CHECK_EQUAL(assignedLineBounds.r(), lineBoundsObject.r());
- BOOST_CHECK_EQUAL(assignedLineBounds.halflengthZ(),
- lineBoundsObject.halflengthZ());
-}
+
BOOST_AUTO_TEST_SUITE_END()
} // namespace Test
diff --git a/Tests/UnitTests/Core/Surfaces/LineSurfaceTests.cpp b/Tests/UnitTests/Core/Surfaces/LineSurfaceTests.cpp
index 26230b928e1d55660b8c1fb9d3cd8dc188c04a64..b70d4763a8380d85bc1a9da91da2302ebe744925 100644
--- a/Tests/UnitTests/Core/Surfaces/LineSurfaceTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/LineSurfaceTests.cpp
@@ -44,7 +44,7 @@ BOOST_AUTO_TEST_CASE(LineSurface_Constructors_test) {
// ctor with nullptr for LineBounds
BOOST_CHECK(LineSurfaceStub(pTransform).constructedOk());
// ctor with LineBounds
- auto pLineBounds = std::make_shared<const LineBounds>(10.0);
+ auto pLineBounds = std::make_shared<const LineBounds>(2., 10.0);
BOOST_CHECK(LineSurfaceStub(pTransform, pLineBounds).constructedOk());
// ctor with LineBounds, detector element, Identifier
MaterialProperties properties{1., 1., 1., 20., 10, 5.};
@@ -79,11 +79,11 @@ BOOST_AUTO_TEST_CASE(LineSurface_allNamedMethods_test) {
1e-6);
//
// bounds()
- auto pLineBounds = std::make_shared<const LineBounds>(10.0);
+ auto pLineBounds = std::make_shared<const LineBounds>(2., 10.0);
LineSurfaceStub boundedLine(pTransform, pLineBounds);
const LineBounds& bounds =
dynamic_cast<const LineBounds&>(boundedLine.bounds());
- BOOST_CHECK_EQUAL(bounds, LineBounds(10.0));
+ BOOST_CHECK_EQUAL(bounds, LineBounds(2., 10.0));
//
// globalToLocal()
Vector3D gpos{0., 1., 0.};
diff --git a/Tests/UnitTests/Core/Surfaces/PlaneSurfaceTests.cpp b/Tests/UnitTests/Core/Surfaces/PlaneSurfaceTests.cpp
index ad2253faf2c7c5b17006765a81f734d6f161dfba..c1dfc1c7400604b0279a63112b72c83f370e94bb 100644
--- a/Tests/UnitTests/Core/Surfaces/PlaneSurfaceTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/PlaneSurfaceTests.cpp
@@ -14,7 +14,6 @@
#include "Acts/Surfaces/PlaneSurface.hpp"
#include "Acts/Surfaces/RectangleBounds.hpp"
-#include "Acts/Surfaces/TriangleBounds.hpp"
#include "Acts/Tests/CommonHelpers/DetectorElementStub.hpp"
#include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
#include "Acts/Utilities/Definitions.hpp"
@@ -124,7 +123,7 @@ BOOST_AUTO_TEST_CASE(PlaneSurfaceProperties) {
//
/// Test bounds
BOOST_CHECK_EQUAL(planeSurfaceObject->bounds().type(),
- SurfaceBounds::Rectangle);
+ SurfaceBounds::eRectangle);
/// Test localToGlobal
Vector2D localPosition{1.5, 1.7};
diff --git a/Tests/UnitTests/Core/Surfaces/RadialBoundsTests.cpp b/Tests/UnitTests/Core/Surfaces/RadialBoundsTests.cpp
index 8de0a5a7d4594d3b5b2e513e65bc05438a58abab..15b2cfed8748464b3138fc35d5e37fa75df5813c 100644
--- a/Tests/UnitTests/Core/Surfaces/RadialBoundsTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/RadialBoundsTests.cpp
@@ -20,6 +20,7 @@ namespace Acts {
namespace Test {
BOOST_AUTO_TEST_SUITE(Surfaces)
+
/// Unit tests for RadialBounds constrcuctors
BOOST_AUTO_TEST_CASE(RadialBoundsConstruction) {
double minRadius(1.0), maxRadius(5.0), halfPhiSector(M_PI / 8.0);
@@ -28,16 +29,57 @@ BOOST_AUTO_TEST_CASE(RadialBoundsConstruction) {
//
/// Test construction with radii and default sector
BOOST_CHECK_EQUAL(RadialBounds(minRadius, maxRadius).type(),
- SurfaceBounds::Disc);
+ SurfaceBounds::eDisc);
//
/// Test construction with radii and sector half angle
BOOST_CHECK_EQUAL(RadialBounds(minRadius, maxRadius, halfPhiSector).type(),
- SurfaceBounds::Disc);
+ SurfaceBounds::eDisc);
//
/// Copy constructor
RadialBounds original(minRadius, maxRadius);
RadialBounds copied(original);
- BOOST_CHECK_EQUAL(copied.type(), SurfaceBounds::Disc);
+ BOOST_CHECK_EQUAL(copied, original);
+}
+
+// Streaning and recreation test
+BOOST_AUTO_TEST_CASE(RadialBoundsRecreation) {
+ double minRadius(1.0), maxRadius(5.0), halfPhiSector(M_PI / 8.0), avgPhi(0.1);
+ RadialBounds original(minRadius, maxRadius, halfPhiSector, avgPhi);
+ // const bool symmetric(false);
+ auto valvector = original.values();
+ std::array<double, RadialBounds::eSize> values;
+ std::copy_n(valvector.begin(), RadialBounds::eSize, values.begin());
+ RadialBounds recreated(values);
+ BOOST_CHECK_EQUAL(original, recreated);
+}
+
+// Streaning and recreation test
+BOOST_AUTO_TEST_CASE(RadialBoundsException) {
+ double minRadius(1.0), maxRadius(5.0), halfPhiSector(M_PI / 8.0), avgPhi(0.1);
+
+ // Negative inner radius
+ BOOST_CHECK_THROW(RadialBounds(-minRadius, maxRadius, halfPhiSector, avgPhi),
+ std::logic_error);
+
+ // Negative outer radius
+ BOOST_CHECK_THROW(RadialBounds(minRadius, -maxRadius, halfPhiSector, avgPhi),
+ std::logic_error);
+
+ // Negative inner and outer radius
+ BOOST_CHECK_THROW(RadialBounds(-minRadius, -maxRadius, halfPhiSector, avgPhi),
+ std::logic_error);
+
+ // Swapped radii
+ BOOST_CHECK_THROW(RadialBounds(maxRadius, minRadius, halfPhiSector, avgPhi),
+ std::logic_error);
+
+ // Out of bound phi sector
+ BOOST_CHECK_THROW(RadialBounds(minRadius, -maxRadius, -5., avgPhi),
+ std::logic_error);
+
+ // Out of bound phi position
+ BOOST_CHECK_THROW(RadialBounds(minRadius, -maxRadius, halfPhiSector, 5.),
+ std::logic_error);
}
/// Unit tests for RadialBounds properties
@@ -50,7 +92,7 @@ BOOST_AUTO_TEST_CASE(RadialBoundsProperties) {
delete pClonedRadialBounds;
//
/// Test type() (redundant; already used in constructor confirmation)
- BOOST_CHECK_EQUAL(radialBoundsObject.type(), SurfaceBounds::Disc);
+ BOOST_CHECK_EQUAL(radialBoundsObject.type(), SurfaceBounds::eDisc);
//
/// Test distanceToBoundary
Vector2D origin(0., 0.);
@@ -65,25 +107,26 @@ BOOST_AUTO_TEST_CASE(RadialBoundsProperties) {
boost::test_tools::output_test_stream dumpOuput;
radialBoundsObject.toStream(dumpOuput);
BOOST_CHECK(
- dumpOuput.is_equal("Acts::RadialBounds: (innerRadius, "
- "outerRadius, hPhiSector) = (1.0000000, "
- "5.0000000, 0.0000000, 0.3926991)"));
+ dumpOuput.is_equal("Acts::RadialBounds: (innerRadius, outerRadius, "
+ "hPhiSector, averagePhi) = (1.0000000, "
+ "5.0000000, 0.3926991, 0.0000000)"));
//
/// Test inside
BOOST_CHECK(radialBoundsObject.inside(inSurface, BoundaryCheck(true)));
BOOST_CHECK(!radialBoundsObject.inside(outside, BoundaryCheck(true)));
//
/// Test rMin
- BOOST_CHECK_EQUAL(radialBoundsObject.rMin(), minRadius);
+ BOOST_CHECK_EQUAL(radialBoundsObject.get(RadialBounds::eMinR), minRadius);
//
/// Test rMax
- BOOST_CHECK_EQUAL(radialBoundsObject.rMax(), maxRadius);
+ BOOST_CHECK_EQUAL(radialBoundsObject.get(RadialBounds::eMaxR), maxRadius);
//
/// Test averagePhi (should be a redundant method, this is not configurable)
- BOOST_CHECK_EQUAL(radialBoundsObject.averagePhi(), 0.0);
+ BOOST_CHECK_EQUAL(radialBoundsObject.get(RadialBounds::eAveragePhi), 0.0);
//
/// Test halfPhiSector
- BOOST_CHECK_EQUAL(radialBoundsObject.halfPhiSector(), halfPhiSector);
+ BOOST_CHECK_EQUAL(radialBoundsObject.get(RadialBounds::eHalfPhiSector),
+ halfPhiSector);
}
/// Unit test for testing RadialBounds assignment
BOOST_AUTO_TEST_CASE(RadialBoundsAssignment) {
diff --git a/Tests/UnitTests/Core/Surfaces/RectangleBoundsTests.cpp b/Tests/UnitTests/Core/Surfaces/RectangleBoundsTests.cpp
index e7d4e7c3d6056f5b353d18b8ac7be466d34fe89b..00ffee7f069200a7c739da4a8536e8475d0a2db9 100644
--- a/Tests/UnitTests/Core/Surfaces/RectangleBoundsTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/RectangleBoundsTests.cpp
@@ -20,7 +20,6 @@
namespace utf = boost::unit_test;
const double inf = std::numeric_limits<double>::infinity();
-const double NaN = std::numeric_limits<double>::quiet_NaN();
namespace Acts {
@@ -38,36 +37,49 @@ bool approximatelyEqual(const Vector2D& a, const Vector2D& b) {
return ((dif0 < tol) and (dif1 < tol));
}
BOOST_AUTO_TEST_SUITE(Surfaces)
+
/// Unit test for creating compliant/non-compliant RectangleBounds object
BOOST_AUTO_TEST_CASE(RectangleBoundsConstruction) {
const double halfX(10.), halfY(5.);
RectangleBounds twentyByTenRectangle(halfX, halfY);
BOOST_CHECK_EQUAL(twentyByTenRectangle.type(),
- Acts::SurfaceBounds::Rectangle);
+ Acts::SurfaceBounds::eRectangle);
//
// nonsensical bounds are also permitted, but maybe should not be
const double zeroHalfX(0.), zeroHalfY(0.);
const double infHalfX(inf), infHalfY(inf);
- const double nanHalfX(NaN), nanHalfY(NaN);
- const double negHalfX(-10.), negHalfY(-5.);
//
// BOOST_TEST_MESSAGE("Initialise with zero dimensions");
RectangleBounds zeroDimensionsRectangle(zeroHalfX, zeroHalfY);
BOOST_CHECK_EQUAL(zeroDimensionsRectangle.type(),
- Acts::SurfaceBounds::Rectangle);
+ Acts::SurfaceBounds::eRectangle);
//
// BOOST_TEST_MESSAGE("Initialise with infinite dimensions");
RectangleBounds infinite(infHalfX, infHalfY);
- BOOST_CHECK_EQUAL(infinite.type(), Acts::SurfaceBounds::Rectangle);
- //
- // BOOST_TEST_MESSAGE("Initialise with NaN dimensions");
- RectangleBounds nanRectangle(nanHalfX, nanHalfY);
- BOOST_CHECK_EQUAL(nanRectangle.type(), Acts::SurfaceBounds::Rectangle);
- //
- // BOOST_TEST_MESSAGE("Initialise with negative dimensions");
- RectangleBounds negativeDimensionedRectangle(negHalfX, negHalfY);
- BOOST_CHECK_EQUAL(negativeDimensionedRectangle.type(),
- Acts::SurfaceBounds::Rectangle);
+ BOOST_CHECK_EQUAL(infinite.type(), Acts::SurfaceBounds::eRectangle);
+}
+
+/// Recreation
+BOOST_AUTO_TEST_CASE(RectangleBoundsRecreation) {
+ const double halfX(10.), halfY(2.);
+ RectangleBounds original(halfX, halfY);
+ // const bool symmetric(false);
+ auto valvector = original.values();
+ std::array<double, RectangleBounds::eSize> values;
+ std::copy_n(valvector.begin(), RectangleBounds::eSize, values.begin());
+ RectangleBounds recreated(values);
+ BOOST_CHECK_EQUAL(original, recreated);
+}
+
+// Exception tests
+BOOST_AUTO_TEST_CASE(RadialBoundsException) {
+ const double halfX(10.), halfY(2.);
+
+ // Negative x half length
+ BOOST_CHECK_THROW(RectangleBounds(-halfX, halfY), std::logic_error);
+
+ // Negative y half length
+ BOOST_CHECK_THROW(RectangleBounds(halfX, -halfY), std::logic_error);
}
/// Unit test for testing RectangleBounds properties
@@ -75,8 +87,8 @@ BOOST_TEST_DECORATOR(*utf::tolerance(1e-10))
BOOST_AUTO_TEST_CASE(RectangleBoundsProperties) {
const double halfX(10.), halfY(5.);
RectangleBounds rect(halfX, halfY);
- BOOST_CHECK_EQUAL(rect.halflengthX(), 10.);
- BOOST_CHECK_EQUAL(rect.halflengthY(), 5.);
+ BOOST_CHECK_EQUAL(rect.halfLengthX(), 10.);
+ BOOST_CHECK_EQUAL(rect.halfLengthY(), 5.);
CHECK_CLOSE_ABS(rect.min(), Vector2D(-halfX, -halfY), 1e-6);
CHECK_CLOSE_ABS(rect.max(), Vector2D(halfX, halfY), 1e-6);
diff --git a/Tests/UnitTests/Core/Surfaces/SurfaceBoundsTests.cpp b/Tests/UnitTests/Core/Surfaces/SurfaceBoundsTests.cpp
index eb25763bd8bca54c807898c1a5f67dc297ca598d..edeeef24798d3d7621c1c7acb10d718b60b471a8 100644
--- a/Tests/UnitTests/Core/Surfaces/SurfaceBoundsTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/SurfaceBoundsTests.cpp
@@ -9,6 +9,7 @@
#include <boost/test/data/test_case.hpp>
#include <boost/test/tools/output_test_stream.hpp>
#include <boost/test/unit_test.hpp>
+#include <numeric>
#include "Acts/Surfaces/SurfaceBounds.hpp"
#include "Acts/Utilities/Definitions.hpp"
@@ -19,16 +20,15 @@ namespace Acts {
class SurfaceBoundsStub : public SurfaceBounds {
public:
/// Implement ctor and pure virtual methods of SurfaceBounds
- explicit SurfaceBoundsStub(size_t nValues = 0) : m_values(nValues) {
- for (size_t i = 0; i < nValues; ++i) {
- m_values[i] = i;
- }
+ explicit SurfaceBoundsStub(size_t nValues = 0) : m_values(nValues, 0) {
+ std::iota(m_values.begin(), m_values.end(), 0);
}
+
~SurfaceBoundsStub() override { /*nop*/
}
SurfaceBounds* clone() const final { return nullptr; }
- BoundsType type() const final { return SurfaceBounds::Other; }
- std::vector<TDD_real_t> valueStore() const override { return m_values; }
+ BoundsType type() const final { return SurfaceBounds::eOther; }
+ std::vector<double> values() const override { return m_values; }
bool inside(const Vector2D& /*lpos*/,
const BoundaryCheck& /*bcheck*/) const final {
return true;
@@ -42,7 +42,7 @@ class SurfaceBoundsStub : public SurfaceBounds {
}
private:
- std::vector<TDD_real_t> m_values;
+ std::vector<double> m_values;
};
namespace Test {
@@ -56,10 +56,10 @@ BOOST_AUTO_TEST_CASE(SurfaceBoundsConstruction) {
}
BOOST_AUTO_TEST_CASE(SurfaceBoundsProperties) {
SurfaceBoundsStub surface(5);
- std::vector<TDD_real_t> reference{0, 1, 2, 3, 4};
- const auto& valueStore = surface.valueStore();
+ std::vector<double> reference{0, 1, 2, 3, 4};
+ const auto& boundValues = surface.values();
BOOST_CHECK_EQUAL_COLLECTIONS(reference.cbegin(), reference.cend(),
- valueStore.cbegin(), valueStore.cend());
+ boundValues.cbegin(), boundValues.cend());
}
/// Unit test for testing SurfaceBounds properties
BOOST_AUTO_TEST_CASE(SurfaceBoundsEquality) {
@@ -71,11 +71,11 @@ BOOST_AUTO_TEST_CASE(SurfaceBoundsEquality) {
SurfaceBoundsStub assignedSurface;
assignedSurface = surface;
BOOST_CHECK_EQUAL(surface, assignedSurface);
- const auto& surfaceValueStore = surface.valueStore();
- const auto& assignedValueStore = assignedSurface.valueStore();
+ const auto& surfaceboundValues = surface.values();
+ const auto& assignedboundValues = assignedSurface.values();
BOOST_CHECK_EQUAL_COLLECTIONS(
- surfaceValueStore.cbegin(), surfaceValueStore.cend(),
- assignedValueStore.cbegin(), assignedValueStore.cend());
+ surfaceboundValues.cbegin(), surfaceboundValues.cend(),
+ assignedboundValues.cbegin(), assignedboundValues.cend());
}
BOOST_AUTO_TEST_SUITE_END()
diff --git a/Tests/UnitTests/Core/Surfaces/TrapezoidBoundsTests.cpp b/Tests/UnitTests/Core/Surfaces/TrapezoidBoundsTests.cpp
index 6914a2781fb334f2e2a2b9b56634306e84e59f87..ce0b6487418e2ad10aa5b6a27cd1afb66ef5e1ad 100644
--- a/Tests/UnitTests/Core/Surfaces/TrapezoidBoundsTests.cpp
+++ b/Tests/UnitTests/Core/Surfaces/TrapezoidBoundsTests.cpp
@@ -22,6 +22,7 @@ namespace Acts {
namespace Test {
BOOST_AUTO_TEST_SUITE(Surfaces)
+
/// Unit test for creating compliant/non-compliant TrapezoidBounds object
BOOST_AUTO_TEST_CASE(TrapezoidBoundsConstruction) {
double minHalfX(1.), maxHalfX(6.), halfY(2.);
@@ -31,11 +32,45 @@ BOOST_AUTO_TEST_CASE(TrapezoidBoundsConstruction) {
//
/// Test construction with defining half lengths
BOOST_CHECK_EQUAL(TrapezoidBounds(minHalfX, maxHalfX, halfY).type(),
- SurfaceBounds::Trapezoid);
+ SurfaceBounds::eTrapezoid);
/// Copy constructor
TrapezoidBounds original(minHalfX, maxHalfX, halfY);
TrapezoidBounds copied(original);
- BOOST_CHECK_EQUAL(copied.type(), SurfaceBounds::Trapezoid);
+ BOOST_CHECK_EQUAL(copied, original);
+}
+
+/// Unit test for creating compliant/non-compliant TrapezoidBounds object
+BOOST_AUTO_TEST_CASE(TrapezoidBoundsRecreated) {
+ double minHalfX(1.), maxHalfX(6.), halfY(2.);
+ /// Copy constructor
+ TrapezoidBounds original(minHalfX, maxHalfX, halfY);
+ // const bool symmetric(false);
+ auto valvector = original.values();
+ std::array<double, TrapezoidBounds::eSize> values;
+ std::copy_n(valvector.begin(), TrapezoidBounds::eSize, values.begin());
+ TrapezoidBounds recreated(values);
+ BOOST_CHECK_EQUAL(original, recreated);
+}
+
+// Exception tests
+BOOST_AUTO_TEST_CASE(TrapezoidBoundsException) {
+ double minHalfX(1.), maxHalfX(6.), halfY(2.);
+
+ // Negative x at min y
+ BOOST_CHECK_THROW(TrapezoidBounds(-minHalfX, maxHalfX, halfY),
+ std::logic_error);
+
+ // Negative x at max y
+ BOOST_CHECK_THROW(TrapezoidBounds(minHalfX, -maxHalfX, halfY),
+ std::logic_error);
+
+ // Negative x at miny and max y
+ BOOST_CHECK_THROW(TrapezoidBounds(-minHalfX, -maxHalfX, halfY),
+ std::logic_error);
+
+ // Negative y
+ BOOST_CHECK_THROW(TrapezoidBounds(minHalfX, maxHalfX, -halfY),
+ std::logic_error);
}
/// Unit tests for TrapezoidBounds properties
@@ -49,16 +84,19 @@ BOOST_AUTO_TEST_CASE(TrapezoidBoundsProperties, *utf::expected_failures(3)) {
delete pClonedTrapezoidBounds;
//
/// Test type() (redundant; already used in constructor confirmation)
- BOOST_CHECK_EQUAL(trapezoidBoundsObject.type(), SurfaceBounds::Trapezoid);
+ BOOST_CHECK_EQUAL(trapezoidBoundsObject.type(), SurfaceBounds::eTrapezoid);
//
/// Test minHalflengthX
- BOOST_CHECK_EQUAL(trapezoidBoundsObject.minHalflengthX(), minHalfX);
+ BOOST_CHECK_EQUAL(
+ trapezoidBoundsObject.get(TrapezoidBounds::eHalfLengthXnegY), minHalfX);
//
/// Test maxHalfLengthX
- BOOST_CHECK_EQUAL(trapezoidBoundsObject.maxHalflengthX(), maxHalfX);
+ BOOST_CHECK_EQUAL(
+ trapezoidBoundsObject.get(TrapezoidBounds::eHalfLengthXposY), maxHalfX);
//
/// Test halflengthY
- BOOST_CHECK_EQUAL(trapezoidBoundsObject.halflengthY(), halfY);
+ BOOST_CHECK_EQUAL(trapezoidBoundsObject.get(TrapezoidBounds::eHalfLengthY),
+ halfY);
//
/// Test distanceToBoundary
Vector2D origin(0., 0.);
diff --git a/Tests/UnitTests/Core/Surfaces/TriangleBoundsTests.cpp b/Tests/UnitTests/Core/Surfaces/TriangleBoundsTests.cpp
deleted file mode 100644
index 3d2471744eca9155a947f0a0108f152453c0b887..0000000000000000000000000000000000000000
--- a/Tests/UnitTests/Core/Surfaces/TriangleBoundsTests.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-// This file is part of the Acts project.
-//
-// Copyright (C) 2017-2018 CERN for the benefit of the Acts project
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#include <boost/test/data/test_case.hpp>
-#include <boost/test/tools/output_test_stream.hpp>
-#include <boost/test/unit_test.hpp>
-
-#include <limits>
-
-#include "Acts/Surfaces/TriangleBounds.hpp"
-#include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
-#include "Acts/Utilities/Definitions.hpp"
-
-namespace utf = boost::unit_test;
-
-namespace Acts {
-
-namespace Test {
-BOOST_AUTO_TEST_SUITE(Surfaces)
-/// Unit test for creating compliant/non-compliant TriangleBounds object
-BOOST_AUTO_TEST_CASE(TriangleBoundsConstruction) {
- std::array<Vector2D, 3> vertices({{Vector2D(1., 1.), Vector2D(4., 1.),
- Vector2D(4., 5.)}}); // 3-4-5 triangle
- // test default construction
- // TriangleBounds defaultConstructedTriangleBounds; //deleted
- //
- /// Test construction with vertices
- BOOST_CHECK_EQUAL(TriangleBounds(vertices).type(), SurfaceBounds::Triangle);
- //
- /// Copy constructor
- TriangleBounds original(vertices);
- TriangleBounds copied(original);
- BOOST_CHECK_EQUAL(copied.type(), SurfaceBounds::Triangle);
-}
-
-/// Unit tests for TriangleBounds properties
-BOOST_AUTO_TEST_CASE(TriangleBoundsProperties) {
- std::array<Vector2D, 3> vertices({{Vector2D(1., 1.), Vector2D(4., 1.),
- Vector2D(4., 5.)}}); // 3-4-5 triangle
- /// Test clone
- TriangleBounds triangleBoundsObject(vertices);
- auto pClonedTriangleBounds = triangleBoundsObject.clone();
- BOOST_CHECK_NE(pClonedTriangleBounds, nullptr);
- delete pClonedTriangleBounds;
- //
- /// Test type() (redundant; already used in constructor confirmation)
- BOOST_CHECK_EQUAL(triangleBoundsObject.type(), SurfaceBounds::Triangle);
- //
- /// Test distanceToBoundary
- Vector2D origin(0., 0.);
- Vector2D outside(30., 1.);
- Vector2D inTriangle(2., 1.5);
- CHECK_CLOSE_REL(triangleBoundsObject.distanceToBoundary(origin),
- std::sqrt(2.),
- 1e-6); // makes sense
- CHECK_CLOSE_REL(triangleBoundsObject.distanceToBoundary(outside), 26.,
- 1e-6); // ok
- //
- /// Test vertices : fail; there are in fact 6 vertices (10.03.2017)
- std::array<Vector2D, 3> expectedVertices = vertices;
- BOOST_TEST_MESSAGE(
- "Following two tests fail because the triangle has six vertices");
- BOOST_CHECK_EQUAL(triangleBoundsObject.vertices().size(), (size_t)3);
- for (size_t i = 0; i < 3; i++) {
- CHECK_CLOSE_REL(triangleBoundsObject.vertices().at(i),
- expectedVertices.at(i), 1e-6);
- }
- /// Test boundingBox NOTE: Bounding box too big
- BOOST_CHECK_EQUAL(triangleBoundsObject.boundingBox(),
- RectangleBounds(4., 5.));
- //
-
- //
- /// Test dump
- boost::test_tools::output_test_stream dumpOuput;
- triangleBoundsObject.toStream(dumpOuput);
- BOOST_CHECK(dumpOuput.is_equal(
- "Acts::TriangleBounds: generating vertices (X, Y)(1.0000000 , 1.0000000) \n\
-(4.0000000 , 1.0000000) \n\
-(4.0000000 , 5.0000000) "));
- //
- /// Test inside
- BOOST_CHECK(triangleBoundsObject.inside(inTriangle, BoundaryCheck(true)));
- BOOST_CHECK(!triangleBoundsObject.inside(outside, BoundaryCheck(true)));
-}
-/// Unit test for testing TriangleBounds assignment
-BOOST_AUTO_TEST_CASE(TriangleBoundsAssignment) {
- std::array<Vector2D, 3> vertices({{Vector2D(1., 1.), Vector2D(4., 1.),
- Vector2D(4., 5)}}); // 3-4-5 triangle
- std::array<Vector2D, 3> invalid(
- {{Vector2D(-1, -1), Vector2D(-1, -1), Vector2D(-1, -1)}});
- TriangleBounds triangleBoundsObject(vertices);
- // operator == not implemented in this class
- //
- /// Test assignment
- TriangleBounds assignedTriangleBoundsObject(
- invalid); // invalid object, in some sense
- assignedTriangleBoundsObject = triangleBoundsObject;
- const auto& assignedVertices = assignedTriangleBoundsObject.vertices();
- const auto& originalVertices = triangleBoundsObject.vertices();
- BOOST_CHECK_EQUAL_COLLECTIONS(
- assignedVertices.cbegin(), assignedVertices.cend(),
- originalVertices.cbegin(), originalVertices.cend());
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-} // namespace Test
-
-} // namespace Acts