diff --git a/.static_analysis_limits.yml b/.static_analysis_limits.yml
index 9f6c12a610c9a1ec2b4d4ad1625535e7ae11ed56..4a33f7eb7d98ec2bd26b9e21d53c60423e7f2104 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 cba2c2acd7b381ab60bb305e49dfaf367bdc5952..7ba62a3146f84e9953cba7d3062377729b3bbfd4 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 a25ae755cff357050f980d8f4602ef750eadc80f..49a57f2cac63f4435290c11a3365eebeb24aa031 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 c8b175422c6343437985c857a4cd9e3224fbe2e6..98c669dbefe23303db4042d74bfaaa58c7fd0fc3 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 a0298689fe4403271970b071240950bbbd0c4c3e..019aacba7029ab8e6d6d5e8860cc5ed2e5de1257 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 e766b7a174d123de45461c4446b0595bfdbe52de..bfc0597244809fad71ec2c82354a689d789b29b0 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 8a1a8ac905a6e64c934320d241c8c2558bb59b87..d346776076f0c9247e65c897c47c31429c0af421 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 3415b23ea8caaeb2c76e85f86c7d425d46b288f0..ba7d72ac8e245fae024deab7b46c1a26e78cee3b 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 77048b2b0ce99412ac916d343ba0776147af207e..c5800e090bc79567b9ddb1a2b4f47031b144b9d6 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 519a678288c27334bbc2e15664c2175848cc6592..93efa4877cede1e2eca177ee49cf148c5b16fc43 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 06ca5b1667a517e2467021592c337cc0610fe97e..c560ceaf2955b849293e357501a55944a3c80a71 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 9214a4f580eeb6ba9962f89e191ab753bbc05220..04a22ccd95f5a6a1bbba65775e62e8c52dae06c4 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 cc68fcbdd8868cf162e769f496cc2f439137fbb5..344982eb38de2816532cde047de2b08b71c3dd61 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 08d715dd9933d45e9f7e13381b6f1ee1b8997868..d34a549cf160c2050da57a2a6830f5fe750e2c31 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 ef3c0a9f1144591d01fc066a98d7dc26801ac7bc..0fee10f412b71083b1d1362f2d170da36b3eb8c9 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 99e113629b277e3bd871912642235efec3408f75..e6891857f3cc2abcaab313ab4d00e6fbda71eafc 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 787d0ca5e418ae6e277bf26e04d7aff13066daf2..f095e029ca3fb6fc000dec8f9b22845a3edbb840 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 47af2b5f5aa6530ebb35d9499863f42b740592e3..708afb46fd7354eade4f88bb289a0f3fc0940197 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 f6330b79b09f31e178923dde0a00fd36215333a3..4fe75f269fe4fc8f6b85a5b58862861fee8c8e97 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 b259de272bb3d2a1be9ed49a933891473d38ab94..99a4edf65a8e354af1be5e2c38830a8000478925 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 4bc27b6cffaf98440c3aaf81e81e8872de0ba77f..50183c9959a4c927a51696bfa3526089f2361103 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 cf1aa1138ffda80e01a53174b6f0e991071b74d3..9cf92b46ac47afded64edf6a0483abd888f580cc 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 1e2fad8f01917fb0df0c850fa9ead63c4d170a87..81d29a77952b507189f0715d6492afa7df3f925f 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 d74cf2cf44c225a3deb78c48c049f46b65b912c4..3abe6b83054a433b7575f8f8cb3814e0993b4803 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 fcdb4e11a41c3e21283261868dcf4d89b3827750..392f24d3c22842aee4b8f731ce0caa432bf48edd 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 b990f1308a27a378cc5700fe1622a7efba8f08a4..10468134969022632af9bcab0fce8e4ac8f4e5e1 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 4d0ca0e22d5425322b032faa066a0b798dd96471..e5e5fb8974c505163b9554cd3751eb01727fd0f0 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 048912c572e34d7c41c0e24d8290dfa2ba7ab11f..e87e811d494c1b6f08f421ed885b0ba36a13f0cb 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 7a32872e62ff97c3b527ca1f9fbf5d0a74e2175b..13be29b460a9b5c78a62f7be029544ae84949fcd 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 7d8c694c1c590cb9400f583aa45e298c61bfdadb..83e24061712e78ab5f0a16bf8a84bf8483f09ade 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 102ed78b0b38525c501593c0ada68910cfe042d8..3a042701c518ebbed46b0248ccdf72e1c9f4e712 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 57a6c40d862a8bbcb6e8f6b96c49d3adb869d95f..f4024d9a4b4febf2d42103b0d40336f16045ffbe 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 cede97e4fbbf0b5239b71ec009826a77dcfbd5d3..03537e94ad353edb9ea56909760b8a2fd4b30cd0 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 66c654f0374b3dd796d86e73e3a4835458362fea..d1580435d19fd3c9a672d3cf272458d37bc2a218 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 7bbf1e348b78dd5630c1a444874b8be0f4fe2da3..23652aed1d89f5c81015e09a8fb5d0ba1724c81e 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 317e225a6b68011e7611e4fc709b4b0bb998c442..7a430f5889081c877632f777cd5fea23cdee60ec 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 f4bfb71b89e771cf2c676df659cd8de4a23dbfad..fea68587ce7b760edd4646332d3162bcf27c3c68 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 a2d52908c0909deacf725272310743dd4535f399..670994b95f48d6c1e1d93918d0eb7ded1aa196d3 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 e8d1d6ac74ef481d4f5bdd7f9ca1b0407ae0fd94..ee595e54214e55228f41fe75fefe569e9679aa75 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 ad10a09d8dac53eae352d8dd398aab8998409277..25eb65a48fc0bc45606cdb6deb312bd00fca7283 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 e09cba852064fedcb4ad8dbf814fdde680b78f6d..6ee9cae1011449be4f9d1fdfd0d7e9e1d3a8e712 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 3e4989566c0bccadebf718832179dd97688a02a6..2c51f7f20c831417361a428f4060faef45b9c6c0 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 9be8b32ba7659bb3a19a3cea5e105b245991aa85..2439cb249591f8c3f6cec13cc433955d560fc804 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 cf6ebe15f328e991e777a18a1bf28bf99c516ecf..6c12432576f0162f82946c78792b18625fe041a6 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 61f6ae89dbc91fffc4570b6479265c84983a9603..8ce8663572e2e10dbd3d8981fc76803eb244ebcb 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 32a50735a7d41b1ba00df449fe3e0c381ddba7ca..a3d628c8d320d850eb79d6bd273dc25ebe2d577a 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 a7206eca710a3c7a3634ad6259e9de470fa20957..3becb8402d79dc1f8dc11d4f2785fc0a54214fb7 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 14424f96e1e64c2352116e6f8f09bbf804a92456..d1402419f902ad6983d310f2f00c6d3d0645c9b0 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 b72870c28989ba0377f17365102d486d49ad0619..f3ca6a8df9b7a457c5e2a6944e1298e4874e0b89 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 1641b5f9848ea166ce70030895c8dc653fbec381..16754da1ef8fc35133937736b0f6652e7390416c 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 e815f335fb6e2e9227d8497a8eb35056aed9b61d..ad384730c7ae542e43756476c5c2723c718cce95 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 78fdde930e9c6555baf7c8d36c68f97bbdee4140..8299b4b0d2f5c9df4f600c87521fc0cc8856f408 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 3b54ea82864b063b34603b04ee4db6140399bccb..b7118a7f662ce07c29a73432da5bcd4f7fbad6bf 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 17cb445d44862971e3b5e6ff26ffc6f51bdcf5d4..443aad027fb9cfcb03052a28bf69329c0634fd14 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 875d3d9e39bb542f53193b2bf8a181db04fdf00d..f04769a36a45c705a1200b4819ecdb028a354d7b 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 632ed17d9b9180500f493d6022dc49dd90a3123e..ef8b5ed72693314adbf195be5a25fdeb872e7b43 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 c98a91c4b6b486d8f602d492b37d8ec3ab75d64d..7febf71a2882e23032e803a930c536baea07e67f 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 c266a324199f9a213d596a20400aec1c55c0cac1..05ac5a1e674e93bcd4a13e4223c88a2f04debdd3 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 a75f0345abe9b205f5b5a283e9619704073babb9..ae78d7e47d09b32a21b23a3dcef4ecba2c075e30 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 340b526629fdd1eb97cebbef530e406c5ed61ba8..3c20f87ea790d32f79faca90280c2a2b43dd306d 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 61b4f26cc773961cd8a9e634b1a91d657e33d56f..9a9bd5cb06c5b52e8f9c6e45849d196f5f1c5afb 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 551c7ff5e5b66da70b5a11caf223ff632e9b785e..5a3079c2ce4d4e4fc672a3dacfb9658df128d43f 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 5e898a2c31cdced5f1ff830708d5e5f3454f2fe1..b91bfd2a7e2ef755133cde688cea0fe1d12c7650 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 bddfc48f5806a26aa09956c796a4f85f466cbda7..f393e7f91c1aabe182f41dbdeccb5f0270cc5b11 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 e00307568877fd0bb0b204e917a20fd660edf48a..3c3e400a4163b5419977e648e76b336487ff49c8 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 c1998cada9f72f9843affdd70300923c034d2971..f8543e7dd77ed1c430236be3ec3d1b2005a917b3 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 06c7d5b97701ac66e92ecf4e2a3bf6be8a1289c7..abd3c35801458f6289f3ec25336c840c3f7c2184 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 9fab26303be4a833fd2a47a281989121fc5293db..bc2f293fef46d79f592e1e47b1da65e8c2f712cf 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 3fffe971dc2b6a2e5c6b3014c7841dd738215920..6fbae7bf4d4c8cbe197d5d59e6d6a6ecd01d1af4 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 8aae550463a7cbc32ae37b8afffbed694da8533d..8b3bf66a548e4bae87cbcff97f44a32cc3c9e077 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 aab65b1ad4dd56dc63e1e59349d89046928366e9..3bfc9270fb8066cabeda699f388b9bf757a37075 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 00be1250fb124a6ea33a599e53e53f1ed64a527a..bbf5ed3cc8054e1ddb4c4ce6f6944828e4c06868 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 0874736bc0e3dcd95882a860ab51175dcf2cce1c..997ead49ae8612bec50b191c79dbc43ed7383623 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 41d27446717bab375341091ff6bfcd3793b99cd1..53af88cf59df4a0b83c78fc8021fb7d6c0c3f0dd 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 610c6ff4dc0ca7ae756aba4ee5c95c142890f435..bb91284969729ca2399df16755d7d29e55db44b1 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 8c20ddccca1cc414fde704230dac1cfde77e2b54..411a68f94944eefc6da4ab55411a2479dc812e3c 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 b91c6cff154619d55e8aa7b57be918662dd34e96..210f7eb457082690ab51be715ef4593b46056a5b 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 b5df6f7fda25ba86a462867194c715012504b6ee..015971519619b8d38e3718a7d6976ca7b0f0b926 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 9bd971064da8a757e5a242af1e0d30d477dfb17b..e146ec4cab8ebc7483c921f6ddb1159f7650e16a 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 63cfe3fce70e3fb56df7608e82756c323511e53c..cfa826660ad147c2c973a257692840603ae2e41c 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 67d79f5106edf7716a05d5b2df7dbff4fb233673..a8f59bc103fcfb52eb631a4b8219599cfd8312bb 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 c3be2c32e874d47a8f40a515642932c5eed6014e..ba081333deff0dda46bd6997cd14551204f88e95 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 cdd4d18fe62659df51bc79e8f4140ffb7d02aa7c..9f91a6b147204b97fc3db2a8e291b38296c0a7b1 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 d7f4cebabe465c15d4ce468b32f80987df63f834..f82b50375849a0fb46e47999dc1490174f86b835 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 7eaabbdd86be1aee42f56777ce24d4a00d4431f7..e771d21e1c1920c9087cfe12230f465933049b00 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 23077cf37d6f0daf6bf2931ce03f528a0c9c5b3c..9bb9237c82b7b7a3e1f4c27c1bd29f75bb7dc3d2 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 1e8f782a65c533b4d5a99e001058ced117178346..aabc8dee76e5b4da01bb0d6713c7a8c7e5598ede 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 7e02701bf66d59cb1e5be5dca8ede024bde8d9a0..fafdddea2bd78a7db42a1af007e82f8c54065a4c 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 ce41e683062b82b85b7d4b8396f225e6c9a13122..dbe2d91b3d6c3cd2f86ad3a56bb930ea65490e09 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