From e3729e3f2c870c7da6db5f58229df4c6a46df052 Mon Sep 17 00:00:00 2001
From: ATS Jenkins <ats.jenkins@cern.ch>
Date: Fri, 10 Feb 2017 10:02:57 +0000
Subject: [PATCH] clang-format: enforce code style [ci-skip]
---
.../ACTS/Detector/DetectorElementBase.hpp | 12 +-
.../ACTS/Detector/TrackingGeometry.hpp | 6 +-
.../Digitization/CartesianSegmentation.hpp | 50 ++++----
.../ACTS/Digitization/DigitizationCell.hpp | 22 ++--
.../ACTS/Digitization/DigitizationModule.hpp | 11 +-
.../ACTS/Digitization/PlanarModuleCluster.hpp | 110 +++++++++---------
.../ACTS/Digitization/PlanarModuleStepper.hpp | 2 +-
.../ACTS/Digitization/PolarSegmentation.hpp | 72 ++++++------
.../ACTS/Digitization/Segmentation.hpp | 11 +-
.../ACTS/EventData/ParticleDefinitions.hpp | 59 +++++-----
.../ACTS/Extrapolation/ExtrapolationCell.hpp | 16 +--
.../Extrapolation/detail/RungeKuttaEngine.ipp | 14 +--
.../Extrapolation/detail/StaticEngine.ipp | 7 +-
.../detail/StaticNavigationEngine.ipp | 12 +-
Core/include/ACTS/Propagator/AtlasStepper.hpp | 10 +-
Core/include/ACTS/Surfaces/DiamondBounds.hpp | 16 +--
Core/include/ACTS/Surfaces/EllipseBounds.hpp | 23 ++--
Core/include/ACTS/Surfaces/InfiniteBounds.hpp | 4 +-
Core/include/ACTS/Surfaces/PlanarBounds.hpp | 13 +--
.../include/ACTS/Surfaces/RectangleBounds.hpp | 8 +-
.../include/ACTS/Surfaces/TrapezoidBounds.hpp | 24 ++--
Core/include/ACTS/Surfaces/TriangleBounds.hpp | 21 ++--
Core/include/ACTS/Utilities/BinUtility.hpp | 15 ++-
Core/include/ACTS/Utilities/Definitions.hpp | 1 -
Core/include/ACTS/Utilities/GeometryID.hpp | 6 +-
Core/include/ACTS/Utilities/Helpers.hpp | 6 +-
Core/include/ACTS/Utilities/Identifier.hpp | 10 +-
Core/src/Detector/TrackingGeometry.cpp | 7 +-
Core/src/Detector/TrackingVolume.cpp | 6 +-
.../Digitization/CartesianSegmentation.cpp | 42 ++++---
Core/src/Digitization/PlanarModuleStepper.cpp | 13 +--
Core/src/Digitization/PolarSegmentation.cpp | 6 +-
.../Extrapolation/MaterialEffectsEngine.cpp | 53 ++++-----
Core/src/Surfaces/DiamondBounds.cpp | 16 ++-
Core/src/Surfaces/EllipseBounds.cpp | 12 +-
Core/src/Surfaces/TrapezoidBounds.cpp | 28 ++---
Core/src/Surfaces/TriangleBounds.cpp | 9 +-
.../ACTS/Examples/GenericDetectorElement.hpp | 10 +-
.../ACTS/Examples/GenericLayerBuilder.hpp | 2 +-
Examples/src/BuildGenericDetector.cpp | 2 +-
Examples/src/GenericDetector.ipp | 100 ++++++++--------
Examples/src/GenericDetectorElement.cpp | 10 +-
Examples/src/GenericLayerBuilder.cpp | 13 ++-
.../TGeoPlugins/TGeoDetectorElement.hpp | 6 +-
.../TrackingGeometry_closeGeometry_tests.cpp | 8 +-
Tests/Utilities/GeometryID_tests.cpp | 2 +-
46 files changed, 453 insertions(+), 453 deletions(-)
diff --git a/Core/include/ACTS/Detector/DetectorElementBase.hpp b/Core/include/ACTS/Detector/DetectorElementBase.hpp
index 4add2cf9d..01e0872a7 100644
--- a/Core/include/ACTS/Detector/DetectorElementBase.hpp
+++ b/Core/include/ACTS/Detector/DetectorElementBase.hpp
@@ -45,10 +45,10 @@ class DetectorElementBase
public:
/// Constructor
DetectorElementBase() {}
-
+
/// virtual Destructor
virtual ~DetectorElementBase() {}
-
+
/// Identifier
virtual Identifier
identify() const = 0;
@@ -79,7 +79,7 @@ public:
/// Return the DigitizationModule
/// @return optionally the DigitizationModule
virtual std::shared_ptr<const DigitizationModule>
- digitizationModule() const;
+ digitizationModule() const;
/// Returns the thickness of the module
/// @return double that indicates the thickness of the module
@@ -87,7 +87,7 @@ public:
thickness() const = 0;
/// Set the identifier after construction (sometimes needed)
- virtual void
+ virtual void
assignIdentifier(const Identifier& identifier) const = 0;
/// Fast access to bin members
@@ -124,19 +124,17 @@ public:
/// @param neighbours are DetectorElementBase objects that are neighbours
void
registerNeighbours(std::vector<const DetectorElementBase*>& neighbours) const;
-
private:
mutable std::vector<const DetectorElementBase*> m_binmembers;
mutable std::vector<const DetectorElementBase*> m_neighbours;
-
};
inline std::shared_ptr<const DigitizationModule>
DetectorElementBase::digitizationModule() const
{
return nullptr;
-}
+}
inline const std::vector<const DetectorElementBase*>&
DetectorElementBase::binmembers() const
diff --git a/Core/include/ACTS/Detector/TrackingGeometry.hpp b/Core/include/ACTS/Detector/TrackingGeometry.hpp
index 54b8259e8..5b708678f 100644
--- a/Core/include/ACTS/Detector/TrackingGeometry.hpp
+++ b/Core/include/ACTS/Detector/TrackingGeometry.hpp
@@ -48,9 +48,9 @@ class TrackingGeometry
public:
/// Constructor
- ///
- /// @param assignIdentifiers is a boolean to assign the
- /// geometryID sensitive has as an identifier
+ ///
+ /// @param assignIdentifiers is a boolean to assign the
+ /// geometryID sensitive has as an identifier
TrackingGeometry(TrackingVolumePtr highestVolume);
/// Destructor
diff --git a/Core/include/ACTS/Digitization/CartesianSegmentation.hpp b/Core/include/ACTS/Digitization/CartesianSegmentation.hpp
index 787bee5ba..46939603f 100644
--- a/Core/include/ACTS/Digitization/CartesianSegmentation.hpp
+++ b/Core/include/ACTS/Digitization/CartesianSegmentation.hpp
@@ -20,14 +20,16 @@ namespace Acts {
/// @brief Segmentation Base class
///
-/// Segementation class for generic pixel, strixels and strip segmentations
-/// in a cartesian frame, this uses a cartesian X/Y local surface definition
-///
-/// The calculation can be done in full 3D, i.e. the segments of the path through
-/// the planar module are calculated in a 3D model - or in 2D, when the entire
+/// Segementation class for generic pixel, strixels and strip segmentations
+/// in a cartesian frame, this uses a cartesian X/Y local surface definition
+///
+/// The calculation can be done in full 3D, i.e. the segments of the path
+/// through
+/// the planar module are calculated in a 3D model - or in 2D, when the entire
/// calculation is done on the projective surface. When the 2D option is used,
/// segmentation surfaces are not created. The 2D calculation is faster and uses
-/// less memory, however, effects witin the sensor volume can not be easily integrated
+/// less memory, however, effects witin the sensor volume can not be easily
+/// integrated
///
/// Conventions:
/// - 3D positions are within the 3D frame of the module
@@ -38,41 +40,43 @@ namespace Acts {
class CartesianSegmentation : public Segmentation
{
public:
- /// Constructor for all same-size pixels or strips
+ /// 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 numCellsX is the number of cells in X
+ /// @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,
- size_t numCellsX,
- size_t numCellsY = 1);
+ size_t numCellsX,
+ size_t numCellsY = 1);
/// @todo contructor from BinUtilities for more complex readouts
- ///
- /// @param bUtility is the bin Utility,
+ ///
+ /// @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 optimisation
+ /// @param rBounds are the rectangle bounds if provided for memory
+ /// optimisation
///
- /// @note if both RectangleBounds and BinUtility are provided, no check is done
+ /// @note if both RectangleBounds and BinUtility are provided, no check is
+ /// done
/// for consitency
- CartesianSegmentation(std::shared_ptr<BinUtility> bUtility,
+ CartesianSegmentation(std::shared_ptr<BinUtility> bUtility,
std::shared_ptr<const PlanarBounds> rBounds = nullptr);
-
- /// Virtual Destructor
+
+ /// Virtual Destructor
virtual ~CartesianSegmentation();
/// @copydoc Acts::Segmentation::createSegmentationSurfaces
///
/// Create the segmentation surfaces in X and Y for rectangular shapes
- /// These are needed for a full three dimensional module
+ /// These are needed for a full three dimensional module
void
createSegmentationSurfaces(SurfacePtrVector& boundarySurfaces,
SurfacePtrVector& segmentationSurfacesX,
SurfacePtrVector& segmentationSurfacesY,
double halfThickness,
int readoutDirection = 1.,
- double lorentzAngle = 0.) const final;
+ double lorentzAngle = 0.) const final;
/// @copydoc Segmentation::cell
const DigitizationCell
@@ -101,9 +105,9 @@ public:
/// specialization for Rectangle Bounds
const PlanarBounds&
moduleBounds() const final;
-
+
/// return the bin utility that defines the
- /// readout segmentation
+ /// readout segmentation
const BinUtility&
binUtility() const final;
@@ -114,7 +118,6 @@ private:
std::shared_ptr<const PlanarBounds> m_activeBounds; /// active area size
std::shared_ptr<BinUtility> m_binUtility; /// bin Utility
-
};
inline const PlanarBounds&
@@ -126,10 +129,9 @@ CartesianSegmentation::moduleBounds() const
inline const BinUtility&
CartesianSegmentation::binUtility() const
{
- return (*(m_binUtility.get()));
+ return (*(m_binUtility.get()));
}
-
template <class T>
const DigitizationCell
CartesianSegmentation::cellT(const T& position) const
diff --git a/Core/include/ACTS/Digitization/DigitizationCell.hpp b/Core/include/ACTS/Digitization/DigitizationCell.hpp
index b1100c4fb..8735c7231 100644
--- a/Core/include/ACTS/Digitization/DigitizationCell.hpp
+++ b/Core/include/ACTS/Digitization/DigitizationCell.hpp
@@ -14,24 +14,22 @@
namespace Acts {
/// @brief pair of ints for definition of a cell
-struct DigitizationCell {
+struct DigitizationCell
+{
// identification and data
size_t channel0 = 0;
size_t channel1 = 1;
- float data = 0.;
+ float data = 0.;
// connstruct them
DigitizationCell(size_t ch0, size_t ch1, float d = 0.)
- : channel0(ch0)
- , channel1(ch1)
- , data(d)
- {}
+ : channel0(ch0), channel1(ch1), data(d)
+ {
+ }
// copy them
DigitizationCell(const DigitizationCell& dc)
- : channel0(dc.channel0)
- , channel1(dc.channel1)
- , data(dc.data)
- {}
-
+ : channel0(dc.channel0), channel1(dc.channel1), data(dc.data)
+ {
+ }
};
/// @brief DigitizationStep for further handling
@@ -46,8 +44,6 @@ struct DigitizationStep
Vector2D stepReadoutProjected; /// this is the projected position at the
/// readout surface
Vector2D stepCellCenter; /// this is the cell position
-
-
/// Standard constructor
DigitizationStep()
diff --git a/Core/include/ACTS/Digitization/DigitizationModule.hpp b/Core/include/ACTS/Digitization/DigitizationModule.hpp
index 91e8dd89b..c780ebd39 100644
--- a/Core/include/ACTS/Digitization/DigitizationModule.hpp
+++ b/Core/include/ACTS/Digitization/DigitizationModule.hpp
@@ -24,13 +24,14 @@ typedef std::vector<SurfacePtr> SurfacePtrVector;
///
/// Class that holds the surfaces for a planar digitization detector module.
///
-/// It needs a descriptor to design different pixel/strixels/strip setups
+/// It needs a descriptor to design different pixel/strixels/strip setups
/// (with a segmentation class) in order to define the readout segmentation
///
/// The digitizaiton is done in the local frame of the surface.
///
/// The lorentz angle is assumed to be only in x-direction and constant for the
-/// module, it is measured from the local z-direction towards the local x-direction.
+/// module, it is measured from the local z-direction towards the local
+/// x-direction.
///
/// The readout direction defines the charge drift either:
/// a) towards the surface at -halfThickness if readout is defined at -1
@@ -118,9 +119,9 @@ public:
segmentationSurfacesY() const;
private:
- double m_halfThickness; ///< half thickness of the module
- int m_readoutDirection; ///< readout is along (+1) / (-1) wrt local z axis
- double m_lorentzAngle; ///< the lorentz angle
+ double m_halfThickness; ///< half thickness of the module
+ int m_readoutDirection; ///< readout is along (+1) / (-1) wrt local z axis
+ double m_lorentzAngle; ///< the lorentz angle
double m_tanLorentzAngle; ///< and the tangent of it
std::shared_ptr<const Segmentation>
diff --git a/Core/include/ACTS/Digitization/PlanarModuleCluster.hpp b/Core/include/ACTS/Digitization/PlanarModuleCluster.hpp
index 5dbe8d2cd..220dd6a0c 100644
--- a/Core/include/ACTS/Digitization/PlanarModuleCluster.hpp
+++ b/Core/include/ACTS/Digitization/PlanarModuleCluster.hpp
@@ -9,71 +9,75 @@
#ifndef ACTS_DIGITIZATION_PLANARMODULECLUSTER_H
#define ACTS_DIGITIZATION_PLANARMODULECLUSTER_H 1
-#include "ACTS/Utilities/Logger.hpp"
-#include "ACTS/Utilities/Identifier.hpp"
+#include "ACTS/Digitization/DigitizationCell.hpp"
+#include "ACTS/EventData/Measurement.hpp"
+#include "ACTS/EventData/ParticleDefinitions.hpp"
#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Utilities/Identifier.hpp"
+#include "ACTS/Utilities/Logger.hpp"
#include "ACTS/Utilities/ParameterDefinitions.hpp"
-#include "ACTS/EventData/ParticleDefinitions.hpp"
-#include "ACTS/EventData/Measurement.hpp"
-#include "ACTS/Digitization/DigitizationCell.hpp"
namespace Acts {
-
- template <ParID_t... params>
- using Measurement_t = Measurement<Identifier, params...>;
-
- class PlanarModuleCluster : public Measurement_t<ParDef::eLOC_1, ParDef::eLOC_2> {
- public:
- /// Constructor from DigitizationCells
- ///
- /// @param mSurface is the module surface
- /// @param cIendifier is the channel identifier of the local position
- /// @param cov is the covariance matrix
- /// @param loc1 is the local position in the first coordinate
- /// @param loc2 is the local position in the second coordinate
- /// @param dCells is the vector of digitization cells
- PlanarModuleCluster(const Surface& mSurface,
- const Identifier& cIdentifier,
- ActsSymMatrixD<2> cov,
- double loc1, double loc2,
- std::vector<DigitizationCell> dCells,
- std::vector<barcode_type> barcodes = {})
- : Measurement_t<ParDef::eLOC_1, ParDef::eLOC_2>(mSurface, cIdentifier, std::move(cov), loc1, loc2)
- , m_digitizationCells(dCells)
- , m_barcodes(barcodes)
- {}
-
- /// access to the digitization cells
- ///
- /// @return the vector to the digitization cells
- const std::vector<DigitizationCell>&
- digitizationCells() const;
-
- /// access to the contributing barcodes
- ///
- /// @return the vector of the particle barcode
- const std::vector<barcode_type>&
- barcodes() const;
-
- private:
- std::vector<DigitizationCell> m_digitizationCells; /// the digitization cells
- std::vector<barcode_type> m_barcodes; /// barcode types
-
- };
-
+
+template <ParID_t... params>
+using Measurement_t = Measurement<Identifier, params...>;
+
+class PlanarModuleCluster : public Measurement_t<ParDef::eLOC_1, ParDef::eLOC_2>
+{
+public:
+ /// Constructor from DigitizationCells
+ ///
+ /// @param mSurface is the module surface
+ /// @param cIendifier is the channel identifier of the local position
+ /// @param cov is the covariance matrix
+ /// @param loc1 is the local position in the first coordinate
+ /// @param loc2 is the local position in the second coordinate
+ /// @param dCells is the vector of digitization cells
+ PlanarModuleCluster(const Surface& mSurface,
+ const Identifier& cIdentifier,
+ ActsSymMatrixD<2> cov,
+ double loc1,
+ double loc2,
+ std::vector<DigitizationCell> dCells,
+ std::vector<barcode_type> barcodes = {})
+ : Measurement_t<ParDef::eLOC_1, ParDef::eLOC_2>(mSurface,
+ cIdentifier,
+ std::move(cov),
+ loc1,
+ loc2)
+ , m_digitizationCells(dCells)
+ , m_barcodes(barcodes)
+ {
+ }
+
+ /// access to the digitization cells
+ ///
+ /// @return the vector to the digitization cells
+ const std::vector<DigitizationCell>&
+ digitizationCells() const;
+
+ /// access to the contributing barcodes
+ ///
+ /// @return the vector of the particle barcode
+ const std::vector<barcode_type>&
+ barcodes() const;
+
+private:
+ std::vector<DigitizationCell> m_digitizationCells; /// the digitization cells
+ std::vector<barcode_type> m_barcodes; /// barcode types
+};
+
inline const std::vector<DigitizationCell>&
PlanarModuleCluster::digitizationCells() const
{
return m_digitizationCells;
}
-
+
inline const std::vector<barcode_type>&
PlanarModuleCluster::barcodes() const
{
return m_barcodes;
-}
-
+}
}
-#endif // ACTS_DIGITIZATION_PLANARMODULECLUSTER_H
-
+#endif // ACTS_DIGITIZATION_PLANARMODULECLUSTER_H
diff --git a/Core/include/ACTS/Digitization/PlanarModuleStepper.hpp b/Core/include/ACTS/Digitization/PlanarModuleStepper.hpp
index 4d47e66ef..65657591b 100644
--- a/Core/include/ACTS/Digitization/PlanarModuleStepper.hpp
+++ b/Core/include/ACTS/Digitization/PlanarModuleStepper.hpp
@@ -89,7 +89,7 @@ private:
}
/// the config class
- Config m_cfg;
+ Config m_cfg;
/// logging instance
std::unique_ptr<Logger> m_logger;
diff --git a/Core/include/ACTS/Digitization/PolarSegmentation.hpp b/Core/include/ACTS/Digitization/PolarSegmentation.hpp
index 1c1f40b67..4e76b8904 100644
--- a/Core/include/ACTS/Digitization/PolarSegmentation.hpp
+++ b/Core/include/ACTS/Digitization/PolarSegmentation.hpp
@@ -8,7 +8,7 @@
// #ifndef ACTS_DIGITIZATION_POLARSEGMENTATION_H
// #define ACTS_DIGITIZATION_POLARSEGMENTATION_H
-//
+//
// #include <memory>
// #include "ACTS/Digitization/DigitizationCell.hpp"
// #include "ACTS/Digitization/Segmentation.hpp"
@@ -17,10 +17,11 @@
// #include "ACTS/Utilities/Definitions.hpp"
// namespace Acts {
-//
+//
// /// @class TrapezoidSegmentation class
// ///
-// /// Segementation class for generic pixel, strixels and strip segmentations on
+// /// Segementation class for generic pixel, strixels and strip segmentations
+// on
// /// a trapezoidal shape
// ///
// /// Conventions:
@@ -37,12 +38,12 @@
// TrapezoidSegmentation(std::shared_ptr<const TrapezoidBounds>,
// size_t numCellsX,
// size_t numCellsY = 1);
-//
+//
// /// TODO contructor from BinUtilities for more complex readouts
-//
+//
// /// Virtual Destructor
// virtual ~TrapezoidSegmentation();
-//
+//
// /// @copydoc Acts::Segmentation::createSegmentationSurfaces
// void
// createSegmentationSurfaces(SurfacePtrVector& boundarySurfaces,
@@ -50,20 +51,21 @@
// SurfacePtrVector& segmentationSurfacesY,
// double halfThickness,
// int readoutDirection = 1.,
-// double lorentzAngle = 0.) const override;
-//
+// double lorentzAngle = 0.) const
+// override;
+//
// /// @copydoc Segmentation::cell
// const DigitizationCell
// cell(const Vector3D& position) const override;
-//
+//
// /// @copydoc Segmentation::cell
// const DigitizationCell
// cell(const Vector2D& position) const override;
-//
+//
// /// @copydoc Segmentation::cellPosition
// const Vector2D
// cellPosition(const DigitizationCell& cId) const override;
-//
+//
// /// @copydoc Segmentation::digitizationStep
// const DigitizationStep
// digitizationStep(const Vector3D& start,
@@ -71,66 +73,66 @@
// double halfThickness,
// int readoutDirection = 1,
// double lorentzAngle = 0.) const override;
-//
+//
// /// return the surface bounds by reference
// /// specification for TrapezoidBounds
// const TrapezoidBounds&
// moduleBounds() const override;
-//
+//
// /// Return the simple binning parameters
// size_t
// numCellsX() const;
-//
+//
// /// Return the simple binning parameters
// size_t
// numCellsY() const;
-//
+//
// private:
// /// private helper method - templated
// template <class T>
// const DigitizationCell
// cellT(const T& position) const;
-//
+//
// /// Return the local pitch X at Y
// double
// PitchX(const Vector2D& localPos) const;
-//
+//
// /// Return the local sinStereo
// double
// sinStereoLocal(const Vector2D& localPos) const;
-//
+//
// /// Return the projected x value on the y=0
// double
// projectLocX(const Vector2D& localPos) const;
-//
+//
// /// Return the radius correponding to the given module
// double
// radius() const;
-//
+//
// std::shared_ptr<const TrapezoidBounds> m_activeBounds;
// std::unique_ptr<BinUtility> m_binUtility;
// size_t m_binsX;
// size_t m_binsY;
// };
-//
+//
// inline const TrapezoidBounds&
// TrapezoidSegmentation::moduleBounds() const
// {
// return (*(m_activeBounds.get()));
// }
-//
+//
// inline size_t
// TrapezoidSegmentation::numCellsX() const
// {
// return m_binsX;
// }
-//
+//
// inline size_t
// TrapezoidSegmentation::numCellsY() const
// {
// return m_binsY;
// }
-//
+//
// template <class T>
// const DigitizationCell
// TrapezoidSegmentation::cellT(const T& position) const
@@ -142,15 +144,16 @@
// return DigitizationCell(m_binUtility->bin(position, 0),
// m_binUtility->bin(position, 1));
// }
-//
+//
// inline const DigitizationCell
// TrapezoidSegmentation::cell(const Vector3D& position) const
// {
// Vector3D CorrPosition = position;
-// CorrPosition.x() = projectLocX(Vector2D(CorrPosition.x(), CorrPosition.y()));
+// CorrPosition.x() = projectLocX(Vector2D(CorrPosition.x(),
+// CorrPosition.y()));
// return cellT<Vector3D>(CorrPosition);
// }
-//
+//
// inline const DigitizationCell
// TrapezoidSegmentation::cell(const Vector2D& position) const
// {
@@ -158,15 +161,16 @@
// corrPosition[0] = projectLocX(Vector2D(corrPosition[0], corrPosition[1]));
// return cellT<Vector2D>(corrPosition);
// }
-//
+//
// double
// TrapezoidSegmentation::radius() const
// {
// return m_activeBounds->halflengthY()
// / (m_activeBounds->maxHalflengthX() - m_activeBounds->minHalflengthX())
-// * (m_activeBounds->maxHalflengthX() + m_activeBounds->minHalflengthX());
+// * (m_activeBounds->maxHalflengthX() +
+// m_activeBounds->minHalflengthX());
// }
-//
+//
// double
// TrapezoidSegmentation::sinStereoLocal(const Vector2D& localPos) const
// {
@@ -177,7 +181,7 @@
// / sqrt((1 + y * oneOverRadius) * (1 + y * oneOverRadius)
// + x * oneOverRadius * x * oneOverRadius);
// }
-//
+//
// double
// TrapezoidSegmentation::PitchX(const Vector2D& localPos) const
// {
@@ -187,13 +191,13 @@
// double lengthXatHit = (radius() + localPos[1]) * tanPhi;
// return lengthXatHit / float(m_binsX);
// }
-//
+//
// double
// TrapezoidSegmentation::projectLocX(const Vector2D& localPos) const
// {
// return -radius() * tan(asin(sinStereoLocal(localPos)));
// }
// }
-//
+//
// #endif
-//
\ No newline at end of file
+//
\ No newline at end of file
diff --git a/Core/include/ACTS/Digitization/Segmentation.hpp b/Core/include/ACTS/Digitization/Segmentation.hpp
index a94bcdc77..df703ae50 100644
--- a/Core/include/ACTS/Digitization/Segmentation.hpp
+++ b/Core/include/ACTS/Digitization/Segmentation.hpp
@@ -30,8 +30,9 @@ typedef std::vector<SurfacePtr> SurfacePtrVector;
/// module
///
/// Since the segmentation description might be identical for many elements
-/// while the lorentz angle may change, lorentzAngle and readoutDirection
-/// are provided and th the segmenation class only creates the surfaces for the module,
+/// while the lorentz angle may change, lorentzAngle and readoutDirection
+/// are provided and th the segmenation class only creates the surfaces for the
+/// module,
/// but hosts the binning information.
///
class Segmentation
@@ -39,7 +40,7 @@ class Segmentation
public:
/// Virtual Destructor
virtual ~Segmentation() {}
-
+
/// Create the segmentation surfaces in X
///
/// This method is only used if the full 3D digitization is done
@@ -106,12 +107,10 @@ public:
/// return the surface bounds by reference
virtual const SurfaceBounds&
moduleBounds() const = 0;
-
+
/// return the bin utility that defines the readout
virtual const BinUtility&
binUtility() const = 0;
-
-
};
} // end of namespace Acts
diff --git a/Core/include/ACTS/EventData/ParticleDefinitions.hpp b/Core/include/ACTS/EventData/ParticleDefinitions.hpp
index e22f4a642..1e5a074d4 100644
--- a/Core/include/ACTS/EventData/ParticleDefinitions.hpp
+++ b/Core/include/ACTS/EventData/ParticleDefinitions.hpp
@@ -33,7 +33,7 @@ namespace Acts {
///
enum ParticleType {
- nonInteracting = 0, //!< for non-interacting extrapolation
+ nonInteracting = 0, //!< for non-interacting extrapolation
geantino = 0, //!< for non-interacting extrapolation
electron = 1, //!< reconstruction + fatras : type as electron hypothesis
muon = 2, //!< reconstruction + fatras : type as muon hypothesis
@@ -44,7 +44,8 @@ enum ParticleType {
neutron = 7, //!< for fatras usage
pi0 = 8, //!< for fatras usage
k0 = 9, //!< for fatras usage
- nonInteractingMuon = 10, //!< for material collection @todo check if this is still needed
+ nonInteractingMuon
+ = 10, //!< for material collection @todo check if this is still needed
noHypothesis = 99,
undefined = 99
};
@@ -81,7 +82,7 @@ struct ParticleMasses
}
};
-/// Static method : convert to ParticleType from pdg
+/// Static method : convert to ParticleType from pdg
static ParticleType
convertToParticleType(pdg_type pdg, bool& stable, bool& exiting, double charge)
{
@@ -278,9 +279,9 @@ public:
{
}
- /// destructor
+ /// destructor
~ParticleProperties() {}
-
+
/** assignment operator */
ParticleProperties&
operator=(const ParticleProperties& pProperties)
@@ -297,59 +298,63 @@ public:
return (*this);
}
- /// shift the particle
+ /// shift the particle
void
shift(const Vector3D& shift)
- { m_vertex += shift; }
+ {
+ m_vertex += shift;
+ }
/// assign the barcode
void
assign(barcode_type barcode)
- { m_barcode = barcode; }
-
- /// return the momentum
+ {
+ m_barcode = barcode;
+ }
+
+ /// return the momentum
const Vector3D&
vertex() const
{
return m_vertex;
}
-
- /// return the momentum
+
+ /// return the momentum
const Vector3D&
momentum() const
{
return m_momentum;
}
- /// return the mass
+ /// return the mass
double
mass() const
{
return m_mass;
}
- /// return the charge
+ /// return the charge
double
charge() const
{
return m_charge;
}
- /// return the particle ID
+ /// return the particle ID
pdg_type
pdgID() const
{
return m_pdgID;
}
- /// return the particle type
+ /// return the particle type
ParticleType
particleType() const
{
return m_particleType;
}
- /// return the particle barcode
+ /// return the particle barcode
barcode_type
barcode() const
{
@@ -357,7 +362,7 @@ public:
}
private:
- Vector3D m_vertex;
+ Vector3D m_vertex;
Vector3D m_momentum;
double m_mass;
double m_charge;
@@ -374,7 +379,7 @@ private:
class ProcessVertex
{
public:
- /// constructor
+ /// constructor
ProcessVertex(const Vector3D& pVertex,
double pTime,
process_type pType,
@@ -383,35 +388,35 @@ public:
{
}
- /// destructor
+ /// destructor
~ProcessVertex() {}
-
- /// Add a particle
+
+ /// Add a particle
void
addOutgoing(const ParticleProperties& pProperties);
- /// Return the vertex position
+ /// Return the vertex position
const Vector3D&
vertex() const
{
return m_vertex;
}
- /// Return the time of production
+ /// Return the time of production
double
interactionTime() const
{
return m_time;
}
- /// Return the type of production
+ /// Return the type of production
process_type
processType() const
{
return m_type;
}
- /// Return the outgoing properties
+ /// Return the outgoing properties
const std::vector<ParticleProperties>&
outgoingParticles() const
{
@@ -432,4 +437,4 @@ ProcessVertex::addOutgoing(const ParticleProperties& pProperties)
}
}
-#endif // ACTS_EVENTDATA_PARTICLEDEFINITIONS_H
+#endif // ACTS_EVENTDATA_PARTICLEDEFINITIONS_H
diff --git a/Core/include/ACTS/Extrapolation/ExtrapolationCell.hpp b/Core/include/ACTS/Extrapolation/ExtrapolationCell.hpp
index 87358e41f..04337a337 100644
--- a/Core/include/ACTS/Extrapolation/ExtrapolationCell.hpp
+++ b/Core/include/ACTS/Extrapolation/ExtrapolationCell.hpp
@@ -41,8 +41,8 @@ class ExtrapolationMode
{
public:
enum eMode {
- Destination = 1, // try to hit the destination, if not other means to stop
- Propagation = 2, // any propagation but the final one to destinaion
+ Destination = 1, // try to hit the destination, if not other means to stop
+ Propagation = 2, // any propagation but the final one to destinaion
StopWithPathLimit = 3, // stop when the path limit is reached
StopWithMaterialLimitX0 = 4, // stop when material limit is reached in X0
StopWithMaterialLimitL0 = 5, // stop when material limit is reached in L0
@@ -119,11 +119,11 @@ public:
SuccessMaterialLimit = 5, // successful : material limit reached
Recovered = 6, // successful : recovered
FailureDestination = 7, // failure : could not reach destination
- FailureLoop = 8, // failure : loop or oscillation between volumes
- FailureNavigation = 9, // failure : general navigation failure
- FailureUpdateKill = 10, // failure : updated track under threshold
- FailureConfiguration = 11, // failure : general configuration failure
- LeftKnownWorld = 12 // successful ? failure ? if we just knew ...
+ FailureLoop = 8, // failure : loop or oscillation between volumes
+ FailureNavigation = 9, // failure : general navigation failure
+ FailureUpdateKill = 10, // failure : updated track under threshold
+ FailureConfiguration = 11, // failure : general configuration failure
+ LeftKnownWorld = 12 // successful ? failure ? if we just knew ...
};
/// the actual code
@@ -370,7 +370,7 @@ public:
/// the configuration concentrated
ExtrapolationConfig extrapolationConfiguration;
/// The process vertices that occured (for FATRAS)
- /// @todo move to templated extension
+ /// @todo move to templated extension
std::vector<ProcessVertex> interactionVertices;
float time; ///< timing info
diff --git a/Core/include/ACTS/Extrapolation/detail/RungeKuttaEngine.ipp b/Core/include/ACTS/Extrapolation/detail/RungeKuttaEngine.ipp
index 35eb29309..3dc54677b 100644
--- a/Core/include/ACTS/Extrapolation/detail/RungeKuttaEngine.ipp
+++ b/Core/include/ACTS/Extrapolation/detail/RungeKuttaEngine.ipp
@@ -24,10 +24,8 @@ Acts::RungeKuttaEngine<MagneticField>::propagateRungeKuttaT(
const T& parametersT,
const Surface& dSurface) const
{
- EX_MSG_VERBOSE(eCell.navigationStep,
- "propagate",
- "<T> ",
- "propagateRungeKuttaT called");
+ EX_MSG_VERBOSE(
+ eCell.navigationStep, "propagate", "<T> ", "propagateRungeKuttaT called");
// bail out if you can't transform into global frame
if (!m_rkUtils.transformLocalToGlobal(
@@ -1136,9 +1134,7 @@ Acts::RungeKuttaEngine<MagneticField>::buildTrackParametersWithoutPropagation(
// fix - how to copy a covariance ?
}
return std::make_unique<const BoundParameters>(
- std::move(cov),
- tParameters.parameters(),
- tParameters.referenceSurface());
+ std::move(cov), tParameters.parameters(), tParameters.referenceSurface());
}
/////////////////////////////////////////////////////////////////////////////////
@@ -1162,9 +1158,7 @@ Acts::RungeKuttaEngine<MagneticField>::buildNeutralParametersWithoutPropagation(
// fix - how to copy a covariance ?
}
return std::make_unique<const NeutralBoundParameters>(
- std::move(cov),
- nParameters.parameters(),
- nParameters.referenceSurface());
+ std::move(cov), nParameters.parameters(), nParameters.referenceSurface());
}
/////////////////////////////////////////////////////////////////////////////////
diff --git a/Core/include/ACTS/Extrapolation/detail/StaticEngine.ipp b/Core/include/ACTS/Extrapolation/detail/StaticEngine.ipp
index 9bf30bdce..70576e734 100644
--- a/Core/include/ACTS/Extrapolation/detail/StaticEngine.ipp
+++ b/Core/include/ACTS/Extrapolation/detail/StaticEngine.ipp
@@ -32,8 +32,7 @@ Acts::StaticEngine::extrapolateT(Acts::ExtrapolationCell<T>& eCell,
//
// obviously need a surface to exercise the fallback & need to be configured
// to do so
- if (sf
- && eCell.checkConfigurationMode(ExtrapolationMode::Destination)) {
+ if (sf && eCell.checkConfigurationMode(ExtrapolationMode::Destination)) {
EX_MSG_DEBUG(
++eCell.navigationStep,
"extrapolate",
@@ -121,7 +120,7 @@ Acts::StaticEngine::extrapolateT(Acts::ExtrapolationCell<T>& eCell,
"layer",
"loop",
"found " << layerIntersections.size()
- << " layers for the layer-to-layer loop.");
+ << " layers for the layer-to-layer loop.");
// layer-to-layer loop starts here
for (auto& layerCandidate : layerIntersections) {
@@ -165,7 +164,7 @@ Acts::StaticEngine::extrapolateT(Acts::ExtrapolationCell<T>& eCell,
if (!eCode.inProgress())
return handleReturnT<T>(eCode, eCell, sf, pDir, bcheck);
}
- // the layer-to-layer loop is done,
+ // the layer-to-layer loop is done,
// the lead parameters are at the last valid option
// ----- [3] now resolve the boundary situation, call includes information
// wheather one is alreay at a boundary
diff --git a/Core/include/ACTS/Extrapolation/detail/StaticNavigationEngine.ipp b/Core/include/ACTS/Extrapolation/detail/StaticNavigationEngine.ipp
index 430cfadb1..1ae6a7531 100644
--- a/Core/include/ACTS/Extrapolation/detail/StaticNavigationEngine.ipp
+++ b/Core/include/ACTS/Extrapolation/detail/StaticNavigationEngine.ipp
@@ -97,15 +97,13 @@ Acts::StaticNavigationEngine::resolveBoundaryT(
return eCode;
}
// bail-out in case no boundary has been found for Fatras mode
- if (eCell.checkConfigurationMode(ExtrapolationMode::FATRAS)){
- EX_MSG_VERBOSE(eCell.navigationStep,
- "navigation",
- "",
- "Fatras loop protection.");
- // get out of this, we will not simulate loopers
+ if (eCell.checkConfigurationMode(ExtrapolationMode::FATRAS)) {
+ EX_MSG_VERBOSE(
+ eCell.navigationStep, "navigation", "", "Fatras loop protection.");
+ // get out of this, we will not simulate loopers
return ExtrapolationCode::SuccessPathLimit;
}
-
+
// [2] ------------------------ slow boundary access : take all boundary
// surfaces and simply try --------------
EX_MSG_VERBOSE(eCell.navigationStep,
diff --git a/Core/include/ACTS/Propagator/AtlasStepper.hpp b/Core/include/ACTS/Propagator/AtlasStepper.hpp
index 94c190303..92807572b 100644
--- a/Core/include/ACTS/Propagator/AtlasStepper.hpp
+++ b/Core/include/ACTS/Propagator/AtlasStepper.hpp
@@ -9,10 +9,10 @@
#ifndef ACTS_ATLAS_STEPPER_HPP
#define ACTS_ATLAS_STEPPER_HPP 1
+#include <cmath>
#include "ACTS/EventData/TrackParameters.hpp"
#include "ACTS/Surfaces/Surface.hpp"
#include "ACTS/Utilities/Units.hpp"
-#include <cmath>
namespace Acts {
@@ -68,12 +68,14 @@ class AtlasStepper
ActsVectorD<NGlobalPars> Vp = pars.parameters();
double Sf, Cf, Ce, Se;
- // AS : __sincos vs sincos trouble in gcc vs. clang
+ // AS : __sincos vs sincos trouble in gcc vs. clang
// __sincos(Vp(2), &Sf, &Cf);
// __sincos(Vp(3), &Se, &Ce);
// @TODO fix later accordingly
- Sf = sin(Vp(2)); Cf = cos(Vp(2));
- Se = sin(Vp(3)); Ce = cos(Vp(3));
+ Sf = sin(Vp(2));
+ Cf = cos(Vp(2));
+ Se = sin(Vp(3));
+ Ce = cos(Vp(3));
double Ax[3] = {-Sf, Cf, 0.};
double Ay[3] = {-Cf * Ce, -Sf * Ce, Se};
diff --git a/Core/include/ACTS/Surfaces/DiamondBounds.hpp b/Core/include/ACTS/Surfaces/DiamondBounds.hpp
index e44cfb1c0..40ea23108 100644
--- a/Core/include/ACTS/Surfaces/DiamondBounds.hpp
+++ b/Core/include/ACTS/Surfaces/DiamondBounds.hpp
@@ -116,7 +116,7 @@ public:
/// This method returns the opening angle alpha in point A'
double
alpha2() const;
-
+
/// Inside check for the bounds object driven by the boundary check directive
/// Each Bounds has a method inside, which checks if a LocalPosition is inside
/// the bounds Inside can be called without/with tolerances.
@@ -165,9 +165,9 @@ public:
vertices() const override;
// Bounding box representation
- virtual const RectangleBounds&
- boundingBox() const final;
-
+ virtual const RectangleBounds&
+ boundingBox() const final;
+
/// Output Method for std::ostream
///
/// @param sl is the ostream in which it is dumped
@@ -188,9 +188,9 @@ private:
initCache();
std::vector<TDD_real_t> m_valueStore; ///< internal parameter store
- TDD_real_t m_alpha1; ///< internal parameter cache for alpha1
- TDD_real_t m_alpha2; ///< internal parameter cache for alpha2
- RectangleBounds m_boundingBox; ///< internal bounding box cache
+ TDD_real_t m_alpha1; ///< internal parameter cache for alpha1
+ TDD_real_t m_alpha2; ///< internal parameter cache for alpha2
+ RectangleBounds m_boundingBox; ///< internal bounding box cache
};
inline DiamondBounds*
@@ -365,7 +365,7 @@ DiamondBounds::vertices() const
return vertices;
}
-inline const RectangleBounds&
+inline const RectangleBounds&
DiamondBounds::boundingBox() const
{
return m_boundingBox;
diff --git a/Core/include/ACTS/Surfaces/EllipseBounds.hpp b/Core/include/ACTS/Surfaces/EllipseBounds.hpp
index f560d40da..e570e139b 100644
--- a/Core/include/ACTS/Surfaces/EllipseBounds.hpp
+++ b/Core/include/ACTS/Surfaces/EllipseBounds.hpp
@@ -66,10 +66,10 @@ public:
///
/// @param ebo is the source bounds for the copy
EllipseBounds(const EllipseBounds& ebo)
- : PlanarBounds(ebo),
- m_boundingBox(0.,0.)
- {}
-
+ : PlanarBounds(ebo), m_boundingBox(0., 0.)
+ {
+ }
+
/// Destructor
virtual ~EllipseBounds();
@@ -157,10 +157,10 @@ public:
/// Return the vertices - or, the points of the extremas
virtual const std::vector<Vector2D>
vertices() const override;
-
+
// Bounding box representation
- virtual const RectangleBounds&
- boundingBox() const final;
+ virtual const RectangleBounds&
+ boundingBox() const final;
/// This method returns the halfPhiSector which is covered by the disc
double
@@ -187,9 +187,8 @@ private:
{
return x * x;
};
-
- RectangleBounds m_boundingBox; ///< internal bounding box cache
-
+
+ RectangleBounds m_boundingBox; ///< internal bounding box cache
};
inline EllipseBounds*
@@ -314,11 +313,11 @@ EllipseBounds::vertices() const
return vertices;
}
-inline const RectangleBounds&
+inline const RectangleBounds&
EllipseBounds::boundingBox() const
{
return m_boundingBox;
-}
+}
} // end of namespace
diff --git a/Core/include/ACTS/Surfaces/InfiniteBounds.hpp b/Core/include/ACTS/Surfaces/InfiniteBounds.hpp
index d0d4e0953..74cbacf4f 100644
--- a/Core/include/ACTS/Surfaces/InfiniteBounds.hpp
+++ b/Core/include/ACTS/Surfaces/InfiniteBounds.hpp
@@ -28,10 +28,10 @@ class InfiniteBounds : public SurfaceBounds
public:
/// Default Constructor
InfiniteBounds() {}
-
+
/// Destructor
~InfiniteBounds() {}
-
+
/// Return SurfaceBounds type for persistency mainly
virtual SurfaceBounds::BoundsType
type() const final
diff --git a/Core/include/ACTS/Surfaces/PlanarBounds.hpp b/Core/include/ACTS/Surfaces/PlanarBounds.hpp
index ac94fc6bb..589cdbf80 100644
--- a/Core/include/ACTS/Surfaces/PlanarBounds.hpp
+++ b/Core/include/ACTS/Surfaces/PlanarBounds.hpp
@@ -16,7 +16,7 @@
#include "ACTS/Surfaces/SurfaceBounds.hpp"
namespace Acts {
-
+
/// forward declare rectangle bounds as boundary box
class RectangleBounds;
///
@@ -32,10 +32,10 @@ public:
///
/// @param sStore is the store size for the initialisation
PlanarBounds(size_t sStore = 0) : SurfaceBounds(sStore) {}
-
+
/// Destructor
virtual ~PlanarBounds() {}
-
+
/// Virtual Constructor
virtual PlanarBounds*
clone() const = 0;
@@ -43,11 +43,10 @@ public:
/// Return the vertices - or, the points of the extremas
virtual const std::vector<Vector2D>
vertices() const = 0;
-
+
// Bounding box parameters
- virtual const RectangleBounds&
- boundingBox() const = 0;
-
+ virtual const RectangleBounds&
+ boundingBox() const = 0;
};
} // end of namespace
diff --git a/Core/include/ACTS/Surfaces/RectangleBounds.hpp b/Core/include/ACTS/Surfaces/RectangleBounds.hpp
index adb077911..bae03dbfa 100644
--- a/Core/include/ACTS/Surfaces/RectangleBounds.hpp
+++ b/Core/include/ACTS/Surfaces/RectangleBounds.hpp
@@ -47,7 +47,7 @@ public:
///
/// @param recbo are the source bounds
RectangleBounds(const RectangleBounds& recbo) : PlanarBounds(recbo) {}
-
+
/// Destructor
virtual ~RectangleBounds();
@@ -120,7 +120,7 @@ public:
vertices() const final;
// Bounding box representation
- virtual const RectangleBounds&
+ virtual const RectangleBounds&
boundingBox() const final;
/// Output Method for std::ostream
@@ -260,11 +260,11 @@ RectangleBounds::vertices() const
return vertices;
}
-inline const RectangleBounds&
+inline const RectangleBounds&
RectangleBounds::boundingBox() const
{
return (*this);
-}
+}
} // end of namespace
diff --git a/Core/include/ACTS/Surfaces/TrapezoidBounds.hpp b/Core/include/ACTS/Surfaces/TrapezoidBounds.hpp
index 124b90e60..eed32a050 100644
--- a/Core/include/ACTS/Surfaces/TrapezoidBounds.hpp
+++ b/Core/include/ACTS/Surfaces/TrapezoidBounds.hpp
@@ -62,10 +62,10 @@ public:
///
/// @param trabo are the source bounds for assignment
TrapezoidBounds(const TrapezoidBounds& trabo)
- : PlanarBounds(trabo),
- m_boundingBox(0.,0.)
- {}
-
+ : PlanarBounds(trabo), m_boundingBox(0., 0.)
+ {
+ }
+
/// Destructor
virtual ~TrapezoidBounds();
@@ -192,9 +192,9 @@ public:
/// Return the vertices - or, the points of the extremas
virtual const std::vector<Vector2D>
vertices() const final;
-
+
// Bounding box representation
- virtual const RectangleBounds&
+ virtual const RectangleBounds&
boundingBox() const final;
/// Output Method for std::ostream
@@ -250,10 +250,9 @@ private:
isAbove(const Vector2D& lpos, double tol0, double tol1, double k, double d)
const;
- TDD_real_t m_alpha; ///< private cache of angle alpha
- TDD_real_t m_beta; ///< private cache of angle beta
- RectangleBounds m_boundingBox; ///< internal bounding box cache
-
+ TDD_real_t m_alpha; ///< private cache of angle alpha
+ TDD_real_t m_beta; ///< private cache of angle beta
+ RectangleBounds m_boundingBox; ///< internal bounding box cache
};
inline TrapezoidBounds*
@@ -401,12 +400,11 @@ TrapezoidBounds::vertices() const
return vertices;
}
-inline const RectangleBounds&
+inline const RectangleBounds&
TrapezoidBounds::boundingBox() const
{
return m_boundingBox;
-}
-
+}
} // end of namespace
diff --git a/Core/include/ACTS/Surfaces/TriangleBounds.hpp b/Core/include/ACTS/Surfaces/TriangleBounds.hpp
index 65de69e35..18b24d37f 100644
--- a/Core/include/ACTS/Surfaces/TriangleBounds.hpp
+++ b/Core/include/ACTS/Surfaces/TriangleBounds.hpp
@@ -53,10 +53,10 @@ public:
///
/// @param tribo are the source bounds for assignment
TriangleBounds(const TriangleBounds& tribo)
- : PlanarBounds(tribo)
- , m_boundingBox(0.,0.)
- {}
-
+ : PlanarBounds(tribo), m_boundingBox(0., 0.)
+ {
+ }
+
/// Destructor
virtual ~TriangleBounds();
@@ -76,7 +76,7 @@ public:
{
return SurfaceBounds::Triangle;
}
-
+
/// This method checks if the provided local coordinates are inside the
/// surface bounds
///
@@ -118,10 +118,10 @@ public:
/// This method returns the coordinates of vertices
const std::vector<Vector2D>
vertices() const final;
-
+
// Bounding box representation
- virtual const RectangleBounds&
- boundingBox() const final;
+ virtual const RectangleBounds&
+ boundingBox() const final;
/// Output Method for std::ostream
///
@@ -139,9 +139,8 @@ private:
/// @return boolean indicator for the success of this operation
bool
inside(const Vector2D& lpos, double tol0, double tol1) const;
-
- RectangleBounds m_boundingBox; ///< internal bounding box cache
+ RectangleBounds m_boundingBox; ///< internal bounding box cache
};
inline TriangleBounds*
@@ -269,7 +268,7 @@ TriangleBounds::vertices() const
return vertices;
}
-inline const RectangleBounds&
+inline const RectangleBounds&
TriangleBounds::boundingBox() const
{
return m_boundingBox;
diff --git a/Core/include/ACTS/Utilities/BinUtility.hpp b/Core/include/ACTS/Utilities/BinUtility.hpp
index 1ff293de3..8195651d1 100644
--- a/Core/include/ACTS/Utilities/BinUtility.hpp
+++ b/Core/include/ACTS/Utilities/BinUtility.hpp
@@ -337,21 +337,20 @@ public:
/// Serialize the bin triple
/// - this creates a simple size_t from a triple object
- ///
+ ///
/// @param bin is the bin to be serialized
size_t
- serialize(const std::array<size_t, 3>& bin) const
+ serialize(const std::array<size_t, 3>& bin) const
{
size_t serializedBin = bin[0];
if (m_binningData.size() == 2) {
- serializedBin += bin[1]*m_binningData[0].bins();
- } else if (m_binningData.size() == 3){
- serializedBin += (bin[1]*m_binningData[0].bins()
- *bin[2]*m_binningData[1].bins());
+ serializedBin += bin[1] * m_binningData[0].bins();
+ } else if (m_binningData.size() == 3) {
+ serializedBin += (bin[1] * m_binningData[0].bins() * bin[2]
+ * m_binningData[1].bins());
}
return bin[0];
-
- }
+ }
/// Output Method for std::ostream, to be overloaded by child classes
///
diff --git a/Core/include/ACTS/Utilities/Definitions.hpp b/Core/include/ACTS/Utilities/Definitions.hpp
index fd0c8e7a5..2d55b6d45 100644
--- a/Core/include/ACTS/Utilities/Definitions.hpp
+++ b/Core/include/ACTS/Utilities/Definitions.hpp
@@ -22,7 +22,6 @@
#include <Eigen/Dense>
#pragma GCC diagnostic pop
-
#ifdef TRKDETDESCR_USEFLOATPRECISON
typedef float TDD_real_t;
#else
diff --git a/Core/include/ACTS/Utilities/GeometryID.hpp b/Core/include/ACTS/Utilities/GeometryID.hpp
index 9bbd34b4c..40df154f6 100644
--- a/Core/include/ACTS/Utilities/GeometryID.hpp
+++ b/Core/include/ACTS/Utilities/GeometryID.hpp
@@ -31,9 +31,8 @@ namespace Acts {
class GeometryID
{
-
-public:
+public:
const static geo_id_value volume_mask = 0xff00000000000000;
const static geo_id_value boundary_mask = 0x00ff000000000000;
const static geo_id_value layer_mask = 0x0000ff0000000000;
@@ -115,8 +114,7 @@ private:
inline geo_id_value
GeometryID::value(geo_id_value mask) const
{
- if (mask)
- return ACTS_BIT_DECODE(m_value, mask);
+ if (mask) return ACTS_BIT_DECODE(m_value, mask);
return m_value;
}
diff --git a/Core/include/ACTS/Utilities/Helpers.hpp b/Core/include/ACTS/Utilities/Helpers.hpp
index 2b79a988d..4f9616213 100644
--- a/Core/include/ACTS/Utilities/Helpers.hpp
+++ b/Core/include/ACTS/Utilities/Helpers.hpp
@@ -24,16 +24,16 @@
#ifndef ACTS_BIT_CODING
#define ACTS_BIT_CODING 1
-#define ACTS_BIT_SHIFT(mask) (__builtin_ffsl(mask)-1)
+#define ACTS_BIT_SHIFT(mask) (__builtin_ffsl(mask) - 1)
#define ACTS_BIT_ENCODE(value, mask) (value << ACTS_BIT_SHIFT(mask))
#define ACTS_BIT_DECODE(code, mask) ((code & mask) >> ACTS_BIT_SHIFT(mask))
-#endif
+#endif
/** Geometry primitives helper functions
*/
namespace Acts {
-
+
/** EventPrimitvesToStringConverter
inline methods for conversion of EventPrimitives (Matrix)
diff --git a/Core/include/ACTS/Utilities/Identifier.hpp b/Core/include/ACTS/Utilities/Identifier.hpp
index bb30d0568..8e0406f9b 100644
--- a/Core/include/ACTS/Utilities/Identifier.hpp
+++ b/Core/include/ACTS/Utilities/Identifier.hpp
@@ -86,9 +86,13 @@ public:
operator=(value_type value);
///----------------------------------------------------------------
- /// Cast operators to value @todo to bool
- operator value_type() const { return m_id; }
- value_type value() const { return m_id; }
+ /// Cast operators to value @todo to bool
+ operator value_type() const { return m_id; }
+ value_type
+ value() const
+ {
+ return m_id;
+ }
///----------------------------------------------------------------
/// Comparison operators
diff --git a/Core/src/Detector/TrackingGeometry.cpp b/Core/src/Detector/TrackingGeometry.cpp
index 81459b885..2dedb9f99 100644
--- a/Core/src/Detector/TrackingGeometry.cpp
+++ b/Core/src/Detector/TrackingGeometry.cpp
@@ -23,9 +23,8 @@ Acts::TrackingGeometry::TrackingGeometry(TrackingVolumePtr highestVolume)
{
// create the GeometryID for this
GeometryID geoID(0);
- // close up the geometry
- if (m_world)
- m_world->closeGeometry(geoID, m_trackingVolumes);
+ // close up the geometry
+ if (m_world) m_world->closeGeometry(geoID, m_trackingVolumes);
}
Acts::TrackingGeometry::~TrackingGeometry()
@@ -48,7 +47,7 @@ const Acts::DetachedVolumeVector*
Acts::TrackingGeometry::lowestDetachedTrackingVolumes(const Vector3D& gp) const
{
double tol = 0.001;
- const TrackingVolume* currentVolume = lowestStaticTrackingVolume(gp);
+ const TrackingVolume* currentVolume = lowestStaticTrackingVolume(gp);
if (currentVolume) return currentVolume->detachedTrackingVolumes(gp, tol);
return nullptr;
}
diff --git a/Core/src/Detector/TrackingVolume.cpp b/Core/src/Detector/TrackingVolume.cpp
index 8e9c40884..bb984a605 100644
--- a/Core/src/Detector/TrackingVolume.cpp
+++ b/Core/src/Detector/TrackingVolume.cpp
@@ -414,7 +414,7 @@ Acts::TrackingVolume::interlinkLayers()
{
if (m_confinedLayers) {
auto& layers = m_confinedLayers->arrayObjects();
-
+
// forward register the last one as the previous one
// first <- | -> second, first <- | -> second, first <- | -> second
const Layer* lastLayer = nullptr;
@@ -446,15 +446,13 @@ Acts::TrackingVolume::closeGeometry(
// insert the volume into the map
volumeMap[volumeName()] = this;
-
-
// A) this is NOT a container volume, volumeID is already incremented
if (!m_confinedVolumes) {
// assign the Volume ID to the volume itself
assignGeoID(volumeID);
// loop over the boundary surfaces
geo_id_value iboundary = 0;
- // loop over the boundary surfaces
+ // loop over the boundary surfaces
for (auto& bSurfIter : boundarySurfaces()) {
// get the intersection soltuion
auto& bSurface = bSurfIter->surfaceRepresentation();
diff --git a/Core/src/Digitization/CartesianSegmentation.cpp b/Core/src/Digitization/CartesianSegmentation.cpp
index 01a3780c2..1195189c5 100644
--- a/Core/src/Digitization/CartesianSegmentation.cpp
+++ b/Core/src/Digitization/CartesianSegmentation.cpp
@@ -21,11 +21,12 @@ Acts::CartesianSegmentation::CartesianSegmentation(
size_t numCellsY)
: m_activeBounds(mBounds), m_binUtility(nullptr)
{
- m_binUtility = std::make_shared<BinUtility>(numCellsX,
- -mBounds->boundingBox().halflengthX(),
- mBounds->boundingBox().halflengthX(),
- Acts::open,
- Acts::binX);
+ m_binUtility
+ = std::make_shared<BinUtility>(numCellsX,
+ -mBounds->boundingBox().halflengthX(),
+ mBounds->boundingBox().halflengthX(),
+ Acts::open,
+ Acts::binX);
(*m_binUtility) += BinUtility(numCellsY,
-mBounds->boundingBox().halflengthY(),
mBounds->boundingBox().halflengthY(),
@@ -34,7 +35,7 @@ Acts::CartesianSegmentation::CartesianSegmentation(
}
Acts::CartesianSegmentation::CartesianSegmentation(
- std::shared_ptr<BinUtility> bUtility,
+ std::shared_ptr<BinUtility> bUtility,
std::shared_ptr<const PlanarBounds> mBounds)
: m_activeBounds(mBounds), m_binUtility(bUtility)
{
@@ -67,8 +68,9 @@ Acts::CartesianSegmentation::createSegmentationSurfaces(
// there are some things to consider
// - they share the RectangleBounds only if the lorentzAngle is 0
// otherwise only the readout surface has full length bounds like the module
- std::shared_ptr<const PlanarBounds> moduleBounds(new RectangleBounds(
- m_activeBounds->boundingBox().halflengthX(), m_activeBounds->boundingBox().halflengthY()));
+ std::shared_ptr<const PlanarBounds> moduleBounds(
+ new RectangleBounds(m_activeBounds->boundingBox().halflengthX(),
+ m_activeBounds->boundingBox().halflengthY()));
// - they are separated by half a thickness in z
auto readoutPlaneTransform
= std::make_shared<Transform3D>(Transform3D::Identity());
@@ -88,8 +90,8 @@ Acts::CartesianSegmentation::createSegmentationSurfaces(
= Vector3D(0., 0., -readoutDirection * halfThickness);
} else {
// lorentz reduced Bounds
- double lorentzReducedHalfX
- = m_activeBounds->boundingBox().halflengthX() - fabs(lorentzPlaneShiftX);
+ double lorentzReducedHalfX = m_activeBounds->boundingBox().halflengthX()
+ - fabs(lorentzPlaneShiftX);
std::shared_ptr<const PlanarBounds> lorentzReducedBounds(
new RectangleBounds(lorentzReducedHalfX,
m_activeBounds->boundingBox().halflengthY()));
@@ -109,12 +111,13 @@ Acts::CartesianSegmentation::createSegmentationSurfaces(
// (B) - bin X and lorentz surfaces
// -----------------------------------------------------------
// easy stuff first, constant pitch size and
- double pitchX = 2. * m_activeBounds->boundingBox().halflengthX() / m_binUtility->bins(0);
+ double pitchX = 2. * m_activeBounds->boundingBox().halflengthX()
+ / m_binUtility->bins(0);
// now, let's create the shared bounds of all surfaces marking x bins - choice
// fixes orientation of the matrix
- std::shared_ptr<const PlanarBounds> xBinBounds(
- new RectangleBounds(m_activeBounds->boundingBox().halflengthY(), halfThickness));
+ std::shared_ptr<const PlanarBounds> xBinBounds(new RectangleBounds(
+ m_activeBounds->boundingBox().halflengthY(), halfThickness));
// now, let's create the shared bounds of all surfaces marking lorentz planes
double lorentzPlaneHalfX = std::abs(halfThickness / cos(lorentzAngle));
// teh bounds of the lorentz plane
@@ -140,7 +143,8 @@ Acts::CartesianSegmentation::createSegmentationSurfaces(
// create and fill them
for (size_t ibinx = 0; ibinx <= m_binUtility->bins(0); ++ibinx) {
// the current step x position
- double cPosX = -m_activeBounds->boundingBox().halflengthX() + ibinx * pitchX;
+ double cPosX
+ = -m_activeBounds->boundingBox().halflengthX() + ibinx * pitchX;
// (i) this is the low/high boundary --- ( ibin == 0/m_binUtility->bins(0) )
if (!ibinx || ibinx == m_binUtility->bins(0)) {
// check if it a straight boundary or not: always straight for no lorentz
@@ -190,16 +194,18 @@ Acts::CartesianSegmentation::createSegmentationSurfaces(
yBinRotationMatrix.col(1) = Vector3D::UnitZ();
yBinRotationMatrix.col(2) = Vector3D(0., -1., 0.);
// easy stuff first, constant pitch in Y
- double pitchY = 2. * m_activeBounds->boundingBox().halflengthY() / m_binUtility->bins(1);
+ double pitchY = 2. * m_activeBounds->boundingBox().halflengthY()
+ / m_binUtility->bins(1);
// let's create the shared bounds of all surfaces marking y bins
- std::shared_ptr<const PlanarBounds> yBinBounds(
- new RectangleBounds(m_activeBounds->boundingBox().halflengthX(), halfThickness));
+ std::shared_ptr<const PlanarBounds> yBinBounds(new RectangleBounds(
+ m_activeBounds->boundingBox().halflengthX(), halfThickness));
// reserve, it's always (number of bins-1) as the boundaries are within the
// boundarySurfaces
segmentationSurfacesY.reserve(m_binUtility->bins(1));
for (size_t ibiny = 0; ibiny <= m_binUtility->bins(1); ++ibiny) {
// the position of the bin surface
- double binPosY = -m_activeBounds->boundingBox().halflengthY() + ibiny * pitchY;
+ double binPosY
+ = -m_activeBounds->boundingBox().halflengthY() + ibiny * pitchY;
Vector3D binSurfaceCenter(0., binPosY, 0.);
// the binning transform
auto binTransform = std::make_shared<Transform3D>(
diff --git a/Core/src/Digitization/PlanarModuleStepper.cpp b/Core/src/Digitization/PlanarModuleStepper.cpp
index eb4d281ac..8e3757bd9 100644
--- a/Core/src/Digitization/PlanarModuleStepper.cpp
+++ b/Core/src/Digitization/PlanarModuleStepper.cpp
@@ -16,12 +16,10 @@
#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Utilities/Intersection.hpp"
-Acts::PlanarModuleStepper::PlanarModuleStepper(const Config& pmsConfig,
- std::unique_ptr<Logger> mlogger)
- : m_cfg(pmsConfig)
- , m_logger(std::move(mlogger))
+Acts::PlanarModuleStepper::PlanarModuleStepper(const Config& pmsConfig,
+ std::unique_ptr<Logger> mlogger)
+ : m_cfg(pmsConfig), m_logger(std::move(mlogger))
{
-
}
std::vector<Acts::DigitizationStep>
@@ -84,7 +82,7 @@ Acts::PlanarModuleStepper::cellSteps(const Acts::DigitizationModule& dmodule,
{
// first, intersect the boundary surfaces
auto boundarySurfaces = dmodule.boundarySurfaces();
- // intersect them - fast exit for cases where
+ // intersect them - fast exit for cases where
// readout and counter readout are hit
Vector3D intersection3D(moduleIntersection.x(), moduleIntersection.y(), 0.);
size_t attempts = 0;
@@ -127,7 +125,8 @@ Acts::PlanarModuleStepper::cellSteps(const Acts::DigitizationModule& dmodule,
boundaryIntersections.erase(boundaryIntersections.begin());
}
// if for some reason the intersection does not work
- if (!boundaryIntersections.size()) return std::vector<Acts::DigitizationStep>();
+ if (!boundaryIntersections.size())
+ return std::vector<Acts::DigitizationStep>();
// return
return cellSteps(dmodule,
boundaryIntersections[0].position,
diff --git a/Core/src/Digitization/PolarSegmentation.cpp b/Core/src/Digitization/PolarSegmentation.cpp
index 600b0d90b..8cf721d4f 100644
--- a/Core/src/Digitization/PolarSegmentation.cpp
+++ b/Core/src/Digitization/PolarSegmentation.cpp
@@ -178,11 +178,13 @@ Acts::TrapezoidSegmentation::cellPosition(const DigitizationCell& dCell) const
projectLocX(Vector2D(dCell.channel0, dCell.channel1)))
: 0.;
double bY
- = m_binsY > 1 ? m_binUtility->binningData()[1].center(dCell.channel1) : 0.;
+ = m_binsY > 1 ? m_binUtility->binningData()[1].center(dCell.channel1) :
+0.;
return Vector2D(bX, bY);
}
-// Get the digitization cell from 3D position, it used the projection to the readout surface to estimate the 2D positon
+// Get the digitization cell from 3D position, it used the projection to the
+readout surface to estimate the 2D positon
const Acts::DigitizationStep
Acts::TrapezoidSegmentation::digitizationStep(const Vector3D& startStep,
const Vector3D& endStep,
diff --git a/Core/src/Extrapolation/MaterialEffectsEngine.cpp b/Core/src/Extrapolation/MaterialEffectsEngine.cpp
index bb905b3b5..d6a92fa44 100644
--- a/Core/src/Extrapolation/MaterialEffectsEngine.cpp
+++ b/Core/src/Extrapolation/MaterialEffectsEngine.cpp
@@ -62,15 +62,14 @@ Acts::MaterialEffectsEngine::handleMaterial(
const Surface& mSurface = eCell.leadParameters->referenceSurface();
// go on if you have material associated
if (mSurface.associatedMaterial()) {
- EX_MSG_DEBUG(
+ EX_MSG_DEBUG(
++eCell.navigationStep,
"layer",
mSurface.geoID().value(GeometryID::layer_mask),
"handleMaterial for neutral parameters called - collect material.");
// path correction
- double pathCorrection
- = fabs(mSurface.pathCorrection(eCell.leadParameters->position(),
- eCell.leadParameters->momentum()));
+ double pathCorrection = fabs(mSurface.pathCorrection(
+ eCell.leadParameters->position(), eCell.leadParameters->momentum()));
// screen output
EX_MSG_VERBOSE(eCell.navigationStep,
"layer",
@@ -115,16 +114,17 @@ Acts::MaterialEffectsEngine::handleMaterial(
PropDirection dir,
MaterialUpdateStage matupstage) const
{
-
+
// parameters are the lead parameters
// by definition the material surface is the one the parametrs are on
const Surface& mSurface = eCell.leadParameters->referenceSurface();
- // go on if you have material to deal with
+ // go on if you have material to deal with
if (mSurface.associatedMaterial()) {
- EX_MSG_DEBUG(++eCell.navigationStep,
- "layer",
- mSurface.geoID().value(GeometryID::layer_mask),
- "handleMaterial for charged parameters called - apply correction.");
+ EX_MSG_DEBUG(
+ ++eCell.navigationStep,
+ "layer",
+ mSurface.geoID().value(GeometryID::layer_mask),
+ "handleMaterial for charged parameters called - apply correction.");
// update the track parameters
updateTrackParameters(*eCell.leadParameters, eCell, dir, matupstage);
}
@@ -136,9 +136,9 @@ Acts::MaterialEffectsEngine::handleMaterial(
void
Acts::MaterialEffectsEngine::updateTrackParameters(
const TrackParameters& parameters,
- ExCellCharged& eCell,
- PropDirection dir,
- MaterialUpdateStage matupstage) const
+ ExCellCharged& eCell,
+ PropDirection dir,
+ MaterialUpdateStage matupstage) const
{
// parameters are the lead parameters
// by definition the material surface is the one the parametrs are on
@@ -147,8 +147,8 @@ Acts::MaterialEffectsEngine::updateTrackParameters(
if (!mSurface.associatedMaterial()) return;
// path correction
- double pathCorrection = fabs(mSurface.pathCorrection(
- parameters.position(), parameters.momentum()));
+ double pathCorrection = fabs(
+ mSurface.pathCorrection(parameters.position(), parameters.momentum()));
// screen output
EX_MSG_VERBOSE(eCell.navigationStep,
@@ -159,8 +159,9 @@ Acts::MaterialEffectsEngine::updateTrackParameters(
const MaterialProperties* materialProperties
= mSurface.associatedMaterial()->material(parameters.position());
// check if anything should be done
- bool corrConfig = (m_cfg.eLossCorrection || m_cfg.mscCorrection ||
- eCell.checkConfigurationMode(ExtrapolationMode::CollectMaterial));
+ bool corrConfig
+ = (m_cfg.eLossCorrection || m_cfg.mscCorrection
+ || eCell.checkConfigurationMode(ExtrapolationMode::CollectMaterial));
// and let's check if there's acutally something to do
if (materialProperties && corrConfig) {
// and add them
@@ -185,7 +186,7 @@ Acts::MaterialEffectsEngine::updateTrackParameters(
if (m_cfg.eLossCorrection) {
double sigmaP = 0.;
double kazl = 0.;
- // dE/dl ionization energy loss per path unit
+ // dE/dl ionization energy loss per path unit
double dEdl = sign * dir
* m_interactionFormulae.dEdl_ionization(
p, &material, eCell.particleType, sigmaP, kazl);
@@ -202,7 +203,7 @@ Acts::MaterialEffectsEngine::updateTrackParameters(
}
// (B) - update the covariance if needed
if (uCovariance && m_cfg.mscCorrection) {
- // multiple scattering as function of dInX0
+ // multiple scattering as function of dInX0
double sigmaMS = m_interactionFormulae.sigmaMS(
thicknessInX0 * pathCorrection, p, beta);
double sinTheta = sin(parameters.parameters()[eTHETA]);
@@ -228,15 +229,15 @@ Acts::MaterialEffectsEngine::updateTrackParameters(
"layer",
mSurface.geoID().value(GeometryID::layer_mask),
"material update on initial parameters, creating new ones.");
- // these are newly created
- auto stepParameters = std::make_unique<const BoundParameters>(
- std::move(uCovariance), uParameters, mSurface);
- // this should change the leadParameters to the new stepParameters
- eCell.step(std::move(stepParameters), ExtrapolationMode::CollectMaterial);
+ // these are newly created
+ auto stepParameters = std::make_unique<const BoundParameters>(
+ std::move(uCovariance), uParameters, mSurface);
+ // this should change the leadParameters to the new stepParameters
+ eCell.step(std::move(stepParameters), ExtrapolationMode::CollectMaterial);
}
- // check if material filling was requested,
- // then fill it into the extrapolation cache
+ // check if material filling was requested,
+ // then fill it into the extrapolation cache
if (eCell.checkConfigurationMode(ExtrapolationMode::CollectMaterial)) {
EX_MSG_VERBOSE(eCell.navigationStep,
"layer",
diff --git a/Core/src/Surfaces/DiamondBounds.cpp b/Core/src/Surfaces/DiamondBounds.cpp
index 8762bf437..e29c47055 100644
--- a/Core/src/Surfaces/DiamondBounds.cpp
+++ b/Core/src/Surfaces/DiamondBounds.cpp
@@ -23,20 +23,19 @@ Acts::DiamondBounds::DiamondBounds(double minhalex,
: PlanarBounds(DiamondBounds::bv_length)
, m_alpha1(0.)
, m_alpha2(0.)
- , m_boundingBox(0.,0.)
+ , m_boundingBox(0., 0.)
{
m_valueStore.at(DiamondBounds::bv_minHalfX) = minhalex;
m_valueStore.at(DiamondBounds::bv_medHalfX) = medhalex;
m_valueStore.at(DiamondBounds::bv_maxHalfX) = maxhalex;
m_valueStore.at(DiamondBounds::bv_halfY1) = haley1;
m_valueStore.at(DiamondBounds::bv_halfY2) = haley2;
- double mx = minhalex > medhalex ?
- ( minhalex > maxhalex ? minhalex : maxhalex ) :
- ( medhalex > maxhalex ? medhalex : maxhalex );
+ double mx = minhalex > medhalex ? (minhalex > maxhalex ? minhalex : maxhalex)
+ : (medhalex > maxhalex ? medhalex : maxhalex);
double my = haley1 > haley2 ? haley1 : haley2;
// the boundary box is being set
- m_boundingBox = RectangleBounds(mx,my);
- // init the cache
+ m_boundingBox = RectangleBounds(mx, my);
+ // init the cache
initCache();
}
@@ -73,8 +72,7 @@ Acts::DiamondBounds::operator==(const SurfaceBounds& sbo) const
// fast exit
if (&sbo == this) return true;
// check the type first not to compare apples with oranges
- const DiamondBounds* diabo
- = dynamic_cast<const DiamondBounds*>(&sbo);
+ const DiamondBounds* diabo = dynamic_cast<const DiamondBounds*>(&sbo);
if (!diabo) return false;
return (m_valueStore == diabo->m_valueStore);
}
@@ -95,7 +93,7 @@ Acts::DiamondBounds::insideFull(const Vector2D& locpo,
double tol1) const
{
// @todo updat with bounding box
-
+
// the cases:
// (0)
if (!m_valueStore.at(DiamondBounds::bv_halfY1)
diff --git a/Core/src/Surfaces/EllipseBounds.cpp b/Core/src/Surfaces/EllipseBounds.cpp
index c82b11cfc..8b0945a36 100644
--- a/Core/src/Surfaces/EllipseBounds.cpp
+++ b/Core/src/Surfaces/EllipseBounds.cpp
@@ -21,8 +21,7 @@ Acts::EllipseBounds::EllipseBounds(double minradX,
double maxradY,
double avephi,
double hphisec)
- : PlanarBounds(EllipseBounds::bv_length),
- m_boundingBox(0.,0.)
+ : PlanarBounds(EllipseBounds::bv_length), m_boundingBox(0., 0.)
{
m_valueStore.at(EllipseBounds::bv_rMinX) = minradX;
m_valueStore.at(EllipseBounds::bv_rMinY) = minradY;
@@ -30,10 +29,9 @@ Acts::EllipseBounds::EllipseBounds(double minradX,
m_valueStore.at(EllipseBounds::bv_rMaxY) = maxradY;
m_valueStore.at(EllipseBounds::bv_averagePhi) = avephi;
m_valueStore.at(EllipseBounds::bv_halfPhiSector) = hphisec;
- double mx = minradX > maxradX ? minradX : maxradX;
- double my = minradY > maxradY ? minradY : maxradY;
- m_boundingBox = RectangleBounds(mx,my);
-
+ double mx = minradX > maxradX ? minradX : maxradX;
+ double my = minradY > maxradY ? minradY : maxradY;
+ m_boundingBox = RectangleBounds(mx, my);
}
Acts::EllipseBounds::~EllipseBounds()
@@ -45,7 +43,7 @@ Acts::EllipseBounds::operator=(const EllipseBounds& ebo)
{
if (this != &ebo) {
PlanarBounds::operator=(ebo);
- m_boundingBox = ebo.m_boundingBox;
+ m_boundingBox = ebo.m_boundingBox;
}
return *this;
}
diff --git a/Core/src/Surfaces/TrapezoidBounds.cpp b/Core/src/Surfaces/TrapezoidBounds.cpp
index 4b08c27bc..e9bb3a425 100644
--- a/Core/src/Surfaces/TrapezoidBounds.cpp
+++ b/Core/src/Surfaces/TrapezoidBounds.cpp
@@ -21,17 +21,18 @@ Acts::TrapezoidBounds::TrapezoidBounds(double minhalex,
: PlanarBounds(TrapezoidBounds::bv_length)
, m_alpha(0.)
, m_beta(0.)
- , m_boundingBox(0.,0.)
+ , m_boundingBox(0., 0.)
{
m_valueStore.at(TrapezoidBounds::bv_minHalfX) = std::abs(minhalex);
m_valueStore.at(TrapezoidBounds::bv_maxHalfX) = std::abs(maxhalex);
m_valueStore.at(TrapezoidBounds::bv_halfY) = std::abs(haley);
- // find the maximum at for the bounding box
- double mx = m_valueStore.at(TrapezoidBounds::bv_minHalfX) >
- m_valueStore.at(TrapezoidBounds::bv_maxHalfX) ?
- m_valueStore.at(TrapezoidBounds::bv_minHalfX) :
- m_valueStore.at(TrapezoidBounds::bv_maxHalfX);
- m_boundingBox = RectangleBounds(mx, m_valueStore.at(TrapezoidBounds::bv_halfY));
+ // find the maximum at for the bounding box
+ double mx = m_valueStore.at(TrapezoidBounds::bv_minHalfX)
+ > m_valueStore.at(TrapezoidBounds::bv_maxHalfX)
+ ? m_valueStore.at(TrapezoidBounds::bv_minHalfX)
+ : m_valueStore.at(TrapezoidBounds::bv_maxHalfX);
+ m_boundingBox
+ = RectangleBounds(mx, m_valueStore.at(TrapezoidBounds::bv_halfY));
}
Acts::TrapezoidBounds::TrapezoidBounds(double minhalex,
@@ -41,7 +42,7 @@ Acts::TrapezoidBounds::TrapezoidBounds(double minhalex,
: PlanarBounds(TrapezoidBounds::bv_length)
, m_alpha(alpha)
, m_beta(beta)
- , m_boundingBox(0.,0.)
+ , m_boundingBox(0., 0.)
{
double gamma = (alpha > beta) ? (alpha - 0.5 * M_PI) : (beta - 0.5 * M_PI);
// now fill them
@@ -50,11 +51,12 @@ Acts::TrapezoidBounds::TrapezoidBounds(double minhalex,
+ (2. * m_valueStore.at(TrapezoidBounds::bv_halfY)) * tan(gamma);
m_valueStore.at(TrapezoidBounds::bv_halfY) = std::abs(haley);
// find the maximum for the bounding box
- double mx = m_valueStore.at(TrapezoidBounds::bv_minHalfX) >
- m_valueStore.at(TrapezoidBounds::bv_maxHalfX) ?
- m_valueStore.at(TrapezoidBounds::bv_minHalfX) :
- m_valueStore.at(TrapezoidBounds::bv_maxHalfX);
- m_boundingBox = RectangleBounds(mx, m_valueStore.at(TrapezoidBounds::bv_halfY));
+ double mx = m_valueStore.at(TrapezoidBounds::bv_minHalfX)
+ > m_valueStore.at(TrapezoidBounds::bv_maxHalfX)
+ ? m_valueStore.at(TrapezoidBounds::bv_minHalfX)
+ : m_valueStore.at(TrapezoidBounds::bv_maxHalfX);
+ m_boundingBox
+ = RectangleBounds(mx, m_valueStore.at(TrapezoidBounds::bv_halfY));
}
Acts::TrapezoidBounds::~TrapezoidBounds()
diff --git a/Core/src/Surfaces/TriangleBounds.cpp b/Core/src/Surfaces/TriangleBounds.cpp
index 17e2174cb..9b1d521cd 100644
--- a/Core/src/Surfaces/TriangleBounds.cpp
+++ b/Core/src/Surfaces/TriangleBounds.cpp
@@ -15,16 +15,15 @@
#include <iostream>
Acts::TriangleBounds::TriangleBounds(const std::vector<Vector2D>& vertices)
- : PlanarBounds()
- , m_boundingBox(0.,0.)
+ : PlanarBounds(), m_boundingBox(0., 0.)
{
m_valueStore.reserve(6);
double mx, my = 0.;
for (auto& v : vertices) {
m_valueStore.push_back(v.x());
m_valueStore.push_back(v.y());
- mx = (fabs(v.x()) > mx)? fabs(v.x()) : mx;
- my = (fabs(v.y()) > my)? fabs(v.y()) : my;
+ mx = (fabs(v.x()) > mx) ? fabs(v.x()) : mx;
+ my = (fabs(v.y()) > my) ? fabs(v.y()) : my;
}
m_boundingBox = RectangleBounds(mx, my);
}
@@ -38,7 +37,7 @@ Acts::TriangleBounds::operator=(const TriangleBounds& tribo)
{
if (this != &tribo) {
PlanarBounds::operator=(tribo);
- m_boundingBox = tribo.m_boundingBox;
+ m_boundingBox = tribo.m_boundingBox;
}
return *this;
}
diff --git a/Examples/include/ACTS/Examples/GenericDetectorElement.hpp b/Examples/include/ACTS/Examples/GenericDetectorElement.hpp
index d1b6f2f44..bbb388e30 100644
--- a/Examples/include/ACTS/Examples/GenericDetectorElement.hpp
+++ b/Examples/include/ACTS/Examples/GenericDetectorElement.hpp
@@ -96,10 +96,10 @@ public:
/// Return the DigitizationModule
/// @return optionally the DigitizationModule
std::shared_ptr<const DigitizationModule>
- digitizationModule() const final;
+ digitizationModule() const final;
/// Set the identifier after construction (sometimes needed)
- virtual void
+ virtual void
assignIdentifier(const Identifier& identifier) const final;
/// The maximal thickness of the detector element wrt normal axis
@@ -132,11 +132,11 @@ inline std::shared_ptr<const DigitizationModule>
GenericDetectorElement::digitizationModule() const
{
return m_digitizationModule;
-}
+}
-inline void
+inline void
GenericDetectorElement::assignIdentifier(const Identifier& identifier) const
-{
+{
m_elementIdentifier = identifier;
}
diff --git a/Examples/include/ACTS/Examples/GenericLayerBuilder.hpp b/Examples/include/ACTS/Examples/GenericLayerBuilder.hpp
index 4dcc7ed4e..0a905b014 100644
--- a/Examples/include/ACTS/Examples/GenericLayerBuilder.hpp
+++ b/Examples/include/ACTS/Examples/GenericLayerBuilder.hpp
@@ -113,7 +113,7 @@ public:
/// the central volume readout schema
std::vector<std::vector<size_t>> posnegModuleReadoutBinsY;
/// the central volume readout schema
- std::vector<std::vector<int>> posnegModuleReadoutSide;
+ std::vector<std::vector<int>> posnegModuleReadoutSide;
/// the central volume readout schema
std::vector<std::vector<double>> posnegModuleLorentzAngle;
/// the module material @todo change to surface material
diff --git a/Examples/src/BuildGenericDetector.cpp b/Examples/src/BuildGenericDetector.cpp
index 33be0a2ec..4bff97233 100644
--- a/Examples/src/BuildGenericDetector.cpp
+++ b/Examples/src/BuildGenericDetector.cpp
@@ -68,7 +68,7 @@ buildGenericDetector(Logging::Level surfaceLLevel,
// get the geometry
auto trackingGeometry = cylinderGeometryBuilder->trackingGeometry();
// let's assign the identifiers
- // @todo recursive stepping through geometry with identifier assignment
+ // @todo recursive stepping through geometry with identifier assignment
return std::move(trackingGeometry);
}
diff --git a/Examples/src/GenericDetector.ipp b/Examples/src/GenericDetector.ipp
index 632158bf2..6a6d99f63 100644
--- a/Examples/src/GenericDetector.ipp
+++ b/Examples/src/GenericDetector.ipp
@@ -119,15 +119,15 @@ if (stage == 0) {
plbConfig.posnegLayerMaterialConcentration = {1};
plbConfig.posnegLayerMaterialProperties = {pcmProperties};
plbConfig.posnegModuleMinHalfX = {{8.4}};
- plbConfig.posnegModuleMaxHalfX = {};
- plbConfig.posnegModuleHalfY = {{42.}};
- plbConfig.posnegModulePhiBins = {{48}};
- plbConfig.posnegModuleThickness = {{0.15}};
- plbConfig.posnegModuleReadoutBinsX = {{336}};
- plbConfig.posnegModuleReadoutBinsY = {{1680}};
- plbConfig.posnegModuleReadoutSide = {{-1}};
- plbConfig.posnegModuleLorentzAngle = {{0.12}};
- plbConfig.posnegModuleMaterial = {{pcMaterial}};
+ plbConfig.posnegModuleMaxHalfX = {};
+ plbConfig.posnegModuleHalfY = {{42.}};
+ plbConfig.posnegModulePhiBins = {{48}};
+ plbConfig.posnegModuleThickness = {{0.15}};
+ plbConfig.posnegModuleReadoutBinsX = {{336}};
+ plbConfig.posnegModuleReadoutBinsY = {{1680}};
+ plbConfig.posnegModuleReadoutSide = {{-1}};
+ plbConfig.posnegModuleLorentzAngle = {{0.12}};
+ plbConfig.posnegModuleMaterial = {{pcMaterial}};
} else {
// STAGE > 0 - pixel endcap detector
// configure the endcaps
@@ -137,10 +137,10 @@ if (stage == 0) {
plbConfig.posnegLayerMaterialConcentration = {1, 1, 1, 1};
plbConfig.posnegLayerMaterialProperties
= {pcmProperties, pcmProperties, pcmProperties, pcmProperties};
- plbConfig.posnegModuleMinHalfX = {{8.4}, {8.4}, {8.4}, {8.4}};
- plbConfig.posnegModuleMaxHalfX = {};
- plbConfig.posnegModuleHalfY = {{42.}, {42.}, {42.}, {42.}};
- plbConfig.posnegModulePhiBins = {{48}, {48}, {48}, {48}};
+ plbConfig.posnegModuleMinHalfX = {{8.4}, {8.4}, {8.4}, {8.4}};
+ plbConfig.posnegModuleMaxHalfX = {};
+ plbConfig.posnegModuleHalfY = {{42.}, {42.}, {42.}, {42.}};
+ plbConfig.posnegModulePhiBins = {{48}, {48}, {48}, {48}};
plbConfig.posnegModuleThickness = {{0.15}, {0.15}, {0.15}, {0.15}};
plbConfig.posnegModuleReadoutBinsX = {{336}, {336}, {336}, {336}};
plbConfig.posnegModuleReadoutBinsY = {{1680}, {1680}, {1680}, {1680}};
@@ -202,7 +202,7 @@ if (stage > 1) {
pstConfig.centralLayerHalflengthZ = std::vector<double>(1, 1200.);
pstConfig.centralLayerThickness = std::vector<double>(1, 1.8);
pstConfig.centralLayerMaterial = {Material(352.8, 407., 9.012, 4., 1.848e-3)};
- auto pstBuilder = std::make_shared<PassiveLayerBuilder>(
+ auto pstBuilder = std::make_shared<PassiveLayerBuilder>(
pstConfig, getDefaultLogger("PstBuilder", layerLLevel));
// create the volume for the beam pipe
CylinderVolumeBuilder::Config pstvolConfig;
@@ -241,16 +241,16 @@ if (stage > 1) {
sslbConfig.centralLayerMaterialProperties
= {ssmProperties, ssmProperties, ssmProperties};
sslbConfig.centralModuleBinningSchema = {{42, 12}, {64, 12}, {84, 12}};
- sslbConfig.centralModuleTiltPhi = {-0.15, -0.15, -0.15};
- sslbConfig.centralModuleHalfX = {18.2, 18.2, 18.2};
- sslbConfig.centralModuleHalfY = {68., 68., 68.};
- sslbConfig.centralModuleThickness = {0.25, 0.25, 0.25};
-
- sslbConfig.centralModuleReadoutBinsX = { 728, 728, 728 }; // 50 um pitch
- sslbConfig.centralModuleReadoutBinsY = { 85, 85, 85 }; // 1.6 mm strixels
- sslbConfig.centralModuleReadoutSide = { 1, 1, 1};
- sslbConfig.centralModuleLorentzAngle = { 0.12, 0.12, 0.12 };
-
+ sslbConfig.centralModuleTiltPhi = {-0.15, -0.15, -0.15};
+ sslbConfig.centralModuleHalfX = {18.2, 18.2, 18.2};
+ sslbConfig.centralModuleHalfY = {68., 68., 68.};
+ sslbConfig.centralModuleThickness = {0.25, 0.25, 0.25};
+
+ sslbConfig.centralModuleReadoutBinsX = {728, 728, 728}; // 50 um pitch
+ sslbConfig.centralModuleReadoutBinsY = {85, 85, 85}; // 1.6 mm strixels
+ sslbConfig.centralModuleReadoutSide = {1, 1, 1};
+ sslbConfig.centralModuleLorentzAngle = {0.12, 0.12, 0.12};
+
sslbConfig.centralModuleMaterial
= {ssMaterial, ssMaterial, ssMaterial, ssMaterial};
sslbConfig.centralModuleFrontsideStereo = {-0.02, -0.02, -0.02};
@@ -269,17 +269,17 @@ if (stage > 1) {
}
sslbConfig.centralModulePositions = centralModulePositions;
- // configure the endcaps
- std::vector<double> mrMinHx = { 16.4, 24.2, 32.2 };
- std::vector<double> mrMaxHx = { 24.2, 32.2, 40.0 };
- std::vector<double> mrHy = { 48., 48., 48. };
-
+ // configure the endcaps
+ std::vector<double> mrMinHx = {16.4, 24.2, 32.2};
+ std::vector<double> mrMaxHx = {24.2, 32.2, 40.0};
+ std::vector<double> mrHy = {48., 48., 48.};
+
// simplified strixels readout
- std::vector<size_t> mrReadoutBinsX = { 968 , 1288, 1600}; // 50 um pitch
- std::vector<size_t> mrReadoutBinsY = { 60, 60, 60 }; // 1.6 mm strixels
- std::vector<int> mrReadoutSide = { 1, 1, 1 };
- std::vector<double> mrLorentzAngle = { 0., 0., 0. };
-
+ std::vector<size_t> mrReadoutBinsX = {968, 1288, 1600}; // 50 um pitch
+ std::vector<size_t> mrReadoutBinsY = {60, 60, 60}; // 1.6 mm strixels
+ std::vector<int> mrReadoutSide = {1, 1, 1};
+ std::vector<double> mrLorentzAngle = {0., 0., 0.};
+
std::vector<int> mPhiBins = {42, 58, 72};
std::vector<double> mThickness = {0.2, 0.2, 0.2};
std::vector<Material> mMaterial = {ssMaterial, ssMaterial, ssMaterial};
@@ -304,7 +304,7 @@ if (stage > 1) {
= std::vector<std::vector<int>>(nposnegs, mPhiBins);
sslbConfig.posnegModuleThickness
= std::vector<std::vector<double>>(nposnegs, mThickness);
-
+
sslbConfig.posnegModuleReadoutBinsX
= std::vector<std::vector<size_t>>(nposnegs, mrReadoutBinsX);
sslbConfig.posnegModuleReadoutBinsY
@@ -313,8 +313,7 @@ if (stage > 1) {
= std::vector<std::vector<int>>(nposnegs, mrReadoutSide);
sslbConfig.posnegModuleLorentzAngle
= std::vector<std::vector<double>>(nposnegs, mrLorentzAngle);
-
-
+
sslbConfig.posnegModuleMaterial
= std::vector<std::vector<Material>>(nposnegs, mMaterial);
sslbConfig.posnegModuleFrontsideStereo
@@ -389,12 +388,12 @@ if (stage > 2) {
lslbConfig.centralModuleThickness = {0.25, 0.25, 0.25};
lslbConfig.centralModuleMaterial
= {lsMaterial, lsMaterial, lsMaterial, lsMaterial};
-
- lslbConfig.centralModuleReadoutBinsX = { 840, 840 }; // 100 um pitch
- lslbConfig.centralModuleReadoutBinsY = { 2, 2 }; //2 strips
- lslbConfig.centralModuleReadoutSide = { 1, 1 };
- lslbConfig.centralModuleLorentzAngle = { 0.08, 0.08 };
-
+
+ lslbConfig.centralModuleReadoutBinsX = {840, 840}; // 100 um pitch
+ lslbConfig.centralModuleReadoutBinsY = {2, 2}; // 2 strips
+ lslbConfig.centralModuleReadoutSide = {1, 1};
+ lslbConfig.centralModuleLorentzAngle = {0.08, 0.08};
+
lslbConfig.centralModuleFrontsideStereo = {-0.02, -0.02};
lslbConfig.centralModuleBacksideStereo = {0.02, 0.02};
lslbConfig.centralModuleBacksideGap = {2., 2.};
@@ -422,11 +421,10 @@ if (stage > 2) {
std::vector<double> mbStereo = {0.02, 0.02, 0.02};
std::vector<double> mfbGap = {4., 4., 4.};
- std::vector<size_t> mrReadoutBinsX = { 1120 , 1120, 1120}; // 100 um pitch
- std::vector<size_t> mrReadoutBinsY = { 2, 2, 2 }; // 2 strips
- std::vector<int> mrReadoutSide = { 1, 1, 1 };
- std::vector<double> mrLorentzAngle = { 0., 0., 0. };
-
+ std::vector<size_t> mrReadoutBinsX = {1120, 1120, 1120}; // 100 um pitch
+ std::vector<size_t> mrReadoutBinsY = {2, 2, 2}; // 2 strips
+ std::vector<int> mrReadoutSide = {1, 1, 1};
+ std::vector<double> mrLorentzAngle = {0., 0., 0.};
// endcap
lslbConfig.posnegLayerBinMultipliers = {1, 2};
@@ -446,7 +444,7 @@ if (stage > 2) {
= std::vector<std::vector<int>>(nposnegs, mPhiBins);
lslbConfig.posnegModuleThickness
= std::vector<std::vector<double>>(nposnegs, mThickness);
-
+
lslbConfig.posnegModuleReadoutBinsX
= std::vector<std::vector<size_t>>(nposnegs, mrReadoutBinsX);
lslbConfig.posnegModuleReadoutBinsY
@@ -454,8 +452,8 @@ if (stage > 2) {
lslbConfig.posnegModuleReadoutSide
= std::vector<std::vector<int>>(nposnegs, mrReadoutSide);
lslbConfig.posnegModuleLorentzAngle
- = std::vector<std::vector<double>>(nposnegs, mrLorentzAngle);
-
+ = std::vector<std::vector<double>>(nposnegs, mrLorentzAngle);
+
lslbConfig.posnegModuleMaterial
= std::vector<std::vector<Material>>(nposnegs, mMaterial);
lslbConfig.posnegModuleFrontsideStereo
diff --git a/Examples/src/GenericDetectorElement.cpp b/Examples/src/GenericDetectorElement.cpp
index 10bf56e1a..5194c7801 100644
--- a/Examples/src/GenericDetectorElement.cpp
+++ b/Examples/src/GenericDetectorElement.cpp
@@ -17,11 +17,11 @@
#include "ACTS/Surfaces/PlaneSurface.hpp"
Acts::GenericDetectorElement::GenericDetectorElement(
- const Identifier identifier,
- std::shared_ptr<Transform3D> transform,
- std::shared_ptr<const PlanarBounds> pBounds,
- double thickness,
- std::shared_ptr<const SurfaceMaterial> material,
+ const Identifier identifier,
+ std::shared_ptr<Transform3D> transform,
+ std::shared_ptr<const PlanarBounds> pBounds,
+ double thickness,
+ std::shared_ptr<const SurfaceMaterial> material,
std::shared_ptr<const DigitizationModule> dModule)
: DetectorElementBase()
, m_elementIdentifier(std::move(identifier))
diff --git a/Examples/src/GenericLayerBuilder.cpp b/Examples/src/GenericLayerBuilder.cpp
index b29e143cb..d51a1b540 100644
--- a/Examples/src/GenericLayerBuilder.cpp
+++ b/Examples/src/GenericLayerBuilder.cpp
@@ -13,6 +13,8 @@
#include "ACTS/Examples/GenericLayerBuilder.hpp"
#include <iostream>
#include "ACTS/Detector/DetectorElementBase.hpp"
+#include "ACTS/Digitization/CartesianSegmentation.hpp"
+#include "ACTS/Digitization/DigitizationModule.hpp"
#include "ACTS/Examples/GenericDetectorElement.hpp"
#include "ACTS/Material/HomogeneousSurfaceMaterial.hpp"
#include "ACTS/Material/Material.hpp"
@@ -27,8 +29,6 @@
#include "ACTS/Utilities/BinUtility.hpp"
#include "ACTS/Utilities/BinnedArray.hpp"
#include "ACTS/Utilities/Helpers.hpp"
-#include "ACTS/Digitization/CartesianSegmentation.hpp"
-#include "ACTS/Digitization/DigitizationModule.hpp"
Acts::GenericLayerBuilder::GenericLayerBuilder(
const Acts::GenericLayerBuilder::Config& glbConfig,
@@ -310,14 +310,15 @@ Acts::GenericLayerBuilder::constructLayers()
// create the bounds
PlanarBounds* pBounds = nullptr;
if (moduleMaxHalfX != 0. && moduleMinHalfX != moduleMaxHalfX)
- pBounds = new TrapezoidBounds(
- moduleMinHalfX, moduleMaxHalfX, moduleHalfY);
+ pBounds = new TrapezoidBounds(
+ moduleMinHalfX, moduleMaxHalfX, moduleHalfY);
else
- pBounds = new RectangleBounds(moduleMinHalfX, moduleHalfY);
+ pBounds = new RectangleBounds(moduleMinHalfX, moduleHalfY);
// now create the shared bounds from it
std::shared_ptr<const PlanarBounds> moduleBounds(pBounds);
// (2) create digitizaiton module
- std::shared_ptr<const DigitizationModule> moduleDigitizationPtr = nullptr;
+ std::shared_ptr<const DigitizationModule> moduleDigitizationPtr
+ = nullptr;
if (m_cfg.posnegModuleReadoutBinsX.size()) {
// create the CartesianSegmentation
std::shared_ptr<const Segmentation> moduleSegmentation
diff --git a/Plugins/TGeoPlugins/include/ACTS/Plugins/TGeoPlugins/TGeoDetectorElement.hpp b/Plugins/TGeoPlugins/include/ACTS/Plugins/TGeoPlugins/TGeoDetectorElement.hpp
index bde3a2ef9..148843fee 100644
--- a/Plugins/TGeoPlugins/include/ACTS/Plugins/TGeoPlugins/TGeoDetectorElement.hpp
+++ b/Plugins/TGeoPlugins/include/ACTS/Plugins/TGeoPlugins/TGeoDetectorElement.hpp
@@ -97,7 +97,7 @@ public:
/// Set the identifier after construction (sometimes needed)
virtual void
assignIdentifier(const Identifier& identifier) const final;
-
+
/// Return surface associated with this identifier, which should come from the
virtual const Surface&
surface(const Identifier& identifier = Identifier()) const final;
@@ -141,9 +141,9 @@ TGeoDetectorElement::identify() const
inline void
TGeoDetectorElement::assignIdentifier(const Identifier& identifier) const
{
- m_identifier = identifier;
+ m_identifier = identifier;
}
-
+
inline const Transform3D&
TGeoDetectorElement::transform(const Identifier&) const
{
diff --git a/Tests/Detector/TrackingGeometry_closeGeometry_tests.cpp b/Tests/Detector/TrackingGeometry_closeGeometry_tests.cpp
index e8adcbc70..ffad79bc6 100644
--- a/Tests/Detector/TrackingGeometry_closeGeometry_tests.cpp
+++ b/Tests/Detector/TrackingGeometry_closeGeometry_tests.cpp
@@ -9,8 +9,8 @@
/// Boost include(s)
#define BOOST_TEST_MODULE GeometryID Tests
#include <boost/test/included/unit_test.hpp>
-#include "ACTS/Utilities/Units.hpp"
#include "ACTS/Utilities/Helpers.hpp"
+#include "ACTS/Utilities/Units.hpp"
#include "GeometryCreation.hpp"
namespace Acts {
@@ -120,7 +120,8 @@ namespace Test {
// id
geo_id_value asf_vol_id = asf->geoID().value(GeometryID::volume_mask);
geo_id_value asf_lay_id = asf->geoID().value(GeometryID::layer_mask);
- geo_id_value asf_asf_id = asf->geoID().value(GeometryID::approach_mask);
+ geo_id_value asf_asf_id
+ = asf->geoID().value(GeometryID::approach_mask);
BOOST_CHECK_EQUAL(layer_id, asf_lay_id);
BOOST_CHECK_EQUAL(c_vol_id, asf_vol_id);
BOOST_CHECK_EQUAL(++asurface_id, asf_asf_id);
@@ -132,7 +133,8 @@ namespace Test {
// id
geo_id_value ssf_vol_id = ssf->geoID().value(GeometryID::volume_mask);
geo_id_value ssf_lay_id = ssf->geoID().value(GeometryID::layer_mask);
- geo_id_value ssf_ssf_id = ssf->geoID().value(GeometryID::sensitive_mask);
+ geo_id_value ssf_ssf_id
+ = ssf->geoID().value(GeometryID::sensitive_mask);
BOOST_CHECK_EQUAL(layer_id, ssf_lay_id);
BOOST_CHECK_EQUAL(c_vol_id, ssf_vol_id);
BOOST_CHECK_EQUAL(++ssurface_id, ssf_ssf_id);
diff --git a/Tests/Utilities/GeometryID_tests.cpp b/Tests/Utilities/GeometryID_tests.cpp
index 3fa6046c6..aa35c752e 100644
--- a/Tests/Utilities/GeometryID_tests.cpp
+++ b/Tests/Utilities/GeometryID_tests.cpp
@@ -9,8 +9,8 @@
// Boost include(s)
#define BOOST_TEST_MODULE GeometryID Tests
#include "ACTS/Utilities/GeometryID.hpp"
-#include "ACTS/Utilities/Helpers.hpp"
#include <boost/test/included/unit_test.hpp>
+#include "ACTS/Utilities/Helpers.hpp"
namespace Acts {
namespace Test {
--
GitLab