From 66904f6226ea90701d372083b3879f25535e3a06 Mon Sep 17 00:00:00 2001
From: Paul Gessinger <paul.gessinger@cern.ch>
Date: Fri, 24 Aug 2018 18:57:29 +0200
Subject: [PATCH] readability-inconsistent-declaration-parameter-name
---
.static_analysis_limits.yml | 1 +
.../Acts/Detector/DetachedTrackingVolume.hpp | 8 +-
.../Acts/Detector/GlueVolumesDescriptor.hpp | 2 +-
.../Acts/Detector/TrackingGeometry.hpp | 26 +++---
Core/include/Acts/Detector/TrackingVolume.hpp | 71 ++++++++--------
.../Acts/EventData/TrackParametersBase.hpp | 2 +-
Core/include/Acts/Layers/ConeLayer.hpp | 4 +-
Core/include/Acts/Layers/CylinderLayer.hpp | 8 +-
Core/include/Acts/Layers/DiscLayer.hpp | 6 +-
.../Acts/Layers/GenericApproachDescriptor.hpp | 4 +-
Core/include/Acts/Layers/Layer.hpp | 60 ++++++-------
Core/include/Acts/Layers/NavigationLayer.hpp | 9 +-
Core/include/Acts/Layers/PlaneLayer.hpp | 4 +-
.../Acts/Material/BinnedSurfaceMaterial.hpp | 6 +-
.../Material/HomogeneousSurfaceMaterial.hpp | 8 +-
.../Acts/Material/MaterialProperties.hpp | 12 +--
Core/include/Acts/Surfaces/ConeBounds.hpp | 4 +-
Core/include/Acts/Surfaces/ConeSurface.hpp | 24 +++---
Core/include/Acts/Surfaces/CylinderBounds.hpp | 10 +--
.../include/Acts/Surfaces/CylinderSurface.hpp | 10 +--
Core/include/Acts/Surfaces/DiamondBounds.hpp | 4 +-
Core/include/Acts/Surfaces/DiscSurface.hpp | 39 +++++----
.../Acts/Surfaces/DiscTrapezoidalBounds.hpp | 12 +--
Core/include/Acts/Surfaces/EllipseBounds.hpp | 4 +-
Core/include/Acts/Surfaces/LineBounds.hpp | 4 +-
Core/include/Acts/Surfaces/LineSurface.hpp | 16 ++--
Core/include/Acts/Surfaces/PerigeeSurface.hpp | 12 +--
Core/include/Acts/Surfaces/PlaneSurface.hpp | 16 ++--
Core/include/Acts/Surfaces/RadialBounds.hpp | 4 +-
.../include/Acts/Surfaces/RectangleBounds.hpp | 10 +--
Core/include/Acts/Surfaces/StrawSurface.hpp | 4 +-
Core/include/Acts/Surfaces/Surface.hpp | 39 ++++-----
.../include/Acts/Surfaces/TrapezoidBounds.hpp | 4 +-
Core/include/Acts/Surfaces/TriangleBounds.hpp | 4 +-
.../Acts/Tools/CylinderVolumeBuilder.hpp | 4 +-
.../Acts/Tools/CylinderVolumeHelper.hpp | 85 ++++++++++---------
Core/include/Acts/Tools/LayerArrayCreator.hpp | 14 +--
Core/include/Acts/Tools/LayerCreator.hpp | 3 +-
.../Acts/Tools/PassiveLayerBuilder.hpp | 4 +-
.../Acts/Tools/SurfaceArrayCreator.hpp | 34 ++++----
.../Acts/Tools/TrackingGeometryBuilder.hpp | 3 +-
.../Acts/Tools/TrackingVolumeArrayCreator.hpp | 8 +-
.../Acts/Utilities/ApproachDescriptor.hpp | 3 +-
Core/include/Acts/Utilities/GeometryID.hpp | 2 +-
Core/include/Acts/Utilities/VariantData.hpp | 22 ++---
.../include/Acts/Volumes/BoundarySurfaceT.hpp | 6 +-
.../Acts/Volumes/CuboidVolumeBounds.hpp | 16 ++--
.../Acts/Volumes/CylinderVolumeBounds.hpp | 10 +--
.../Volumes/DoubleTrapezoidVolumeBounds.hpp | 36 ++++----
.../Acts/Volumes/TrapezoidVolumeBounds.hpp | 38 +++++----
Core/include/Acts/Volumes/Volume.hpp | 4 +-
Core/src/Layers/CylinderLayer.cpp | 6 +-
Core/src/Layers/DiscLayer.cpp | 6 +-
Core/src/Layers/NavigationLayer.cpp | 6 +-
Core/src/Surfaces/ConeBounds.cpp | 6 +-
Core/src/Surfaces/ConeSurface.cpp | 6 +-
Core/src/Surfaces/CylinderBounds.cpp | 6 +-
Core/src/Surfaces/CylinderSurface.cpp | 6 +-
Core/src/Surfaces/DiamondBounds.cpp | 6 +-
Core/src/Surfaces/DiscSurface.cpp | 6 +-
Core/src/Surfaces/DiscTrapezoidalBounds.cpp | 6 +-
Core/src/Surfaces/EllipseBounds.cpp | 6 +-
Core/src/Surfaces/LineBounds.cpp | 6 +-
Core/src/Surfaces/LineSurface.cpp | 6 +-
Core/src/Surfaces/PerigeeSurface.cpp | 6 +-
Core/src/Surfaces/PlaneSurface.cpp | 6 +-
Core/src/Surfaces/RadialBounds.cpp | 6 +-
Core/src/Surfaces/RectangleBounds.cpp | 6 +-
Core/src/Surfaces/StrawSurface.cpp | 6 +-
Core/src/Surfaces/TrapezoidBounds.cpp | 6 +-
Core/src/Surfaces/TriangleBounds.cpp | 6 +-
Core/src/Tools/SurfaceArrayCreator.cpp | 32 +++----
.../Acts/Extrapolation/ExtrapolationCell.hpp | 9 +-
.../Extrapolation/ExtrapolationEngine.hpp | 4 +-
.../Extrapolation/MaterialEffectsEngine.hpp | 20 ++---
.../Acts/Extrapolation/RungeKuttaEngine.hpp | 40 ++++-----
.../Acts/Extrapolation/StaticEngine.hpp | 19 ++---
.../Extrapolation/StaticNavigationEngine.hpp | 34 ++++----
.../Acts/Extrapolation/TransportJacobian.hpp | 10 +--
.../Extrapolation/detail/RungeKuttaUtils.hpp | 17 ++--
.../Plugins/DD4hep/DD4hepLayerBuilder.hpp | 4 +-
.../Digitization/CartesianSegmentation.hpp | 14 +--
.../Digitization/PlanarModuleStepper.hpp | 20 ++---
.../MaterialMapping/MaterialMapper.hpp | 13 +--
.../Plugins/MaterialMapping/MaterialStep.hpp | 2 +-
.../Plugins/MaterialMapping/MaterialTrack.hpp | 8 +-
.../MaterialMapping/SurfaceMaterialRecord.hpp | 4 +-
.../Acts/Plugins/TGeo/TGeoDetectorElement.hpp | 10 +--
.../Acts/Plugins/TGeo/TGeoLayerBuilder.hpp | 16 ++--
89 files changed, 575 insertions(+), 564 deletions(-)
diff --git a/.static_analysis_limits.yml b/.static_analysis_limits.yml
index 9f6c12a61..4a33f7eb7 100644
--- a/.static_analysis_limits.yml
+++ b/.static_analysis_limits.yml
@@ -1,4 +1,5 @@
limits:
+ "readability-inconsistent-declaration-parameter-name": 0
"modernize-use-using": 0
"readability-braces-around-statements": 0
"modernize-use-override": 0
diff --git a/Core/include/Acts/Detector/DetachedTrackingVolume.hpp b/Core/include/Acts/Detector/DetachedTrackingVolume.hpp
index cba2c2acd..7ba62a314 100644
--- a/Core/include/Acts/Detector/DetachedTrackingVolume.hpp
+++ b/Core/include/Acts/Detector/DetachedTrackingVolume.hpp
@@ -101,9 +101,9 @@ public:
/// Set the simplified calculable components
/// @todo check with Sharka
///
- /// @param consts are the constituents to be saved
+ /// @param constituents are the constituents to be saved
void
- saveConstituents(std::vector<std::pair<const Volume*, float>>* consts);
+ saveConstituents(std::vector<std::pair<const Volume*, float>>* constituents);
/// Get the simplified calculable components
///
@@ -125,11 +125,11 @@ protected:
/// Constructor with name & layer representation
///
/// @param name is name identifier
- /// @param vol is the contained TrackingVolume
+ /// @param volume is the contained TrackingVolume
/// @param layer is the contained layer
/// @param multiLayer is the multi layer representation
DetachedTrackingVolume(const std::string& name,
- TrackingVolumePtr vol,
+ TrackingVolumePtr volume,
LayerPtr layer,
std::vector<LayerPtr> multiLayer);
diff --git a/Core/include/Acts/Detector/GlueVolumesDescriptor.hpp b/Core/include/Acts/Detector/GlueVolumesDescriptor.hpp
index a25ae755c..49a57f2ca 100644
--- a/Core/include/Acts/Detector/GlueVolumesDescriptor.hpp
+++ b/Core/include/Acts/Detector/GlueVolumesDescriptor.hpp
@@ -83,5 +83,5 @@ GlueVolumesDescriptor::glueFaces() const
}
std::ostream&
-operator<<(std::ostream& sl, const GlueVolumesDescriptor& mprop);
+operator<<(std::ostream& sl, const GlueVolumesDescriptor& gvd);
}
\ No newline at end of file
diff --git a/Core/include/Acts/Detector/TrackingGeometry.hpp b/Core/include/Acts/Detector/TrackingGeometry.hpp
index c8b175422..98c669dbe 100644
--- a/Core/include/Acts/Detector/TrackingGeometry.hpp
+++ b/Core/include/Acts/Detector/TrackingGeometry.hpp
@@ -61,27 +61,27 @@ public:
/// return the lowest tracking Volume
///
- /// @param gpos is the global position fo the call
+ /// @param gp is the global position fo the call
///
/// @return plain pointer to the lowest TrackingVolume
const TrackingVolume*
- lowestTrackingVolume(const Vector3D& gpos) const;
+ lowestTrackingVolume(const Vector3D& gp) const;
/// return the vector of lowest detached tracking Volume(->overlaps)
///
- /// @param gpos is the global position fo the call
+ /// @param gp is the global position fo the call
///
/// @return plain pointer to the the lowest DetachedTrackingVolume
const DetachedVolumeVector*
- lowestDetachedTrackingVolumes(const Vector3D& gpos) const;
+ lowestDetachedTrackingVolumes(const Vector3D& gp) const;
/// return the lowest static volume
///
- /// @param gpos is the global position fo the call
+ /// @param gp is the global position fo the call
///
/// @return plain pointer to the the lowest static tracking volume
const TrackingVolume*
- lowestStaticTrackingVolume(const Vector3D& gpos) const;
+ lowestStaticTrackingVolume(const Vector3D& gp) const;
/// return the lowest tracking Volume
///
@@ -93,15 +93,15 @@ public:
/// Forward the associated Layer information
///
- /// @param gpos is the global position fo the call
+ /// @param gp is the global position fo the call
///
/// @return plain pointer to assocaiated layer
const Layer*
- associatedLayer(const Vector3D& gpos) const;
+ associatedLayer(const Vector3D& gp) const;
/// check position at volume boundary
///
- /// @param gpos is the global position fo the call
+ /// @param gp is the global position fo the call
/// @param vol is the volume to be cheked
/// @param tol is the tolerance parameter
///
@@ -109,7 +109,7 @@ public:
///
/// @return boolean indicating if this is at a volume boundary
bool
- atVolumeBoundary(const Vector3D& gpos,
+ atVolumeBoundary(const Vector3D& gp,
const TrackingVolume* vol,
double tol) const;
@@ -126,7 +126,7 @@ public:
///
/// @return boolean indicating if this is at a volume boundary
bool
- atVolumeBoundary(const Vector3D& gpos,
+ atVolumeBoundary(const Vector3D& gp,
const Vector3D& mom,
const TrackingVolume* vol,
const TrackingVolume*& nextVol,
@@ -151,10 +151,10 @@ public:
private:
/// Geometry Builder busineess: the geometry builder has to sign
///
- /// @param signat is the volume signature
+ /// @param geosit is the volume signature
/// @param geotype is the volume navigation type
void
- sign(GeometrySignature signat, GeometryType geotype = Static);
+ sign(GeometrySignature geosit, GeometryType geotype = Static);
/// The known world - and the beamline
TrackingVolumePtr m_world;
diff --git a/Core/include/Acts/Detector/TrackingVolume.hpp b/Core/include/Acts/Detector/TrackingVolume.hpp
index a0298689f..019aacba7 100644
--- a/Core/include/Acts/Detector/TrackingVolume.hpp
+++ b/Core/include/Acts/Detector/TrackingVolume.hpp
@@ -137,11 +137,11 @@ public:
/// Return the associated Layer to the global position
///
- /// @param gpos is the associated global position
+ /// @param gp is the associated global position
///
/// @return plain pointer to layer object
const Layer*
- associatedLayer(const Vector3D& gpos) const;
+ associatedLayer(const Vector3D& gp) const;
/// @brief Resolves the volume into (compatible) Layers
///
@@ -194,7 +194,7 @@ public:
/// returned)
/// @param eLayer is the end layer for the search (@todo docu: check if
/// returned)
- /// @param parameters are the templated parameters for searching
+ /// @param pars are the templated parameters for searching
/// @param pDir is an additional direction prescription
/// @param bcheck is a boundary check directive
/// @param resolveMaterial is the prescription how to deal with material
@@ -206,7 +206,7 @@ public:
std::vector<LayerIntersection>
layerCandidatesOrdered(const Layer* sLayer,
const Layer* eLayer,
- const parameters_t& parameters,
+ const parameters_t& pars,
NavigationDirection pDir = forward,
const BoundaryCheck& bcheck = true,
bool resolveSensitive = true,
@@ -221,33 +221,33 @@ public:
/// Returns the boundary surfaces ordered in probability to hit them based
/// on straight line intersection
///
- /// @param parameters are the templated tracking parameters
+ /// @param pars are the templated tracking parameters
/// @param pDir is the additional direction presciprion
///
/// @return is the templated boundary intersection
template <typename parameters_t>
std::vector<BoundaryIntersection>
- boundarySurfacesOrdered(const parameters_t& parameters,
+ boundarySurfacesOrdered(const parameters_t& pars,
NavigationDirection pDir = forward,
bool skipCurrent = false) const;
/// Return the associated sub Volume, returns THIS if no subVolume exists
///
- /// @param gpos is the global position associated with that search
+ /// @param gp is the global position associated with that search
///
/// @return plain pointer to associated with the position
const TrackingVolume*
- trackingVolume(const Vector3D& gpos) const;
+ trackingVolume(const Vector3D& gp) const;
/// Return the dynamically created vector of detached sub volumes
///
- /// @param pos is the glboal position associated with that search
+ /// @param gp is the glboal position associated with that search
/// @param tol is the absolute tolerance for the search
///
/// @return the list of associated detached tracking volumes, nullptr if it
/// does not exist
const DetachedVolumeVector*
- detachedTrackingVolumes(const Vector3D& pos, double tol) const;
+ detachedTrackingVolumes(const Vector3D& gp, double tol) const;
/// Return the confined static layer array - if it exists
/// @return the BinnedArray of static layers if exists
@@ -302,21 +302,21 @@ public:
///
/// @param bsfMine is the boundary face indicater where to glue
/// @param neighbors are the TrackingVolumes to be glued
- /// @param bsfNeighbors are the boudnary surface of the neighbors
+ /// @param bsfNeighbor are the boudnary surface of the neighbors
void
glueTrackingVolumes(BoundarySurfaceFace bsfMine,
std::shared_ptr<TrackingVolumeArray> neighbors,
- BoundarySurfaceFace bsfNeighbors);
+ BoundarySurfaceFace bsfNeighbor);
/// Provide a new BoundarySurface from the glueing
///
///
- /// @param bsfMine is the boundary face indicater where to glue
- /// @param bsSurface is the new boudnary surface
+ /// @param bsf is the boundary face indicater where to glue
+ /// @param bs is the new boudnary surface
void
updateBoundarySurface(
- BoundarySurfaceFace bsfMine,
- std::shared_ptr<const BoundarySurfaceT<TrackingVolume>> bsSurface);
+ BoundarySurfaceFace bsf,
+ std::shared_ptr<const BoundarySurfaceT<TrackingVolume>> bs);
/// Register the outside glue volumes -
/// ordering is in the TrackingVolume Frame:
@@ -339,10 +339,10 @@ public:
/// Sign the volume - the geometry builder has to do that
///
- /// @param signat is the volume signature
+ /// @param geosign is the volume signature
/// @param geotype is the volume navigation type
void
- sign(GeometrySignature signat, GeometryType geotype = Static);
+ sign(GeometrySignature geosign, GeometryType geotype = Static);
/// return the Signature
GeometrySignature
@@ -380,37 +380,38 @@ protected:
/// - vacuum filled volume either as a for other tracking volumes
///
/// @param htrans is the global 3D transform to position the volume in space
- /// @param volumeBounds is the description of the volume boundaries
- /// @param containedVolumes are the static volumes that fill this volume
+ /// @param volbounds is the description of the volume boundaries
+ /// @param containedVolumeArray are the static volumes that fill this volume
/// @param volumeName is a string identifier
TrackingVolume(
std::shared_ptr<const Transform3D> htrans,
- VolumeBoundsPtr volumeBounds,
- const std::shared_ptr<const TrackingVolumeArray> containedVolumes
+ VolumeBoundsPtr volbounds,
+ const std::shared_ptr<const TrackingVolumeArray> containedVolumeArray
= nullptr,
const std::string& volumeName = "undefined");
/// Constructor for a full equipped Tracking Volume
///
/// @param htrans is the global 3D transform to position the volume in space
- /// @param volumeBounds is the description of the volume boundaries
+ /// @param volbounds is the description of the volume boundaries
/// @param matprop is are materials of the tracking volume
- /// @param cLayerArray is the confined layer array (optional)
- /// @param cLayerVector is the confined arbitrary layer vector
- /// @param cVolumeArray is the confined volume array
- /// @param cVolumeVector is the confined arbitrary volume vector
- /// @param dVolumeVector is the confined arbeitrary detached volume vector
+ /// @param staticLayerArray is the confined layer array (optional)
+ /// @param arbitraryLayerVector is the confined arbitrary layer vector
+ /// @param containedVolumeARray is the confined volume array
+ /// @param denseVolumeVector is the confined arbitrary volume vector
+ /// @param detachedVolumeVector is the confined arbeitrary detached volume
+ /// vector
/// @param volumeName is a string identifier
TrackingVolume(std::shared_ptr<const Transform3D> htrans,
- VolumeBoundsPtr volumeBounds,
+ VolumeBoundsPtr volbounds,
std::shared_ptr<const Material> matprop,
- std::unique_ptr<const LayerArray> cLayerArray = nullptr,
- const LayerVector cLayerVector = {},
- std::shared_ptr<const TrackingVolumeArray> cVolumeArray
+ std::unique_ptr<const LayerArray> staticLayerArray = nullptr,
+ const LayerVector arbitraryLayerVector = {},
+ std::shared_ptr<const TrackingVolumeArray> containedVolumeArray
= nullptr,
- const TrackingVolumeVector cVolumeVector = {},
- const DetachedVolumeVector dVolumeVector = {},
- const std::string& volumeName = "undefined");
+ const TrackingVolumeVector denseVolumeVector = {},
+ const DetachedVolumeVector detachedVolumeVector = {},
+ const std::string& volumeName = "undefined");
/// Copy Constructor with a shift
///
diff --git a/Core/include/Acts/EventData/TrackParametersBase.hpp b/Core/include/Acts/EventData/TrackParametersBase.hpp
index e766b7a17..bfc059724 100644
--- a/Core/include/Acts/EventData/TrackParametersBase.hpp
+++ b/Core/include/Acts/EventData/TrackParametersBase.hpp
@@ -187,6 +187,6 @@ protected:
///
/// @return modified output stream object
virtual std::ostream&
- print(std::ostream& out) const;
+ print(std::ostream& sl) const;
};
} // namespace Acts
\ No newline at end of file
diff --git a/Core/include/Acts/Layers/ConeLayer.hpp b/Core/include/Acts/Layers/ConeLayer.hpp
index 8a1a8ac90..d34677607 100644
--- a/Core/include/Acts/Layers/ConeLayer.hpp
+++ b/Core/include/Acts/Layers/ConeLayer.hpp
@@ -86,7 +86,7 @@ protected:
/// @param cbounds is the conical bound description
/// @param surfaceArray is the array of sensitive surfaces
/// @param thickness is the layer thickness along the normal axis
- /// @param ad is the approach descriptor for navigation towards the layer
+ /// @param ade is the approach descriptor for navigation towards the layer
/// @param laytyp is the layer type
///
/// @todo chage od and ad to unique_ptr
@@ -94,7 +94,7 @@ protected:
std::shared_ptr<const ConeBounds> cbounds,
std::unique_ptr<SurfaceArray> surfaceArray,
double thickness = 0.,
- std::unique_ptr<ApproachDescriptor> ad = nullptr,
+ std::unique_ptr<ApproachDescriptor> ade = nullptr,
LayerType laytyp = Acts::active);
/// Private copy constructor with shift, called by create(args*)
diff --git a/Core/include/Acts/Layers/CylinderLayer.hpp b/Core/include/Acts/Layers/CylinderLayer.hpp
index 3415b23ea..ba7d72ac8 100644
--- a/Core/include/Acts/Layers/CylinderLayer.hpp
+++ b/Core/include/Acts/Layers/CylinderLayer.hpp
@@ -66,10 +66,10 @@ public:
}
/// Factory for shared Layer pointer, that accepts @c variant_data
- /// @param data The data to build from
+ /// @param vardata The data to build from
/// @return The return object is a shared poiter to the layer.
static MutableLayerPtr
- create(const variant_data& data);
+ create(const variant_data& vardata);
/// Copy constructor - deleted
CylinderLayer(const CylinderLayer& cla) = delete;
@@ -117,10 +117,10 @@ protected:
///
/// @return The return object is a shared poiter to the layer.
CylinderLayer(std::shared_ptr<const Transform3D> transform,
- std::shared_ptr<const CylinderBounds> cbounds,
+ std::shared_ptr<const CylinderBounds> cBounds,
std::unique_ptr<SurfaceArray> surfaceArray = nullptr,
double thickness = 0.,
- std::unique_ptr<ApproachDescriptor> ad = nullptr,
+ std::unique_ptr<ApproachDescriptor> ades = nullptr,
LayerType laytyp = passive);
/// Private copy constructor with shift, called by create(args*)
diff --git a/Core/include/Acts/Layers/DiscLayer.hpp b/Core/include/Acts/Layers/DiscLayer.hpp
index 77048b2b0..c5800e090 100644
--- a/Core/include/Acts/Layers/DiscLayer.hpp
+++ b/Core/include/Acts/Layers/DiscLayer.hpp
@@ -63,9 +63,9 @@ public:
}
/// Factory for shared Layer pointer, that accepts @c variant_data
- /// @param data The data to build from
+ /// @param vardata The data to build from
static MutableLayerPtr
- create(const variant_data& data);
+ create(const variant_data& vardata);
/// Default Constructor
DiscLayer() = delete;
@@ -113,7 +113,7 @@ protected:
std::shared_ptr<const DiscBounds> dbounds,
std::unique_ptr<SurfaceArray> surfaceArray = nullptr,
double thickness = 0.,
- std::unique_ptr<ApproachDescriptor> ad = nullptr,
+ std::unique_ptr<ApproachDescriptor> ades = nullptr,
LayerType laytyp = Acts::active);
/// Copy constructor with shift
diff --git a/Core/include/Acts/Layers/GenericApproachDescriptor.hpp b/Core/include/Acts/Layers/GenericApproachDescriptor.hpp
index 519a67828..93efa4877 100644
--- a/Core/include/Acts/Layers/GenericApproachDescriptor.hpp
+++ b/Core/include/Acts/Layers/GenericApproachDescriptor.hpp
@@ -68,14 +68,14 @@ public:
/// get the compatible surfaces
///
/// @param gpos is the global position to start the approach from
- /// @param mom is the momentum vector
+ /// @param gdir is the momentum vector
/// @param bcheck is the boundary check prescription
/// @param corrfnc is an noption correction function
///
/// @return : a boolean indicating if an actual intersection had been tried
ObjectIntersection<Surface>
approachSurface(const Vector3D& gpos,
- const Vector3D& mom,
+ const Vector3D& gdir,
NavigationDirection navDir,
const BoundaryCheck& bcheck,
CorrFnc corrfnc = nullptr) const override;
diff --git a/Core/include/Acts/Layers/Layer.hpp b/Core/include/Acts/Layers/Layer.hpp
index 06ca5b166..c560ceaf2 100644
--- a/Core/include/Acts/Layers/Layer.hpp
+++ b/Core/include/Acts/Layers/Layer.hpp
@@ -133,24 +133,23 @@ public:
/// templated onLayer() method
///
- /// @param parameters are the templated (charged/neutral) on layer check
+ /// @param pars are the templated (charged/neutral) on layer check
/// @param bcheck is the boundary check directive
///
/// @return boolean that indicates success of the operation
template <typename parameters_t>
bool
- onLayer(const parameters_t& parameters,
- const BoundaryCheck& bcheck = true) const;
+ onLayer(const parameters_t& pars, const BoundaryCheck& bcheck = true) const;
/// geometrical isOnLayer() method
///
/// @note using isOnSurface() with Layer specific tolerance
- /// @param pos is the gobal position to be checked
+ /// @param gp 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& pos, const BoundaryCheck& bcheck = true) const;
+ isOnLayer(const Vector3D& gp, const BoundaryCheck& bcheck = true) const;
/// Return method for the approach descriptor, can be nullptr
const ApproachDescriptor*
@@ -303,7 +302,7 @@ public:
/// get compatible surfaces starting from the parameters
///
/// @param pars are the (charged) track parameters for the search
- /// @param pdir is the propagation direction prescription
+ /// @param pDir is the propagation direction prescription
/// @param bcheck is the boundary check directive
/// @param resolveSensitive is the prescription to find the sensitive surfaces
/// @param resolveMaterial is the prescription to find surfaces with material
@@ -318,7 +317,7 @@ public:
template <typename parameters_t>
std::vector<SurfaceIntersection>
getCompatibleSurfaces(const parameters_t& pars,
- NavigationDirection pdir,
+ NavigationDirection pDir,
const BoundaryCheck& bcheck,
bool resolveSensitive,
bool resolveMaterial,
@@ -336,9 +335,9 @@ public:
///
/// for layers without sub structure, this is the surfaceRepresentation
/// for layers with sub structure, this is the approachSurface
- /// @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 position is the global position to start the approach from
+ /// @param momentum is the direction from where to attempt the approach
+ /// @param nDir is the direction prescription
/// @param bcheck is the boundary check directive
/// @param resolveSensitive is the prescription to find the sensitive surfaces
/// @param resolveMaterial is the precription to find material surfaces
@@ -346,9 +345,9 @@ public:
/// @param ice is a (future) compatibility estimator t
/// the straight line approach
virtual const SurfaceIntersection
- surfaceOnApproach(const Vector3D& gpos,
- const Vector3D& dir,
- NavigationDirection pdir,
+ surfaceOnApproach(const Vector3D& position,
+ const Vector3D& momentum,
+ NavigationDirection nDir,
const BoundaryCheck& bcheck,
bool resolveSensitive,
bool resolveMaterial,
@@ -363,24 +362,19 @@ public:
/// @param cSurfaces are the retrun surface intersections
/// @param surface is the parameter surface
/// @todo how is this different from the start surface
- /// @param gpos is the resolved global position
+ /// @param pos is the resolved global position
/// @param dir is themomentum direction
- /// @param pdir is the propagation direction prescription
+ /// @param navDir is the propagation direction prescription
/// @param bcheck is the boundary check directive
/// @param pathLimit is the maximal path length allowed to the surface
- /// @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 of search: excluded in
- /// return
///
/// @return boolean that indicates if a compatible surface exists at all
void
testCompatibleSurface(std::vector<SurfaceIntersection>& cSurfaces,
const Surface& surface,
- const Vector3D& gpos,
+ const Vector3D& pos,
const Vector3D& dir,
- NavigationDirection pdir,
+ NavigationDirection navDir,
const BoundaryCheck& bcheck,
double pathLimit) const;
@@ -389,12 +383,12 @@ public:
/// Fast navigation to next layer
///
- /// @param pos is the start position for the search
- /// @param dir is the direction for the search
+ /// @param gp is the start position for the search
+ /// @param mom is the direction for the search
///
/// @return the pointer to the next layer
const Layer*
- nextLayer(const Vector3D& pos, const Vector3D& dir) const;
+ nextLayer(const Vector3D& gp, const Vector3D& mom) const;
/// get the confining TrackingVolume
///
@@ -411,9 +405,9 @@ public:
/// register Volume associated to the layer
/// - if you want to do that by hand: should be shared or unique ptr
///
- /// @param avol is the provided volume
+ /// @param theVol is the provided volume
void
- registerRepresentingVolume(const AbstractVolume* avol);
+ registerRepresentingVolume(const AbstractVolume* theVol);
/// return the abstract volume that represents the layer
///
@@ -430,12 +424,12 @@ protected:
///
/// @param surfaceArray is the array of sensitive surfaces
/// @param thickness is the normal thickness of the Layer
- /// @param ad oapproach descriptor
- /// @param ltype is the layer type if active or passive
+ /// @param ades oapproach descriptor
+ /// @param laytyp is the layer type if active or passive
Layer(std::unique_ptr<SurfaceArray> surfaceArray,
double thickness = 0.,
- std::unique_ptr<ApproachDescriptor> ad = nullptr,
- LayerType ltype = passive);
+ std::unique_ptr<ApproachDescriptor> ades = nullptr,
+ LayerType laytyp = passive);
/// private method to set enclosing TrackingVolume, called by friend class
/// only
@@ -452,9 +446,9 @@ protected:
/// private method to set the enclosed detached TV,
/// called by friend class only
///
- /// @param dtvol is the detached tracking volume the layer is confined
+ /// @param tvol is the detached tracking volume the layer is confined
void
- encloseDetachedTrackingVolume(const DetachedTrackingVolume& dtvol);
+ encloseDetachedTrackingVolume(const DetachedTrackingVolume& tvol);
/// the previous Layer according to BinGenUtils
NextLayers m_nextLayers;
diff --git a/Core/include/Acts/Layers/NavigationLayer.hpp b/Core/include/Acts/Layers/NavigationLayer.hpp
index 9214a4f58..04a22ccd9 100644
--- a/Core/include/Acts/Layers/NavigationLayer.hpp
+++ b/Core/include/Acts/Layers/NavigationLayer.hpp
@@ -43,9 +43,9 @@ public:
}
/// Factory for shared Layer pointer, that accepts @c variant_data
- /// @param data The data to build from
+ /// @param vardata The data to build from
static LayerPtr
- create(const variant_data& data);
+ create(const variant_data& vardata);
/// Destructor
~NavigationLayer() override;
@@ -79,13 +79,12 @@ public:
/// Geometric isOnLayer() method
/// using isOnSurface() with Layer specific tolerance
///
- /// @param gpos is the global position for the check
+ /// @param gp is the global position for the check
/// @param bcheck is the boundary check directive
///
/// @return boolean that indicates if the position is on surface
bool
- isOnLayer(const Vector3D& gpos,
- const BoundaryCheck& bcheck = true) const final;
+ isOnLayer(const Vector3D& gp, const BoundaryCheck& bcheck = true) const final;
/// Accept layer according to the following colelction directives
///
diff --git a/Core/include/Acts/Layers/PlaneLayer.hpp b/Core/include/Acts/Layers/PlaneLayer.hpp
index cc68fcbdd..344982eb3 100644
--- a/Core/include/Acts/Layers/PlaneLayer.hpp
+++ b/Core/include/Acts/Layers/PlaneLayer.hpp
@@ -88,7 +88,7 @@ protected:
/// @param pbounds the planar bounds that define the layer dimensions
/// @param surfaceArray is the surface array that holds the sensitive surfaces
/// @param thickness is the thickness of the layer (normal direction to plane)
- /// @param ad is the approach descriptor for describing the approach surface
+ /// @param ades is the approach descriptor for describing the approach surface
/// @param laytyp is the layer type
///
/// @return shared pointer to a PlaneLayer
@@ -96,7 +96,7 @@ protected:
std::shared_ptr<const PlanarBounds>& pbounds,
std::unique_ptr<SurfaceArray> surfaceArray = nullptr,
double thickness = 0.,
- std::unique_ptr<ApproachDescriptor> ad = nullptr,
+ std::unique_ptr<ApproachDescriptor> ades = nullptr,
LayerType laytyp = Acts::active);
/// Private constructor for a PlaneLayer, is called by create(arge*
diff --git a/Core/include/Acts/Material/BinnedSurfaceMaterial.hpp b/Core/include/Acts/Material/BinnedSurfaceMaterial.hpp
index 08d715dd9..d34a549cf 100644
--- a/Core/include/Acts/Material/BinnedSurfaceMaterial.hpp
+++ b/Core/include/Acts/Material/BinnedSurfaceMaterial.hpp
@@ -59,15 +59,15 @@ public:
/// @param fullProperties is the vector of properties as recorded
/// @param splitFactor is the pre/post splitting directive
/// @param entries is the (optional) number of mapping entries
- BinnedSurfaceMaterial(const BinUtility& binutility,
+ BinnedSurfaceMaterial(const BinUtility& binUtility,
const MaterialPropertiesMatrix& fullProperties,
double splitFactor = 0.,
size_t entries = 1);
/// Copy Constructor
///
- /// @param bsm is the source object to be copied
- BinnedSurfaceMaterial(const BinnedSurfaceMaterial& bsm);
+ /// @param lmp is the source object to be copied
+ BinnedSurfaceMaterial(const BinnedSurfaceMaterial& lmp);
/// Destructor
~BinnedSurfaceMaterial() override;
diff --git a/Core/include/Acts/Material/HomogeneousSurfaceMaterial.hpp b/Core/include/Acts/Material/HomogeneousSurfaceMaterial.hpp
index ef3c0a9f1..0fee10f41 100644
--- a/Core/include/Acts/Material/HomogeneousSurfaceMaterial.hpp
+++ b/Core/include/Acts/Material/HomogeneousSurfaceMaterial.hpp
@@ -31,15 +31,15 @@ public:
/// Explizit constructor
///
- /// @param fullmat are the full material properties
+ /// @param full are the full material properties
/// @param splitFactor is the split for pre/post update
- HomogeneousSurfaceMaterial(const MaterialProperties& fullmat,
+ HomogeneousSurfaceMaterial(const MaterialProperties& full,
double splitFactor = 1.);
/// Copy Constructor
///
- /// @param hsm is the source material
- HomogeneousSurfaceMaterial(const HomogeneousSurfaceMaterial& hsm);
+ /// @param lmp is the source material
+ HomogeneousSurfaceMaterial(const HomogeneousSurfaceMaterial& lmp);
/// Destructor
~HomogeneousSurfaceMaterial() override;
diff --git a/Core/include/Acts/Material/MaterialProperties.hpp b/Core/include/Acts/Material/MaterialProperties.hpp
index 99e113629..e6891857f 100644
--- a/Core/include/Acts/Material/MaterialProperties.hpp
+++ b/Core/include/Acts/Material/MaterialProperties.hpp
@@ -37,14 +37,14 @@ public:
/// Constructor - for averaged material
///
- /// @param X0 is the radiation length in mm
- /// @param L0 is the nuclear interaction length in mm
+ /// @param Xo is the radiation length in mm
+ /// @param Lo is the nuclear interaction length in mm
/// @param averageA is the average atomic weight
/// @param averageZ is the average atomic number
/// @param averageRho is the average density in g/mm3
/// @param thickness is the thickness of the material
- MaterialProperties(float X0,
- float L0,
+ MaterialProperties(float Xo,
+ float Lo,
float averageA,
float averageZ,
float averageRho,
@@ -52,9 +52,9 @@ public:
/// Constructor - for full Material class
///
- /// @param mat is the material
+ /// @param material is the material
/// @param thickness is the thickness of the material
- MaterialProperties(const Material& mat, float thickness);
+ MaterialProperties(const Material& material, float thickness);
/// Constructor - for different layers of Material
///
diff --git a/Core/include/Acts/Surfaces/ConeBounds.hpp b/Core/include/Acts/Surfaces/ConeBounds.hpp
index 787d0ca5e..f095e029c 100644
--- a/Core/include/Acts/Surfaces/ConeBounds.hpp
+++ b/Core/include/Acts/Surfaces/ConeBounds.hpp
@@ -71,8 +71,8 @@ public:
double avphi = 0.);
/// Constructor which accepts @c variant_data
- /// @param data The data to build from
- ConeBounds(const variant_data& data);
+ /// @param vardata The data to build from
+ ConeBounds(const variant_data& vardata);
~ConeBounds() override;
diff --git a/Core/include/Acts/Surfaces/ConeSurface.hpp b/Core/include/Acts/Surfaces/ConeSurface.hpp
index 47af2b5f5..708afb46f 100644
--- a/Core/include/Acts/Surfaces/ConeSurface.hpp
+++ b/Core/include/Acts/Surfaces/ConeSurface.hpp
@@ -50,13 +50,13 @@ public:
///
/// @param htrans is the transform that places the cone in the global frame
/// @param alpha is the opening angle of the cone
- /// @param locZmin is the z range over which the cone spans
- /// @param locZmax is the z range over which the cone spans
+ /// @param zmin is the z range over which the cone spans
+ /// @param zmax is the z range over which the cone spans
/// @param halfPhi is the openen angle for cone ssectors
ConeSurface(std::shared_ptr<const Transform3D> htrans,
double alpha,
- double locZmin,
- double locZmax,
+ double zmin,
+ double zmax,
double halfPhi = M_PI);
/// Constructor from HepTransform and ConeBounds
@@ -74,13 +74,13 @@ public:
/// Copy constructor - with shift
///
/// @param other is the source cone surface
- /// @param htrans is the additional transfrom applied after copying
- ConeSurface(const ConeSurface& other, const Transform3D& htrans);
+ /// @param transf is the additional transfrom applied after copying
+ ConeSurface(const ConeSurface& other, const Transform3D& transf);
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- ConeSurface(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ ConeSurface(const variant_data& vardata);
~ConeSurface() override;
@@ -111,20 +111,20 @@ public:
/// for StraightLine and Perigee Surface
/// - the default implementation is the the RotationMatrix3D of the transform
///
- /// @param gpos is the global position where the measurement frame is
+ /// @param pos is the global position where the measurement frame is
/// constructed
/// @param mom is the momentum used for the measurement frame construction
/// @return matrix that indicates the measurement frame
const RotationMatrix3D
- referenceFrame(const Vector3D& gpos, const Vector3D& mom) const final;
+ referenceFrame(const Vector3D& pos, const Vector3D& mom) const final;
/// Return method for surface normal information
///
- /// @param lpos is the local position on the cone for which the normal vector
+ /// @param lp is the local position on the cone for which the normal vector
/// is requested
/// @return Vector3D normal vector in global frame
const Vector3D
- normal(const Vector2D& lpos) const final;
+ normal(const Vector2D& lp) const final;
/// Return method for surface normal information
///
diff --git a/Core/include/Acts/Surfaces/CylinderBounds.hpp b/Core/include/Acts/Surfaces/CylinderBounds.hpp
index f6330b79b..4fe75f269 100644
--- a/Core/include/Acts/Surfaces/CylinderBounds.hpp
+++ b/Core/include/Acts/Surfaces/CylinderBounds.hpp
@@ -61,9 +61,9 @@ public:
/// Constructor - open cylinder
///
/// @param radius is the radius of the cylinder
- /// @param halfphi is the half opening angle
- /// @param halez is the half length in z
- CylinderBounds(double radius, double halfPhi, double haleZ);
+ /// @param halfPhi is the half opening angle
+ /// @param halfZ is the half length in z
+ CylinderBounds(double radius, double halfPhi, double halfZ);
/// Constructor - open cylinder
///
@@ -78,8 +78,8 @@ public:
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- CylinderBounds(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ CylinderBounds(const variant_data& vardata);
~CylinderBounds() override;
diff --git a/Core/include/Acts/Surfaces/CylinderSurface.hpp b/Core/include/Acts/Surfaces/CylinderSurface.hpp
index b259de272..99a4edf65 100644
--- a/Core/include/Acts/Surfaces/CylinderSurface.hpp
+++ b/Core/include/Acts/Surfaces/CylinderSurface.hpp
@@ -86,14 +86,14 @@ public:
/// Copy constructor with shift
///
/// @param other is the source cylinder for the copy
- /// @param htrans is the additional transform applied after copying the
+ /// @param transf is the additional transform applied after copying the
/// cylinder
- CylinderSurface(const CylinderSurface& other, const Transform3D& htrans);
+ CylinderSurface(const CylinderSurface& other, const Transform3D& transf);
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- CylinderSurface(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ CylinderSurface(const variant_data& vardata);
/// Destructor
~CylinderSurface() override;
@@ -237,7 +237,7 @@ public:
/// @return is the intersection object
Intersection
intersectionEstimate(const Vector3D& gpos,
- const Vector3D& gidr,
+ const Vector3D& gdir,
NavigationDirection navDir = forward,
const BoundaryCheck& bcheck = false,
CorrFnc correct = nullptr) const final;
diff --git a/Core/include/Acts/Surfaces/DiamondBounds.hpp b/Core/include/Acts/Surfaces/DiamondBounds.hpp
index 4bc27b6cf..50183c995 100644
--- a/Core/include/Acts/Surfaces/DiamondBounds.hpp
+++ b/Core/include/Acts/Surfaces/DiamondBounds.hpp
@@ -54,8 +54,8 @@ public:
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- DiamondBounds(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ DiamondBounds(const variant_data& vardata);
~DiamondBounds() override;
diff --git a/Core/include/Acts/Surfaces/DiscSurface.hpp b/Core/include/Acts/Surfaces/DiscSurface.hpp
index cf1aa1138..9cf92b46a 100644
--- a/Core/include/Acts/Surfaces/DiscSurface.hpp
+++ b/Core/include/Acts/Surfaces/DiscSurface.hpp
@@ -70,15 +70,15 @@ public:
/// (can be nullptr)
/// @param minhalfx The half length in x at minimal r
/// @param maxhalfx The half length in x at maximal r
- /// @param rmin The inner radius of the disc surface
- /// @param rmax The outer radius of the disc surface
+ /// @param maxR The inner radius of the disc surface
+ /// @param minR The outer radius of the disc surface
/// @param avephi The position in phi (default is 0.)
/// @param stereo The optional stereo angle
DiscSurface(std::shared_ptr<const Transform3D> htrans,
double minhalfx,
double maxhalfx,
- double rmin,
- double rmax,
+ double maxR,
+ double minR,
double avephi = 0.,
double stereo = 0.);
@@ -109,8 +109,8 @@ public:
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- DiscSurface(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ DiscSurface(const variant_data& vardata);
~DiscSurface() override;
@@ -156,11 +156,11 @@ public:
/// within or without check of whether the local position is inside boundaries
/// or not
///
- /// @param gpos The global position to be checked
+ /// @param glopo The global position to be checked
/// @param bcheck The boundary check directive
/// @return bollean that indicates if the position is on surface
bool
- isOnSurface(const Vector3D& gpos,
+ isOnSurface(const Vector3D& glopo,
const BoundaryCheck& bcheck = true) const final;
/// Local to global transformation
@@ -212,18 +212,18 @@ public:
/// Special method for DiscSurface : local<->local transformations polar <->
/// cartesian
///
- /// @param lpolar is a local position in polar coordinates
+ /// @param locpol is a local position in polar coordinates
/// @return values is local 2D position in cartesian coordinates
const Vector2D
- localPolarToLocalCartesian(const Vector2D& lpolar) const;
+ localPolarToLocalCartesian(const Vector2D& locpol) const;
/// Special method for DiscSurface : local<->global transformation when
/// provided cartesian coordinates
///
- /// @param lcart is local 2D position in cartesian coordinates
+ /// @param lpos is local 2D position in cartesian coordinates
/// @return value is a global cartesian 3D position
const Vector3D
- localCartesianToGlobal(const Vector2D& lcart) const;
+ localCartesianToGlobal(const Vector2D& lpos) const;
/// Special method for DiscSurface : global<->local from cartesian coordinates
///
@@ -238,11 +238,11 @@ public:
/// The jacobian is assumed to be initialised, so only the
/// relevant entries are filled
///
- /// @param jac The jacobian to be initialized
+ /// @param jacobian The jacobian to be initialized
/// @param gpos The global position of the parameters
/// @param dir The direction at of the parameters
/// @param pars The paranmeters vector
- void initJacobianToGlobal(ActsMatrixD<7, 5>& jac,
+ void initJacobianToGlobal(ActsMatrixD<7, 5>& jacobian,
const Vector3D& gpos,
const Vector3D& dir,
const ActsVectorD<5>& pars) const final;
@@ -252,23 +252,22 @@ public:
/// The jacobian is assumed to be initialised, so only the
/// relevant entries are filled
///
- /// @param jac The jacobian to be initialized
- /// @param pos The global position of the parameters
+ /// @param jacobian The jacobian to be initialized
+ /// @param gpos The global position of the parameters
/// @param dir The direction at of the parameters
- /// @param pars The parameter vector
///
/// @return the transposed reference frame (avoids recalculation)
- const RotationMatrix3D initJacobianToLocal(ActsMatrixD<5, 7>& jac,
+ const RotationMatrix3D initJacobianToLocal(ActsMatrixD<5, 7>& jacobian,
const Vector3D& gpos,
const Vector3D& dir) const final;
/// Path correction due to incident of the track
///
- /// @param gpos The global position as a starting point
+ /// @param pos The global position as a starting point
/// @param mom The global momentum at the starting point
/// @return The correction factor due to incident
double
- pathCorrection(const Vector3D& gpos, const Vector3D& mom) const final;
+ pathCorrection(const Vector3D& pos, const Vector3D& mom) const final;
/// @brief Fast straight line intersection schema
///
diff --git a/Core/include/Acts/Surfaces/DiscTrapezoidalBounds.hpp b/Core/include/Acts/Surfaces/DiscTrapezoidalBounds.hpp
index 1e2fad8f0..81d29a779 100644
--- a/Core/include/Acts/Surfaces/DiscTrapezoidalBounds.hpp
+++ b/Core/include/Acts/Surfaces/DiscTrapezoidalBounds.hpp
@@ -49,21 +49,21 @@ public:
/// Rmin and R max
/// @param minhalfx half length in X at min radius
/// @param maxhalfx half length in X at maximum radius
- /// @param rMin inner radius
- /// @param rMax outer radius
+ /// @param maxR outer radius
+ /// @param minR inner radius
/// @param avephi average phi value
/// @param stereo optional stero angle applied
DiscTrapezoidalBounds(double minhalfx,
double maxhalfx,
- double rMin,
- double rMax,
+ double maxR,
+ double minR,
double avephi = M_PI_2,
double stereo = 0.);
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- DiscTrapezoidalBounds(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ DiscTrapezoidalBounds(const variant_data& vardata);
~DiscTrapezoidalBounds() override;
diff --git a/Core/include/Acts/Surfaces/EllipseBounds.hpp b/Core/include/Acts/Surfaces/EllipseBounds.hpp
index d74cf2cf4..3abe6b830 100644
--- a/Core/include/Acts/Surfaces/EllipseBounds.hpp
+++ b/Core/include/Acts/Surfaces/EllipseBounds.hpp
@@ -63,8 +63,8 @@ public:
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- EllipseBounds(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ EllipseBounds(const variant_data& vardata);
~EllipseBounds() override;
diff --git a/Core/include/Acts/Surfaces/LineBounds.hpp b/Core/include/Acts/Surfaces/LineBounds.hpp
index fcdb4e11a..392f24d3c 100644
--- a/Core/include/Acts/Surfaces/LineBounds.hpp
+++ b/Core/include/Acts/Surfaces/LineBounds.hpp
@@ -37,8 +37,8 @@ public:
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- LineBounds(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ LineBounds(const variant_data& vardata);
~LineBounds() override;
diff --git a/Core/include/Acts/Surfaces/LineSurface.hpp b/Core/include/Acts/Surfaces/LineSurface.hpp
index b990f1308..104681349 100644
--- a/Core/include/Acts/Surfaces/LineSurface.hpp
+++ b/Core/include/Acts/Surfaces/LineSurface.hpp
@@ -72,8 +72,8 @@ public:
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- LineSurface(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ LineSurface(const variant_data& vardata);
~LineSurface() override;
@@ -118,11 +118,11 @@ public:
/// The jacobian is assumed to be initialised, so only the
/// relevant entries are filled
///
- /// @param jac is the jacobian to be initialized
- /// @param pos is the global position of the parameters
+ /// @param jacobian is the jacobian to be initialized
+ /// @param gpos is the global position of the parameters
/// @param dir is the direction at of the parameters
/// @param pars is the paranmeters vector
- void initJacobianToGlobal(ActsMatrixD<7, 5>& jac,
+ void initJacobianToGlobal(ActsMatrixD<7, 5>& jacobian,
const Vector3D& gpos,
const Vector3D& dir,
const ActsVectorD<5>& pars) const final;
@@ -131,14 +131,14 @@ public:
/// the calculation is identical for all surfaces where the
/// reference frame does not depend on the direction
///
- /// @param gpos is the position of the paramters in global
+ /// @param pos is the position of the paramters in global
/// @param dir is the direction of the track
/// @param rft is the transposed reference frame (avoids recalculation)
/// @param jac is the transport jacobian
///
/// @return a five-dim vector
const ActsRowVectorD<5>
- derivativeFactors(const Vector3D& gpos,
+ derivativeFactors(const Vector3D& pos,
const Vector3D& dir,
const RotationMatrix3D& rft,
const ActsMatrixD<7, 5>& jac) const final;
@@ -295,4 +295,4 @@ private:
#include "Acts/Surfaces/detail/LineSurface.ipp"
-} // namespace
\ No newline at end of file
+} // namespace
diff --git a/Core/include/Acts/Surfaces/PerigeeSurface.hpp b/Core/include/Acts/Surfaces/PerigeeSurface.hpp
index 4d0ca0e22..e5e5fb897 100644
--- a/Core/include/Acts/Surfaces/PerigeeSurface.hpp
+++ b/Core/include/Acts/Surfaces/PerigeeSurface.hpp
@@ -33,8 +33,8 @@ public:
/// Constructor from GlobalPosition
///
- /// @param gpos position where the perigee is centered
- PerigeeSurface(const Vector3D& gpos);
+ /// @param gp position where the perigee is centered
+ PerigeeSurface(const Vector3D& gp);
/// Constructor with a Transform - needed for tilt
///
@@ -49,13 +49,13 @@ public:
/// Copy constructor with shift
///
/// @param other is the source surface to be copied
- /// @param transf is the transformed applied after copying
- PerigeeSurface(const PerigeeSurface& other, const Transform3D& transf);
+ /// @param shift is the transformed applied after copying
+ PerigeeSurface(const PerigeeSurface& other, const Transform3D& shift);
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- PerigeeSurface(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ PerigeeSurface(const variant_data& vardata);
~PerigeeSurface() override;
diff --git a/Core/include/Acts/Surfaces/PlaneSurface.hpp b/Core/include/Acts/Surfaces/PlaneSurface.hpp
index 048912c57..e87e811d4 100644
--- a/Core/include/Acts/Surfaces/PlaneSurface.hpp
+++ b/Core/include/Acts/Surfaces/PlaneSurface.hpp
@@ -46,8 +46,8 @@ public:
/// Copy Constructor with shift
///
/// @param psf is the source surface for the copy
- /// @param htrans is the transformation that positions the surface in space
- PlaneSurface(const PlaneSurface& other, const Transform3D& htrans);
+ /// @param transf is the transformation that positions the surface in space
+ PlaneSurface(const PlaneSurface& other, const Transform3D& transf);
/// Dedicated Constructor with normal vector
/// This is for curvilinear surfaces which are by definition boundless
@@ -72,8 +72,8 @@ public:
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- PlaneSurface(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ PlaneSurface(const variant_data& vardata);
~PlaneSurface() override;
@@ -122,12 +122,12 @@ public:
/// within or without check of whether the local position is inside boundaries
/// or not
///
- /// @param gpos global position to be checked
+ /// @param glopo global position to be checked
/// @param bcheck gboundary check directive
///
/// @return is a boolean indicator if the position is on surface
bool
- isOnSurface(const Vector3D& gpos,
+ isOnSurface(const Vector3D& glopo,
const BoundaryCheck& bcheck = true) const override;
/// Local to global transformation
@@ -162,7 +162,7 @@ public:
/// Method that calculates the correction due to incident angle
///
- /// @param gpos global 3D position - considered to be on surface but not
+ /// @param pos global 3D position - considered to be on surface but not
/// inside bounds (check is done)
/// @param mom global 3D momentum representation (optionally ignored)
///
@@ -170,7 +170,7 @@ public:
///
/// @return a double representing the scaling factor
double
- pathCorrection(const Vector3D& gpos, const Vector3D& mom) const final;
+ pathCorrection(const Vector3D& pos, const Vector3D& mom) const final;
/// @brief Fast straight line intersection schema
///
diff --git a/Core/include/Acts/Surfaces/RadialBounds.hpp b/Core/include/Acts/Surfaces/RadialBounds.hpp
index 7a32872e6..13be29b46 100644
--- a/Core/include/Acts/Surfaces/RadialBounds.hpp
+++ b/Core/include/Acts/Surfaces/RadialBounds.hpp
@@ -62,8 +62,8 @@ public:
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- RadialBounds(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ RadialBounds(const variant_data& vardata);
~RadialBounds() override;
diff --git a/Core/include/Acts/Surfaces/RectangleBounds.hpp b/Core/include/Acts/Surfaces/RectangleBounds.hpp
index 7d8c694c1..83e240617 100644
--- a/Core/include/Acts/Surfaces/RectangleBounds.hpp
+++ b/Core/include/Acts/Surfaces/RectangleBounds.hpp
@@ -37,14 +37,14 @@ public:
/// Constructor with halflength in x and y
///
- /// @param halfX halflength in X
- /// @param halfY halflength in Y
- RectangleBounds(double halfX, double halfY);
+ /// @param halex halflength in X
+ /// @param haley halflength in Y
+ RectangleBounds(double halex, double haley);
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- RectangleBounds(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ RectangleBounds(const variant_data& vardata);
~RectangleBounds() override;
diff --git a/Core/include/Acts/Surfaces/StrawSurface.hpp b/Core/include/Acts/Surfaces/StrawSurface.hpp
index 102ed78b0..3a042701c 100644
--- a/Core/include/Acts/Surfaces/StrawSurface.hpp
+++ b/Core/include/Acts/Surfaces/StrawSurface.hpp
@@ -75,8 +75,8 @@ public:
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- StrawSurface(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ StrawSurface(const variant_data& vardata);
~StrawSurface() override;
diff --git a/Core/include/Acts/Surfaces/Surface.hpp b/Core/include/Acts/Surfaces/Surface.hpp
index 57a6c40d8..f4024d9a4 100644
--- a/Core/include/Acts/Surfaces/Surface.hpp
+++ b/Core/include/Acts/Surfaces/Surface.hpp
@@ -65,9 +65,9 @@ public:
/// Constructor with Transform3D as a shared object
///
- /// @param htrans Transform3D positions the surface in 3D global space
+ /// @param tform Transform3D positions the surface in 3D global space
/// @note also acts as default constructor
- Surface(std::shared_ptr<const Transform3D> htrans = nullptr);
+ Surface(std::shared_ptr<const Transform3D> tform = nullptr);
/// Copy constructor
/// @note copy construction invalidates the association
@@ -81,8 +81,8 @@ public:
/// to detector element and identifier
///
/// @param other Source surface for copy
- /// @param transf Additional transform applied after copying from the source
- Surface(const Surface& other, const Transform3D& transf);
+ /// @param shift Additional transform applied after copying from the source
+ Surface(const Surface& other, const Transform3D& shift);
/// Constructor fromt DetectorElementBase: Element proxy
///
@@ -113,9 +113,9 @@ public:
/// Comparison (non-equality) operator
///
- /// @param other Source surface for the comparison
+ /// @param sf Source surface for the comparison
virtual bool
- operator!=(const Surface& other) const;
+ operator!=(const Surface& sf) const;
/// Implicit constructor
/// uses the copy constructor a new position can optionally be given
@@ -216,12 +216,12 @@ public:
///
/// @tparam parameters_t The parameters type
///
- /// @param parameters TrackParameters to be checked
+ /// @param pars TrackParameters to be checked
/// @param bcheck BoundaryCheck directive for this onSurface check
/// @return boolean indication if operation was successful
template <typename parameters_t>
bool
- onSurface(const parameters_t& parameters,
+ onSurface(const parameters_t& pars,
const BoundaryCheck& bcheck = BoundaryCheck(true)) const;
/// The geometric onSurface method
@@ -235,11 +235,12 @@ public:
/// The insideBounds method for local positions
///
- /// @param lpos local position to check
+ /// @param locpos local position to check
/// @param bcheck BoundaryCheck directive for this onSurface check
/// @return boolean indication if operation was successful
virtual bool
- insideBounds(const Vector2D& lpos, const BoundaryCheck& bcheck = true) const;
+ insideBounds(const Vector2D& locpos,
+ const BoundaryCheck& bcheck = true) const;
/// Local to global transformation
/// Generalized local to global transformation for the surface types. Since
@@ -289,11 +290,11 @@ public:
/// The jacobian is assumed to be initialised, so only the
/// relevant entries are filled
///
- /// @param jac is the jacobian to be initialized
- /// @param pos is the global position of the parameters
+ /// @param jacobian is the jacobian to be initialized
+ /// @param gpos is the global position of the parameters
/// @param dir is the direction at of the parameters
/// @param pars is the parameter vector
- virtual void initJacobianToGlobal(ActsMatrixD<7, 5>& jac,
+ virtual void initJacobianToGlobal(ActsMatrixD<7, 5>& jacobian,
const Vector3D& gpos,
const Vector3D& dir,
const ActsVectorD<5>& pars) const;
@@ -303,15 +304,15 @@ public:
/// The jacobian is assumed to be initialised, so only the
/// relevant entries are filled
///
- /// @param jac is the jacobian to be initialized
- /// @param pos is the global position of the parameters
+ /// @param jacobian is the jacobian to be initialized
+ /// @param gpos is the global position of the parameters
/// @param dir is the direction at of the parameters
- /// @param pars is the parameter vector
///
/// @return the transposed reference frame (avoids recalculation)
- virtual const RotationMatrix3D initJacobianToLocal(ActsMatrixD<5, 7>& jac,
- const Vector3D& gpos,
- const Vector3D& dir) const;
+ virtual const RotationMatrix3D
+ initJacobianToLocal(ActsMatrixD<5, 7>& jacobian,
+ const Vector3D& gpos,
+ const Vector3D& dir) const;
/// Calculate the form factors for the derivatives
/// the calculation is identical for all surfaces where the
diff --git a/Core/include/Acts/Surfaces/TrapezoidBounds.hpp b/Core/include/Acts/Surfaces/TrapezoidBounds.hpp
index cede97e4f..03537e94a 100644
--- a/Core/include/Acts/Surfaces/TrapezoidBounds.hpp
+++ b/Core/include/Acts/Surfaces/TrapezoidBounds.hpp
@@ -52,8 +52,8 @@ public:
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- TrapezoidBounds(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ TrapezoidBounds(const variant_data& vardata);
~TrapezoidBounds() override;
diff --git a/Core/include/Acts/Surfaces/TriangleBounds.hpp b/Core/include/Acts/Surfaces/TriangleBounds.hpp
index 66c654f03..d1580435d 100644
--- a/Core/include/Acts/Surfaces/TriangleBounds.hpp
+++ b/Core/include/Acts/Surfaces/TriangleBounds.hpp
@@ -51,8 +51,8 @@ public:
/// Constructor which accepts @c variant_data
///
- /// @param data the @c variant_data to build from
- TriangleBounds(const variant_data& data);
+ /// @param vardata the @c variant_data to build from
+ TriangleBounds(const variant_data& vardata);
~TriangleBounds() override;
diff --git a/Core/include/Acts/Tools/CylinderVolumeBuilder.hpp b/Core/include/Acts/Tools/CylinderVolumeBuilder.hpp
index 7bbf1e348..23652aed1 100644
--- a/Core/include/Acts/Tools/CylinderVolumeBuilder.hpp
+++ b/Core/include/Acts/Tools/CylinderVolumeBuilder.hpp
@@ -562,9 +562,9 @@ public:
/// set logging instance
///
- /// @param [in] logger is the logging istance to be set
+ /// @param [in] newLogger is the logging istance to be set
void
- setLogger(std::unique_ptr<const Logger> logger);
+ setLogger(std::unique_ptr<const Logger> newLogger);
private:
/// Configuration struct
diff --git a/Core/include/Acts/Tools/CylinderVolumeHelper.hpp b/Core/include/Acts/Tools/CylinderVolumeHelper.hpp
index 317e225a6..7a430f588 100644
--- a/Core/include/Acts/Tools/CylinderVolumeHelper.hpp
+++ b/Core/include/Acts/Tools/CylinderVolumeHelper.hpp
@@ -84,7 +84,7 @@ public:
/// @param transform (optional) placement of this TrackingVolume - ownership
/// given
/// @param volumeName volume name to be given
- /// @param btype (optional) BinningType - arbitrary(default) or equidistant
+ /// @param bType (optional) BinningType - arbitrary(default) or equidistant
///
/// @return shared pointer to a new TrackingVolume
MutableTrackingVolumePtr
@@ -93,35 +93,41 @@ public:
VolumeBoundsPtr volBounds,
std::shared_ptr<const Transform3D> transform = nullptr,
const std::string& volumeName = "UndefinedVolume",
- BinningType btype = arbitrary) const override;
+ BinningType bType = arbitrary) const override;
/// Create a TrackingVolume* from a set of layers and (optional) parameters
+ /// @note this TrackingVolume is restricted to Translation only
///
/// @param layers vector of static layers confined by the TrackingVolume
/// if no bounds or HepTransform is given, they define the size
/// together with the volume enevlope parameters
/// @param matprop dense material properties for this TrackingVolume
- /// @param loc0Min, loc0Max, loc1Min, loc1Max : local position in space,
- /// this TrackingVolume is restricted to Translation only
+ /// @param rMin minimum radius
+ /// @param rMax maximum radius
+ /// @param zMin minimum z
+ /// @param zMax maximum z
/// @param volumeName volume name to be given
- /// @param btype (optional) BinningType - arbitrary(default) or equidistant
+ /// @param bType (optional) BinningType - arbitrary(default) or equidistant
///
/// @return shared pointer to a new TrackingVolume
MutableTrackingVolumePtr
createTrackingVolume(const LayerVector& layers,
std::shared_ptr<const Material> matprop,
- double loc0Min,
- double loc0Max,
- double loc1Min,
- double loc1Max,
+ double rMin,
+ double rMax,
+ double zMin,
+ double zMax,
const std::string& volumeName = "UndefinedVolume",
- BinningType btype = arbitrary) const override;
+ BinningType bType = arbitrary) const override;
/// Create a gap volume from dimensions and
+ /// @note this TrackingVolume is restricted to Translation only
///
/// @param matprop dense material properties for this TrackingVolume
- /// @param loc0Min, loc0Max, loc1Min, loc1Max : local position in space,
- /// this TrackingVolume is restricted to Translation only
+ /// @param rMin minimum radius
+ /// @param rMax maximum radius
+ /// @param zMin minimum z
+ /// @param zMax maximum z
/// @param materialLayers number of material layers (aequidistant binning)
/// @param cylinder type of layers
/// @param volumeName volume name to be given
@@ -129,10 +135,10 @@ public:
/// @return shared pointer to a new TrackingVolume
MutableTrackingVolumePtr
createGapTrackingVolume(std::shared_ptr<const Material> matprop,
- double loc0Min,
- double loc0Max,
- double loc1Min,
- double loc1Max,
+ double rMin,
+ double rMax,
+ double zMin,
+ double zMax,
unsigned int materialLayers,
bool cylinder = true,
const std::string& volumeName
@@ -141,23 +147,26 @@ public:
/// Create a gap volume from dimensions and
///
/// @param matprop dense material properties for this TrackingVolume
- /// @param loc0Min, loc0Max, loc1Min, loc1Max local position in space,
+ /// @param rMin minimum radius
+ /// @param rMax maximum radius
+ /// @param zMin minimum z
+ /// @param zMax maximum z
/// @param layerPositions custom layer positions
/// @param cylinder type of layers
/// @param volumeName : volume name to be given
- /// @param btype (optional) BinningType - arbitrary(default) or equidistant
+ /// @param bType (optional) BinningType - arbitrary(default) or equidistant
///
/// @return shared pointer to a new TrackingVolume
MutableTrackingVolumePtr
createGapTrackingVolume(std::shared_ptr<const Material> matprop,
- double loc0Min,
- double loc0Max,
- double loc1Min,
- double loc1Max,
+ double rMin,
+ double rMax,
+ double zMin,
+ double zMax,
const std::vector<double>& layerPositions,
bool cylinder = true,
const std::string& volumeName = "UndefinedVolume",
- BinningType btype = arbitrary) const override;
+ BinningType bType = arbitrary) const override;
/// Create a container volumes from sub volumes, input volumes are ordered in
/// R or Z by convention
@@ -172,9 +181,9 @@ public:
/// Set configuration method
///
- /// @param cvbConfig is the configurtion struct assigned
+ /// @param cvhConfig is the configurtion struct assigned
void
- setConfiguration(const Config& cvbConfig);
+ setConfiguration(const Config& cvhConfig);
/// Get configuration method
Config
@@ -182,9 +191,9 @@ public:
/// Set logging instance
///
- /// @param logger is the logger isntance to be set
+ /// @param newLogger is the logger isntance to be set
void
- setLogger(std::unique_ptr<const Logger> logger);
+ setLogger(std::unique_ptr<const Logger> newLogger);
protected:
/// Configuration object
@@ -205,7 +214,7 @@ private:
/// of layers, these are checked against the layer positions/dimensions.
///
/// @param layers the layers for which the dimensions are checked
- /// @param cylBounds the cylinder volume bounds needed for wrapping
+ /// @param cylinderVolumeBounds the cylinder volume bounds needed for wrapping
/// @param transform a transformation of the layers, volume
/// @param rMinClean the smallest radius given by layers
/// @param rMaxClean the maximal radius given by layers
@@ -214,8 +223,8 @@ private:
/// @param bValue the binning value in which the binning works
/// @param bType is the type of binning: equidistant, arbitrary
bool
- estimateAndCheckDimension(const LayerVector& layers,
- const CylinderVolumeBounds*& cylBounds,
+ estimateAndCheckDimension(const LayerVector& layers,
+ const CylinderVolumeBounds*& cylinderVolumeBounds,
std::shared_ptr<const Transform3D>& transform,
double& rMinClean,
double& rMaxClean,
@@ -245,9 +254,9 @@ private:
/// Private method - glue volume to the other
///
- /// @param volumeOne is the first volume in the glue process
+ /// @param tvolOne is the first volume in the glue process
/// @param faceOne is the first boundary face of the glue process
- /// @param volumeTwo is the second volume in the glue process
+ /// @param tvolTwo is the second volume in the glue process
/// @param faceTwo is the second boundary face of the glue process
/// @param rMin the minimum radius of the volume
/// @param rGlueMin the minimum glue radius (@todo check and document)
@@ -255,9 +264,9 @@ private:
/// @param zMin the minimum z extend of the volume
/// @param zMax the maximum z extend of the volume
void
- glueTrackingVolumes(MutableTrackingVolumePtr volumeOne,
+ glueTrackingVolumes(MutableTrackingVolumePtr tvolOne,
BoundarySurfaceFace faceOne,
- MutableTrackingVolumePtr volumeTwo,
+ MutableTrackingVolumePtr tvolTwo,
BoundarySurfaceFace faceTwo,
double rMin,
double rGlueMin,
@@ -271,15 +280,15 @@ private:
/// @param bsf is the boundary surface to which faces are added
/// @param vols are the voluems which are added
void
- addFaceVolumes(MutableTrackingVolumePtr tVolume,
- BoundarySurfaceFace bsf,
+ addFaceVolumes(MutableTrackingVolumePtr tvol,
+ BoundarySurfaceFace glueFace,
TrackingVolumeVector& vols) const;
/// Private method - helper method to save some code
///
/// @param z is the z position of the layer (@todo use Transform)
/// @param r is the radius of the layer
- /// @param halflength is the half lengthz in z of the cylinder
+ /// @param halflengthZ is the half lengthz in z of the cylinder
/// @param thickness is the thickness of the cylinder
/// @param binsPhi are the bins for the material in phi
/// @param binsZ are the bins for the material in z
@@ -288,7 +297,7 @@ private:
LayerPtr
createCylinderLayer(double z,
double r,
- double halflength,
+ double halflengthZ,
double thickness,
int binsPhi,
int binsZ) const;
diff --git a/Core/include/Acts/Tools/LayerArrayCreator.hpp b/Core/include/Acts/Tools/LayerArrayCreator.hpp
index f4bfb71b8..fea68587c 100644
--- a/Core/include/Acts/Tools/LayerArrayCreator.hpp
+++ b/Core/include/Acts/Tools/LayerArrayCreator.hpp
@@ -57,19 +57,19 @@ public:
/// LayerArrayCreator interface method
///
- /// @param layers are the layers to be moved into an array
+ /// @param layersInput are the layers to be moved into an array
/// @param min is the minimum value for binning
/// @param max is the maximum value for binning
- /// @param btype is the binning type
- /// @param bvalue is the value in which the binning should be done
+ /// @param bType is the binning type
+ /// @param bValue is the value in which the binning should be done
///
/// @return unique pointer to a newly created LayerArray
std::unique_ptr<const LayerArray>
- layerArray(const LayerVector& layers,
+ layerArray(const LayerVector& layersInput,
double min,
double max,
- BinningType btype = arbitrary,
- BinningValue bvalue = binX) const override;
+ BinningType bType = arbitrary,
+ BinningValue bValue = binX) const override;
/// set logging instance
void
@@ -93,7 +93,7 @@ private:
/// the NavigationLayer
Surface*
createNavigationSurface(const Layer& layer,
- BinningValue bvalue,
+ BinningValue bValue,
double offset) const;
};
diff --git a/Core/include/Acts/Tools/LayerCreator.hpp b/Core/include/Acts/Tools/LayerCreator.hpp
index a2d52908c..670994b95 100644
--- a/Core/include/Acts/Tools/LayerCreator.hpp
+++ b/Core/include/Acts/Tools/LayerCreator.hpp
@@ -204,8 +204,9 @@ public:
getConfiguration() const;
/// set logging instance
+ /// @param newLogger the logger instance
void
- setLogger(std::unique_ptr<const Logger> logger);
+ setLogger(std::unique_ptr<const Logger> newLogger);
// associate surfaces contained by this layer to this layer
void
diff --git a/Core/include/Acts/Tools/PassiveLayerBuilder.hpp b/Core/include/Acts/Tools/PassiveLayerBuilder.hpp
index e8d1d6ac7..ee595e542 100644
--- a/Core/include/Acts/Tools/PassiveLayerBuilder.hpp
+++ b/Core/include/Acts/Tools/PassiveLayerBuilder.hpp
@@ -98,9 +98,9 @@ public:
/// Set logging instance
///
- /// @param logger is the logging instance to be set
+ /// @param newLogger the logger instance
void
- setLogger(std::unique_ptr<const Logger> logger);
+ setLogger(std::unique_ptr<const Logger> newLogger);
protected:
Config m_cfg; //!< configuration
diff --git a/Core/include/Acts/Tools/SurfaceArrayCreator.hpp b/Core/include/Acts/Tools/SurfaceArrayCreator.hpp
index ad10a09d8..25eb65a48 100644
--- a/Core/include/Acts/Tools/SurfaceArrayCreator.hpp
+++ b/Core/include/Acts/Tools/SurfaceArrayCreator.hpp
@@ -114,7 +114,7 @@ public:
/// to be ordered on the cylinder
/// @pre the pointers to the sensitive surfaces in the surfaces vectors all
/// need to be valid, since no check is performed
- /// @param protoLayer The proto layer containing the layer size
+ /// @param protoLayerOpt The proto layer containing the layer size
/// @param binsPhi is the number of bins in phi for the surfaces
/// @param binsZ is the number of bin in Z for the surfaces
/// @param transform is the (optional) additional transform applied
@@ -125,7 +125,7 @@ public:
size_t binsPhi,
size_t binsZ,
boost::optional<ProtoLayer> protoLayer = boost::none,
- std::shared_ptr<const Transform3D> transform
+ std::shared_ptr<const Transform3D> transformOpt
= nullptr) const;
/// SurfaceArrayCreator interface method
@@ -137,7 +137,7 @@ public:
/// to be ordered on the cylinder
/// @pre the pointers to the sensitive surfaces in the surfaces vectors all
/// need to be valid, since no check is performed
- /// @param protoLayer The proto layer containing the layer size
+ /// @param protoLayerOpt The proto layer containing the layer size
/// @param bTypePhi the binning type in phi direction (equidistant/aribtrary)
/// @param bTypeZ the binning type in z direction (equidistant/aribtrary)
/// @param transform is the (optional) additional transform applied
@@ -145,10 +145,11 @@ public:
/// @return a unique pointer a new SurfaceArray
std::unique_ptr<Acts::SurfaceArray>
surfaceArrayOnCylinder(const std::vector<const Surface*>& surfaces,
- BinningType bTypePhi = equidistant,
- BinningType bTypeZ = equidistant,
- boost::optional<ProtoLayer> protoLayer = boost::none,
- std::shared_ptr<const Transform3D> transform
+ BinningType bTypePhi = equidistant,
+ BinningType bTypeZ = equidistant,
+ boost::optional<ProtoLayer> protoLayerOpt
+ = boost::none,
+ std::shared_ptr<const Transform3D> transformOpt
= nullptr) const;
/// SurfaceArrayCreator interface method
@@ -159,18 +160,18 @@ public:
/// to be ordered on the disc
/// @pre the pointers to the sensitive surfaces in the surfaces vectors all
/// need to be valid, since no check is performed
- /// @param protoLayer The proto layer containing the layer size
+ /// @param protoLayerOpt The proto layer containing the layer size
/// @param binsPhi is the number of bins in phi for the surfaces
/// @param binsR is the number of bin in R for the surfaces
- /// @param transform is the (optional) additional transform applied
+ /// @param transformOpt is the (optional) additional transform applied
///
/// @return a unique pointer a new SurfaceArray
std::unique_ptr<SurfaceArray>
surfaceArrayOnDisc(const std::vector<const Surface*>& surfaces,
size_t binsR,
size_t binsPhi,
- boost::optional<ProtoLayer> protoLayer = boost::none,
- std::shared_ptr<const Transform3D> transform
+ boost::optional<ProtoLayer> protoLayerOpt = boost::none,
+ std::shared_ptr<const Transform3D> transformOpt
= nullptr) const;
/// SurfaceArrayCreator interface method
@@ -182,10 +183,10 @@ public:
/// to be ordered on the disc
/// @pre the pointers to the sensitive surfaces in the surfaces vectors all
/// need to be valid, since no check is performed
- /// @param protoLayer The proto layer containing the layer size
+ /// @param protoLayerOpt The proto layer containing the layer size
/// @param bTypeR the binning type in r direction (equidistant/aribtrary)
/// @param bTypePhi the binning type in phi direction (equidistant/aribtrary)
- /// @param transform is the (optional) additional transform applied
+ /// @param transformOpt is the (optional) additional transform applied
///
/// @return a unique pointer a new SurfaceArray
/// @note If there is more than on R-Ring, number of phi bins
@@ -195,8 +196,8 @@ public:
surfaceArrayOnDisc(const std::vector<const Surface*>& surfaces,
BinningType bTypeR,
BinningType bTypePhi,
- boost::optional<ProtoLayer> protoLayer = boost::none,
- std::shared_ptr<const Transform3D> transform
+ boost::optional<ProtoLayer> protoLayerOpt = boost::none,
+ std::shared_ptr<const Transform3D> transformOpt
= nullptr) const;
/// SurfaceArrayCreator interface method
@@ -301,6 +302,7 @@ private:
/// @param surfaces are the sensitive surfaces to be
/// @param bValue the BinningValue in which direction should be binned
/// (currently possible: binPhi, binR, binZ)
+ /// @param protoLayer Instance of @c ProtoLayer holding generic layer info
/// @param transform is the (optional) additional transform applied
/// @return Instance of @c ProtoAxis containing determined properties
/// @note This only creates the @c ProtoAxis, this needs to be turned
@@ -449,4 +451,4 @@ private:
const std::vector<Acts::Vector2D>& locVertices) const;
};
-} // namespace Acts
\ No newline at end of file
+} // namespace Acts
diff --git a/Core/include/Acts/Tools/TrackingGeometryBuilder.hpp b/Core/include/Acts/Tools/TrackingGeometryBuilder.hpp
index e09cba852..6ee9cae10 100644
--- a/Core/include/Acts/Tools/TrackingGeometryBuilder.hpp
+++ b/Core/include/Acts/Tools/TrackingGeometryBuilder.hpp
@@ -79,8 +79,9 @@ public:
getConfiguration() const;
/// set logging instance
+ /// @param newLogger the new logging instance
void
- setLogger(std::unique_ptr<const Logger> logger);
+ setLogger(std::unique_ptr<const Logger> newLogger);
private:
/// Configuration member
diff --git a/Core/include/Acts/Tools/TrackingVolumeArrayCreator.hpp b/Core/include/Acts/Tools/TrackingVolumeArrayCreator.hpp
index 3e4989566..2c51f7f20 100644
--- a/Core/include/Acts/Tools/TrackingVolumeArrayCreator.hpp
+++ b/Core/include/Acts/Tools/TrackingVolumeArrayCreator.hpp
@@ -48,13 +48,13 @@ public:
/// create a tracking volume array
///
- /// @param vols is the vector of TrackingVolumes to be
- /// @param bVal is the binning value
+ /// @param tVolumes is the vector of TrackingVolumes to be
+ /// @param bValue is the binning value
///
/// @return new created volume array
std::shared_ptr<const TrackingVolumeArray>
- trackingVolumeArray(const TrackingVolumeVector& vols,
- BinningValue bVal) const override;
+ trackingVolumeArray(const TrackingVolumeVector& tVolumes,
+ BinningValue bValue) const override;
/// Set logging instance
///
diff --git a/Core/include/Acts/Utilities/ApproachDescriptor.hpp b/Core/include/Acts/Utilities/ApproachDescriptor.hpp
index 9be8b32ba..2439cb249 100644
--- a/Core/include/Acts/Utilities/ApproachDescriptor.hpp
+++ b/Core/include/Acts/Utilities/ApproachDescriptor.hpp
@@ -56,13 +56,14 @@ public:
///
/// @param parameters The actual parameters object
/// @param options are the steering options for the search
+ /// @param corrfnc The actual Corrector object
template <typename parameters_t,
typename options_t,
typename corrector_t = VoidCorrector>
ObjectIntersection<Surface>
approachSurface(const parameters_t& parameters,
const options_t& options,
- const corrector_t& correct = corrector_t()) const;
+ const corrector_t& corrfnc = corrector_t()) const;
/// @brief Get the surface on approach
///
diff --git a/Core/include/Acts/Utilities/GeometryID.hpp b/Core/include/Acts/Utilities/GeometryID.hpp
index cf6ebe15f..6c1243257 100644
--- a/Core/include/Acts/Utilities/GeometryID.hpp
+++ b/Core/include/Acts/Utilities/GeometryID.hpp
@@ -167,5 +167,5 @@ operator>=(const GeometryID& one, const GeometryID& two);
/// Overload of << operator for std::ostream for debug output
std::ostream&
-operator<<(std::ostream& sl, const GeometryID& tddID);
+operator<<(std::ostream& sl, const GeometryID& tid);
}
\ No newline at end of file
diff --git a/Core/include/Acts/Utilities/VariantData.hpp b/Core/include/Acts/Utilities/VariantData.hpp
index 61f6ae89d..8ce866357 100644
--- a/Core/include/Acts/Utilities/VariantData.hpp
+++ b/Core/include/Acts/Utilities/VariantData.hpp
@@ -566,21 +566,21 @@ to_variant(const ActsMatrixD<4, 4>& matrix)
/// This is the unimplemented base template that is specialized
/// for various types.
/// @tparam T The type you want
-/// @param data The data
+/// @param vardata The data
/// @return The converted data as type @c T
template <typename T>
inline T
-from_variant(const variant_data& data);
+from_variant(const variant_data& vardata);
/// Function to produce a @c Transform3D from @c variant_data.
-/// @param data_ The input @c variant_data
+/// @param vardata The input @c variant_data
/// @return The converted @c Transform3D
template <>
inline Transform3D
-from_variant<Transform3D>(const variant_data& data_)
+from_variant<Transform3D>(const variant_data& vardata)
{
- throw_assert(data_.which() == 4, "Must be variant_map");
- const variant_map& data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Must be variant_map");
+ const variant_map& data = boost::get<variant_map>(vardata);
throw_assert(data.get<std::string>("type") == "Transform3D",
"Must be type Transform3D");
@@ -601,14 +601,14 @@ from_variant<Transform3D>(const variant_data& data_)
}
/// Function to produce a @c Vector2D from @c variant_data.
-/// @param data_ The input @c variant_data
+/// @param vardata The input @c variant_data
/// @return The converted @c Vector2D
template <>
inline Vector2D
-from_variant<Vector2D>(const variant_data& data_)
+from_variant<Vector2D>(const variant_data& vardata)
{
- throw_assert(data_.which() == 4, "Must be variant_map");
- const variant_map& data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Must be variant_map");
+ const variant_map& data = boost::get<variant_map>(vardata);
throw_assert(data.get<std::string>("type") == "Vector2D",
"Must be type Vector2D");
@@ -619,4 +619,4 @@ from_variant<Vector2D>(const variant_data& data_)
return vec;
}
-} // namespace Acts
\ No newline at end of file
+} // namespace Acts
diff --git a/Core/include/Acts/Volumes/BoundarySurfaceT.hpp b/Core/include/Acts/Volumes/BoundarySurfaceT.hpp
index 32a50735a..a3d628c8d 100644
--- a/Core/include/Acts/Volumes/BoundarySurfaceT.hpp
+++ b/Core/include/Acts/Volumes/BoundarySurfaceT.hpp
@@ -111,15 +111,15 @@ public:
/// Get the next Volume depending on GlobalPosition, GlobalMomentum, dir on
/// the TrackParameters and the requested direction
///
- /// @param gpos is the global position on surface
+ /// @param pos is the global position on surface
/// @param mom is the direction on the surface
/// @param dir is an aditional direction corrective
///
/// @return is the attached volume at that position
virtual const T*
- attachedVolume(const Vector3D& gpos,
+ attachedVolume(const Vector3D& pos,
const Vector3D& mom,
- NavigationDirection dir) const;
+ NavigationDirection pdir) const;
/// templated onBoundary method
///
diff --git a/Core/include/Acts/Volumes/CuboidVolumeBounds.hpp b/Core/include/Acts/Volumes/CuboidVolumeBounds.hpp
index a7206eca7..3becb8402 100644
--- a/Core/include/Acts/Volumes/CuboidVolumeBounds.hpp
+++ b/Core/include/Acts/Volumes/CuboidVolumeBounds.hpp
@@ -54,24 +54,24 @@ public:
/// Constructor - the box boundaries
///
- /// @param hlengthx is the half length of the cube in x
- /// @param hlengthy is the half length of the cube in y
- /// @param hlengthz is the half length of the cube in z
- CuboidVolumeBounds(double hlengthx, double hlengthy, double hlengthz);
+ /// @param halex is the half length of the cube in x
+ /// @param haley is the half length of the cube in y
+ /// @param halez is the half length of the cube in z
+ CuboidVolumeBounds(double halex, double haley, double halez);
/// Copy Constructor
///
- /// @param cubo is the source volume bounds to be copied
- CuboidVolumeBounds(const CuboidVolumeBounds& cubo);
+ /// @param bobo is the source volume bounds to be copied
+ CuboidVolumeBounds(const CuboidVolumeBounds& bobo);
/// Destructor
~CuboidVolumeBounds() override;
/// Assignment operator
///
- /// @param cubo is the source volume bounds to be assigned
+ /// @param bobo is the source volume bounds to be assigned
CuboidVolumeBounds&
- operator=(const CuboidVolumeBounds& cubo);
+ operator=(const CuboidVolumeBounds& bobo);
/// Virtual constructor
CuboidVolumeBounds*
diff --git a/Core/include/Acts/Volumes/CylinderVolumeBounds.hpp b/Core/include/Acts/Volumes/CylinderVolumeBounds.hpp
index 14424f96e..d1402419f 100644
--- a/Core/include/Acts/Volumes/CylinderVolumeBounds.hpp
+++ b/Core/include/Acts/Volumes/CylinderVolumeBounds.hpp
@@ -96,11 +96,11 @@ public:
///
/// @param rinner is the inner radius of the cylinder
/// @param router is the outer radius of the cylinder
- /// @param halfPhiSector is the half opening angle
+ /// @param haphi is the half opening angle
/// @param halez is the half length in z
CylinderVolumeBounds(double rinner,
double router,
- double halfPhiSector,
+ double haphi,
double halez);
/// Copy Constructor
@@ -122,10 +122,10 @@ public:
/// This method checks if position in the 3D volume
/// frame is inside the cylinder
///
- /// @param gpos is a global position to be checked
+ /// @param pos is a global position to be checked
/// @param tol is the tolerance for the check
bool
- inside(const Vector3D& gpos, double tol = 0.) const override;
+ inside(const Vector3D& pos, double tol = 0.) const override;
/// Method to decompose the Bounds into boundarySurfaces
/// @param transformPtr is the transform where the boundary surfaces are
@@ -179,7 +179,7 @@ private:
/// templated dumpT method
template <class T>
T&
- dumpT(T& t) const;
+ dumpT(T& tstream) const;
/// This method returns the associated CylinderBounds
/// of the inner CylinderSurfaces.
diff --git a/Core/include/Acts/Volumes/DoubleTrapezoidVolumeBounds.hpp b/Core/include/Acts/Volumes/DoubleTrapezoidVolumeBounds.hpp
index b72870c28..f3ca6a8df 100644
--- a/Core/include/Acts/Volumes/DoubleTrapezoidVolumeBounds.hpp
+++ b/Core/include/Acts/Volumes/DoubleTrapezoidVolumeBounds.hpp
@@ -75,32 +75,32 @@ public:
/// Constructor - the double trapezoid boundaries (
/// symmetric trapezoid/diamond
///
- /// @param minhlenghtx half length in x at minimum y
- /// @param medhlengthx half length in x aty = 0
- /// @param maxhlengthx half length in x at maximum x
- /// @param hlenghty1 first half length in y (to negative)
- /// @param hlenghty2 second half length in y (to positive)
- /// @param hlengthz half length in z
- DoubleTrapezoidVolumeBounds(double minhlenghtx,
- double medhlengthx,
- double maxhlengthx,
- double hlenghty1,
- double hlenghty2,
- double hlengthz);
+ /// @param minhalex half length in x at minimum y
+ /// @param medhalex half length in x aty = 0
+ /// @param maxhalex half length in x at maximum x
+ /// @param haley1 first half length in y (to negative)
+ /// @param haley2 second half length in y (to positive)
+ /// @param halez half length in z
+ DoubleTrapezoidVolumeBounds(double minhalex,
+ double medhalex,
+ double maxhalex,
+ double haley1,
+ double haley2,
+ double halez);
/// Copy Constructor
///
- /// @param dtbo is the source bounds
- DoubleTrapezoidVolumeBounds(const DoubleTrapezoidVolumeBounds& dtbo);
+ /// @param trabo is the source bounds
+ DoubleTrapezoidVolumeBounds(const DoubleTrapezoidVolumeBounds& trabo);
/// Destructor
~DoubleTrapezoidVolumeBounds() override;
/// Assignment operator
///
- /// @param dtbo is the source bounds
+ /// @param trabo is the source bounds
DoubleTrapezoidVolumeBounds&
- operator=(const DoubleTrapezoidVolumeBounds& dtbo);
+ operator=(const DoubleTrapezoidVolumeBounds& trabo);
/// Virtual constructor
DoubleTrapezoidVolumeBounds*
@@ -109,10 +109,10 @@ public:
/// This method checks if position in the 3D volume frame
/// is inside the cylinder
///
- /// @param gpos is the global position to be checked for inside
+ /// @param pos is the global position to be checked for inside
/// @param tol is the tolerance parametere
bool
- inside(const Vector3D& gpos, double tol = 0.) const override;
+ inside(const Vector3D& pos, double tol = 0.) const override;
/// decompose into boundary surfaces
///
diff --git a/Core/include/Acts/Volumes/TrapezoidVolumeBounds.hpp b/Core/include/Acts/Volumes/TrapezoidVolumeBounds.hpp
index 1641b5f98..16754da1e 100644
--- a/Core/include/Acts/Volumes/TrapezoidVolumeBounds.hpp
+++ b/Core/include/Acts/Volumes/TrapezoidVolumeBounds.hpp
@@ -64,37 +64,39 @@ public:
/// Constructor - the trapezoid boundaries (symmetric trapezoid)
///
- /// @param minhlengthx is the half length in x at minimal y
- /// @param maxhlengthx is the half length in x at maximal y
- /// @param hlenghty is the half length in y
- /// @param hlengthz is the half length in z
- TrapezoidVolumeBounds(double minhlengthx,
- double maxhlengthx,
- double hlenghty,
- double hlengthz);
+ /// @param minhalex is the half length in x at minimal y
+ /// @param maxhalex is the half length in x at maximal y
+ /// @param haley is the half length in y
+ /// @param halez is the half length in z
+ TrapezoidVolumeBounds(double minhalex,
+ double maxhalex,
+ double haley,
+ double halez);
/// Constructor - the trapezoid boundaries (arbitrary trapezoid)
///
- /// @param minhlengthx is the half length in x at minimal y
- /// @param hlenghty is the half length in y
- /// @param hlengthz is the half length in z
+ /// @param minhalex is the half length in x at minimal y
+ /// @param haley is the half length in y
+ /// @param halez is the half length in z
/// @param alpha is the openeing angle at -x,-y
/// @param beta is the openeing angle at +x,-y
- TrapezoidVolumeBounds(double minhlengthx,
- double hlenghty,
- double hlengthz,
+ TrapezoidVolumeBounds(double minhalex,
+ double haley,
+ double halez,
double alpha,
double beta);
/// Copy Constructor
- TrapezoidVolumeBounds(const TrapezoidVolumeBounds& bobo);
+ /// @param trabo The object to be copied
+ TrapezoidVolumeBounds(const TrapezoidVolumeBounds& trabo);
/// Destructor
~TrapezoidVolumeBounds() override;
/// Assignment operator
+ /// @param trabo The object to be assigned
TrapezoidVolumeBounds&
- operator=(const TrapezoidVolumeBounds& bobo);
+ operator=(const TrapezoidVolumeBounds& trabo);
/// Virtual constructor
TrapezoidVolumeBounds*
@@ -103,12 +105,12 @@ public:
/// This method checks if position in the 3D volume frame
/// is inside the cylinder
///
- /// @param gpos is the global position to be checked
+ /// @param pos is the global position to be checked
/// @param tol is the tolerance applied
///
/// @return boolean indicator if position is inside
bool
- inside(const Vector3D& gpos, double tol = 0.) const override;
+ inside(const Vector3D& pos, double tol = 0.) const override;
/// Method to decompose the Bounds into Surfaces
///
diff --git a/Core/include/Acts/Volumes/Volume.hpp b/Core/include/Acts/Volumes/Volume.hpp
index e815f335f..ad384730c 100644
--- a/Core/include/Acts/Volumes/Volume.hpp
+++ b/Core/include/Acts/Volumes/Volume.hpp
@@ -37,8 +37,8 @@ public:
/// Explicit constructor with shared arguments
///
/// @param htrans is the transform to position the volume in 3D space
- /// @param volBounds is the volume boundary definitions
- Volume(std::shared_ptr<const Transform3D> htrans, VolumeBoundsPtr volBounds);
+ /// @param volbounds is the volume boundary definitions
+ Volume(std::shared_ptr<const Transform3D> htrans, VolumeBoundsPtr volbounds);
/// Copy Constructor - with optional shift
///
diff --git a/Core/src/Layers/CylinderLayer.cpp b/Core/src/Layers/CylinderLayer.cpp
index 78fdde930..8299b4b0d 100644
--- a/Core/src/Layers/CylinderLayer.cpp
+++ b/Core/src/Layers/CylinderLayer.cpp
@@ -52,10 +52,10 @@ Acts::CylinderLayer::CylinderLayer(
}
std::shared_ptr<Acts::Layer>
-Acts::CylinderLayer::create(const variant_data& data_)
+Acts::CylinderLayer::create(const variant_data& vardata)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- const variant_map& data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ const variant_map& data = boost::get<variant_map>(vardata);
std::string type = data.get<std::string>("type");
throw_assert(type == "CylinderLayer", "Type must be CylinderLayer");
diff --git a/Core/src/Layers/DiscLayer.cpp b/Core/src/Layers/DiscLayer.cpp
index 3b54ea828..b7118a7f6 100644
--- a/Core/src/Layers/DiscLayer.cpp
+++ b/Core/src/Layers/DiscLayer.cpp
@@ -55,10 +55,10 @@ Acts::DiscLayer::DiscLayer(std::shared_ptr<const Transform3D> transform,
}
std::shared_ptr<Acts::Layer>
-Acts::DiscLayer::create(const variant_data& data_)
+Acts::DiscLayer::create(const variant_data& vardata)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- const variant_map& data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ const variant_map& data = boost::get<variant_map>(vardata);
std::string type = data.get<std::string>("type");
throw_assert(type == "DiscLayer", "Type must be DiscLayer");
diff --git a/Core/src/Layers/NavigationLayer.cpp b/Core/src/Layers/NavigationLayer.cpp
index 17cb445d4..443aad027 100644
--- a/Core/src/Layers/NavigationLayer.cpp
+++ b/Core/src/Layers/NavigationLayer.cpp
@@ -26,10 +26,10 @@ Acts::NavigationLayer::NavigationLayer(
}
std::shared_ptr<const Acts::Layer>
-Acts::NavigationLayer::create(const variant_data& data_)
+Acts::NavigationLayer::create(const variant_data& vardata)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- const variant_map& data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ const variant_map& data = boost::get<variant_map>(vardata);
std::string type = data.get<std::string>("type");
throw_assert(type == "NavigationLayer", "Type must be NavigationLayer");
diff --git a/Core/src/Surfaces/ConeBounds.cpp b/Core/src/Surfaces/ConeBounds.cpp
index 875d3d9e3..f04769a36 100644
--- a/Core/src/Surfaces/ConeBounds.cpp
+++ b/Core/src/Surfaces/ConeBounds.cpp
@@ -46,10 +46,10 @@ Acts::ConeBounds::ConeBounds(double alpha,
{
}
-Acts::ConeBounds::ConeBounds(const variant_data& data_)
+Acts::ConeBounds::ConeBounds(const variant_data& vardata)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- const variant_map& data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ const variant_map& data = boost::get<variant_map>(vardata);
std::string type = data.get<std::string>("type");
throw_assert(type == "ConeBounds", "Type must be ConeBounds");
diff --git a/Core/src/Surfaces/ConeSurface.cpp b/Core/src/Surfaces/ConeSurface.cpp
index 632ed17d9..ef8b5ed72 100644
--- a/Core/src/Surfaces/ConeSurface.cpp
+++ b/Core/src/Surfaces/ConeSurface.cpp
@@ -59,10 +59,10 @@ Acts::ConeSurface::ConeSurface(std::shared_ptr<const Transform3D> htrans,
throw_assert(cbounds, "ConeBounds must not be nullptr");
}
-Acts::ConeSurface::ConeSurface(const variant_data& data_)
+Acts::ConeSurface::ConeSurface(const variant_data& vardata)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- variant_map data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ variant_map data = boost::get<variant_map>(vardata);
throw_assert(data.count("type"), "Variant data must have type.");
std::string type = data.get<std::string>("type");
throw_assert(type == "ConeSurface", "Variant data type must be ConeSurface");
diff --git a/Core/src/Surfaces/CylinderBounds.cpp b/Core/src/Surfaces/CylinderBounds.cpp
index c98a91c4b..7febf71a2 100644
--- a/Core/src/Surfaces/CylinderBounds.cpp
+++ b/Core/src/Surfaces/CylinderBounds.cpp
@@ -47,11 +47,11 @@ Acts::CylinderBounds::CylinderBounds(double radius,
}
}
-Acts::CylinderBounds::CylinderBounds(const variant_data& data_)
+Acts::CylinderBounds::CylinderBounds(const variant_data& vardata)
: m_radius(0), m_avgPhi(0), m_halfPhi(0), m_halfZ(0)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- const variant_map& data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ const variant_map& data = boost::get<variant_map>(vardata);
std::string type = data.get<std::string>("type");
throw_assert(type == "CylinderBounds", "Type must be CylinderBounds");
diff --git a/Core/src/Surfaces/CylinderSurface.cpp b/Core/src/Surfaces/CylinderSurface.cpp
index c266a3241..05ac5a1e6 100644
--- a/Core/src/Surfaces/CylinderSurface.cpp
+++ b/Core/src/Surfaces/CylinderSurface.cpp
@@ -70,10 +70,10 @@ Acts::CylinderSurface::CylinderSurface(
throw_assert(cbounds, "CylinderBounds must not be nullptr");
}
-Acts::CylinderSurface::CylinderSurface(const variant_data& data_)
+Acts::CylinderSurface::CylinderSurface(const variant_data& vardata)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- variant_map data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ variant_map data = boost::get<variant_map>(vardata);
throw_assert(data.count("type"), "Variant data must have type.");
std::string type = data.get<std::string>("type");
throw_assert(type == "CylinderSurface",
diff --git a/Core/src/Surfaces/DiamondBounds.cpp b/Core/src/Surfaces/DiamondBounds.cpp
index a75f0345a..ae78d7e47 100644
--- a/Core/src/Surfaces/DiamondBounds.cpp
+++ b/Core/src/Surfaces/DiamondBounds.cpp
@@ -35,11 +35,11 @@ Acts::DiamondBounds::DiamondBounds(double minhalex,
throw_assert((maxhalex <= medhalex), "Hexagon must be a convex polygon");
}
-Acts::DiamondBounds::DiamondBounds(const variant_data& data_)
+Acts::DiamondBounds::DiamondBounds(const variant_data& vardata)
: m_boundingBox(0, 0)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- const variant_map& data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ const variant_map& data = boost::get<variant_map>(vardata);
std::string type = data.get<std::string>("type");
throw_assert(type == "DiamondBounds", "Type must be DiamondBounds");
diff --git a/Core/src/Surfaces/DiscSurface.cpp b/Core/src/Surfaces/DiscSurface.cpp
index 340b52662..3c20f87ea 100644
--- a/Core/src/Surfaces/DiscSurface.cpp
+++ b/Core/src/Surfaces/DiscSurface.cpp
@@ -77,11 +77,11 @@ Acts::DiscSurface::DiscSurface(std::shared_ptr<const DiscBounds> dbounds,
throw_assert(dbounds, "nullptr as DiscBounds");
}
-Acts::DiscSurface::DiscSurface(const variant_data& data_) : GeometryObject()
+Acts::DiscSurface::DiscSurface(const variant_data& vardata) : GeometryObject()
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- variant_map data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ variant_map data = boost::get<variant_map>(vardata);
throw_assert(data.count("type"), "Variant data must have type.");
// std::string type = boost::get<std::string>(data["type"]);
std::string type = data.get<std::string>("type");
diff --git a/Core/src/Surfaces/DiscTrapezoidalBounds.cpp b/Core/src/Surfaces/DiscTrapezoidalBounds.cpp
index 61b4f26cc..9a9bd5cb0 100644
--- a/Core/src/Surfaces/DiscTrapezoidalBounds.cpp
+++ b/Core/src/Surfaces/DiscTrapezoidalBounds.cpp
@@ -34,10 +34,10 @@ Acts::DiscTrapezoidalBounds::DiscTrapezoidalBounds(double minhalfx,
{
}
-Acts::DiscTrapezoidalBounds::DiscTrapezoidalBounds(const variant_data& data_)
+Acts::DiscTrapezoidalBounds::DiscTrapezoidalBounds(const variant_data& vardata)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- const variant_map& data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ const variant_map& data = boost::get<variant_map>(vardata);
std::string type = data.get<std::string>("type");
throw_assert(type == "DiscTrapezoidalBounds",
"Type must be DiscTrapezoidalBounds");
diff --git a/Core/src/Surfaces/EllipseBounds.cpp b/Core/src/Surfaces/EllipseBounds.cpp
index 551c7ff5e..5a3079c2c 100644
--- a/Core/src/Surfaces/EllipseBounds.cpp
+++ b/Core/src/Surfaces/EllipseBounds.cpp
@@ -36,11 +36,11 @@ Acts::EllipseBounds::EllipseBounds(double minRadius0,
{
}
-Acts::EllipseBounds::EllipseBounds(const variant_data& data_)
+Acts::EllipseBounds::EllipseBounds(const variant_data& vardata)
: m_boundingBox(0, 0)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- const variant_map& data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ const variant_map& data = boost::get<variant_map>(vardata);
std::string type = data.get<std::string>("type");
throw_assert(type == "EllipseBounds", "Type must be EllipseBounds");
diff --git a/Core/src/Surfaces/LineBounds.cpp b/Core/src/Surfaces/LineBounds.cpp
index 5e898a2c3..b91bfd2a7 100644
--- a/Core/src/Surfaces/LineBounds.cpp
+++ b/Core/src/Surfaces/LineBounds.cpp
@@ -21,11 +21,11 @@ Acts::LineBounds::LineBounds(double radius, double halez)
{
}
-Acts::LineBounds::LineBounds(const variant_data& data_)
+Acts::LineBounds::LineBounds(const variant_data& vardata)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- variant_map data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ variant_map data = boost::get<variant_map>(vardata);
throw_assert(data.count("type"), "Variant data must have type.");
// std::string type = boost::get<std::string>(data["type"]);
std::string type = data.get<std::string>("type");
diff --git a/Core/src/Surfaces/LineSurface.cpp b/Core/src/Surfaces/LineSurface.cpp
index bddfc48f5..f393e7f91 100644
--- a/Core/src/Surfaces/LineSurface.cpp
+++ b/Core/src/Surfaces/LineSurface.cpp
@@ -62,10 +62,10 @@ Acts::LineSurface::operator=(const LineSurface& other)
return *this;
}
-Acts::LineSurface::LineSurface(const variant_data& data_) : GeometryObject()
+Acts::LineSurface::LineSurface(const variant_data& vardata) : GeometryObject()
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- variant_map data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ variant_map data = boost::get<variant_map>(vardata);
throw_assert(data.count("type"), "Variant data must have type.");
// std::string type = boost::get<std::string>(data["type"]);
std::string type = data.get<std::string>("type");
diff --git a/Core/src/Surfaces/PerigeeSurface.cpp b/Core/src/Surfaces/PerigeeSurface.cpp
index e00307568..3c3e400a4 100644
--- a/Core/src/Surfaces/PerigeeSurface.cpp
+++ b/Core/src/Surfaces/PerigeeSurface.cpp
@@ -40,12 +40,12 @@ Acts::PerigeeSurface::PerigeeSurface(const PerigeeSurface& other,
{
}
-Acts::PerigeeSurface::PerigeeSurface(const variant_data& data_)
+Acts::PerigeeSurface::PerigeeSurface(const variant_data& vardata)
: GeometryObject(), LineSurface(nullptr, nullptr)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- variant_map data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ variant_map data = boost::get<variant_map>(vardata);
throw_assert(data.count("type"), "Variant data must have type.");
// std::string type = boost::get<std::string>(data["type"]);
std::string type = data.get<std::string>("type");
diff --git a/Core/src/Surfaces/PlaneSurface.cpp b/Core/src/Surfaces/PlaneSurface.cpp
index c1998cada..f8543e7dd 100644
--- a/Core/src/Surfaces/PlaneSurface.cpp
+++ b/Core/src/Surfaces/PlaneSurface.cpp
@@ -71,11 +71,11 @@ Acts::PlaneSurface::PlaneSurface(std::shared_ptr<const Transform3D> htrans,
{
}
-Acts::PlaneSurface::PlaneSurface(const variant_data& data_)
+Acts::PlaneSurface::PlaneSurface(const variant_data& vardata)
{
// we need to figure out which way the PS was constructed before
- throw_assert(data_.which() == 4, "Variant data must be map");
- variant_map data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ variant_map data = boost::get<variant_map>(vardata);
throw_assert(data.count("type"), "Variant data must have type.");
// std::string type = boost::get<std::string>(data["type"]);
std::string type = data.get<std::string>("type");
diff --git a/Core/src/Surfaces/RadialBounds.cpp b/Core/src/Surfaces/RadialBounds.cpp
index 06c7d5b97..abd3c3580 100644
--- a/Core/src/Surfaces/RadialBounds.cpp
+++ b/Core/src/Surfaces/RadialBounds.cpp
@@ -35,11 +35,11 @@ Acts::RadialBounds::RadialBounds(double minrad,
{
}
-Acts::RadialBounds::RadialBounds(const variant_data& data_)
+Acts::RadialBounds::RadialBounds(const variant_data& vardata)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- const variant_map& data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ const variant_map& data = boost::get<variant_map>(vardata);
std::string type = data.get<std::string>("type");
throw_assert(type == "RadialBounds", "Type must be RadialBounds");
diff --git a/Core/src/Surfaces/RectangleBounds.cpp b/Core/src/Surfaces/RectangleBounds.cpp
index 9fab26303..bc2f293fe 100644
--- a/Core/src/Surfaces/RectangleBounds.cpp
+++ b/Core/src/Surfaces/RectangleBounds.cpp
@@ -23,10 +23,10 @@ Acts::RectangleBounds::RectangleBounds(double halex, double haley)
{
}
-Acts::RectangleBounds::RectangleBounds(const variant_data& data_)
+Acts::RectangleBounds::RectangleBounds(const variant_data& vardata)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- const variant_map& data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ const variant_map& data = boost::get<variant_map>(vardata);
std::string type = data.get<std::string>("type");
throw_assert(type == "RectangleBounds", "Type must be RectangleBounds");
diff --git a/Core/src/Surfaces/StrawSurface.cpp b/Core/src/Surfaces/StrawSurface.cpp
index 3fffe971d..6fbae7bf4 100644
--- a/Core/src/Surfaces/StrawSurface.cpp
+++ b/Core/src/Surfaces/StrawSurface.cpp
@@ -49,11 +49,11 @@ Acts::StrawSurface::StrawSurface(const StrawSurface& other,
{
}
-Acts::StrawSurface::StrawSurface(const variant_data& data_)
+Acts::StrawSurface::StrawSurface(const variant_data& vardata)
: GeometryObject(), LineSurface(nullptr, nullptr)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- variant_map data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ variant_map data = boost::get<variant_map>(vardata);
throw_assert(data.count("type"), "Variant data must have type.");
// std::string type = boost::get<std::string>(data["type"]);
std::string type = data.get<std::string>("type");
diff --git a/Core/src/Surfaces/TrapezoidBounds.cpp b/Core/src/Surfaces/TrapezoidBounds.cpp
index 8aae55046..8b3bf66a5 100644
--- a/Core/src/Surfaces/TrapezoidBounds.cpp
+++ b/Core/src/Surfaces/TrapezoidBounds.cpp
@@ -27,11 +27,11 @@ Acts::TrapezoidBounds::TrapezoidBounds(double minhalex,
{
}
-Acts::TrapezoidBounds::TrapezoidBounds(const variant_data& data_)
+Acts::TrapezoidBounds::TrapezoidBounds(const variant_data& vardata)
: m_boundingBox(0, 0)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- const variant_map& data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ const variant_map& data = boost::get<variant_map>(vardata);
std::string type = data.get<std::string>("type");
throw_assert(type == "TrapezoidBounds", "Type must be TrapezoidBounds");
diff --git a/Core/src/Surfaces/TriangleBounds.cpp b/Core/src/Surfaces/TriangleBounds.cpp
index aab65b1ad..3bfc9270f 100644
--- a/Core/src/Surfaces/TriangleBounds.cpp
+++ b/Core/src/Surfaces/TriangleBounds.cpp
@@ -28,11 +28,11 @@ Acts::TriangleBounds::TriangleBounds(const std::array<Vector2D, 3>& vertices)
m_boundingBox = RectangleBounds(mx, my);
}
-Acts::TriangleBounds::TriangleBounds(const variant_data& data_)
+Acts::TriangleBounds::TriangleBounds(const variant_data& vardata)
: m_vertices(), m_boundingBox(0, 0)
{
- throw_assert(data_.which() == 4, "Variant data must be map");
- const variant_map& data = boost::get<variant_map>(data_);
+ throw_assert(vardata.which() == 4, "Variant data must be map");
+ const variant_map& data = boost::get<variant_map>(vardata);
std::string type = data.get<std::string>("type");
throw_assert(type == "TriangleBounds", "Type must be TriangleBounds");
diff --git a/Core/src/Tools/SurfaceArrayCreator.cpp b/Core/src/Tools/SurfaceArrayCreator.cpp
index 00be1250f..bbf5ed3cc 100644
--- a/Core/src/Tools/SurfaceArrayCreator.cpp
+++ b/Core/src/Tools/SurfaceArrayCreator.cpp
@@ -27,11 +27,11 @@ Acts::SurfaceArrayCreator::surfaceArrayOnCylinder(
const std::vector<const Surface*>& surfaces,
size_t binsPhi,
size_t binsZ,
- boost::optional<ProtoLayer> _protoLayer,
- std::shared_ptr<const Transform3D> _transform) const
+ boost::optional<ProtoLayer> protoLayerOpt,
+ std::shared_ptr<const Transform3D> transformOpt) const
{
// check if we have proto layer, else build it
- ProtoLayer protoLayer = _protoLayer ? *_protoLayer : ProtoLayer(surfaces);
+ ProtoLayer protoLayer = protoLayerOpt ? *protoLayerOpt : ProtoLayer(surfaces);
ACTS_VERBOSE("Creating a SurfaceArray on a cylinder");
ACTS_VERBOSE(" -- with " << surfaces.size() << " surfaces.")
@@ -40,7 +40,7 @@ Acts::SurfaceArrayCreator::surfaceArrayOnCylinder(
<< " bins.");
Transform3D transform
- = _transform != nullptr ? *_transform : Transform3D::Identity();
+ = transformOpt != nullptr ? *transformOpt : Transform3D::Identity();
ProtoAxis pAxisPhi
= createEquidistantAxis(surfaces, binPhi, protoLayer, transform, binsPhi);
@@ -77,15 +77,15 @@ Acts::SurfaceArrayCreator::surfaceArrayOnCylinder(
const std::vector<const Surface*>& surfaces,
BinningType bTypePhi,
BinningType bTypeZ,
- boost::optional<ProtoLayer> _protoLayer,
- std::shared_ptr<const Transform3D> _transform) const
+ boost::optional<ProtoLayer> protoLayerOpt,
+ std::shared_ptr<const Transform3D> transformOpt) const
{
// check if we have proto layer, else build it
- ProtoLayer protoLayer = _protoLayer ? *_protoLayer : ProtoLayer(surfaces);
+ ProtoLayer protoLayer = protoLayerOpt ? *protoLayerOpt : ProtoLayer(surfaces);
double R = 0.5 * (protoLayer.maxR - protoLayer.minR);
Transform3D transform
- = _transform != nullptr ? *_transform : Transform3D::Identity();
+ = transformOpt != nullptr ? *transformOpt : Transform3D::Identity();
ProtoAxis pAxisPhi;
ProtoAxis pAxisZ;
@@ -141,16 +141,16 @@ Acts::SurfaceArrayCreator::surfaceArrayOnDisc(
const std::vector<const Surface*>& surfaces,
size_t binsR,
size_t binsPhi,
- boost::optional<ProtoLayer> _protoLayer,
- std::shared_ptr<const Transform3D> _transform) const
+ boost::optional<ProtoLayer> protoLayerOpt,
+ std::shared_ptr<const Transform3D> transformOpt) const
{
// check if we have proto layer, else build it
- ProtoLayer protoLayer = _protoLayer ? *_protoLayer : ProtoLayer(surfaces);
+ ProtoLayer protoLayer = protoLayerOpt ? *protoLayerOpt : ProtoLayer(surfaces);
ACTS_VERBOSE("Creating a SurfaceArray on a disc");
Transform3D transform
- = _transform != nullptr ? *_transform : Transform3D::Identity();
+ = transformOpt != nullptr ? *transformOpt : Transform3D::Identity();
ProtoAxis pAxisR
= createEquidistantAxis(surfaces, binR, protoLayer, transform, binsR);
@@ -197,16 +197,16 @@ Acts::SurfaceArrayCreator::surfaceArrayOnDisc(
const std::vector<const Surface*>& surfaces,
BinningType bTypeR,
BinningType bTypePhi,
- boost::optional<ProtoLayer> _protoLayer,
- std::shared_ptr<const Transform3D> _transform) const
+ boost::optional<ProtoLayer> protoLayerOpt,
+ std::shared_ptr<const Transform3D> transformOpt) const
{
// check if we have proto layer, else build it
- ProtoLayer protoLayer = _protoLayer ? *_protoLayer : ProtoLayer(surfaces);
+ ProtoLayer protoLayer = protoLayerOpt ? *protoLayerOpt : ProtoLayer(surfaces);
ACTS_VERBOSE("Creating a SurfaceArray on a disc");
Transform3D transform
- = _transform != nullptr ? *_transform : Transform3D::Identity();
+ = transformOpt != nullptr ? *transformOpt : Transform3D::Identity();
ProtoAxis pAxisPhi;
ProtoAxis pAxisR;
diff --git a/Legacy/include/Acts/Extrapolation/ExtrapolationCell.hpp b/Legacy/include/Acts/Extrapolation/ExtrapolationCell.hpp
index 0874736bc..997ead49a 100644
--- a/Legacy/include/Acts/Extrapolation/ExtrapolationCell.hpp
+++ b/Legacy/include/Acts/Extrapolation/ExtrapolationCell.hpp
@@ -492,15 +492,16 @@ public:
/// saving when transport + material are done successively.
/// If nullptr is provided, then the stepParameters.referenceSurface
/// is taken.
- /// @param fillModes are the different indications of the step
+ /// @param stepModes are the different indications of the step
/// @param pathLength is the path length of this step
- /// @param tjac is the transport jacobian of the step
+ /// @param stepJacobian is the transport jacobian of the step
void
stepTransport(std::unique_ptr<const T> stepParameters,
const Surface* stepSurface = nullptr,
- std::vector<ExtrapolationMode::eMode> fillModes = {},
+ std::vector<ExtrapolationMode::eMode> stepModes = {},
double stepLength = 0.,
- std::unique_ptr<const TransportJacobian> tjac = nullptr);
+ std::unique_ptr<const TransportJacobian> stepJacobian
+ = nullptr);
/// Fill a step without transport
/// -> desinged for material
diff --git a/Legacy/include/Acts/Extrapolation/ExtrapolationEngine.hpp b/Legacy/include/Acts/Extrapolation/ExtrapolationEngine.hpp
index 41d274467..53af88cf5 100644
--- a/Legacy/include/Acts/Extrapolation/ExtrapolationEngine.hpp
+++ b/Legacy/include/Acts/Extrapolation/ExtrapolationEngine.hpp
@@ -125,9 +125,9 @@ public:
/// Set logging instance
///
- /// @param logger is the logging instance
+ /// @param newLogger is the logging instance
void
- setLogger(std::unique_ptr<const Logger> logger);
+ setLogger(std::unique_ptr<const Logger> newLogger);
protected:
/// ExtrapolationEngine config object
diff --git a/Legacy/include/Acts/Extrapolation/MaterialEffectsEngine.hpp b/Legacy/include/Acts/Extrapolation/MaterialEffectsEngine.hpp
index 610c6ff4d..bb9128496 100644
--- a/Legacy/include/Acts/Extrapolation/MaterialEffectsEngine.hpp
+++ b/Legacy/include/Acts/Extrapolation/MaterialEffectsEngine.hpp
@@ -66,31 +66,31 @@ public:
/// Public charged material effects interface
///
- /// @param ecCharged is the charged extrapolaiton cell
- /// @param msurface is the (optional) material surface
+ /// @param eCell is the charged extrapolaiton cell
+ /// @param surface is the (optional) material surface
/// - this is for curvilinear parameters
/// @param dir is the additional direction prescription
/// @param matupstage is the update stage (pre/full/post)
///
/// @return extrapolation code to indicate progress
ExtrapolationCode
- handleMaterial(ExCellCharged& ecCharged,
- const Surface* msurface = nullptr,
+ handleMaterial(ExCellCharged& eCell,
+ const Surface* surface = nullptr,
NavigationDirection dir = forward,
MaterialUpdateStage matupstage = fullUpdate) const final;
/// Public neutral material effects interface
///
- /// @param ecNeutral is the neutral extrapolaiton cell
- /// @param msurface is the (optional) material surface
+ /// @param eCell is the neutral extrapolaiton cell
+ /// @param surface is the (optional) material surface
/// - this is for curvilinear parameters
/// @param dir is the additional direction prescription
/// @param matupstage is the update stage (pre/full/post)
///
/// @return extrapolation code to indicate progress
ExtrapolationCode
- handleMaterial(ExCellNeutral& ecNeutral,
- const Surface* msurface = nullptr,
+ handleMaterial(ExCellNeutral& eCell,
+ const Surface* surface = nullptr,
NavigationDirection dir = forward,
MaterialUpdateStage matupstage = fullUpdate) const final;
@@ -106,9 +106,9 @@ public:
/// Set logging instance
///
- /// @param logger the logging instance to be set
+ /// @param newLogger the logging instance to be set
void
- setLogger(std::unique_ptr<const Logger> logger);
+ setLogger(std::unique_ptr<const Logger> newLogger);
protected:
/// Configuration struct
diff --git a/Legacy/include/Acts/Extrapolation/RungeKuttaEngine.hpp b/Legacy/include/Acts/Extrapolation/RungeKuttaEngine.hpp
index 8c20ddccc..411a68f94 100644
--- a/Legacy/include/Acts/Extrapolation/RungeKuttaEngine.hpp
+++ b/Legacy/include/Acts/Extrapolation/RungeKuttaEngine.hpp
@@ -204,9 +204,9 @@ public:
/// Main Charged extrapolation method
///
- /// @param ecCell is the charged extrapolation cell
+ /// @param eCell is the charged extrapolation cell
/// @param sf is the destination surface
- /// @param dir is the additional direction prescription
+ /// @param pDir is the additional direction prescription
/// @param purpose sets the fill mode in to the ExtrapolationCache
/// @param bcheck is the boundary check prescription
/// @param returnCurvilinear is a boolean switch to not collapse onto the
@@ -218,9 +218,9 @@ public:
/// - InProgress (surface hit, when finalPropagation == false)
/// - Recovered (surface not hit, leadParameters stay untouched)
ExtrapolationCode
- propagate(ExCellCharged& ecCell,
+ propagate(ExCellCharged& eCell,
const Surface& sf,
- NavigationDirection dir = forward,
+ NavigationDirection pDir = forward,
std::vector<ExtrapolationMode::eMode> purpose
= {ExtrapolationMode::Destination},
const BoundaryCheck& bcheck = true,
@@ -228,9 +228,9 @@ public:
/// Main Neutral extrapolation method
///
- /// @param enCell is the neutral extrapolation cell
+ /// @param eCell is the neutral extrapolation cell
/// @param sf is the destination surface
- /// @param dir is the additional direction prescription
+ /// @param pDir is the additional direction prescription
/// @param purpose sets the fill mode in to the ExtrapolationCache
/// @param bcheck is the boundary check prescription
/// @param returnCurvilinear is a boolean switch to not collapse onto the
@@ -242,9 +242,9 @@ public:
/// - InProgress (surface hit, when finalPropagation == false)
/// - Recovered (surface not hit, leadParameters stay untouched)
ExtrapolationCode
- propagate(ExCellNeutral& enCell,
+ propagate(ExCellNeutral& eCell,
const Surface& sf,
- NavigationDirection dir = forward,
+ NavigationDirection pDir = forward,
std::vector<ExtrapolationMode::eMode> purpose
= {ExtrapolationMode::Destination},
const BoundaryCheck& bcheck = true,
@@ -297,50 +297,50 @@ private:
///
/// @param eCell the extrapolation cell that holds the configuration
/// @param propState the progation chache
- /// @param tParameters the parameters
- /// @param sf the destination surace
+ /// @param parametersT the parameters
+ /// @param dSurface the destination surace
template <class T>
bool
propagateRungeKuttaT(ExtrapolationCell<T>& eCell,
PropagationCache& propState,
- const T& tParameters,
- const Surface& sf) const;
+ const T& parametersT,
+ const Surface& dSurface) const;
/// Internal RungeKutta propagation method for propation with jacobian
///
/// @param navigationStep the step parameter for screen output
/// @param propState the progation chache
- /// @param surfaceType an integer to indicate which surface type is presen
- /// @param sVector a double array holding propagation information
+ /// @param kind an integer to indicate which surface type is presen
+ /// @param Su a double array holding propagation information
bool
propagateWithJacobian(int navigationStep,
PropagationCache& propState,
- int surfaceType,
- double* sVector) const;
+ int kind,
+ double* Su) const;
/// Propagation methods runge kutta step - returns the step length
///
/// @param navigationStep the step parameter for screen output
/// @param propState the progation chache
/// @param S step size
- /// @param inS flag whether the step was performed along the given direction
+ /// @param InS flag whether the step was performed along the given direction
double
rungeKuttaStep(int navigationStep,
PropagationCache& propState,
double S,
- bool& inS) const;
+ bool& InS) const;
/// Propagation methods runge kutta step - returns the step length
///
/// @param navigationStep the step parameter for screen output
/// @param propState the progation chache
/// @param S step size
- /// @param inS flag whether the step was performed along the given direction
+ /// @param InS flag whether the step was performed along the given direction
double
rungeKuttaStepWithGradient(int navigationStep,
PropagationCache& propState,
double S,
- bool& inS) const;
+ bool& InS) const;
/// Propagation methods straight line step
///
diff --git a/Legacy/include/Acts/Extrapolation/StaticEngine.hpp b/Legacy/include/Acts/Extrapolation/StaticEngine.hpp
index b91c6cff1..210f7eb45 100644
--- a/Legacy/include/Acts/Extrapolation/StaticEngine.hpp
+++ b/Legacy/include/Acts/Extrapolation/StaticEngine.hpp
@@ -135,9 +135,9 @@ public:
/// Set logging instance
///
- /// @param logger is the logging instance to be set
+ /// @param newLogger is the logging instance to be set
void
- setLogger(std::unique_ptr<const Logger> logger);
+ setLogger(std::unique_ptr<const Logger> newLogger);
protected:
/// Configuration struct
@@ -173,7 +173,7 @@ private:
///
/// @param eCell ist he extrapolaiton cell
/// @param sf is the (optional) destinaton surface
- /// @param dir is the additional direction prescription
+ /// @param pDir is the additional direction prescription
/// @param bcheck is the boudnary check directive @todo shift to cell after
/// splitting
///
@@ -182,25 +182,22 @@ private:
ExtrapolationCode
initNavigationT(ExtrapolationCell<T>& eCell,
const Surface* sf = 0,
- NavigationDirection dir = forward,
+ NavigationDirection pDir = forward,
const BoundaryCheck& bcheck = true) const;
/// Main static layer handling
///
/// @param eCell ist he extrapolaiton cell
/// @param sf is the (optional) destinaton surface
- /// @param dir is the additional direction prescription
+ /// @param pDir is the additional direction prescription
/// @param bcheck is the boudnary check directive
- /// @param collectSenstivie steers whether sensitive surfaces are searched
- /// @param resolveMaterial steers whether material has to be integrated
- /// @param resolvePassive steers whether all passive steps are being done
///
/// @return is a extrapolation code indication
template <class T>
ExtrapolationCode
handleLayerT(ExtrapolationCell<T>& eCell,
const Surface* sf = 0,
- NavigationDirection dir = forward,
+ NavigationDirection pDir = forward,
const BoundaryCheck& bcheck = true) const;
/// Handle the failure - as configured
@@ -208,7 +205,7 @@ private:
/// @param eCode is the extrapolation code at entry
/// @param eCell ist he extrapolaiton cell
/// @param sf is the (optional) destinaton surface
- /// @param dir is the additional direction prescription
+ /// @param pDir is the additional direction prescription
/// @param bcheck is the boudnary check directive @todo shift to cell after
/// splitting
///
@@ -218,7 +215,7 @@ private:
handleReturnT(ExtrapolationCode eCode,
ExtrapolationCell<T>& eCell,
const Surface* sf = 0,
- NavigationDirection dir = forward,
+ NavigationDirection pDir = forward,
const BoundaryCheck& bcheck = true) const;
};
diff --git a/Legacy/include/Acts/Extrapolation/StaticNavigationEngine.hpp b/Legacy/include/Acts/Extrapolation/StaticNavigationEngine.hpp
index b5df6f7fd..015971519 100644
--- a/Legacy/include/Acts/Extrapolation/StaticNavigationEngine.hpp
+++ b/Legacy/include/Acts/Extrapolation/StaticNavigationEngine.hpp
@@ -69,45 +69,45 @@ public:
/// Resolve the boundary situation - for charged particles
///
- /// @param ecCell is the charged extrapolation cell
+ /// @param ecCharged is the charged extrapolation cell
/// @param dir is the additional direction prescription
///
/// @return is a extrapolation code indication
ExtrapolationCode
- resolveBoundary(ExCellCharged& ecCell,
+ resolveBoundary(ExCellCharged& ecCharged,
NavigationDirection dir = forward) const final;
/// Resolve the boundary situation - for neutral particles
///
- /// @param enCell is the neutral extrapolation cell
+ /// @param ecNeutral is the neutral extrapolation cell
/// @param dir is the additional direction prescription
///
/// @return is a extrapolation code indication
ExtrapolationCode
- resolveBoundary(ExCellNeutral& enCell,
+ resolveBoundary(ExCellNeutral& ecNeutral,
NavigationDirection dir = forward) const final;
/// Resolve the boundary situation - for charged particles
///
- /// @param ecCell is the charged extrapolation cell
+ /// @param ecCharged is the charged extrapolation cell
/// @param dir is the additional direction prescription
/// @param noLoop is a loop protection @todo check with ST
///
/// @return is a extrapolation code indication
ExtrapolationCode
- resolvePosition(ExCellCharged& ecCell,
+ resolvePosition(ExCellCharged& ecCharged,
NavigationDirection dir = forward,
bool noLoop = false) const final;
/// Resolve the boundary situation - for neutral particles
///
- /// @param enCell is the neutral extrapolation cell
+ /// @param ecNeutral is the neutral extrapolation cell
/// @param dir is the additional direction prescription
/// @param noLoop is a loop protection @todo check with ST
///
/// @return is a extrapolation code indication
ExtrapolationCode
- resolvePosition(ExCellNeutral& enCell,
+ resolvePosition(ExCellNeutral& ecNeutral,
NavigationDirection dir = forward,
bool noLoop = false) const final;
@@ -123,9 +123,9 @@ public:
/// Set logging instance
///
- /// @param logger the logging instance to be seet
+ /// @param newLogger the logging instance to be seet
void
- setLogger(std::unique_ptr<const Logger> logger);
+ setLogger(std::unique_ptr<const Logger> newLogger);
protected:
/// the configuration member of the static navigation engine
@@ -144,18 +144,18 @@ private:
/// Resolve the boundary situation
///
/// @param eCell the extrapolation
- /// @param dir the propagation direction
+ /// @param pDir the propagation direction
///
/// @return is a extrapolation code indication
template <class T>
ExtrapolationCode
resolveBoundaryT(ExtrapolationCell<T>& eCell,
- NavigationDirection dir = forward) const;
+ NavigationDirection pDir = forward) const;
/// Resolve position
///
/// @param eCell the extrapolation
- /// @param dir the propagation direction
+ /// @param pDir the propagation direction
/// @param noLoop
/// @todo check with sharka
///
@@ -163,14 +163,14 @@ private:
template <class T>
ExtrapolationCode
resolvePositionT(ExtrapolationCell<T>& eCell,
- NavigationDirection dir = forward,
+ NavigationDirection pDir = forward,
bool noLoop = false) const;
/// Deal with the boundary Surface - called by resolveBoundary
///
/// @param eCell the extrapolation
/// @param bSurfaceTV the boundary surface
- /// @param dir the propagation direction
+ /// @param pDir the propagation direction
/// @param stepout is a prescription to step out the volume
///
/// @return is a extrapolation code indication
@@ -178,8 +178,8 @@ private:
ExtrapolationCode
handleBoundaryT(ExtrapolationCell<T>& eCell,
const BoundarySurfaceT<TrackingVolume>& bSurfaceTV,
- NavigationDirection dir = forward,
- bool stepout = false) const;
+ NavigationDirection pDir = forward,
+ bool stepout = false) const;
};
inline StaticNavigationEngine::Config
diff --git a/Legacy/include/Acts/Extrapolation/TransportJacobian.hpp b/Legacy/include/Acts/Extrapolation/TransportJacobian.hpp
index 9bd971064..e146ec4ca 100644
--- a/Legacy/include/Acts/Extrapolation/TransportJacobian.hpp
+++ b/Legacy/include/Acts/Extrapolation/TransportJacobian.hpp
@@ -48,12 +48,12 @@ class TransportJacobian : public ActsMatrixD<5, 5>
public:
/// Constructor
///
- /// @param tdata is the double array for containing the jacobian entries
- TransportJacobian(const double* tdata);
+ /// @param J is the double array for containing the jacobian entries
+ TransportJacobian(const double* J);
/// Constructor
///
- /// @param tdata is the matrix containing the jacobian entries
- TransportJacobian(const ActsMatrixD<5, 5>& tdata);
+ /// @param J is the matrix containing the jacobian entries
+ TransportJacobian(const ActsMatrixD<5, 5>& J);
/// Destructor
virtual ~TransportJacobian(){};
@@ -61,6 +61,6 @@ public:
/// Overload of << operator for std::ostream
std::ostream&
-operator<<(std::ostream& sl, const TransportJacobian& jac);
+operator<<(std::ostream& sl, const TransportJacobian& J);
} // namespace
diff --git a/Legacy/include/Acts/Extrapolation/detail/RungeKuttaUtils.hpp b/Legacy/include/Acts/Extrapolation/detail/RungeKuttaUtils.hpp
index 63cfe3fce..cfa826660 100644
--- a/Legacy/include/Acts/Extrapolation/detail/RungeKuttaUtils.hpp
+++ b/Legacy/include/Acts/Extrapolation/detail/RungeKuttaUtils.hpp
@@ -97,16 +97,17 @@ public:
// Step estimators to surface
/////////////////////////////////////////////////////////////////////////////////
///
- /// @param [in] stype The surface type
- /// @param [in] s The surface orientation
- /// @param [in] pdir The position and direction
- /// @param [in,out] q Quality flag
+ /// @param [in] kind The surface type
+ /// @param [in] Su The surface orientation
+ /// @param [in] P The position and direction
+ /// @param [in,out] Q Quality flag
/// @param [in] istep Indicator if it's the initial step (direction!)
+ /// @param [in] maxStep The max step size
double
- stepEstimator(int stype,
- double* s,
- const double* pdir,
- bool& q,
+ stepEstimator(int kind,
+ double* Su,
+ const double* P,
+ bool& Q,
bool istep = false,
double maxStep = std::numeric_limits<double>::max()) const;
double
diff --git a/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepLayerBuilder.hpp b/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepLayerBuilder.hpp
index 67d79f510..a8f59bc10 100644
--- a/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepLayerBuilder.hpp
+++ b/Plugins/DD4hep/include/Acts/Plugins/DD4hep/DD4hepLayerBuilder.hpp
@@ -104,9 +104,9 @@ public:
identification() const final;
/// set the configuration object
- /// @param cfg is the configuration struct
+ /// @param config is the configuration struct
void
- setConfiguration(const Config& cfg);
+ setConfiguration(const Config& config);
/// get the configuration object
Config
diff --git a/Plugins/Digitization/include/Acts/Plugins/Digitization/CartesianSegmentation.hpp b/Plugins/Digitization/include/Acts/Plugins/Digitization/CartesianSegmentation.hpp
index c3be2c32e..ba081333d 100644
--- a/Plugins/Digitization/include/Acts/Plugins/Digitization/CartesianSegmentation.hpp
+++ b/Plugins/Digitization/include/Acts/Plugins/Digitization/CartesianSegmentation.hpp
@@ -43,10 +43,10 @@ public:
/// Constructor for all same-size pixels or strips
/// (in cas numCellsY is set to 1)
///
- /// @param rBounds are the rectangle bounds of the sensitive volume
+ /// @param mBounds are the rectangle bounds of the sensitive volume
/// @param numCellsX is the number of cells in X
/// @param numCellsY is the number of cells in Y
- CartesianSegmentation(std::shared_ptr<const PlanarBounds> rBounds,
+ CartesianSegmentation(std::shared_ptr<const PlanarBounds> mBounds,
size_t numCellsX,
size_t numCellsY = 1);
@@ -54,14 +54,14 @@ public:
///
/// @param bUtility is the bin Utility,
// it will define the RectangleBounds if none are provided
- /// @param rBounds are the rectangle bounds if provided for memory
+ /// @param mBounds are the rectangle bounds if provided for memory
/// optimisation
///
/// @note if both RectangleBounds and BinUtility are provided, no check is
/// done
/// for consitency
CartesianSegmentation(std::shared_ptr<const BinUtility> bUtility,
- std::shared_ptr<const PlanarBounds> rBounds = nullptr);
+ std::shared_ptr<const PlanarBounds> mBounds = nullptr);
/// Virtual Destructor
~CartesianSegmentation() override;
@@ -88,15 +88,15 @@ public:
/// @copydoc Segmentation::cellPosition
Vector2D
- cellPosition(const DigitizationCell& cId) const final;
+ cellPosition(const DigitizationCell& dCell) const final;
/// Fill the associated digitsation cell from this start and end position
/// correct for lorentz effect if needed
///
/// @copydoc Segmentation::digitizationStep
DigitizationStep
- digitizationStep(const Vector3D& start,
- const Vector3D& end,
+ digitizationStep(const Vector3D& startStep,
+ const Vector3D& endStep,
double halfThickness,
int readoutDirection = 1,
double lorentzAngle = 0.) const final;
diff --git a/Plugins/Digitization/include/Acts/Plugins/Digitization/PlanarModuleStepper.hpp b/Plugins/Digitization/include/Acts/Plugins/Digitization/PlanarModuleStepper.hpp
index cdd4d18fe..9f91a6b14 100644
--- a/Plugins/Digitization/include/Acts/Plugins/Digitization/PlanarModuleStepper.hpp
+++ b/Plugins/Digitization/include/Acts/Plugins/Digitization/PlanarModuleStepper.hpp
@@ -37,9 +37,9 @@ public:
/// Constructor
///
/// @param pmsConfig is the configuration
- /// @param logger is the logging istance
+ /// @param mlogger is the logging istance
PlanarModuleStepper(const Config& pmsConfig,
- std::unique_ptr<const Logger> logger
+ std::unique_ptr<const Logger> mlogger
= getDefaultLogger("PlanarModuleStepper", Logging::INFO));
/// Destructor
@@ -48,26 +48,26 @@ public:
/// Calculate the steps caused by this track - full simulation interface
///
/// @param dmodule is the digitization module
- /// @param startPosition is the starting position of the stepping
- /// @param endPosition is the end postion of the stepping
+ /// @param startPoint is the starting position of the stepping
+ /// @param endPoint is the end postion of the stepping
///
/// @return is the vector of digitization steps
std::vector<DigitizationStep>
cellSteps(const DigitizationModule& dmodule,
- const Vector3D& startPosition,
- const Vector3D& endPosition) const;
+ const Vector3D& startPoint,
+ const Vector3D& endPoint) const;
/// Calculate the steps caused by this track - fast simulation interface
///
/// @param dmodule is the digitization module
- /// @param intersection is the 2d intersection at the module surface
- /// @param direction is the track direction at the instersection
+ /// @param moduleIntersection is the 2d intersection at the module surface
+ /// @param trackDirection is the track direction at the instersection
///
/// @return is the vector of digitization steps
std::vector<DigitizationStep>
cellSteps(const DigitizationModule& dmodule,
- const Vector2D& intersection,
- const Vector3D& direction) const;
+ const Vector2D& moduleIntersection,
+ const Vector3D& trackDirection) const;
/// Set logging instance
///
diff --git a/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/MaterialMapper.hpp b/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/MaterialMapper.hpp
index d7f4cebab..f82b50375 100644
--- a/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/MaterialMapper.hpp
+++ b/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/MaterialMapper.hpp
@@ -102,9 +102,9 @@ public:
/// @brief default constructor
///
/// @param cfg the internal configuration object
- /// @param logger the logging instance
+ /// @param log the logging instance
MaterialMapper(const Config& cfg,
- std::unique_ptr<const Logger> logger
+ std::unique_ptr<const Logger> log
= getDefaultLogger("MaterialMapper", Logging::INFO));
/// @brief destructor
@@ -121,12 +121,13 @@ public:
/// maps the material for the given direction(eta,phi) onto the layers of the
/// given tracking geometry
///
- /// @param matTrackRec the MaterialTrack to be mapped
+ /// @param materialTrack the MaterialTrack to be mapped
///
/// @return is the mapped material track, i.e. it is collapsed
/// onto the available
MaterialTrack
- mapMaterialTrack(Cache& mappingCache, const MaterialTrack& matTrackRec) const;
+ mapMaterialTrack(Cache& mappingCache,
+ const MaterialTrack& materialTrack) const;
/// finds the TrackingGeometry steps associated to the material steps
///
@@ -146,9 +147,9 @@ public:
/// set logging instance
///
- /// @param logger is the unique logger instance
+ /// @param newLogger is the unique logger instance
void
- setLogger(std::unique_ptr<const Logger> logger);
+ setLogger(std::unique_ptr<const Logger> newLogger);
private:
/// finds all surfaces with SurfaceMaterialProxy of a volume
diff --git a/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/MaterialStep.hpp b/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/MaterialStep.hpp
index 7eaabbdd8..e771d21e1 100644
--- a/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/MaterialStep.hpp
+++ b/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/MaterialStep.hpp
@@ -84,7 +84,7 @@ public:
/// @param geoID is the geoId value (optional)
MaterialStep(const MaterialProperties& mat,
const Position& pos,
- uint64_t geoId = 0);
+ uint64_t geoID = 0);
/// Copy Constructor
MaterialStep(const MaterialStep& mstep);
diff --git a/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/MaterialTrack.hpp b/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/MaterialTrack.hpp
index 23077cf37..9bb9237c8 100644
--- a/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/MaterialTrack.hpp
+++ b/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/MaterialTrack.hpp
@@ -41,14 +41,14 @@ public:
/// @param theta polar angle indicating of the particle direction
/// @param phi azimuthal angle indicating of the particle direction
/// @param materialSteps the collection material steps along the track
- /// @param totX0 is the optional total budget in X0
- /// @param totL0 is the optional total budget in L0
+ /// @param tX0 is the optional total budget in X0
+ /// @param tL0 is the optional total budget in L0
MaterialTrack(const MaterialStep::Position& startPos,
double theta,
double phi,
std::vector<MaterialStep> materialSteps,
- double totX0 = 0.,
- double totL0 = 0.);
+ double tX0 = 0.,
+ double tL0 = 0.);
/// Copy constructor
MaterialTrack(const MaterialTrack& mtrecord);
diff --git a/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/SurfaceMaterialRecord.hpp b/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/SurfaceMaterialRecord.hpp
index 1e8f782a6..aabc8dee7 100644
--- a/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/SurfaceMaterialRecord.hpp
+++ b/Plugins/MaterialMapping/include/Acts/Plugins/MaterialMapping/SurfaceMaterialRecord.hpp
@@ -80,10 +80,10 @@ public:
/// this is still needed, because the extrapolation
/// might hit a layer, but no material to access was there
///
- /// @param position is where the extrapolation
+ /// @param mPosition is where the extrapolation
/// did hit this surface
void
- assignEmptyStep(const Vector3D& position);
+ assignEmptyStep(const Vector3D& mPosition);
/// @return the surface pointer
const Surface&
diff --git a/Plugins/TGeo/include/Acts/Plugins/TGeo/TGeoDetectorElement.hpp b/Plugins/TGeo/include/Acts/Plugins/TGeo/TGeoDetectorElement.hpp
index 7e02701bf..fafdddea2 100644
--- a/Plugins/TGeo/include/Acts/Plugins/TGeo/TGeoDetectorElement.hpp
+++ b/Plugins/TGeo/include/Acts/Plugins/TGeo/TGeoDetectorElement.hpp
@@ -37,7 +37,7 @@ public:
/// Constructor
/// @param identifier is the detector identifier
/// @param tGeoDetElement is the TGeoNode which should be represented
- /// @param mtoglobal to global is the (optional) transform applied to the
+ /// @param mGlobal to global is the (optional) transform applied to the
/// TGeoNode
/// @param axes is the axis orientation with respect to the tracking frame
/// it is a string of the three characters x, y and z (standing for the
@@ -65,10 +65,10 @@ public:
/// @param material Possible material of detector element
TGeoDetectorElement(const Identifier& identifier,
TGeoNode* tGeoDetElement,
- const TGeoMatrix* mtoglobal = nullptr,
- const std::string& axes = "XYZ",
- double scalor = 1.,
- bool isDisc = false,
+ const TGeoMatrix* mGlobal = nullptr,
+ const std::string& axes = "XYZ",
+ double scalor = 1.,
+ bool isDisc = false,
std::shared_ptr<const Acts::SurfaceMaterial> material
= nullptr);
diff --git a/Plugins/TGeo/include/Acts/Plugins/TGeo/TGeoLayerBuilder.hpp b/Plugins/TGeo/include/Acts/Plugins/TGeo/TGeoLayerBuilder.hpp
index ce41e6830..dbe2d91b3 100644
--- a/Plugins/TGeo/include/Acts/Plugins/TGeo/TGeoLayerBuilder.hpp
+++ b/Plugins/TGeo/include/Acts/Plugins/TGeo/TGeoLayerBuilder.hpp
@@ -79,9 +79,9 @@ public:
};
/// Constructor
- /// @param cfg is the configuration struct
+ /// @param config is the configuration struct
/// @param logger the local logging instance
- TGeoLayerBuilder(const Config& cfg,
+ TGeoLayerBuilder(const Config& config,
std::unique_ptr<const Logger> logger
= getDefaultLogger("LayerArrayCreator", Logging::INFO));
@@ -105,9 +105,9 @@ public:
identification() const final;
/// set the configuration object
- /// @param cfg is the configuration struct
+ /// @param config is the configuration struct
void
- setConfiguration(const Config& cfg);
+ setConfiguration(const Config& config);
/// get the configuration object
Config
@@ -115,7 +115,7 @@ public:
/// set logging instance
void
- setLogger(std::unique_ptr<const Logger> logger);
+ setLogger(std::unique_ptr<const Logger> newLogger);
/// Return the created detector elements
const std::vector<std::shared_ptr<const TGeoDetectorElement>>&
@@ -143,10 +143,10 @@ private:
resolveSensitive(std::vector<const Surface*>& layerSurfaces,
TGeoVolume* tgVolume,
TGeoNode* tgNode,
- const TGeoMatrix& ctGlobal,
+ const TGeoMatrix& tgTransform,
const LayerConfig& layerConfig,
int type,
- bool correctVolume = false,
+ bool correctBranch = false,
const std::string& offset = "");
// Private helper method : build layers
@@ -159,7 +159,7 @@ private:
// @param wc is the one with the potential wildcard
// @param test is the test string
bool
- match(const char* wc, const char* test) const;
+ match(const char* first, const char* second) const;
};
inline TGeoLayerBuilder::Config
--
GitLab