diff --git a/Core/include/ACTS/Detector/TrackingVolume.hpp b/Core/include/ACTS/Detector/TrackingVolume.hpp
index d92ed4859c469ab8f8b250a82708412bfcbd78b7..e674146dadd87e810e4dcd3e0ca9c19af6f88d3c 100644
--- a/Core/include/ACTS/Detector/TrackingVolume.hpp
+++ b/Core/include/ACTS/Detector/TrackingVolume.hpp
@@ -166,7 +166,7 @@ public:
/// returned)
/// @tparam parameters are the templated parameters for searching
/// @param pDir is an additional direction prescription
- /// @param bchk is a boundary check directive
+ /// @param bcheck is a boundary check directive
/// @param resolveMaterial is the prescription how to deal with material
/// @param resolveSubSurfaces is the prescription on how to deal with
/// sensitive surfaces
@@ -178,7 +178,7 @@ public:
const Layer* eLayer,
const T& parameters,
PropDirection pDir = alongMomentum,
- const BoundaryCheck& bchk = true,
+ const BoundaryCheck& bcheck = true,
bool resolveMaterial = true,
bool resolveSubSurfaces = false) const;
@@ -559,7 +559,7 @@ TrackingVolume::layerCandidatesOrdered(const Layer* sLayer,
const Layer* eLayer,
const T& pars,
PropDirection pDir,
- const BoundaryCheck& bchk,
+ const BoundaryCheck& bcheck,
bool resolveMaterial,
bool resolveSensitive) const
{
@@ -595,7 +595,7 @@ TrackingVolume::layerCandidatesOrdered(const Layer* sLayer,
const Surface& tSurface = tLayer->surfaceRepresentation();
// intersect the layer @todo should probably be surface on approach
Intersection lIntersection
- = tSurface.intersectionEstimate(gp, dir, true, bchk);
+ = tSurface.intersectionEstimate(gp, dir, true, bcheck);
// (a) if the current layer is NOT the start layer - intersection is
// ok
if (tLayer != sLayer && lIntersection.valid) {
@@ -634,7 +634,7 @@ TrackingVolume::layerCandidatesOrdered(const Layer* sLayer,
// intersections
Intersection lIntersection
= layer->surfaceRepresentation().intersectionEstimate(
- gp, dir, true, bchk);
+ gp, dir, true, bcheck);
if (lIntersection.valid)
lIntersections.push_back(
LayerIntersection<T>(lIntersection,
diff --git a/Core/include/ACTS/Extrapolation/ExtrapolationEngine.hpp b/Core/include/ACTS/Extrapolation/ExtrapolationEngine.hpp
index a2f3582c66920427abf57f2402714094e3e3fb92..8d92a2a37e5b315840e4eb7b8de29bb30e3cbc6c 100644
--- a/Core/include/ACTS/Extrapolation/ExtrapolationEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/ExtrapolationEngine.hpp
@@ -86,27 +86,27 @@ public:
///
/// @param ecCharged is the charged extrapolation cell that holds the cache
/// @param sf is the (optional) destinaton surface
- /// @param bchk is the boudnary check directive @todo shift to cell after
+ /// @param bcheck is the boudnary check directive @todo shift to cell after
/// splitting
///
/// @return extrapolation code to indicate outcome
ExtrapolationCode
extrapolate(ExCellCharged& ecCharged,
const Surface* sf = nullptr,
- const BoundaryCheck& bchk = true) const final;
+ const BoundaryCheck& bcheck = true) const final;
/// Neutral extrapolation - public interface
///
/// @param ecNeutral is the neutral extrapolation cell that holds the cache
/// @param sf is the (optional) destinaton surface
- /// @param bchk is the boudnary check directive @todo shift to cell after
+ /// @param bcheck is the boudnary check directive @todo shift to cell after
/// splitting
///
/// @return extrapolation code to indicate outcome
ExtrapolationCode
extrapolate(ExCellNeutral& ecNeutral,
const Surface* sf = nullptr,
- const BoundaryCheck& bchk = true) const final;
+ const BoundaryCheck& bcheck = true) const final;
/// define for which geometry type this extrapolator is valid
/// - this is GLOBAL
diff --git a/Core/include/ACTS/Extrapolation/IExtrapolationEngine.hpp b/Core/include/ACTS/Extrapolation/IExtrapolationEngine.hpp
index 98d2eb08c56acc4961fa976c78473d1158deb2f7..39aa937c70631418a7ee929ab860b73a12bbc39d 100644
--- a/Core/include/ACTS/Extrapolation/IExtrapolationEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/IExtrapolationEngine.hpp
@@ -40,13 +40,13 @@ class IExtrapolationEngine
public:
/// Virtual destructor
virtual ~IExtrapolationEngine() {}
+
/// Main extrapolation method, templated to chared/neutral
///
- /// @tparam eCell ist he extrapolaiton cell
+ /// @tparam ecCharged ist he extrapolaiton cell
/// @param sf is the (optional) destinaton surface
- /// @param dir is the additional direction prescription
- /// @param bchk is the boudnary check directive @todo shift to cell after
- /// splitting
+ /// @param bcheck is the boudnary check directive
+ /// @todo shift to cell after splitting
///
/// @return extrapolation code to indicate outcome
virtual ExtrapolationCode
@@ -56,9 +56,9 @@ public:
/// Main extrapolation method, templated to chared/neutral
///
- /// @tparam eCell ist he extrapolaiton cell
+ /// @param ecNeutral ist he extrapolaiton cell
/// @param sf is the (optional) destinaton surface
- /// @param dir is the additional direction prescription
+ /// @param bcheck is the boudnary check directive
///
/// @return extrapolation code to indicate outcome
virtual ExtrapolationCode
diff --git a/Core/include/ACTS/Extrapolation/IMaterialEffectsEngine.hpp b/Core/include/ACTS/Extrapolation/IMaterialEffectsEngine.hpp
index 7909c209d13ad295d4ab7659fbffef13b274eac0..ee2fc39732dc54a1456f3f7b67986bce81fc38ea 100644
--- a/Core/include/ACTS/Extrapolation/IMaterialEffectsEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/IMaterialEffectsEngine.hpp
@@ -37,6 +37,7 @@ class IMaterialEffectsEngine
public:
/// Virtual destructor
virtual ~IMaterialEffectsEngine() {}
+
/// Public charged material effects interface
///
/// @param ecCharged is the charged extrapolaiton cell
@@ -51,7 +52,7 @@ public:
/// Public neutral material effects interface
///
- /// @param ecCharged is the neutral extrapolaiton cell
+ /// @param ecNeutral is the neutral extrapolaiton cell
/// @param dir is the additional direction prescription
/// @param matupstage is the update stage (pre/full/post)
///
diff --git a/Core/include/ACTS/Extrapolation/INavigationEngine.hpp b/Core/include/ACTS/Extrapolation/INavigationEngine.hpp
index 679c72a84c82595803f4a6633fbbb304f2d3a2e9..ee954f3f405e6becc259c31107d698b252d53dff 100644
--- a/Core/include/ACTS/Extrapolation/INavigationEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/INavigationEngine.hpp
@@ -47,7 +47,7 @@ public:
/// Resolve the boundary situation - for neutral particles
///
- /// @param ecCell is the neutral extrapolation cell
+ /// @param enCell is the neutral extrapolation cell
/// @param dir is the additional direction prescription
///
/// @return is a extrapolation code indication
@@ -59,7 +59,7 @@ public:
///
/// @param ecCell is the charged extrapolation cell
/// @param dir is the additional direction prescription
- ///
+ /// @param noLoop is a loop protection
/// @todo check with sharka where this is used
///
/// @return is a extrapolation code indication
@@ -72,7 +72,7 @@ public:
///
/// @param ecCell is the charged extrapolation cell
/// @param dir is the additional direction prescription
- ///
+ /// @param noLoop is a loop protection
/// @todo check with sharka where this is used
///
/// @return is a extrapolation code indication
diff --git a/Core/include/ACTS/Extrapolation/IPropagationEngine.hpp b/Core/include/ACTS/Extrapolation/IPropagationEngine.hpp
index 3adf2ba961645154134574884c7d8e70690a1431..d6a2743394ad40df0792eee0bdf3486863733cf5 100644
--- a/Core/include/ACTS/Extrapolation/IPropagationEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/IPropagationEngine.hpp
@@ -45,7 +45,7 @@ public:
/// @param sf is the destination surface
/// @param dir is the additional direction prescription
/// @param purpose steers whether to set the final parameter or not
- /// @param bchk is the boundary check prescription
+ /// @param bcheck is the boundary check prescription
/// @param returnCurvilinear is a boolean switch to not collapse onto the
/// surface frame but stay in curviliear coordinates
///
@@ -59,16 +59,16 @@ public:
const Surface& sf,
PropDirection dir = alongMomentum,
ExtrapolationMode::eMode purpose = ExtrapolationMode::Destination,
- const BoundaryCheck& bchk = true,
+ const BoundaryCheck& bcheck = true,
bool returnCurvilinear = true) const = 0;
/// Main Neutral extrapolation method
///
- /// @param ecCell is the neutral extrapolation cell
+ /// @param enCell is the neutral extrapolation cell
/// @param sf is the destination surface
/// @param dir is the additional direction prescription
/// @param purpose steers whether to set the final parameter or not
- /// @param bchk is the boundary check prescription
+ /// @param bcheck is the boundary check prescription
/// @param returnCurvilinear is a boolean switch to not collapse onto the
/// surface frame but stay in curviliear coordinates
///
diff --git a/Core/include/ACTS/Extrapolation/RungeKuttaEngine.hpp b/Core/include/ACTS/Extrapolation/RungeKuttaEngine.hpp
index 8a48e964add68b9d410e027d0524b7ad2cfb3961..564f3ca3e0707e91d2477604dd375895dedd20fa 100644
--- a/Core/include/ACTS/Extrapolation/RungeKuttaEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/RungeKuttaEngine.hpp
@@ -199,7 +199,7 @@ public:
/// @param sf is the destination surface
/// @param dir is the additional direction prescription
/// @param purpose steers whether to set the final parameter or not
- /// @param bchk is the boundary check prescription
+ /// @param bcheck is the boundary check prescription
/// @param returnCurvilinear is a boolean switch to not collapse onto the
/// surface frame but stay in curviliear coordinates
///
@@ -222,7 +222,7 @@ public:
/// @param sf is the destination surface
/// @param dir is the additional direction prescription
/// @param purpose steers whether to set the final parameter or not
- /// @param bchk is the boundary check prescription
+ /// @param bcheck is the boundary check prescription
/// @param returnCurvilinear is a boolean switch to not collapse onto the
/// surface frame but stay in curviliear coordinates
///
diff --git a/Core/include/ACTS/Extrapolation/StaticEngine.hpp b/Core/include/ACTS/Extrapolation/StaticEngine.hpp
index c87921091644df14f8d9f85497e5b6533a2d8993..cc37bc4666002c3ab1f50f64ecdc48d4361847af 100644
--- a/Core/include/ACTS/Extrapolation/StaticEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/StaticEngine.hpp
@@ -97,7 +97,7 @@ public:
/// @tparam eCell ist he extrapolaiton cell
/// @param sf is the (optional) destinaton surface
/// @param dir is the additional direction prescription
- /// @param bchk is the boudnary check directive @todo shift to cell after
+ /// @param bcheck is the boudnary check directive @todo shift to cell after
/// splitting
///
/// @return is a extrapolation code indication
diff --git a/Core/include/ACTS/Layers/GenericApproachDescriptor.hpp b/Core/include/ACTS/Layers/GenericApproachDescriptor.hpp
index 81a1633e89db001b7f6f97b50b061aae41b80f9a..9dc8fee3a1ff1c8ef12395a96368f786b6df2d70 100644
--- a/Core/include/ACTS/Layers/GenericApproachDescriptor.hpp
+++ b/Core/include/ACTS/Layers/GenericApproachDescriptor.hpp
@@ -65,14 +65,14 @@ public:
///
/// @param gpos is the global posoition to start the approach from
/// @param dir is the direction in which you approach the layer
- /// @param bchk is the boundary check presrcition
+ /// @param bcheck is the boundary check presrcition
/// @param ice is a (future) compatibility estimater if needed
///
/// @return : a boolean indicating if an actual intersection had been tried
const SurfaceIntersection
approachSurface(const Vector3D& gpos,
const Vector3D& dir,
- const BoundaryCheck& bchk,
+ const BoundaryCheck& bcheck,
const ICompatibilityEstimator* ice = nullptr) const override;
/// return all containes surfaces of this approach descriptor
@@ -99,7 +99,7 @@ const SurfaceIntersection
GenericApproachDescriptor<T>::approachSurface(
const Vector3D& pos,
const Vector3D& dir,
- const BoundaryCheck& bchk,
+ const BoundaryCheck& bcheck,
const ICompatibilityEstimator*) const
{
// prepare the return surface
@@ -109,7 +109,7 @@ GenericApproachDescriptor<T>::approachSurface(
// get the surfaces
for (auto& sfIter : m_surfacesCache) {
// get the intersection with the surface
- sIntersection = sfIter->intersectionEstimate(pos, dir, true, bchk);
+ sIntersection = sfIter->intersectionEstimate(pos, dir, true, bcheck);
// validatie if it's ok and take the closest
if (sIntersection.valid && sIntersection.pathLength < aPathLength) {
aPathLength = sIntersection.pathLength;
diff --git a/Core/include/ACTS/Layers/Layer.hpp b/Core/include/ACTS/Layers/Layer.hpp
index badec4b1ac7c83941152653fa8b035c3789932c9..17d6fa2be7583c691121caed046425eddc41483f 100644
--- a/Core/include/ACTS/Layers/Layer.hpp
+++ b/Core/include/ACTS/Layers/Layer.hpp
@@ -130,22 +130,22 @@ public:
/// templated onLayer() method
///
/// @tparam parameters are the templated (charged/neutral) on layer check
- /// @param bchk is the boundary check directive
+ /// @param bcheck is the boundary check directive
///
/// @return boolean that indicates success of the operation
template <class T>
bool
- onLayer(const T& parameters, const BoundaryCheck& bchk = true) const;
+ onLayer(const T& parameters, const BoundaryCheck& bcheck = true) const;
/// geometrical isOnLayer() method
///
/// @note using isOnSurface() with Layer specific tolerance
- /// @param gpos is the gobal position to be checked
- /// @param bchk is the boundary check directive
+ /// @param pos is the gobal position to be checked
+ /// @param bcheck is the boundary check directive
///
/// @return boolean that indicates success of the operation
virtual bool
- isOnLayer(const Vector3D& gp, const BoundaryCheck& bchk = true) const;
+ isOnLayer(const Vector3D& pos, const BoundaryCheck& bcheck = true) const;
/// Return method for the approach descriptor, can be nullptr
const ApproachDescriptor*
@@ -156,18 +156,18 @@ public:
/// @param gpos is the global position to start the approach from
/// @param dir is the direction from where to attempt the approach
/// @param pdir is the direction prescription
- /// @param bhck is the boundary check directive
+ /// @param bcheck is the boundary check directive
/// @param resolveSubSurfaces is a boolean directive whether to resolve
/// structure or not
/// @note reasons for resolving are: collect & find material, collect & find
/// sensitivex
- /// @ice is a (future) compatibility estimator that could be used to modify
+ /// @param ice is a (future) compatibility estimator that could be used to modify
/// the straight line approach
virtual const SurfaceIntersection
surfaceOnApproach(const Vector3D& gpos,
const Vector3D& dir,
PropDirection pdir,
- const BoundaryCheck& bchk,
+ const BoundaryCheck& bcheck,
bool resolveSubSurfaces = false,
const ICompatibilityEstimator* ice = nullptr) const;
@@ -182,7 +182,7 @@ public:
/// @param cSurfaces are the retrun surface intersections
/// @param pars are the (charged) track parameters for the search
/// @param pdir is the propagation direction prescription
- /// @param bchk is the boundary check directive
+ /// @param bcheck is the boundary check directive
/// @param collectSensitive is the prescription to find the sensitive surfaces
/// @param collectPassive is the prescription to find all passive surfaces
/// @param searchType is the level of depth for the search
@@ -190,7 +190,7 @@ public:
/// excluded in return
/// @param endSurface is an (optional) end surface for the search: excluded in
/// return
- /// @ice is a (future) compatibility estimator that could be used to modify
+ /// @param ice is a (future) compatibility estimator that could be used to modify
/// the straight line approach
///
/// @return boolean that indicates if a compatible surface exists at all
@@ -198,7 +198,7 @@ public:
compatibleSurfaces(std::vector<SurfaceIntersection>& cSurfaces,
const TrackParameters& pars,
PropDirection pdir,
- const BoundaryCheck& bchk,
+ const BoundaryCheck& bcheck,
bool collectSensitive,
bool collectPassive,
int searchType,
@@ -217,7 +217,7 @@ public:
/// @param cSurfaces are the retrun surface intersections
/// @param pars are the (charged) track parameters for the search
/// @param pdir is the propagation direction prescription
- /// @param bchk is the boundary check directive
+ /// @param bcheck is the boundary check directive
/// @param collectSensitive is the prescription to find the sensitive surfaces
/// @param collectPassive is the prescription to find all passive surfaces
/// @param searchType is the level of depth for the search
@@ -225,7 +225,7 @@ public:
/// excluded in return
/// @param endSurface is an (optional) end surface for the search: excluded in
/// return
- /// @ice is a (future) compatibility estimator that could be used to modify
+ /// @param ice is a (future) compatibility estimator that could be used to modify
/// the straight line approach
///
/// @return boolean that indicates if a compatible surface exists at all
@@ -233,7 +233,7 @@ public:
compatibleSurfaces(std::vector<SurfaceIntersection>& cSurfaces,
const NeutralParameters& pars,
PropDirection pdir,
- const BoundaryCheck& bchk,
+ const BoundaryCheck& bcheck,
bool collectSensitive,
bool collectPassive,
int searchType,
@@ -287,7 +287,7 @@ public:
/// Fast navigation to next layer
///
- /// @param gpos is the start position for the search
+ /// @param pos is the start position for the search
/// @param dir is the direction for the search
///
/// @return the pointer to the next layer
@@ -328,18 +328,19 @@ protected:
/// Copy Constructor
///
- /// @param lay is the sourc3 layer for the copye
+ /// @param lay is the source layer for the copye
Layer(const Layer& lay);
/// Constructor with pointer to SurfaceArray (passing ownership)
///
/// @param surfaceArray is the array of sensitive surfaces
/// @param thickness is the normal thickness of the Layer
- /// @param od overlap descriptor (@todo change to unique_ptr)
+ /// @param ad oapproach descriptor
+ /// @param ltype is the layer type if active or passive
Layer(std::unique_ptr<SurfaceArray> surfaceArray,
double thickness = 0.,
ApproachDescriptor* ad = nullptr,
- LayerType ltype = Acts::passive);
+ LayerType ltype = passive);
/// get compatible surfaces starting from charged parameters - forward call
/// from explicit methods
@@ -347,7 +348,7 @@ protected:
/// @param cSurfaces are the retrun surface intersections
/// @tparam pars are the (charged) track parameters for the search
/// @param pdir is the propagation direction prescription
- /// @param bchk is the boundary check directive
+ /// @param bcheck is the boundary check directive
/// @param collectSensitive is the prescription to find the sensitive surfaces
/// @param collectPassive is the prescription to find all passive surfaces
/// @param searchType is the level of depth for the search
@@ -355,7 +356,7 @@ protected:
/// excluded in return
/// @param endSurface is an (optional) end surface for the search: excluded in
/// return
- /// @ice is a (future) compatibility estimator that could be used to modify
+ /// @param ice is a (future) compatibility estimator that could be used to modify
/// the straight line approach
///
/// @return boolean that indicates if a compatible surface exists at all
@@ -364,13 +365,13 @@ protected:
getCompatibleSurfaces(std::vector<SurfaceIntersection>& cSurfaces,
const T& pars,
PropDirection pdir,
- const BoundaryCheck& bchk,
+ const BoundaryCheck& bcheck,
bool collectSensitive,
bool collectPassive,
int searchType,
- const Surface* startSurface = nullptr,
- const Surface* endSurface = nullptr,
- const ICompatibilityEstimator* ice = nullptr) const;
+ const Surface* startSurface = nullptr,
+ const Surface* endSurface = nullptr,
+ const ICompatibilityEstimator* ice = nullptr) const;
/// test compatible surface - checking directly for intersection & collection
///
@@ -379,15 +380,16 @@ protected:
/// @param gpos is the resolved global position
/// @param dir is themomentum direction
/// @param pdir is the propagation direction prescription
- /// @param bchk is the boundary check directive
+ /// @param bcheck is the boundary check directive
+ /// @param maxPathLength is the maximal path length allowed to the surface
/// @param collectSensitive is the prescription to find the sensitive surfaces
/// @param collectPassive is the prescription to find all passive surfaces
- /// @param searchType is the level of depth for the search
+ /// @param intersectionTest is a boolean idicating if intersection is done
/// @param startSurface is an (optional) start surface for the search:
/// excluded in return
/// @param endSurface is an (optional) end surface for the search: excluded in
/// return
- /// @ice is a (future) compatibility estimator that could be used to modify
+ /// @param ice is a (future) compatibility estimator that could be used to modify
/// the straight line approach
///
/// @return boolean that indicates if a compatible surface exists at all
@@ -397,14 +399,14 @@ protected:
const Vector3D& gpos,
const Vector3D& dir,
PropDirection pdir,
- const BoundaryCheck& bchk,
+ const BoundaryCheck& bcheck,
double maxPathLength,
bool collectSensitive,
bool collectPassive,
bool intersectionTest,
- const Surface* startSurface = nullptr,
- const Surface* endSurface = nullptr,
- const ICompatibilityEstimator* ice = nullptr) const;
+ const Surface* startSurface = nullptr,
+ const Surface* endSurface = nullptr,
+ const ICompatibilityEstimator* ice = nullptr) const;
/// private method to set enclosing TrackingVolume, called by friend class
/// only
@@ -423,7 +425,7 @@ protected:
///
/// @param dtvol is the detached tracking volume the layer is confined
void
- encloseDetachedTrackingVolume(const DetachedTrackingVolume& tvol) const;
+ encloseDetachedTrackingVolume(const DetachedTrackingVolume& dtvol) const;
/// the previous Layer according to BinGenUtils
mutable NextLayers m_nextLayers;
@@ -452,7 +454,7 @@ protected:
LayerType m_layerType;
/// pointer to the approach surface carrying the material
/// nullptr if no material set
- /// @TODO remove this concept
+ /// @todo remove this concept
const Surface* m_materialSurface;
private:
diff --git a/Core/include/ACTS/Surfaces/ConeBounds.hpp b/Core/include/ACTS/Surfaces/ConeBounds.hpp
index e271afe39d7f15b060ce0e7f52be16557e678fd3..d93e9ef917df1f207fe6570ea00b51721688b43e 100644
--- a/Core/include/ACTS/Surfaces/ConeBounds.hpp
+++ b/Core/include/ACTS/Surfaces/ConeBounds.hpp
@@ -105,11 +105,11 @@ public:
/// inside method for local position
///
/// @param lpos is the local position to be checked
- /// @param bchk is the boundary check directive
+ /// @param bcheck is the boundary check directive
///
/// @return is a boolean indicating if the position is inside
virtual bool
- inside(const Vector2D& lpos, const BoundaryCheck& bchk = true) const override;
+ inside(const Vector2D& lpos, const BoundaryCheck& bcheck = true) const override;
/// Inside method for the first local parameter
///
@@ -241,9 +241,9 @@ ConeBounds::inside(const Vector2D& lpos, double tol0, double tol1) const
}
inline bool
-ConeBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
+ConeBounds::inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const
{
- return ConeBounds::inside(lpos, bchk.toleranceLoc0, bchk.toleranceLoc1);
+ return ConeBounds::inside(lpos, bcheck.toleranceLoc0, bcheck.toleranceLoc1);
}
inline bool
diff --git a/Core/include/ACTS/Surfaces/ConeSurface.hpp b/Core/include/ACTS/Surfaces/ConeSurface.hpp
index 3030de1c080a44824ad5761137e81a169401dcdc..8c67370bfb1d01c655f2e2940466c183c8781e2d 100644
--- a/Core/include/ACTS/Surfaces/ConeSurface.hpp
+++ b/Core/include/ACTS/Surfaces/ConeSurface.hpp
@@ -176,7 +176,7 @@ public:
/// @param gpos is the start position for the intersection
/// @param dir is the start direction for the intersection
/// @param forceDir is the flag to force to go along the forward direction
- /// @param bchk is the boundary check to be used in this directive
+ /// @param bcheck is the boundary check to be used in this directive
///
/// <b>mathematical motivation:</b>
///
@@ -215,7 +215,7 @@ public:
intersectionEstimate(const Vector3D& gpos,
const Vector3D& dir,
bool forceDir = false,
- const BoundaryCheck& bchk = false) const override;
+ const BoundaryCheck& bcheck = false) const override;
/// the pathCorrection for derived classes with thickness
///
diff --git a/Core/include/ACTS/Surfaces/CylinderBounds.hpp b/Core/include/ACTS/Surfaces/CylinderBounds.hpp
index fa38851dbbfc362b52d081af2dcc63c3d4e3feac..2ea808ceadb520dc10e497f4ea94f30740b9040a 100644
--- a/Core/include/ACTS/Surfaces/CylinderBounds.hpp
+++ b/Core/include/ACTS/Surfaces/CylinderBounds.hpp
@@ -99,21 +99,21 @@ public:
/// the bounds Inside can be called without/with tolerances.
///
/// @param lpos Local position (assumed to be in right surface frame)
- /// @param bchk boundary check directive
+ /// @param bcheck boundary check directive
///
/// @return boolean indicator for the success of this operation
bool
- inside(const Vector2D& lpos, const BoundaryCheck& bchk) const override;
+ inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const override;
/// Specialized method for CylinderBounds that checks if a global position
/// is within the the cylinder cover
///
/// @param pos is the position in the cylinder frame
- /// @param bchk is the boundary check directive
+ /// @param bcheck is the boundary check directive
///
/// return boolean indicator for operation success
bool
- inside3D(const Vector3D& pos, const BoundaryCheck& bchk = true) const;
+ inside3D(const Vector3D& pos, const BoundaryCheck& bcheck = true) const;
/// Inside method for the second local parameter
///
@@ -203,34 +203,34 @@ CylinderBounds::inside(const Vector2D& lpos, double tol0, double tol1) const
}
inline bool
-CylinderBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
+CylinderBounds::inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const
{
- if (bchk.bcType == 0 || bchk.nSigmas == 0
+ if (bcheck.bcType == 0 || bcheck.nSigmas == 0
|| m_valueStore.at(CylinderBounds::bv_halfPhiSector) != M_PI)
- return CylinderBounds::inside(lpos, bchk.toleranceLoc0, bchk.toleranceLoc1);
+ return CylinderBounds::inside(lpos, bcheck.toleranceLoc0, bcheck.toleranceLoc1);
- float theta = ((*bchk.lCovariance)(1, 0) != 0
- && ((*bchk.lCovariance)(1, 1) - (*bchk.lCovariance)(0, 0)) != 0)
+ float theta = ((*bcheck.lCovariance)(1, 0) != 0
+ && ((*bcheck.lCovariance)(1, 1) - (*bcheck.lCovariance)(0, 0)) != 0)
? .5
- * bchk.FastArcTan(2 * (*bchk.lCovariance)(1, 0)
- / ((*bchk.lCovariance)(1, 1) - (*bchk.lCovariance)(0, 0)))
+ * bcheck.FastArcTan(2 * (*bcheck.lCovariance)(1, 0)
+ / ((*bcheck.lCovariance)(1, 1) - (*bcheck.lCovariance)(0, 0)))
: 0.;
- sincosCache scResult = bchk.FastSinCos(theta);
- double dphi = scResult.sinC * scResult.sinC * (*bchk.lCovariance)(0, 0);
- double dz = scResult.cosC * scResult.cosC * (*bchk.lCovariance)(0, 1);
+ sincosCache scResult = bcheck.FastSinCos(theta);
+ double dphi = scResult.sinC * scResult.sinC * (*bcheck.lCovariance)(0, 0);
+ double dz = scResult.cosC * scResult.cosC * (*bcheck.lCovariance)(0, 1);
double max_ell = dphi > dz ? dphi : dz;
- double limit = bchk.nSigmas * sqrt(max_ell);
+ double limit = bcheck.nSigmas * sqrt(max_ell);
return insideLocZ(lpos[Acts::eLOC_Z], limit);
}
inline bool
-CylinderBounds::inside3D(const Vector3D& glopo, const BoundaryCheck& bchk) const
+CylinderBounds::inside3D(const Vector3D& glopo, const BoundaryCheck& bcheck) const
{
return inside(glopo.perp(),
glopo.phi(),
glopo.z(),
- bchk.toleranceLoc0,
- bchk.toleranceLoc0);
+ bcheck.toleranceLoc0,
+ bcheck.toleranceLoc0);
}
//!< @todo integrate tol0
diff --git a/Core/include/ACTS/Surfaces/CylinderSurface.hpp b/Core/include/ACTS/Surfaces/CylinderSurface.hpp
index a0ba836d9f6661d456f06374b0ed6b32cd7c2e05..ea1f3a7c6a873802e79ea013652bd155e3fc6745 100644
--- a/Core/include/ACTS/Surfaces/CylinderSurface.hpp
+++ b/Core/include/ACTS/Surfaces/CylinderSurface.hpp
@@ -175,6 +175,7 @@ public:
///
/// @param gpos is the global position to be checked
/// @param bcheck is the boundary check object
+ ///
/// @return is a boolean indicating if the position is on surface
virtual bool
isOnSurface(const Vector3D& gpos,
@@ -186,7 +187,7 @@ public:
/// @param gpos is the global position as a starting point
/// @param dir is the global direction at the starting point
/// @param forceDir is a boolean forcing a solution along direction
- /// @param bchk is the boundary check
+ /// @param bcheck is the boundary check
///
/// <b>mathematical motivation:</b>
///
@@ -214,7 +215,7 @@ public:
intersectionEstimate(const Vector3D& gpos,
const Vector3D& dir,
bool forceDir = false,
- const BoundaryCheck& bchk = false) const override;
+ const BoundaryCheck& bcheck = false) const override;
/// Path correction due to incident of the track
///
diff --git a/Core/include/ACTS/Surfaces/DiamondBounds.hpp b/Core/include/ACTS/Surfaces/DiamondBounds.hpp
index c3ec01faf26d4edab24ab2e6fdeada23e84d7dad..bc672c70e18bcf76875f2d9c959f55820d3776f3 100644
--- a/Core/include/ACTS/Surfaces/DiamondBounds.hpp
+++ b/Core/include/ACTS/Surfaces/DiamondBounds.hpp
@@ -120,11 +120,11 @@ public:
/// the bounds Inside can be called without/with tolerances.
///
/// @param lpos Local position (assumed to be in right surface frame)
- /// @param bchk boundary check directive
+ /// @param bcheck boundary check directive
///
/// @return boolean indicator for the success of this operation
virtual bool
- inside(const Vector2D& lpos, const BoundaryCheck& bchk) const override;
+ inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const override;
/// This method checks inside bounds in loc1
/// - loc1/loc2 correspond to the natural coordinates of the surface
@@ -223,16 +223,16 @@ DiamondBounds::halflengthY2() const
}
inline bool
-DiamondBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
+DiamondBounds::inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const
{
- if (bchk.bcType == 0)
- return DiamondBounds::inside(lpos, bchk.toleranceLoc0, bchk.toleranceLoc1);
+ if (bcheck.bcType == 0)
+ return DiamondBounds::inside(lpos, bcheck.toleranceLoc0, bcheck.toleranceLoc1);
// a fast FALSE
- double max_ell = (*bchk.lCovariance)(0, 0) > (*bchk.lCovariance)(1, 1)
- ? (*bchk.lCovariance)(0, 0)
- : (*bchk.lCovariance)(1, 1);
- double limit = bchk.nSigmas * sqrt(max_ell);
+ double max_ell = (*bcheck.lCovariance)(0, 0) > (*bcheck.lCovariance)(1, 1)
+ ? (*bcheck.lCovariance)(0, 0)
+ : (*bcheck.lCovariance)(1, 1);
+ double limit = bcheck.nSigmas * sqrt(max_ell);
if (lpos[Acts::eLOC_Y]
< -2 * m_valueStore.at(DiamondBounds::bv_halfY1) - limit)
return false;
@@ -244,10 +244,10 @@ DiamondBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
if (fabsX > (m_valueStore.at(DiamondBounds::bv_medHalfX) + limit))
return false;
// a fast TRUE
- double min_ell = (*bchk.lCovariance)(0, 0) < (*bchk.lCovariance)(1, 1)
- ? (*bchk.lCovariance)(0, 0)
- : (*bchk.lCovariance)(1, 1);
- limit = bchk.nSigmas * sqrt(min_ell);
+ double min_ell = (*bcheck.lCovariance)(0, 0) < (*bcheck.lCovariance)(1, 1)
+ ? (*bcheck.lCovariance)(0, 0)
+ : (*bcheck.lCovariance)(1, 1);
+ limit = bcheck.nSigmas * sqrt(min_ell);
if (fabsX < (fmin(m_valueStore.at(DiamondBounds::bv_minHalfX),
m_valueStore.at(DiamondBounds::bv_maxHalfX))
- limit))
@@ -262,13 +262,13 @@ DiamondBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
// compute KDOP and axes for surface polygon
std::vector<KDOP> elementKDOP(5);
std::vector<Vector2D> elementP(6);
- float theta = ((*bchk.lCovariance)(1, 0) != 0
- && ((*bchk.lCovariance)(1, 1) - (*bchk.lCovariance)(0, 0)) != 0)
+ float theta = ((*bcheck.lCovariance)(1, 0) != 0
+ && ((*bcheck.lCovariance)(1, 1) - (*bcheck.lCovariance)(0, 0)) != 0)
? .5
- * bchk.FastArcTan(2 * (*bchk.lCovariance)(1, 0)
- / ((*bchk.lCovariance)(1, 1) - (*bchk.lCovariance)(0, 0)))
+ * bcheck.FastArcTan(2 * (*bcheck.lCovariance)(1, 0)
+ / ((*bcheck.lCovariance)(1, 1) - (*bcheck.lCovariance)(0, 0)))
: 0.;
- sincosCache scResult = bchk.FastSinCos(theta);
+ sincosCache scResult = bcheck.FastSinCos(theta);
ActsMatrixD<2, 2> rotMatrix;
rotMatrix << scResult.cosC, scResult.sinC, -scResult.sinC, scResult.cosC;
ActsMatrixD<2, 2> normal;
@@ -297,12 +297,12 @@ DiamondBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
normal * (elementP.at(3) - elementP.at(2)),
normal * (elementP.at(4) - elementP.at(3)),
normal * (elementP.at(5) - elementP.at(4))};
- bchk.ComputeKDOP(elementP, axis, elementKDOP);
+ bcheck.ComputeKDOP(elementP, axis, elementKDOP);
// compute KDOP for error ellipse
std::vector<KDOP> errelipseKDOP(5);
- bchk.ComputeKDOP(bchk.EllipseToPoly(3), axis, errelipseKDOP);
+ bcheck.ComputeKDOP(bcheck.EllipseToPoly(3), axis, errelipseKDOP);
// check if KDOPs overlap and return result
- return bchk.TestKDOPKDOP(elementKDOP, errelipseKDOP);
+ return bcheck.TestKDOPKDOP(elementKDOP, errelipseKDOP);
}
inline bool
diff --git a/Core/include/ACTS/Surfaces/DiscSurface.hpp b/Core/include/ACTS/Surfaces/DiscSurface.hpp
index fd0109826edb66656bd0ed629b9456c0a2d88c42..7b64d8ebec4cc9f3e746f58c107592848929fb91 100644
--- a/Core/include/ACTS/Surfaces/DiscSurface.hpp
+++ b/Core/include/ACTS/Surfaces/DiscSurface.hpp
@@ -153,12 +153,12 @@ public:
/// or not
///
/// @param gpos is the global position to be checked
- /// @param bchk is the boundary check directive
+ /// @param bcheck is the boundary check directive
///
/// @return bollean that indicates if the position is on surface
virtual bool
isOnSurface(const Vector3D& gpos,
- const BoundaryCheck& bchk = true) const override;
+ const BoundaryCheck& bcheck = true) const override;
/// Local to global transformation
/// For planar surfaces the momentum is ignroed in the local to global
@@ -252,7 +252,7 @@ public:
/// @param gpos is the global position as a starting point
/// @param dir is the global direction at the starting point
/// @param forceDir is a boolean forcing a solution along direction
- /// @param bchk is the boundary check
+ /// @param bcheck is the boundary check
///
/// <b>mathematical motivation:</b>
///
@@ -276,7 +276,7 @@ public:
intersectionEstimate(const Vector3D& gpos,
const Vector3D& dir,
bool forceDir = false,
- const BoundaryCheck& bchk = false) const override;
+ const BoundaryCheck& bcheck = false) const override;
/// Return properly formatted class name for screen output
virtual std::string
@@ -342,7 +342,7 @@ inline Intersection
DiscSurface::intersectionEstimate(const Vector3D& gpos,
const Vector3D& dir,
bool forceDir,
- const BoundaryCheck& bchk) const
+ const BoundaryCheck& bcheck) const
{
double denom = dir.dot(normal());
if (denom) {
@@ -351,7 +351,7 @@ DiscSurface::intersectionEstimate(const Vector3D& gpos,
// evaluate the intersection in terms of direction
bool isValid = forceDir ? (u > 0.) : true;
// evaluate (if necessary in terms of boundaries)
- isValid = bchk ? (isValid && isOnSurface(intersectPoint, bchk)) : isValid;
+ isValid = bcheck ? (isValid && isOnSurface(intersectPoint, bcheck)) : isValid;
// return the result
return Intersection(intersectPoint, u, isValid);
}
diff --git a/Core/include/ACTS/Surfaces/DiscTrapezoidalBounds.hpp b/Core/include/ACTS/Surfaces/DiscTrapezoidalBounds.hpp
index da8a7855d7d4f26a8a8ddc6760073958613ecbc4..74fbb6aa721283adbd167fcb983aec000b903056 100644
--- a/Core/include/ACTS/Surfaces/DiscTrapezoidalBounds.hpp
+++ b/Core/include/ACTS/Surfaces/DiscTrapezoidalBounds.hpp
@@ -93,9 +93,9 @@ public:
/// [rMin,rMax]
/// if only tol0 is given and additional in the phi sector is tol1 is given
/// @param lpos is the local position to be checked (in polar coordinates)
- /// @param bchk is the boundary check directive
+ /// @param bcheck is the boundary check directive
virtual bool
- inside(const Vector2D& lpos, const BoundaryCheck& bchk = true) const override;
+ inside(const Vector2D& lpos, const BoundaryCheck& bcheck = true) const override;
/// This method checks inside bounds in loc0
/// @param lpos is the local position to be checked (in polar coordinates)
@@ -213,24 +213,24 @@ DiscTrapezoidalBounds::inside(const Vector2D& lpos, double, double) const
inline bool
DiscTrapezoidalBounds::inside(const Vector2D& lpos,
- const BoundaryCheck& bchk) const
+ const BoundaryCheck& bcheck) const
{
- if (bchk.bcType == 0 || bchk.nSigmas == 0
+ if (bcheck.bcType == 0 || bcheck.nSigmas == 0
|| m_valueStore.at(DiscTrapezoidalBounds::bv_rMin) != 0)
return DiscTrapezoidalBounds::inside(
- lpos, bchk.toleranceLoc0, bchk.toleranceLoc1);
+ lpos, bcheck.toleranceLoc0, bcheck.toleranceLoc1);
double alpha = fabs(lpos[Acts::eLOC_PHI]
- m_valueStore.at(DiscTrapezoidalBounds::bv_averagePhi));
if (alpha > M_PI) alpha = 2 * M_PI - alpha;
// a fast FALSE
- sincosCache scResult = bchk.FastSinCos(lpos(1, 0));
- double dx = bchk.nSigmas * sqrt((*bchk.lCovariance)(0, 0));
- double dy = bchk.nSigmas
- * sqrt(scResult.sinC * scResult.sinC * (*bchk.lCovariance)(0, 0)
+ sincosCache scResult = bcheck.FastSinCos(lpos(1, 0));
+ double dx = bcheck.nSigmas * sqrt((*bcheck.lCovariance)(0, 0));
+ double dy = bcheck.nSigmas
+ * sqrt(scResult.sinC * scResult.sinC * (*bcheck.lCovariance)(0, 0)
+ lpos(0, 0) * lpos(0, 0) * scResult.cosC * scResult.cosC
- * (*bchk.lCovariance)(1, 1)
+ * (*bcheck.lCovariance)(1, 1)
+ 2 * scResult.cosC * scResult.sinC * lpos(0, 0)
- * (*bchk.lCovariance)(0, 1));
+ * (*bcheck.lCovariance)(0, 1));
double max_ell = dx > dy ? dx : dy;
if (lpos(0, 0)
> (m_valueStore.at(DiscTrapezoidalBounds::bv_rMax)
@@ -390,22 +390,22 @@ DiscTrapezoidalBounds::inside(const Vector2D& lpos,
covRotMatrix << scResult.cosC, -lpos(0, 0) * scResult.sinC, scResult.sinC,
lpos(0, 0) * scResult.cosC;
ActsMatrixD<2, 2> lCovarianceCar
- = covRotMatrix * (*bchk.lCovariance) * covRotMatrix.transpose();
+ = covRotMatrix * (*bcheck.lCovariance) * covRotMatrix.transpose();
Vector2D lposCar(covRotMatrix(1, 1), -covRotMatrix(0, 1));
// ellipse is always at (0,0), surface is moved to ellipse position and then
// rotated
- double w = bchk.nSigmas * sqrt(lCovarianceCar(0, 0));
- double h = bchk.nSigmas * sqrt(lCovarianceCar(1, 1));
+ double w = bcheck.nSigmas * sqrt(lCovarianceCar(0, 0));
+ double h = bcheck.nSigmas * sqrt(lCovarianceCar(1, 1));
double x0 = 0;
double y0 = 0;
float theta = (lCovarianceCar(1, 0) != 0
&& (lCovarianceCar(1, 1) - lCovarianceCar(0, 0)) != 0)
? .5
- * bchk.FastArcTan(2 * lCovarianceCar(1, 0)
+ * bcheck.FastArcTan(2 * lCovarianceCar(1, 0)
/ (lCovarianceCar(1, 1) - lCovarianceCar(0, 0)))
: 0.;
- scResult = bchk.FastSinCos(theta);
+ scResult = bcheck.FastSinCos(theta);
ActsMatrixD<2, 2> rotMatrix;
rotMatrix << scResult.cosC, scResult.sinC, -scResult.sinC, scResult.cosC;
Vector2D tmp = rotMatrix * (-lposCar);
diff --git a/Core/include/ACTS/Surfaces/EllipseBounds.hpp b/Core/include/ACTS/Surfaces/EllipseBounds.hpp
index e3c780e4d4620b813238cc4b7f5402e0b23a5fa3..4c90700cc805dc47d251402799906aae4caa10c5 100644
--- a/Core/include/ACTS/Surfaces/EllipseBounds.hpp
+++ b/Core/include/ACTS/Surfaces/EllipseBounds.hpp
@@ -95,12 +95,12 @@ public:
/// tol1 is given
///
/// @param lpos Local position (assumed to be in right surface frame)
- /// @param bchk boundary check directive
+ /// @param bcheck boundary check directive
///
/// @return boolean indicator for the success of this operation
virtual bool
- inside(const Vector2D& lpos, const BoundaryCheck& bchk) const override;
+ inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const override;
/// Check for inside first local coordinate
///
@@ -211,9 +211,9 @@ EllipseBounds::inside(const Vector2D& lpos, double tol0, double tol1) const
}
inline bool
-EllipseBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
+EllipseBounds::inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const
{
- return EllipseBounds::inside(lpos, bchk.toleranceLoc0, bchk.toleranceLoc1);
+ return EllipseBounds::inside(lpos, bcheck.toleranceLoc0, bcheck.toleranceLoc1);
}
inline bool
diff --git a/Core/include/ACTS/Surfaces/LineBounds.hpp b/Core/include/ACTS/Surfaces/LineBounds.hpp
index c36ca4aceefb0c4d33c13b2427f9a5919d8d4ab2..6fdd4719c3f7c119d5924a4cbee81cb232d5d658 100644
--- a/Core/include/ACTS/Surfaces/LineBounds.hpp
+++ b/Core/include/ACTS/Surfaces/LineBounds.hpp
@@ -66,11 +66,11 @@ public:
/// the bounds Inside can be called without/with tolerances.
///
/// @param lpos Local position (assumed to be in right surface frame)
- /// @param bchk boundary check directive
+ /// @param bcheck boundary check directive
///
/// @return boolean indicator for the success of this operation
virtual bool
- inside(const Vector2D& lpos, const BoundaryCheck& bchk) const override;
+ inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const override;
/// Inside check for the bounds object with tolerance
/// checks for first coordinate only.
@@ -136,7 +136,7 @@ private:
/// private method for inside check
///
/// @param lpos is the local position to check for the distance
- /// @param r is the radius to be checked
+ /// @param tol0 is the tolerance on the radius
/// @param tol1 is the tolerance on z
///
/// @return is a boolean indicating the operation success
@@ -151,25 +151,25 @@ LineBounds::clone() const
}
inline bool
-LineBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
+LineBounds::inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const
{
// fast exit - this is a public interface method
if (!m_valueStore.size()) return true;
// check with tolerance
- if (bchk.bcType == 0 || bchk.nSigmas == 0)
- return LineBounds::inside(lpos, bchk.toleranceLoc0, bchk.toleranceLoc1);
+ if (bcheck.bcType == 0 || bcheck.nSigmas == 0)
+ return LineBounds::inside(lpos, bcheck.toleranceLoc0, bcheck.toleranceLoc1);
// ellipsoid check
- float theta = ((*bchk.lCovariance)(1, 0) != 0
- && ((*bchk.lCovariance)(1, 1) - (*bchk.lCovariance)(0, 0)) != 0)
+ float theta = ((*bcheck.lCovariance)(1, 0) != 0
+ && ((*bcheck.lCovariance)(1, 1) - (*bcheck.lCovariance)(0, 0)) != 0)
? .5
- * bchk.FastArcTan(2 * (*bchk.lCovariance)(1, 0)
- / ((*bchk.lCovariance)(1, 1) - (*bchk.lCovariance)(0, 0)))
+ * bcheck.FastArcTan(2 * (*bcheck.lCovariance)(1, 0)
+ / ((*bcheck.lCovariance)(1, 1) - (*bcheck.lCovariance)(0, 0)))
: 0.;
- sincosCache scResult = bchk.FastSinCos(theta);
- double dphi = scResult.sinC * scResult.sinC * (*bchk.lCovariance)(0, 0);
- double dz = scResult.cosC * scResult.cosC * (*bchk.lCovariance)(0, 1);
+ sincosCache scResult = bcheck.FastSinCos(theta);
+ double dphi = scResult.sinC * scResult.sinC * (*bcheck.lCovariance)(0, 0);
+ double dz = scResult.cosC * scResult.cosC * (*bcheck.lCovariance)(0, 1);
double max_ell = dphi > dz ? dphi : dz;
- double limit = bchk.nSigmas * sqrt(max_ell);
+ double limit = bcheck.nSigmas * sqrt(max_ell);
return insideLocZ(lpos[Acts::eLOC_Z], limit);
}
diff --git a/Core/include/ACTS/Surfaces/LineSurface.hpp b/Core/include/ACTS/Surfaces/LineSurface.hpp
index 764e0254d1158852ef386787dee9651cfb991a55..cfef735798027274de3f27f08679f1121f0d7e50 100644
--- a/Core/include/ACTS/Surfaces/LineSurface.hpp
+++ b/Core/include/ACTS/Surfaces/LineSurface.hpp
@@ -41,7 +41,7 @@ public:
/// @param htrans is the transform that positions the surface in the global
/// frame
/// @param radius is the straw radius
- /// @param halex is the half length in z
+ /// @param halez is the half length in z
LineSurface(std::shared_ptr<Transform3D> htrans, double radius, double halez);
/// Constructor from Transform3D and a shared bounds object
@@ -154,7 +154,7 @@ public:
/// \image html SignOfDriftCircleD0.gif
/// @param gpos global 3D position - considered to be on surface but not
/// inside bounds (check is done)
- /// @param gmom global 3D momentum representation (optionally ignored)
+ /// @param mom global 3D momentum representation (optionally ignored)
/// @param lpos local 2D position to be filled (given by reference for method
/// symmetry)
///
@@ -177,9 +177,9 @@ public:
/// @param gpos is the global position as a starting point
/// @param dir is the global direction at the starting point
/// @param forceDir is a boolean forcing a solution along direction
- /// @param bchk is the boundary check
+ /// @param bcheck is the boundary check
///
- /// b>mathematical motivation:</b>
+ /// <b>mathematical motivation:</b>
/// Given two lines in parameteric form:<br>
/// - @f$ \vec l_{a}(\lambda) = \vec m_a + \lambda \cdot \vec e_{a} @f$ <br>
/// - @f$ \vec l_{b}(\mu) = \vec m_b + \mu \cdot \vec e_{b} @f$ <br>
@@ -211,7 +211,7 @@ public:
intersectionEstimate(const Vector3D& gpos,
const Vector3D& dir,
bool forceDir,
- const BoundaryCheck& bchk = true) const override;
+ const BoundaryCheck& bcheck = true) const override;
/// the pathCorrection for derived classes with thickness
/// is by definition 1 for LineSurfaces
@@ -231,12 +231,12 @@ public:
/// as it saves the time of sign determination.
///
/// @param gpos is the global position to be checked
- /// @param bchk is the boundary check directive
+ /// @param bcheck is the boundary check directive
///
/// @return bollean that indicates if the position is on surface
virtual bool
isOnSurface(const Vector3D& gpos,
- const BoundaryCheck& bchk = true) const override;
+ const BoundaryCheck& bcheck = true) const override;
/// This method returns the bounds of the Surface by reference */
virtual const SurfaceBounds&
@@ -257,7 +257,7 @@ private:
///
/// @param pos is the global position
/// @param mom is the momentum
- /// @param is the local position to be filled
+ /// @param lpos is the local position to be filled
bool
globalToLocalPlain(const Vector3D& pos,
const Vector3D& mom,
diff --git a/Core/include/ACTS/Surfaces/PlaneSurface.hpp b/Core/include/ACTS/Surfaces/PlaneSurface.hpp
index b98c8f33a374f5b5da932205d784141bfe365d1c..5e5b15b5905da23b0006552e2fd494d147364688 100644
--- a/Core/include/ACTS/Surfaces/PlaneSurface.hpp
+++ b/Core/include/ACTS/Surfaces/PlaneSurface.hpp
@@ -123,12 +123,12 @@ public:
/// or not
///
/// @param gpos global position to be checked
- /// @param bchk gboundary check directive
+ /// @param bcheck gboundary check directive
///
/// @return is a boolean indicator if the position is on surface
virtual bool
isOnSurface(const Vector3D& gpos,
- const BoundaryCheck& bchk = true) const override;
+ const BoundaryCheck& bcheck = true) const override;
/// Local to global transformation
/// For planar surfaces the momentum is ignroed in the local to global
@@ -173,7 +173,7 @@ public:
/// @param dir is the direction of the interesection attempt
/// @param forceDir is the directive whether to force only foward solution
/// (w.r.t dir)
- /// @param bhck is the boundary check directive
+ /// @param bcheck is the boundary check directive
///
/// <b>mathematical motivation:</b>
///
@@ -195,7 +195,7 @@ public:
intersectionEstimate(const Vector3D& gpos,
const Vector3D& dir,
bool forceDir,
- const BoundaryCheck& bchk = true) const override;
+ const BoundaryCheck& bcheck = true) const override;
/// Return properly formatted class name for screen output
virtual std::string
@@ -247,7 +247,7 @@ inline Intersection
PlaneSurface::intersectionEstimate(const Vector3D& gpos,
const Vector3D& dir,
bool forceDir,
- const BoundaryCheck& bchk) const
+ const BoundaryCheck& bcheck) const
{
double denom = dir.dot(normal());
if (denom) {
@@ -256,7 +256,7 @@ PlaneSurface::intersectionEstimate(const Vector3D& gpos,
// evaluate the intersection in terms of direction
bool isValid = forceDir ? (u > 0.) : true;
// evaluate (if necessary in terms of boundaries)
- isValid = bchk ? (isValid && isOnSurface(intersectPoint, bchk)) : isValid;
+ isValid = bcheck ? (isValid && isOnSurface(intersectPoint, bcheck)) : isValid;
// return the result
return Intersection(intersectPoint, u, isValid);
}
diff --git a/Core/include/ACTS/Surfaces/RadialBounds.hpp b/Core/include/ACTS/Surfaces/RadialBounds.hpp
index 40e7e65185b285fdf73c7642da67e6e9979ba55f..c34b316a66ad120e2d3c2177d1ab417dfea9c0d1 100644
--- a/Core/include/ACTS/Surfaces/RadialBounds.hpp
+++ b/Core/include/ACTS/Surfaces/RadialBounds.hpp
@@ -87,11 +87,11 @@ public:
/// For disc surfaces the local position in (r,phi) is checked
///
/// @param lpos local position to be checked
- /// @param bchk boundary check directive
+ /// @param bcheck boundary check directive
///
/// @return is a boolean indicating the operation success
virtual bool
- inside(const Vector2D& lpos, const BoundaryCheck& bchk) const override;
+ inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const override;
/// Inside check for the first coordinate
///
@@ -180,22 +180,22 @@ RadialBounds::inside(const Vector2D& lpos, double tol0, double tol1) const
}
inline bool
-RadialBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
+RadialBounds::inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const
{
- if (bchk.bcType == 0 || bchk.nSigmas == 0
+ if (bcheck.bcType == 0 || bcheck.nSigmas == 0
|| m_valueStore[RadialBounds::bv_rMin] != 0
|| m_valueStore[RadialBounds::bv_halfPhiSector] != M_PI)
- return RadialBounds::inside(lpos, bchk.toleranceLoc0, bchk.toleranceLoc1);
+ return RadialBounds::inside(lpos, bcheck.toleranceLoc0, bcheck.toleranceLoc1);
// a fast FALSE
- sincosCache scResult = bchk.FastSinCos(lpos(1, 0));
- double dx = bchk.nSigmas * sqrt((*bchk.lCovariance)(0, 0));
- double dy = bchk.nSigmas
- * sqrt(scResult.sinC * scResult.sinC * (*bchk.lCovariance)(0, 0)
+ sincosCache scResult = bcheck.FastSinCos(lpos(1, 0));
+ double dx = bcheck.nSigmas * sqrt((*bcheck.lCovariance)(0, 0));
+ double dy = bcheck.nSigmas
+ * sqrt(scResult.sinC * scResult.sinC * (*bcheck.lCovariance)(0, 0)
+ lpos(0, 0) * lpos(0, 0) * scResult.cosC * scResult.cosC
- * (*bchk.lCovariance)(1, 1)
+ * (*bcheck.lCovariance)(1, 1)
+ 2 * scResult.cosC * scResult.sinC * lpos(0, 0)
- * (*bchk.lCovariance)(0, 1));
+ * (*bcheck.lCovariance)(0, 1));
double max_ell = dx > dy ? dx : dy;
if (lpos(0, 0) > (m_valueStore[RadialBounds::bv_rMax] + max_ell))
return false;
@@ -346,22 +346,22 @@ RadialBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
covRotMatrix << scResult.cosC, -lpos(0, 0) * scResult.sinC, scResult.sinC,
lpos(0, 0) * scResult.cosC;
ActsMatrixD<2, 2> lCovarianceCar
- = covRotMatrix * (*bchk.lCovariance) * covRotMatrix.transpose();
+ = covRotMatrix * (*bcheck.lCovariance) * covRotMatrix.transpose();
Vector2D lposCar(covRotMatrix(1, 1), -covRotMatrix(0, 1));
// ellipse is always at (0,0), surface is moved to ellipse position and then
// rotated
- double w = bchk.nSigmas * sqrt(lCovarianceCar(0, 0));
- double h = bchk.nSigmas * sqrt(lCovarianceCar(1, 1));
+ double w = bcheck.nSigmas * sqrt(lCovarianceCar(0, 0));
+ double h = bcheck.nSigmas * sqrt(lCovarianceCar(1, 1));
double x0 = 0;
double y0 = 0;
float theta = (lCovarianceCar(1, 0) != 0
&& (lCovarianceCar(1, 1) - lCovarianceCar(0, 0)) != 0)
? .5
- * bchk.FastArcTan(2 * lCovarianceCar(1, 0)
+ * bcheck.FastArcTan(2 * lCovarianceCar(1, 0)
/ (lCovarianceCar(1, 1) - lCovarianceCar(0, 0)))
: 0.;
- scResult = bchk.FastSinCos(theta);
+ scResult = bcheck.FastSinCos(theta);
ActsMatrixD<2, 2> rotMatrix;
rotMatrix << scResult.cosC, scResult.sinC, -scResult.sinC, scResult.cosC;
Vector2D tmp = rotMatrix * (-lposCar);
diff --git a/Core/include/ACTS/Surfaces/RectangleBounds.hpp b/Core/include/ACTS/Surfaces/RectangleBounds.hpp
index 92c19d1352cbc0d324d530ad5692f1eec2d7fae7..e5f8af1de8898a369a47d5b52f1049db16b9b197 100644
--- a/Core/include/ACTS/Surfaces/RectangleBounds.hpp
+++ b/Core/include/ACTS/Surfaces/RectangleBounds.hpp
@@ -72,11 +72,11 @@ public:
/// the bounds Inside can be called without/with tolerances.
///
/// @param lpos Local position (assumed to be in right surface frame)
- /// @param bchk boundary check directive
+ /// @param bcheck boundary check directive
///
/// @return boolean indicator for the success of this operation
virtual bool
- inside(const Vector2D& lpos, const BoundaryCheck& bchk) const override;
+ inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const override;
/// Inside check for the bounds object with tolerance
/// checks for first coordinate only.
@@ -143,35 +143,35 @@ RectangleBounds::clone() const
}
inline bool
-RectangleBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
+RectangleBounds::inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const
{
- if (bchk.bcType == 0)
- return RectangleBounds::insideLoc0(lpos, bchk.toleranceLoc0)
- && RectangleBounds::insideLoc1(lpos, bchk.toleranceLoc1);
+ if (bcheck.bcType == 0)
+ return RectangleBounds::insideLoc0(lpos, bcheck.toleranceLoc0)
+ && RectangleBounds::insideLoc1(lpos, bcheck.toleranceLoc1);
// a fast FALSE
- double max_ell = (*bchk.lCovariance)(0, 0) > (*bchk.lCovariance)(1, 1)
- ? (*bchk.lCovariance)(0, 0)
- : (*bchk.lCovariance)(1, 1);
- double limit = bchk.nSigmas * sqrt(max_ell);
+ double max_ell = (*bcheck.lCovariance)(0, 0) > (*bcheck.lCovariance)(1, 1)
+ ? (*bcheck.lCovariance)(0, 0)
+ : (*bcheck.lCovariance)(1, 1);
+ double limit = bcheck.nSigmas * sqrt(max_ell);
if (!RectangleBounds::inside(lpos, limit, limit)) return false;
// a fast TRUE
- double min_ell = (*bchk.lCovariance)(0, 0) < (*bchk.lCovariance)(1, 1)
- ? (*bchk.lCovariance)(0, 0)
- : (*bchk.lCovariance)(1, 1);
- limit = bchk.nSigmas * sqrt(min_ell);
+ double min_ell = (*bcheck.lCovariance)(0, 0) < (*bcheck.lCovariance)(1, 1)
+ ? (*bcheck.lCovariance)(0, 0)
+ : (*bcheck.lCovariance)(1, 1);
+ limit = bcheck.nSigmas * sqrt(min_ell);
if (RectangleBounds::inside(lpos, limit, limit)) return true;
// compute KDOP and axes for surface polygon
std::vector<KDOP> elementKDOP(4);
std::vector<Vector2D> elementP(4);
- float theta = ((*bchk.lCovariance)(1, 0) != 0
- && ((*bchk.lCovariance)(1, 1) - (*bchk.lCovariance)(0, 0)) != 0)
+ float theta = ((*bcheck.lCovariance)(1, 0) != 0
+ && ((*bcheck.lCovariance)(1, 1) - (*bcheck.lCovariance)(0, 0)) != 0)
? .5
- * bchk.FastArcTan(2 * (*bchk.lCovariance)(1, 0)
- / ((*bchk.lCovariance)(1, 1) - (*bchk.lCovariance)(0, 0)))
+ * bcheck.FastArcTan(2 * (*bcheck.lCovariance)(1, 0)
+ / ((*bcheck.lCovariance)(1, 1) - (*bcheck.lCovariance)(0, 0)))
: 0.;
- sincosCache scResult = bchk.FastSinCos(theta);
+ sincosCache scResult = bcheck.FastSinCos(theta);
ActsMatrixD<2, 2> rotMatrix;
rotMatrix << scResult.cosC, scResult.sinC, -scResult.sinC, scResult.cosC;
// ellipse is always at (0,0), surface is moved to ellipse position and then
@@ -193,12 +193,12 @@ RectangleBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
elementP.at(0) - elementP.at(2),
elementP.at(0) - elementP.at(3),
elementP.at(1) - elementP.at(2)};
- bchk.ComputeKDOP(elementP, axis, elementKDOP);
+ bcheck.ComputeKDOP(elementP, axis, elementKDOP);
// compute KDOP for error ellipse
std::vector<KDOP> errelipseKDOP(4);
- bchk.ComputeKDOP(bchk.EllipseToPoly(3), axis, errelipseKDOP);
+ bcheck.ComputeKDOP(bcheck.EllipseToPoly(3), axis, errelipseKDOP);
// check if KDOPs overlap and return result
- return bchk.TestKDOPKDOP(elementKDOP, errelipseKDOP);
+ return bcheck.TestKDOPKDOP(elementKDOP, errelipseKDOP);
}
inline bool
diff --git a/Core/include/ACTS/Surfaces/Surface.hpp b/Core/include/ACTS/Surfaces/Surface.hpp
index 6ddd893516dd892494e5d6a7b16aacefd4421a16..2a150c61b6272f45f136a9b784227375fb2a7b9b 100644
--- a/Core/include/ACTS/Surfaces/Surface.hpp
+++ b/Core/include/ACTS/Surfaces/Surface.hpp
@@ -211,32 +211,32 @@ public:
/// If that check fails, it calls the geometrical check isOnSurface
///
/// @tparam parameters TrackParameters to be checked
- /// @param bchk BoundaryCheck directive for this onSurface check
+ /// @param bcheck BoundaryCheck directive for this onSurface check
///
/// @return boolean indication if operation was successful
template <class T>
bool
onSurface(const T& parameters,
- const BoundaryCheck& bchk = BoundaryCheck(true)) const;
+ const BoundaryCheck& bcheck = BoundaryCheck(true)) const;
/// The insideBounds method for local positions
///
/// @param lpos local position to check
- /// @param bchk BoundaryCheck directive for this onSurface check
+ /// @param bcheck BoundaryCheck directive for this onSurface check
///
/// @return boolean indication if operation was successful
virtual bool
- insideBounds(const Vector2D& lpos, const BoundaryCheck& bchk = true) const;
+ insideBounds(const Vector2D& lpos, const BoundaryCheck& bcheck = true) const;
/// The geometric onSurface method
/// Geometrical check whether position is on Surface
///
/// @param gpos global position to be evaludated
- /// @param bchk BoundaryCheck directive for this onSurface check
+ /// @param bcheck BoundaryCheck directive for this onSurface check
///
/// @return boolean indication if operation was successful
virtual bool
- isOnSurface(const Vector3D& gpos, const BoundaryCheck& bchk = true) const;
+ isOnSurface(const Vector3D& gpos, const BoundaryCheck& bcheck = true) const;
/// Local to global transformation
/// Generalized local to global transformation for the surface types. Since
@@ -300,17 +300,17 @@ public:
/// @param pars TrackParameters to start from
/// @param forceDir boolean indication whether to force the direction given by
/// the TrackParameters to hold
- /// @param bchk boundary check directive for this operation
+ /// @param bcheck boundary check directive for this operation
///
/// @return Intersection class
template <class T>
Intersection
intersectionEstimate(const T& pars,
bool forceDir = false,
- const BoundaryCheck& bchk = false) const
+ const BoundaryCheck& bcheck = false) const
{
return intersectionEstimate(
- pars.position(), pars.momentum().unit(), forceDir, bchk);
+ pars.position(), pars.momentum().unit(), forceDir, bcheck);
}
/// Straight line intersection schema from parameters
@@ -322,14 +322,14 @@ public:
/// @param gdir global 3D direction representation
/// @param forceDir boolean indication whether to force the direction given by
/// the TrackParameters to hold
- /// @param bchk boundary check directive for this operation
+ /// @param bcheck boundary check directive for this operation
///
/// @return Intersection class
virtual Intersection
intersectionEstimate(const Vector3D& gpos,
const Vector3D& gdir,
bool forceDir = false,
- const BoundaryCheck& bchk = false) const = 0;
+ const BoundaryCheck& bcheck = false) const = 0;
/// Returns 'true' if this surface is 'free'
/// i.e. it does not belong to a detector element, a layer or a tracking
@@ -412,9 +412,9 @@ Surface::onSurface(const T& pars, const BoundaryCheck& bcheck) const
}
inline bool
-Surface::insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk) const
+Surface::insideBounds(const Vector2D& locpos, const BoundaryCheck& bcheck) const
{
- return bounds().inside(locpos, bchk);
+ return bounds().inside(locpos, bcheck);
}
inline const DetectorElementBase*
diff --git a/Core/include/ACTS/Surfaces/SurfaceBounds.hpp b/Core/include/ACTS/Surfaces/SurfaceBounds.hpp
index 795bb294608b78593b27619a06981e5f540384bc..7cc21301d0b5666aad7d19c9036e3d5f11f2cc05 100644
--- a/Core/include/ACTS/Surfaces/SurfaceBounds.hpp
+++ b/Core/include/ACTS/Surfaces/SurfaceBounds.hpp
@@ -113,11 +113,11 @@ public:
/// the bounds Inside can be called without/with tolerances.
///
/// @param lpos Local position (assumed to be in right surface frame)
- /// @param bchk boundary check directive
+ /// @param bcheck boundary check directive
///
/// @return boolean indicator for the success of this operation
virtual bool
- inside(const Vector2D& lpos, const BoundaryCheck& bchk) const = 0;
+ inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const = 0;
/// Inside check for the bounds object with tolerance
/// checks for first coordinate only.
diff --git a/Core/include/ACTS/Surfaces/TrapezoidBounds.hpp b/Core/include/ACTS/Surfaces/TrapezoidBounds.hpp
index 2040666607946db3adec14ed2a648f10dbd389cd..54a053cb058279107bf8ed9404b6b5bcd96c9d2f 100644
--- a/Core/include/ACTS/Surfaces/TrapezoidBounds.hpp
+++ b/Core/include/ACTS/Surfaces/TrapezoidBounds.hpp
@@ -110,7 +110,7 @@ public:
/// with the negative @f$ y @f$ - axis of the local frame.
///
/// @param lpos is the local position to be checked (carthesian local frame)
- /// @param bchk is the boundary check directive
+ /// @param bcheck is the boundary check directive
///
/// <br>
/// The cases are:<br>
@@ -146,11 +146,11 @@ public:
/// x_{min}) @f$
///
/// @param lpos Local position (assumed to be in right surface frame)
- /// @param bchk boundary check directive
+ /// @param bcheck boundary check directive
///
/// @return boolean indicator for the success of this operation
virtual bool
- inside(const Vector2D& lpos, const BoundaryCheck& bchk) const override;
+ inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const override;
/// This method checks inside bounds in loc0
/// @note loc0/loc1 correspond to the natural coordinates of the surface
@@ -282,17 +282,17 @@ TrapezoidBounds::beta() const
}
inline bool
-TrapezoidBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
+TrapezoidBounds::inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const
{
- if (bchk.bcType == 0)
- return inside(lpos, bchk.toleranceLoc0, bchk.toleranceLoc1);
+ if (bcheck.bcType == 0)
+ return inside(lpos, bcheck.toleranceLoc0, bcheck.toleranceLoc1);
// a fast FALSE
double fabsY = fabs(lpos[Acts::eLOC_Y]);
- double max_ell = (*bchk.lCovariance)(0, 0) > (*bchk.lCovariance)(1, 1)
- ? (*bchk.lCovariance)(0, 0)
- : (*bchk.lCovariance)(1, 1);
- double limit = bchk.nSigmas * sqrt(max_ell);
+ double max_ell = (*bcheck.lCovariance)(0, 0) > (*bcheck.lCovariance)(1, 1)
+ ? (*bcheck.lCovariance)(0, 0)
+ : (*bcheck.lCovariance)(1, 1);
+ double limit = bcheck.nSigmas * sqrt(max_ell);
if (fabsY > (m_valueStore.at(TrapezoidBounds::bv_halfY) + limit))
return false;
// a fast FALSE
@@ -300,10 +300,10 @@ TrapezoidBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
if (fabsX > (m_valueStore.at(TrapezoidBounds::bv_maxHalfX) + limit))
return false;
// a fast TRUE
- double min_ell = (*bchk.lCovariance)(0, 0) < (*bchk.lCovariance)(1, 1)
- ? (*bchk.lCovariance)(0, 0)
- : (*bchk.lCovariance)(1, 1);
- limit = bchk.nSigmas * sqrt(min_ell);
+ double min_ell = (*bcheck.lCovariance)(0, 0) < (*bcheck.lCovariance)(1, 1)
+ ? (*bcheck.lCovariance)(0, 0)
+ : (*bcheck.lCovariance)(1, 1);
+ limit = bcheck.nSigmas * sqrt(min_ell);
if (fabsX < (m_valueStore.at(TrapezoidBounds::bv_minHalfX) + limit)
&& fabsY < (m_valueStore.at(TrapezoidBounds::bv_halfY) + limit))
return true;
@@ -311,13 +311,13 @@ TrapezoidBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
// compute KDOP and axes for surface polygon
std::vector<KDOP> elementKDOP(3);
std::vector<Vector2D> elementP(4);
- float theta = ((*bchk.lCovariance)(1, 0) != 0
- && ((*bchk.lCovariance)(1, 1) - (*bchk.lCovariance)(0, 0)) != 0)
+ float theta = ((*bcheck.lCovariance)(1, 0) != 0
+ && ((*bcheck.lCovariance)(1, 1) - (*bcheck.lCovariance)(0, 0)) != 0)
? .5
- * bchk.FastArcTan(2 * (*bchk.lCovariance)(1, 0)
- / ((*bchk.lCovariance)(1, 1) - (*bchk.lCovariance)(0, 0)))
+ * bcheck.FastArcTan(2 * (*bcheck.lCovariance)(1, 0)
+ / ((*bcheck.lCovariance)(1, 1) - (*bcheck.lCovariance)(0, 0)))
: 0.;
- sincosCache scResult = bchk.FastSinCos(theta);
+ sincosCache scResult = bcheck.FastSinCos(theta);
ActsMatrixD<2, 2> rotMatrix;
rotMatrix << scResult.cosC, scResult.sinC, -scResult.sinC, scResult.cosC;
ActsMatrixD<2, 2> normal;
@@ -331,13 +331,13 @@ TrapezoidBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
p << -m_valueStore.at(TrapezoidBounds::bv_minHalfX),
-m_valueStore.at(TrapezoidBounds::bv_halfY);
elementP.at(1) = (rotMatrix * (p - lpos));
- scResult = bchk.FastSinCos(m_beta);
+ scResult = bcheck.FastSinCos(m_beta);
p << m_valueStore.at(TrapezoidBounds::bv_minHalfX)
+ (2. * m_valueStore.at(TrapezoidBounds::bv_halfY))
* (scResult.sinC / scResult.cosC),
m_valueStore.at(TrapezoidBounds::bv_halfY);
elementP.at(2) = (rotMatrix * (p - lpos));
- scResult = bchk.FastSinCos(m_alpha);
+ scResult = bcheck.FastSinCos(m_alpha);
p << -(m_valueStore.at(TrapezoidBounds::bv_minHalfX)
+ (2. * m_valueStore[TrapezoidBounds::bv_halfY])
* (scResult.sinC / scResult.cosC)),
@@ -346,12 +346,12 @@ TrapezoidBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
std::vector<Vector2D> axis = {normal * (elementP.at(1) - elementP.at(0)),
normal * (elementP.at(3) - elementP.at(1)),
normal * (elementP.at(2) - elementP.at(0))};
- bchk.ComputeKDOP(elementP, axis, elementKDOP);
+ bcheck.ComputeKDOP(elementP, axis, elementKDOP);
// compute KDOP for error ellipse
std::vector<KDOP> errelipseKDOP(3);
- bchk.ComputeKDOP(bchk.EllipseToPoly(3), axis, errelipseKDOP);
+ bcheck.ComputeKDOP(bcheck.EllipseToPoly(3), axis, errelipseKDOP);
// check if KDOPs overlap and return result
- return bchk.TestKDOPKDOP(elementKDOP, errelipseKDOP);
+ return bcheck.TestKDOPKDOP(elementKDOP, errelipseKDOP);
}
inline bool
diff --git a/Core/include/ACTS/Surfaces/TriangleBounds.hpp b/Core/include/ACTS/Surfaces/TriangleBounds.hpp
index 157a206b56ab25892d89da8b671a451d25a2f81f..2ed40357311084ba435ac1f43e569944b47a5797 100644
--- a/Core/include/ACTS/Surfaces/TriangleBounds.hpp
+++ b/Core/include/ACTS/Surfaces/TriangleBounds.hpp
@@ -76,11 +76,11 @@ public:
/// surface bounds
///
/// @param lpos local position in 2D local carthesian frame
- /// @param bchk is the boundary check directive
+ /// @param bcheck is the boundary check directive
///
/// @return boolean indicator for the success of this operation
virtual bool
- inside(const Vector2D& lpos, const BoundaryCheck& bchk) const override;
+ inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const override;
/// This method checks if the provided local coordinate 1 is inside the
/// surface bounds
@@ -182,31 +182,31 @@ TriangleBounds::inside(const Vector2D& lpos, double tol0, double tol1) const
}
inline bool
-TriangleBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
+TriangleBounds::inside(const Vector2D& lpos, const BoundaryCheck& bcheck) const
{
- if (bchk.bcType == 0)
- return TriangleBounds::inside(lpos, bchk.toleranceLoc0, bchk.toleranceLoc1);
+ if (bcheck.bcType == 0)
+ return TriangleBounds::inside(lpos, bcheck.toleranceLoc0, bcheck.toleranceLoc1);
/// @todo check for quick limit test
- /// double max_ell = (*bchk.lCovariance)(0, 0) > (*bchk.lCovariance)(1, 1)
- /// ? (*bchk.lCovariance)(0, 0)
- /// : (*bchk.lCovariance)(1, 1);
+ /// double max_ell = (*bcheck.lCovariance)(0, 0) > (*bcheck.lCovariance)(1, 1)
+ /// ? (*bcheck.lCovariance)(0, 0)
+ /// : (*bcheck.lCovariance)(1, 1);
/// a fast FALSE
/// double fabsR = sqrt(lpos[Acts::eLOC_X] * lpos[Acts::eLOC_X]
/// + lpos[Acts::eLOC_Y] * lpos[Acts::eLOC_Y]);
- /// double limit = bchk.nSigmas * sqrt(max_ell);
+ /// double limit = bcheck.nSigmas * sqrt(max_ell);
/// double r_max = TriangleBounds::r();
/// if (fabsR > (r_max + limit)) return false;
// compute KDOP and axes for surface polygon
std::vector<KDOP> elementKDOP(3);
std::vector<Vector2D> elementP(3);
- double theta = ((*bchk.lCovariance)(1, 0) != 0
- && ((*bchk.lCovariance)(1, 1) - (*bchk.lCovariance)(0, 0)) != 0)
+ double theta = ((*bcheck.lCovariance)(1, 0) != 0
+ && ((*bcheck.lCovariance)(1, 1) - (*bcheck.lCovariance)(0, 0)) != 0)
? .5
- * bchk.FastArcTan(2 * (*bchk.lCovariance)(1, 0)
- / ((*bchk.lCovariance)(1, 1) - (*bchk.lCovariance)(0, 0)))
+ * bcheck.FastArcTan(2 * (*bcheck.lCovariance)(1, 0)
+ / ((*bcheck.lCovariance)(1, 1) - (*bcheck.lCovariance)(0, 0)))
: 0.;
- sincosCache scResult = bchk.FastSinCos(theta);
+ sincosCache scResult = bcheck.FastSinCos(theta);
ActsMatrixD<2, 2> rotMatrix;
rotMatrix << scResult.cosC, scResult.sinC, -scResult.sinC, scResult.cosC;
ActsMatrixD<2, 2> normal;
@@ -226,12 +226,12 @@ TriangleBounds::inside(const Vector2D& lpos, const BoundaryCheck& bchk) const
std::vector<Vector2D> axis = {normal * (elementP.at(1) - elementP.at(0)),
normal * (elementP.at(2) - elementP.at(1)),
normal * (elementP.at(2) - elementP.at(0))};
- bchk.ComputeKDOP(elementP, axis, elementKDOP);
+ bcheck.ComputeKDOP(elementP, axis, elementKDOP);
// compute KDOP for error ellipse
std::vector<KDOP> errelipseKDOP(3);
- bchk.ComputeKDOP(bchk.EllipseToPoly(3), axis, errelipseKDOP);
+ bcheck.ComputeKDOP(bcheck.EllipseToPoly(3), axis, errelipseKDOP);
// check if KDOPs overlap and return result
- return bchk.TestKDOPKDOP(elementKDOP, errelipseKDOP);
+ return bcheck.TestKDOPKDOP(elementKDOP, errelipseKDOP);
}
inline bool
diff --git a/Core/include/ACTS/Utilities/ApproachDescriptor.hpp b/Core/include/ACTS/Utilities/ApproachDescriptor.hpp
index dc9d78494455101d7517d54d75fa27a1c3eeb41e..7c6d18e6c30110f15529e7eabc6d4e15bd8dc4c5 100644
--- a/Core/include/ACTS/Utilities/ApproachDescriptor.hpp
+++ b/Core/include/ACTS/Utilities/ApproachDescriptor.hpp
@@ -54,14 +54,14 @@ public:
///
/// @param pos is the position from start of the search
/// @param dir is the direction
- /// @param bchk is the boundary check directive
+ /// @param bcheck is the boundary check directive
/// @param ice is a (future) compatibility estimator
///
/// @return is a surface isntersection
virtual const SurfaceIntersection
approachSurface(const Vector3D& pos,
const Vector3D& dir,
- const BoundaryCheck& bchk,
+ const BoundaryCheck& bcheck,
const ICompatibilityEstimator* ice = nullptr) const = 0;
/// Tet to all the contained surfaces
diff --git a/Core/include/ACTS/Utilities/GeometryObject.hpp b/Core/include/ACTS/Utilities/GeometryObject.hpp
index 53f75c2e689127f07198b26ffb1c6c24667eb4bd..c45b06b90777ea62c9e2e3a4fe97d2b0a787d663 100644
--- a/Core/include/ACTS/Utilities/GeometryObject.hpp
+++ b/Core/include/ACTS/Utilities/GeometryObject.hpp
@@ -31,13 +31,13 @@ class GeometryObject
{
public:
/// default constructor
- ///
- /// @param geoID the geometry identifier of the object
GeometryObject() : m_geoID(0) {}
+
/// constructor from a ready-made value
///
/// @param geoID the geometry identifier of the object
GeometryObject(const GeometryID& geoID) : m_geoID(geoID) {}
+
/// assignment operator
///
/// @param geoID the source geoID
diff --git a/Core/include/ACTS/Utilities/Intersection.hpp b/Core/include/ACTS/Utilities/Intersection.hpp
index e7b051190f36915e10e78bff698e448b95ce3789..cd32736069e6ae45fd769d3d10ad5970f11e205d 100644
--- a/Core/include/ACTS/Utilities/Intersection.hpp
+++ b/Core/include/ACTS/Utilities/Intersection.hpp
@@ -34,7 +34,7 @@ struct Intersection
/// @param svalid is a boolean indicating if intersection is valid
/// @param dist is the distance to the surface, e.g. when outside bounds
Intersection(const Vector3D& sinter,
- double slenght,
+ double slength,
bool svalid,
double dist = 0.)
: position(sinter), pathLength(slenght), distance(dist), valid(svalid)
@@ -101,9 +101,9 @@ public:
/// Full intersection constructor
///
/// @param sInter is the intersection struct
- /// @param sObject is the intersected object
- /// @param sReprensentation is the surface representation of the object
- /// @param sResult is the type of result: neutral, charged TP e.g.
+ /// @tparam sObject is the intersected object
+ /// @tparam sRepresentation is the surface representation of the object
+ /// @tparam sResult is the type of result: neutral, charged TP e.g.
/// @param dir is the direction
///
/// @todo use unique_ptr for result !
diff --git a/Core/src/Layers/Layer.cpp b/Core/src/Layers/Layer.cpp
index 07e2e568c5a32efbfd684bca8de11972d5d57c85..bae95b434e3f4e71de9acf68e5defa4d4e66aefc 100644
--- a/Core/src/Layers/Layer.cpp
+++ b/Core/src/Layers/Layer.cpp
@@ -72,9 +72,9 @@ Acts::Layer::~Layer()
bool
Acts::Layer::isOnLayer(const Acts::Vector3D& gp,
- const BoundaryCheck& bchk) const
+ const BoundaryCheck& bcheck) const
{
- return (surfaceRepresentation()).isOnSurface(gp, bchk);
+ return (surfaceRepresentation()).isOnSurface(gp, bcheck);
}
const Acts::SurfaceIntersection
diff --git a/Core/src/Surfaces/ConeSurface.cpp b/Core/src/Surfaces/ConeSurface.cpp
index fdda05cd6ac87bcf7ef719f1b803b14c0babb9e5..0b4559dc0e5fdec878753e2b6a070a8cb0d94f6a 100644
--- a/Core/src/Surfaces/ConeSurface.cpp
+++ b/Core/src/Surfaces/ConeSurface.cpp
@@ -137,7 +137,7 @@ Acts::Intersection
Acts::ConeSurface::intersectionEstimate(const Vector3D& gpos,
const Vector3D& dir,
bool forceDir,
- const BoundaryCheck& bchk) const
+ const BoundaryCheck& bcheck) const
{
// transform to a frame with the cone along z, with the tip at 0
Acts::Vector3D tpos1 = m_transform ? transform().inverse() * gpos : gpos;
@@ -192,7 +192,7 @@ Acts::ConeSurface::intersectionEstimate(const Vector3D& gpos,
}
if (m_transform) solution = transform() * solution;
- isValid = bchk ? (isValid && isOnSurface(solution, bchk)) : isValid;
+ isValid = bcheck ? (isValid && isOnSurface(solution, bcheck)) : isValid;
return Intersection(solution, path, isValid);
}
diff --git a/Core/src/Surfaces/CylinderSurface.cpp b/Core/src/Surfaces/CylinderSurface.cpp
index da3451cb5dce19a427a6143ac6bac9e132bc81f6..3396dad6192cf7bf80d7888a8090499716acabc8 100644
--- a/Core/src/Surfaces/CylinderSurface.cpp
+++ b/Core/src/Surfaces/CylinderSurface.cpp
@@ -155,18 +155,18 @@ Acts::CylinderSurface::globalToLocal(const Vector3D& gpos,
bool
Acts::CylinderSurface::isOnSurface(const Acts::Vector3D& gpos,
- const BoundaryCheck& bchk) const
+ const BoundaryCheck& bcheck) const
{
Acts::Vector3D loc3Dframe
= Acts::Surface::m_transform ? (transform().inverse()) * gpos : gpos;
- return (bchk ? bounds().inside3D(loc3Dframe, bchk) : true);
+ return (bcheck ? bounds().inside3D(loc3Dframe, bcheck) : true);
}
Acts::Intersection
Acts::CylinderSurface::intersectionEstimate(const Acts::Vector3D& gpos,
const Acts::Vector3D& dir,
bool forceDir,
- const BoundaryCheck& bchk) const
+ const BoundaryCheck& bcheck) const
{
bool needsTransform = (m_transform || m_associatedDetElement) ? true : false;
// create the hep points
@@ -242,7 +242,7 @@ Acts::CylinderSurface::intersectionEstimate(const Acts::Vector3D& gpos,
}
}
// the solution is still in the local 3D frame, direct check
- isValid = bchk ? (isValid && bounds().inside3D(solution, bchk)) : isValid;
+ isValid = bcheck ? (isValid && bounds().inside3D(solution, bcheck)) : isValid;
// now return
return needsTransform ? Intersection(transform() * solution, path, isValid)
diff --git a/Core/src/Surfaces/DiscSurface.cpp b/Core/src/Surfaces/DiscSurface.cpp
index 06c529690c315d417fd9c18de7da32906128e3ff..7c7e82ff7e3fcaccb2be4a4b2ca523f5d64cb773 100644
--- a/Core/src/Surfaces/DiscSurface.cpp
+++ b/Core/src/Surfaces/DiscSurface.cpp
@@ -146,12 +146,12 @@ Acts::DiscSurface::globalToLocalCartesian(const Vector3D& gpos, double) const
bool
Acts::DiscSurface::isOnSurface(const Vector3D& glopo,
- const BoundaryCheck& bchk) const
+ const BoundaryCheck& bcheck) const
{
Vector3D loc3Dframe = (transform().inverse()) * glopo;
if (fabs(loc3Dframe.z()) > (s_onSurfaceTolerance)) return false;
return (
- bchk
- ? bounds().inside(Vector2D(loc3Dframe.perp(), loc3Dframe.phi()), bchk)
+ bcheck
+ ? bounds().inside(Vector2D(loc3Dframe.perp(), loc3Dframe.phi()), bcheck)
: true);
}
diff --git a/Core/src/Surfaces/LineSurface.cpp b/Core/src/Surfaces/LineSurface.cpp
index a59d1cbea76559e78aedf05800002b1dde3ebf33..9da59975e9053c0e8de573f5a7ee94001961f182 100644
--- a/Core/src/Surfaces/LineSurface.cpp
+++ b/Core/src/Surfaces/LineSurface.cpp
@@ -97,15 +97,15 @@ Acts::LineSurface::globalToLocal(const Vector3D& gpos,
bool
Acts::LineSurface::isOnSurface(const Vector3D& gpos,
- const BoundaryCheck& bchk) const
+ const BoundaryCheck& bcheck) const
{
- if (!bchk) return true;
+ if (!bcheck) return true;
// check whether this is a boundless surface
if (!m_bounds && !Surface::m_associatedDetElement) return true;
// get the standard bounds
Vector3D loc3Dframe = (transform().inverse()) * gpos;
Vector2D locCand(loc3Dframe.perp(), loc3Dframe.z());
- return bounds().inside(locCand, bchk);
+ return bounds().inside(locCand, bcheck);
}
const Acts::RotationMatrix3D
@@ -128,7 +128,7 @@ Acts::Intersection
Acts::LineSurface::intersectionEstimate(const Vector3D& gpos,
const Vector3D& dir,
bool forceDir,
- const BoundaryCheck& bchk) const
+ const BoundaryCheck& bcheck) const
{
// following nominclature found in header file and doxygen documentation
// line one is the straight track
@@ -147,7 +147,7 @@ Acts::LineSurface::intersectionEstimate(const Vector3D& gpos,
bool isValid = forceDir ? (lambda0 > 0.) : true;
// evaluate validaty in terms of bounds
Vector3D result = (ma + lambda0 * ea);
- isValid = bchk ? (isValid && isOnSurface(result, bchk)) : isValid;
+ isValid = bcheck ? (isValid && isOnSurface(result, bcheck)) : isValid;
// return the result
return Intersection(result, lambda0, isValid);
}
diff --git a/Core/src/Surfaces/PlaneSurface.cpp b/Core/src/Surfaces/PlaneSurface.cpp
index 021e5aae813e09c750c1fa8906a4ffb1d4654125..5adaef3b6dad28345c5f63d0068cf7f3e4937490 100644
--- a/Core/src/Surfaces/PlaneSurface.cpp
+++ b/Core/src/Surfaces/PlaneSurface.cpp
@@ -107,11 +107,11 @@ Acts::PlaneSurface::globalToLocal(const Vector3D& gpos,
bool
Acts::PlaneSurface::isOnSurface(const Vector3D& glopo,
- const BoundaryCheck& bchk) const
+ const BoundaryCheck& bcheck) const
{
/// the chance that there is no transform is almost 0, let's apply it
Vector3D loc3Dframe = (transform().inverse()) * glopo;
if (fabs(loc3Dframe.z()) > s_onSurfaceTolerance) return false;
- return (bchk ? bounds().inside(Vector2D(loc3Dframe.x(), loc3Dframe.y()), bchk)
+ return (bcheck ? bounds().inside(Vector2D(loc3Dframe.x(), loc3Dframe.y()), bcheck)
: true);
}
diff --git a/Core/src/Surfaces/Surface.cpp b/Core/src/Surfaces/Surface.cpp
index 05358117ee3029a33407be23c0d1ccc6f924111d..782683d8844880a3d22628faf3125532ca7b6235 100644
--- a/Core/src/Surfaces/Surface.cpp
+++ b/Core/src/Surfaces/Surface.cpp
@@ -95,7 +95,7 @@ Acts::Surface::operator==(const Surface& sf) const
bool
Acts::Surface::isOnSurface(const Acts::Vector3D& gpos,
- const BoundaryCheck& bchk) const
+ const BoundaryCheck& bcheck) const
{
// create the local position
Acts::Vector2D lpos;
@@ -103,9 +103,9 @@ Acts::Surface::isOnSurface(const Acts::Vector3D& gpos,
bool g2L = globalToLocal(gpos, Acts::Vector3D::UnitX(), lpos);
if (g2L) {
// no boundary check, then return true
- if (!bchk) return true;
+ if (!bcheck) return true;
// return what ever the bounds tell you
- return bounds().inside(lpos, bchk);
+ return bounds().inside(lpos, bcheck);
}
// did not succeed
return false;