From c6db44c64c5ee12b60e13a8f52b9a10f67bc1a2e Mon Sep 17 00:00:00 2001
From: cgumpert <christian.gumpert@cern.ch>
Date: Mon, 6 Jun 2016 00:03:35 +0200
Subject: [PATCH] reformat Core headers
---
.../ACTS/Detector/DetachedTrackingVolume.hpp | 268 ++--
.../ACTS/Detector/DetectorElementBase.hpp | 222 ++--
.../Detector/GenericApproachDescriptor.hpp | 198 +--
.../Detector/GenericOverlapDescriptor.hpp | 76 +-
.../ACTS/Detector/GlueVolumesDescriptor.hpp | 107 +-
.../ACTS/Detector/TrackingGeometry.hpp | 177 +--
Core/include/ACTS/Detector/TrackingVolume.hpp | 998 ++++++++------
Core/include/ACTS/EventData/ChargePolicy.hpp | 216 ++--
Core/include/ACTS/EventData/Measurement.hpp | 490 +++----
.../ACTS/EventData/NeutralParameters.hpp | 20 +-
Core/include/ACTS/EventData/ParameterSet.hpp | 956 ++++++++------
.../ACTS/EventData/ParticleDefinitions.hpp | 688 +++++-----
.../EventData/SingleBoundTrackParameters.hpp | 284 ++--
.../SingleCurvilinearTrackParameters.hpp | 200 +--
.../ACTS/EventData/SingleTrackParameters.hpp | 403 +++---
.../ACTS/EventData/TrackParameters.hpp | 17 +-
.../ACTS/EventData/TrackParametersBase.hpp | 351 ++---
.../ACTS/EventData/TransportJacobian.hpp | 86 +-
.../ACTS/EventData/detail/are_sorted.hpp | 124 +-
.../ACTS/EventData/detail/are_within.hpp | 79 +-
.../detail/coordinate_transformations.hpp | 109 +-
.../detail/fittable_type_generator.hpp | 268 ++--
.../EventData/detail/full_parameter_set.hpp | 97 +-
.../ACTS/EventData/detail/get_position.hpp | 69 +-
.../detail/initialize_parameter_set.hpp | 121 +-
.../ACTS/EventData/detail/is_contained.hpp | 92 +-
.../detail/make_projection_matrix.hpp | 106 +-
.../EventData/detail/residual_calculator.hpp | 110 +-
.../ACTS/EventData/detail/value_corrector.hpp | 116 +-
.../ACTS/Extrapolation/ExtrapolationCell.hpp | 1138 +++++++++-------
.../Extrapolation/ExtrapolationEngine.hpp | 255 ++--
.../Extrapolation/IExtrapolationEngine.hpp | 80 +-
.../Extrapolation/IMaterialEffectsEngine.hpp | 81 +-
.../IMultipleScatteringUpdator.hpp | 64 +-
.../ACTS/Extrapolation/INavigationEngine.hpp | 77 +-
.../ACTS/Extrapolation/IPropagationEngine.hpp | 115 +-
.../Extrapolation/MaterialEffectsEngine.hpp | 193 +--
.../ACTS/Extrapolation/MaterialUpdateMode.hpp | 19 +-
.../ACTS/Extrapolation/RungeKuttaEngine.hpp | 552 ++++----
.../ACTS/Extrapolation/StaticEngine.hpp | 325 ++---
.../Extrapolation/StaticNavigationEngine.hpp | 226 ++--
.../detail/ExtrapolationEngine.ipp | 313 +++--
.../detail/ExtrapolationMacros.hpp | 80 +-
.../detail/MaterialInteraction.hpp | 402 +++---
.../detail/RealQuadraticEquation.hpp | 95 +-
.../Extrapolation/detail/RungeKuttaEngine.ipp | 211 +--
.../Extrapolation/detail/RungeKuttaUtils.hpp | 338 ++---
.../Extrapolation/detail/StaticEngine.ipp | 1006 +++++++++------
.../detail/StaticNavigationEngine.ipp | 545 +++++---
Core/include/ACTS/Layers/ConeLayer.hpp | 143 +-
Core/include/ACTS/Layers/CylinderLayer.hpp | 153 ++-
Core/include/ACTS/Layers/DiscLayer.hpp | 165 +--
Core/include/ACTS/Layers/Layer.hpp | 658 +++++-----
Core/include/ACTS/Layers/NavigationLayer.hpp | 183 +--
Core/include/ACTS/Layers/PlaneLayer.hpp | 152 ++-
.../ACTS/Layers/SubtractedCylinderLayer.hpp | 128 +-
.../ACTS/Layers/SubtractedPlaneLayer.hpp | 125 +-
Core/include/ACTS/Layers/detail/Layer.ipp | 307 +++--
.../ACTS/MagneticField/IMagneticFieldSvc.hpp | 51 +-
.../ACTS/Material/BinnedSurfaceMaterial.hpp | 232 ++--
.../Material/HomogeneousSurfaceMaterial.hpp | 180 +--
Core/include/ACTS/Material/Material.hpp | 417 +++---
.../ACTS/Material/MaterialProperties.hpp | 381 +++---
.../include/ACTS/Material/SurfaceMaterial.hpp | 194 +--
Core/include/ACTS/Surfaces/BoundaryCheck.hpp | 560 ++++----
Core/include/ACTS/Surfaces/ConeBounds.hpp | 476 ++++---
Core/include/ACTS/Surfaces/ConeSurface.hpp | 341 ++---
Core/include/ACTS/Surfaces/CylinderBounds.hpp | 411 +++---
.../include/ACTS/Surfaces/CylinderSurface.hpp | 362 +++---
Core/include/ACTS/Surfaces/DiamondBounds.hpp | 509 +++++---
Core/include/ACTS/Surfaces/DiscBounds.hpp | 50 +-
Core/include/ACTS/Surfaces/DiscSurface.hpp | 390 +++---
.../ACTS/Surfaces/DiscTrapezoidalBounds.hpp | 777 ++++++-----
Core/include/ACTS/Surfaces/EllipseBounds.hpp | 413 +++---
Core/include/ACTS/Surfaces/InvalidBounds.hpp | 135 +-
Core/include/ACTS/Surfaces/NoBounds.hpp | 190 +--
Core/include/ACTS/Surfaces/PerigeeSurface.hpp | 374 +++---
Core/include/ACTS/Surfaces/PlanarBounds.hpp | 56 +-
Core/include/ACTS/Surfaces/PlaneSurface.hpp | 305 +++--
Core/include/ACTS/Surfaces/RadialBounds.hpp | 609 +++++----
.../ACTS/Surfaces/RealQuadraticEquation.hpp | 95 +-
.../include/ACTS/Surfaces/RectangleBounds.hpp | 402 +++---
.../ACTS/Surfaces/SlidingCylinderSurface.hpp | 178 +--
.../ACTS/Surfaces/SlidingDiscSurface.hpp | 176 +--
.../ACTS/Surfaces/StraightLineSurface.hpp | 330 +++--
.../Surfaces/SubtractedCylinderSurface.hpp | 143 +-
.../ACTS/Surfaces/SubtractedDiscSurface.hpp | 131 +-
.../ACTS/Surfaces/SubtractedPlaneSurface.hpp | 129 +-
Core/include/ACTS/Surfaces/Surface.hpp | 734 ++++++-----
Core/include/ACTS/Surfaces/SurfaceBounds.hpp | 213 +--
.../include/ACTS/Surfaces/TrapezoidBounds.hpp | 581 +++++----
Core/include/ACTS/Surfaces/TriangleBounds.hpp | 393 +++---
.../ACTS/Tools/CylinderGeometryBuilder.hpp | 115 +-
.../ACTS/Tools/CylinderVolumeBuilder.hpp | 231 ++--
.../ACTS/Tools/CylinderVolumeHelper.hpp | 337 ++---
.../include/ACTS/Tools/ILayerArrayCreator.hpp | 72 +-
Core/include/ACTS/Tools/ILayerBuilder.hpp | 74 +-
Core/include/ACTS/Tools/ILayerCreator.hpp | 100 +-
.../ACTS/Tools/ISurfaceArrayCreator.hpp | 84 +-
.../ACTS/Tools/ITrackingGeometryBuilder.hpp | 56 +-
.../Tools/ITrackingVolumeArrayCreator.hpp | 71 +-
.../ACTS/Tools/ITrackingVolumeBuilder.hpp | 83 +-
.../ACTS/Tools/ITrackingVolumeHelper.hpp | 235 ++--
Core/include/ACTS/Tools/LayerArrayCreator.hpp | 133 +-
Core/include/ACTS/Tools/LayerCreator.hpp | 182 +--
.../ACTS/Tools/PassiveLayerBuilder.hpp | 217 ++--
.../ACTS/Tools/SurfaceArrayCreator.hpp | 181 +--
.../ACTS/Tools/TrackingVolumeArrayCreator.hpp | 103 +-
.../ACTS/Utilities/ApproachDescriptor.hpp | 79 +-
Core/include/ACTS/Utilities/AreaExcluder.hpp | 40 +-
Core/include/ACTS/Utilities/BinStepping.hpp | 28 +-
Core/include/ACTS/Utilities/BinUtility.hpp | 552 ++++----
Core/include/ACTS/Utilities/BinnedArray.hpp | 77 +-
Core/include/ACTS/Utilities/BinnedArray0D.hpp | 130 +-
Core/include/ACTS/Utilities/BinnedArray1D.hpp | 192 +--
Core/include/ACTS/Utilities/BinnedArray2D.hpp | 250 ++--
Core/include/ACTS/Utilities/BinningData.hpp | 1149 +++++++++--------
Core/include/ACTS/Utilities/BinningType.hpp | 41 +-
Core/include/ACTS/Utilities/Definitions.hpp | 214 ++-
Core/include/ACTS/Utilities/GeometryID.hpp | 110 +-
.../include/ACTS/Utilities/GeometryObject.hpp | 133 +-
.../ACTS/Utilities/GeometryObjectSorter.hpp | 105 +-
.../ACTS/Utilities/GeometrySignature.hpp | 69 +-
.../ACTS/Utilities/GeometryStatics.hpp | 35 +-
Core/include/ACTS/Utilities/Helpers.hpp | 522 ++++----
Core/include/ACTS/Utilities/Identifier.hpp | 241 ++--
Core/include/ACTS/Utilities/Intersection.hpp | 184 ++-
Core/include/ACTS/Utilities/Logger.hpp | 460 ++++---
Core/include/ACTS/Utilities/MsgMacros.hpp | 4 +-
.../ACTS/Utilities/OverlapDescriptor.hpp | 79 +-
.../ACTS/Utilities/ParameterDefinitions.hpp | 45 +-
.../include/ACTS/Utilities/ParameterTypes.hpp | 246 ++--
.../Utilities/detail/DefaultMsgMacros.hpp | 15 +-
.../detail/DefaultParameterDefinitions.hpp | 121 +-
.../Utilities/detail/MatrixBasePlugin.hpp | 236 ++--
.../ACTS/Utilities/detail/MatrixPlugin.hpp | 479 +++----
.../ACTS/Utilities/detail/TransformPlugin.hpp | 84 +-
Core/include/ACTS/Volumes/AbstractVolume.hpp | 93 +-
.../Volumes/BevelledCylinderVolumeBounds.hpp | 570 ++++----
.../ACTS/Volumes/BoundaryCylinderSurface.hpp | 192 +--
.../ACTS/Volumes/BoundaryDiscSurface.hpp | 145 ++-
.../ACTS/Volumes/BoundaryPlaneSurface.hpp | 142 +-
.../BoundarySubtractedCylinderSurface.hpp | 185 +--
.../BoundarySubtractedPlaneSurface.hpp | 147 ++-
Core/include/ACTS/Volumes/BoundarySurface.hpp | 246 ++--
.../ACTS/Volumes/BoundarySurfaceFace.hpp | 112 +-
.../ACTS/Volumes/CombinedVolumeBounds.hpp | 155 ++-
.../ACTS/Volumes/CuboidVolumeBounds.hpp | 253 ++--
.../ACTS/Volumes/CylinderVolumeBounds.hpp | 424 +++---
.../Volumes/DoubleTrapezoidVolumeBounds.hpp | 375 +++---
.../ACTS/Volumes/PrismVolumeBounds.hpp | 176 +--
.../Volumes/SimplePolygonBrepVolumeBounds.hpp | 294 +++--
.../ACTS/Volumes/SubtractedVolumeBounds.hpp | 144 ++-
.../ACTS/Volumes/TrapezoidVolumeBounds.hpp | 343 +++--
Core/include/ACTS/Volumes/Volume.hpp | 139 +-
Core/include/ACTS/Volumes/VolumeBounds.hpp | 113 +-
Core/include/ACTS/Volumes/VolumeExcluder.hpp | 77 +-
157 files changed, 21752 insertions(+), 16862 deletions(-)
diff --git a/Core/include/ACTS/Detector/DetachedTrackingVolume.hpp b/Core/include/ACTS/Detector/DetachedTrackingVolume.hpp
index 2eeed37ba..fa17a6607 100644
--- a/Core/include/ACTS/Detector/DetachedTrackingVolume.hpp
+++ b/Core/include/ACTS/Detector/DetachedTrackingVolume.hpp
@@ -24,121 +24,157 @@
// Core module
namespace Acts {
-
- class TrackingVolume;
- class Surface;
-
- typedef std::vector< LayerPtr > LayerVector;
-
- // master typedefs
- class DetachedTrackingVolume;
- typedef std::shared_ptr<const DetachedTrackingVolume> DetachedTrackingVolumePtr;
- typedef std::shared_ptr< const TrackingVolume> TrackingVolumePtr;
-
- /**
- @class DetachedTrackingVolume
-
- Base Class for a navigation object (active/passive) in the Tracking geometry.
-
-
- */
-
- class DetachedTrackingVolume {
-
- /** Declare the IDetachedTrackingVolumeBuilder as a friend, to be able to change the volumelink */
- friend class TrackingVolume;
- friend class DetachedTrackingVolumeBuilder;
- friend class IDetachedTrackingVolumeBuilder;
-
- public:
- /** Factory Constructor */
- static DetachedTrackingVolumePtr create(const std::string& name,
- TrackingVolumePtr vol,
- LayerPtr layer = nullptr,
- LayerVector multiLayer = {})
- { return DetachedTrackingVolumePtr(new DetachedTrackingVolume(name,vol,layer,multiLayer)); }
-
- /** Destructor*/
- ~DetachedTrackingVolume();
-
- /** returns the TrackingVolume */
- const TrackingVolume* trackingVolume() const;
-
- /** returns the Name */
- const std::string name() const;
-
- /** moving object around */
- void move( Transform3D& shift) const;
-
- /** clone with shift */
- DetachedTrackingVolumePtr clone( std::string name, Transform3D& shift) const;
-
- /** returns layer representation */
- const Layer* layerRepresentation() const;
-
- /** returns (multi)layer representation */
- const LayerVector multilayerRepresentation() const;
-
- /** sign the volume - the geometry builder has to do that */
- void sign(GeometrySignature signat, GeometryType geotype) const;
-
- /** return the Signature */
- GeometrySignature geometrySignature() const;
-
- /** return the Type */
- GeometryType geometryType() const;
-
- /** set the simplified calculable components */
- void saveConstituents(std::vector<std::pair<const Acts::Volume*,float> >* ) const;
-
- /** get the simplified calculable components */
- std::vector<std::pair<const Acts::Volume*,float> >* constituents() const;
-
- /** alignment methods: set base transform / default argument to current transform */
- void setBaseTransform( Transform3D* transf=0 ) const;
-
- /** alignment methods: realign / default argument to base transform */
- void realign( Transform3D* transf=0 ) const;
-
- protected:
- /**Default Constructor*/
- DetachedTrackingVolume();
-
- /**Constructor with name & layer representation*/
- DetachedTrackingVolume(const std::string& name,
- TrackingVolumePtr vol,
- LayerPtr layer,
- std::vector< LayerPtr > multilayer);
-
-
- private:
-
- const std::string m_name;
- TrackingVolumePtr m_trkVolume;
- LayerPtr m_layerRepresentation;
- std::vector< LayerPtr > m_multilayerRepresentation;
- mutable Transform3D* m_baseTransform; // optional use (for alignment purpose)
- mutable std::vector<std::pair<const Acts::Volume*,float> >* m_constituents;
-
-
- };
-
-inline const TrackingVolume* DetachedTrackingVolume::trackingVolume() const { return m_trkVolume.get(); }
-
-inline const std::string DetachedTrackingVolume::name() const { return (m_name); }
-
-inline const Layer* DetachedTrackingVolume::layerRepresentation() const { return m_layerRepresentation.get(); }
-
-inline const LayerVector DetachedTrackingVolume::multilayerRepresentation() const { return m_multilayerRepresentation; }
-
-inline void DetachedTrackingVolume::saveConstituents(std::vector<std::pair<const Acts::Volume*,float> >* constituents ) const { m_constituents = constituents; }
-
-inline std::vector<std::pair<const Acts::Volume*,float> >* DetachedTrackingVolume::constituents() const
- { return m_constituents;}
-
-} // end of namespace
-
-#endif // ACTS_DETECTOR_DETACHEDTRACKINGVOLUME_H
-
+class TrackingVolume;
+class Surface;
+
+typedef std::vector<LayerPtr> LayerVector;
+// master typedefs
+class DetachedTrackingVolume;
+typedef std::shared_ptr<const DetachedTrackingVolume> DetachedTrackingVolumePtr;
+typedef std::shared_ptr<const TrackingVolume> TrackingVolumePtr;
+
+/**
+ @class DetachedTrackingVolume
+
+ Base Class for a navigation object (active/passive) in the Tracking geometry.
+
+
+ */
+
+class DetachedTrackingVolume
+{
+ /** Declare the IDetachedTrackingVolumeBuilder as a friend, to be able to
+ * change the volumelink */
+ friend class TrackingVolume;
+ friend class DetachedTrackingVolumeBuilder;
+ friend class IDetachedTrackingVolumeBuilder;
+
+public:
+ /** Factory Constructor */
+ static DetachedTrackingVolumePtr
+ create(const std::string& name,
+ TrackingVolumePtr vol,
+ LayerPtr layer = nullptr,
+ LayerVector multiLayer = {})
+ {
+ return DetachedTrackingVolumePtr(
+ new DetachedTrackingVolume(name, vol, layer, multiLayer));
+ }
+
+ /** Destructor*/
+ ~DetachedTrackingVolume();
+
+ /** returns the TrackingVolume */
+ const TrackingVolume*
+ trackingVolume() const;
+
+ /** returns the Name */
+ const std::string
+ name() const;
+
+ /** moving object around */
+ void
+ move(Transform3D& shift) const;
+
+ /** clone with shift */
+ DetachedTrackingVolumePtr
+ clone(std::string name, Transform3D& shift) const;
+
+ /** returns layer representation */
+ const Layer*
+ layerRepresentation() const;
+
+ /** returns (multi)layer representation */
+ const LayerVector
+ multilayerRepresentation() const;
+
+ /** sign the volume - the geometry builder has to do that */
+ void
+ sign(GeometrySignature signat, GeometryType geotype) const;
+
+ /** return the Signature */
+ GeometrySignature
+ geometrySignature() const;
+
+ /** return the Type */
+ GeometryType
+ geometryType() const;
+
+ /** set the simplified calculable components */
+ void
+ saveConstituents(std::vector<std::pair<const Acts::Volume*, float>>*) const;
+
+ /** get the simplified calculable components */
+ std::vector<std::pair<const Acts::Volume*, float>>*
+ constituents() const;
+
+ /** alignment methods: set base transform / default argument to current
+ * transform */
+ void
+ setBaseTransform(Transform3D* transf = 0) const;
+
+ /** alignment methods: realign / default argument to base transform */
+ void
+ realign(Transform3D* transf = 0) const;
+
+protected:
+ /**Default Constructor*/
+ DetachedTrackingVolume();
+
+ /**Constructor with name & layer representation*/
+ DetachedTrackingVolume(const std::string& name,
+ TrackingVolumePtr vol,
+ LayerPtr layer,
+ std::vector<LayerPtr> multilayer);
+
+private:
+ const std::string m_name;
+ TrackingVolumePtr m_trkVolume;
+ LayerPtr m_layerRepresentation;
+ std::vector<LayerPtr> m_multilayerRepresentation;
+ mutable Transform3D* m_baseTransform; // optional use (for alignment purpose)
+ mutable std::vector<std::pair<const Acts::Volume*, float>>* m_constituents;
+};
+
+inline const TrackingVolume*
+DetachedTrackingVolume::trackingVolume() const
+{
+ return m_trkVolume.get();
+}
+
+inline const std::string
+DetachedTrackingVolume::name() const
+{
+ return (m_name);
+}
+
+inline const Layer*
+DetachedTrackingVolume::layerRepresentation() const
+{
+ return m_layerRepresentation.get();
+}
+
+inline const LayerVector
+DetachedTrackingVolume::multilayerRepresentation() const
+{
+ return m_multilayerRepresentation;
+}
+
+inline void
+DetachedTrackingVolume::saveConstituents(
+ std::vector<std::pair<const Acts::Volume*, float>>* constituents) const
+{
+ m_constituents = constituents;
+}
+
+inline std::vector<std::pair<const Acts::Volume*, float>>*
+DetachedTrackingVolume::constituents() const
+{
+ return m_constituents;
+}
+
+} // end of namespace
+
+#endif // ACTS_DETECTOR_DETACHEDTRACKINGVOLUME_H
diff --git a/Core/include/ACTS/Detector/DetectorElementBase.hpp b/Core/include/ACTS/Detector/DetectorElementBase.hpp
index 96f46d55b..61acefc76 100644
--- a/Core/include/ACTS/Detector/DetectorElementBase.hpp
+++ b/Core/include/ACTS/Detector/DetectorElementBase.hpp
@@ -18,108 +18,134 @@
#else
// Algebra and Identifier
-#include "ACTS/Utilities/Identifier.hpp"
-#include "ACTS/Utilities/Definitions.hpp"
#include <memory>
#include <vector>
+#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Utilities/Identifier.hpp"
+
+namespace Acts {
+
+class Surface;
+class SurfaceBounds;
+
+/** @class DetectorElementBase
+
+ This is the base class for all tracking detector elements
+ with read-out relevant information.
+
+ If a DetectorElement has a second element (or even a triple setup)
+ that would naturally fall into the same bin, one can register that as a
+ binmember.
-namespace Acts
+ DetectorElements close by can be registered as neighbours as this will help
+ the navigation.
+
+
+ */
+
+class DetectorElementBase
+{
+public:
+ /** Constructor */
+ DetectorElementBase() {}
+ /** virtual Destructor */
+ virtual ~DetectorElementBase() {}
+ /** Identifier */
+ virtual Identifier
+ identify() const = 0;
+
+ /** Return local to global transform (optionally associated with an
+ * identifier) */
+ virtual const Transform3D&
+ transform(const Identifier& identifier = Identifier()) const = 0;
+
+ /** Return the surface associated with this detector element (optionally
+ * associated with an identifier) */
+ virtual const Surface&
+ surface(const Identifier& identifier = Identifier()) const = 0;
+
+ /** Return the surface bounds (optionally with an associated detector element)
+ */
+ virtual const SurfaceBounds&
+ bounds(const Identifier& identifier = Identifier()) const = 0;
+
+ /** Returns the full list of all detection surfaces associated to this
+ * detector element */
+ virtual const std::vector<std::shared_ptr<const Surface>>&
+ surfaces() const = 0;
+
+ /** Return the center of the element (optionally associated with an
+ * identifier) */
+ virtual const Vector3D&
+ center(const Identifier& identifier = Identifier()) const = 0;
+
+ /** Return the normal of the element (optionally associated with an
+ * identifier) */
+ virtual const Vector3D&
+ normal(const Identifier& identifier = Identifier()) const = 0;
+
+ /** Returns the thickness of the module */
+ virtual double
+ thickness() const = 0;
+
+ /** Bin members for fast access */
+ const std::vector<const DetectorElementBase*>&
+ binmembers() const;
+
+ /** Neighbours for fast access */
+ void
+ registerBinmembers(std::vector<const DetectorElementBase*>& binmembers) const;
+
+ /** Neighbours for fast access */
+ const std::vector<const DetectorElementBase*>&
+ neighbours() const;
+
+ /** Neighbours for fast access */
+ void
+ registerNeighbours(std::vector<const DetectorElementBase*>& neighbours) const;
+
+private:
+ mutable std::vector<const DetectorElementBase*> m_binmembers;
+ mutable std::vector<const DetectorElementBase*> m_neighbours;
+};
+
+inline const std::vector<const DetectorElementBase*>&
+DetectorElementBase::binmembers() const
{
+ return m_binmembers;
+}
- class Surface;
- class SurfaceBounds;
-
- /** @class DetectorElementBase
-
- This is the base class for all tracking detector elements
- with read-out relevant information.
-
- If a DetectorElement has a second element (or even a triple setup)
- that would naturally fall into the same bin, one can register that as a binmember.
-
- DetectorElements close by can be registered as neighbours as this will help
- the navigation.
-
-
- */
-
- class DetectorElementBase {
-
- public:
-
- /** Constructor */
- DetectorElementBase(){}
-
- /** virtual Destructor */
- virtual ~DetectorElementBase(){}
-
- /** Identifier */
- virtual Identifier identify() const = 0;
-
- /** Return local to global transform (optionally associated with an identifier) */
- virtual const Transform3D& transform(const Identifier& identifier = Identifier()) const = 0;
-
- /** Return the surface associated with this detector element (optionally associated with an identifier) */
- virtual const Surface& surface(const Identifier& identifier = Identifier()) const = 0;
-
- /** Return the surface bounds (optionally with an associated detector element) */
- virtual const SurfaceBounds& bounds(const Identifier& identifier = Identifier()) const = 0;
-
- /** Returns the full list of all detection surfaces associated to this detector element */
- virtual const std::vector< std::shared_ptr<const Surface> >& surfaces() const = 0;
-
- /** Return the center of the element (optionally associated with an identifier) */
- virtual const Vector3D& center(const Identifier& identifier = Identifier()) const = 0;
-
- /** Return the normal of the element (optionally associated with an identifier) */
- virtual const Vector3D& normal(const Identifier& identifier = Identifier()) const = 0;
-
- /** Returns the thickness of the module */
- virtual double thickness() const = 0;
-
- /** Bin members for fast access */
- const std::vector<const DetectorElementBase*>& binmembers() const;
-
- /** Neighbours for fast access */
- void registerBinmembers(std::vector<const DetectorElementBase*>& binmembers) const;
-
- /** Neighbours for fast access */
- const std::vector<const DetectorElementBase*>& neighbours() const;
-
- /** Neighbours for fast access */
- void registerNeighbours(std::vector<const DetectorElementBase*>& neighbours) const;
-
- private:
- mutable std::vector<const DetectorElementBase*> m_binmembers;
- mutable std::vector<const DetectorElementBase*> m_neighbours;
-
- };
-
- inline const std::vector<const DetectorElementBase*>& DetectorElementBase::binmembers() const { return m_binmembers; }
-
- inline const std::vector<const DetectorElementBase*>& DetectorElementBase::neighbours() const { return m_neighbours; }
-
-
- inline void DetectorElementBase::registerBinmembers(std::vector<const DetectorElementBase*>& binmembers) const
- {
- for (auto& bmember : binmembers){
- // only fill if it's not yet registered
- if (find(m_binmembers.begin(),m_binmembers.end(),bmember) == m_binmembers.end())
- m_binmembers.push_back(bmember);
- }
- }
-
- inline void DetectorElementBase::registerNeighbours(std::vector<const DetectorElementBase*>& neighbours) const
- {
- for (auto& neighbour : neighbours){
- // only fill if it's not yet registered
- if (find(m_neighbours.begin(),m_neighbours.end(),neighbour) == m_neighbours.end())
- m_neighbours.push_back(neighbour);
- }
- }
-
-
-}//end of ns
+inline const std::vector<const DetectorElementBase*>&
+DetectorElementBase::neighbours() const
+{
+ return m_neighbours;
+}
+
+inline void
+DetectorElementBase::registerBinmembers(
+ std::vector<const DetectorElementBase*>& binmembers) const
+{
+ for (auto& bmember : binmembers) {
+ // only fill if it's not yet registered
+ if (find(m_binmembers.begin(), m_binmembers.end(), bmember)
+ == m_binmembers.end())
+ m_binmembers.push_back(bmember);
+ }
+}
+
+inline void
+DetectorElementBase::registerNeighbours(
+ std::vector<const DetectorElementBase*>& neighbours) const
+{
+ for (auto& neighbour : neighbours) {
+ // only fill if it's not yet registered
+ if (find(m_neighbours.begin(), m_neighbours.end(), neighbour)
+ == m_neighbours.end())
+ m_neighbours.push_back(neighbour);
+ }
+}
+
+} // end of ns
#endif
-#endif // ACTS_GEOMETRY_DETELEMENT_PLUGIN
+#endif // ACTS_GEOMETRY_DETELEMENT_PLUGIN
diff --git a/Core/include/ACTS/Detector/GenericApproachDescriptor.hpp b/Core/include/ACTS/Detector/GenericApproachDescriptor.hpp
index 4655e9377..dbc24f70b 100644
--- a/Core/include/ACTS/Detector/GenericApproachDescriptor.hpp
+++ b/Core/include/ACTS/Detector/GenericApproachDescriptor.hpp
@@ -17,103 +17,109 @@
#include "ACTS/Utilities/ApproachDescriptor.hpp"
namespace Acts {
-
- /**
- @class GenericApproachDescriptor
-
- Class to decide and return which approaching surface to be taken,
- it's a generic descriptor for n surfaces
-
- It is templated in order to allow for BoundarySurfaces from
- representing volumes of layers to be re-used
-
- */
-
- template <class T> class GenericApproachDescriptor : public ApproachDescriptor {
-
- public:
- /** A generic approach descriptor for new Acts::Surface objects - passing ownership */
- GenericApproachDescriptor(const std::vector<T*>& aSurfaces) :
- ApproachDescriptor(),
- m_surfaces(),
- m_surfacesCache(aSurfaces)
- {
- // create the surface container with memory control
- for (auto& sf : (aSurfaces) )
- m_surfaces.push_back(std::shared_ptr<T>(sf));
- }
-
- /** A generic approach descriptor with shared surfaces to test - can not be used with Acts::Surfaces obejcts */
- GenericApproachDescriptor(std::vector< std::shared_ptr<T> > aSurfaces) :
- ApproachDescriptor(),
- m_surfaces(aSurfaces),
- m_surfacesCache()
- {
- m_surfacesCache.reserve(m_surfaces.size());
- // cache the surfaces
- for (auto& sf : (aSurfaces) )
- m_surfacesCache.push_back(&(sf->surfaceRepresentation()));
- }
-
- /** A generic approach descriptor with n surfaces to test */
- ~GenericApproachDescriptor()
- {}
-
- /** register the Layer to the surfaces */
- void registerLayer(const Layer& lay) override;
-
- /** get the compatible surfaces
- - return : a boolean indicating if an actual intersection had been tried
- - fill vector of intersections
- - primary bin surface : sf
- - position & direction : pos, dir */
- const SurfaceIntersection approachSurface(const Vector3D& pos,
- const Vector3D& dir,
- const BoundaryCheck& bchk,
- const ICompatibilityEstimator* ice = nullptr) const override;
-
- /* return all containes surfaces of this approach descriptor */
- const std::vector< const Surface* >& containedSurfaces() const override;
-
- private:
- std::vector< std::shared_ptr<T> > m_surfaces; //!< approach surfaces with ownership control
- std::vector< const Surface*> m_surfacesCache; //!< the surface container cache
-
- };
-
- template <class T> void GenericApproachDescriptor<T>::registerLayer(const Layer& lay) {
- // go through the surfaces
- for (auto& sf: (m_surfacesCache) )
- sf->associateLayer(lay);
- }
-
- template <class T> const SurfaceIntersection GenericApproachDescriptor<T>::approachSurface(const Vector3D& pos,
- const Vector3D& dir,
- const BoundaryCheck& bchk,
- const ICompatibilityEstimator*) const
- {
- // prepare the return surface
- Intersection sIntersection;
- const Surface* aSurface = nullptr;
- double aPathLength = 10e10;
- // get the surfaces
- for (auto& sfIter : m_surfacesCache){
- // get the intersection with the surface
- sIntersection = sfIter->intersectionEstimate(pos, dir, true, bchk);
- // validatie if it's ok and take the closest
- if (sIntersection.valid && sIntersection.pathLength < aPathLength){
- aPathLength = sIntersection.pathLength;
- aSurface = sfIter;
- }
- }
- // return what you have
- return SurfaceIntersection(sIntersection,aSurface,alongMomentum);
+
+/**
+ @class GenericApproachDescriptor
+
+ Class to decide and return which approaching surface to be taken,
+ it's a generic descriptor for n surfaces
+
+ It is templated in order to allow for BoundarySurfaces from
+ representing volumes of layers to be re-used
+
+*/
+
+template <class T>
+class GenericApproachDescriptor : public ApproachDescriptor
+{
+public:
+ /** A generic approach descriptor for new Acts::Surface objects - passing
+ * ownership */
+ GenericApproachDescriptor(const std::vector<T*>& aSurfaces)
+ : ApproachDescriptor(), m_surfaces(), m_surfacesCache(aSurfaces)
+ {
+ // create the surface container with memory control
+ for (auto& sf : (aSurfaces)) m_surfaces.push_back(std::shared_ptr<T>(sf));
+ }
+
+ /** A generic approach descriptor with shared surfaces to test - can not be
+ * used with Acts::Surfaces obejcts */
+ GenericApproachDescriptor(std::vector<std::shared_ptr<T>> aSurfaces)
+ : ApproachDescriptor(), m_surfaces(aSurfaces), m_surfacesCache()
+ {
+ m_surfacesCache.reserve(m_surfaces.size());
+ // cache the surfaces
+ for (auto& sf : (aSurfaces))
+ m_surfacesCache.push_back(&(sf->surfaceRepresentation()));
+ }
+
+ /** A generic approach descriptor with n surfaces to test */
+ ~GenericApproachDescriptor() {}
+ /** register the Layer to the surfaces */
+ void
+ registerLayer(const Layer& lay) override;
+
+ /** get the compatible surfaces
+ - return : a boolean indicating if an actual intersection had been tried
+ - fill vector of intersections
+ - primary bin surface : sf
+ - position & direction : pos, dir */
+ const SurfaceIntersection
+ approachSurface(const Vector3D& pos,
+ const Vector3D& dir,
+ const BoundaryCheck& bchk,
+ const ICompatibilityEstimator* ice = nullptr) const override;
+
+ /* return all containes surfaces of this approach descriptor */
+ const std::vector<const Surface*>&
+ containedSurfaces() const override;
+
+private:
+ std::vector<std::shared_ptr<T>>
+ m_surfaces; //!< approach surfaces with ownership control
+ std::vector<const Surface*> m_surfacesCache; //!< the surface container cache
+};
+
+template <class T>
+void
+GenericApproachDescriptor<T>::registerLayer(const Layer& lay)
+{
+ // go through the surfaces
+ for (auto& sf : (m_surfacesCache)) sf->associateLayer(lay);
+}
+
+template <class T>
+const SurfaceIntersection
+GenericApproachDescriptor<T>::approachSurface(
+ const Vector3D& pos,
+ const Vector3D& dir,
+ const BoundaryCheck& bchk,
+ const ICompatibilityEstimator*) const
+{
+ // prepare the return surface
+ Intersection sIntersection;
+ const Surface* aSurface = nullptr;
+ double aPathLength = 10e10;
+ // get the surfaces
+ for (auto& sfIter : m_surfacesCache) {
+ // get the intersection with the surface
+ sIntersection = sfIter->intersectionEstimate(pos, dir, true, bchk);
+ // validatie if it's ok and take the closest
+ if (sIntersection.valid && sIntersection.pathLength < aPathLength) {
+ aPathLength = sIntersection.pathLength;
+ aSurface = sfIter;
}
-
- template <class T> const std::vector< const Surface* >& GenericApproachDescriptor<T>::containedSurfaces() const
- {
- return m_surfacesCache;
- }
+ }
+ // return what you have
+ return SurfaceIntersection(sIntersection, aSurface, alongMomentum);
+}
+
+template <class T>
+const std::vector<const Surface*>&
+GenericApproachDescriptor<T>::containedSurfaces() const
+{
+ return m_surfacesCache;
+}
}
#endif
diff --git a/Core/include/ACTS/Detector/GenericOverlapDescriptor.hpp b/Core/include/ACTS/Detector/GenericOverlapDescriptor.hpp
index 3acf94583..7969dfd0d 100644
--- a/Core/include/ACTS/Detector/GenericOverlapDescriptor.hpp
+++ b/Core/include/ACTS/Detector/GenericOverlapDescriptor.hpp
@@ -15,47 +15,47 @@
// Core module
#include "ACTS/Utilities/Definitions.hpp"
-#include "ACTS/Utilities/OverlapDescriptor.hpp"
#include "ACTS/Utilities/Intersection.hpp"
+#include "ACTS/Utilities/OverlapDescriptor.hpp"
namespace Acts {
- class Surface;
-
- /**
- @class GenericOverlapDescriptor
-
- Neighbour & bin member based overlap descriptor
-
- */
-
- class GenericOverlapDescriptor : public OverlapDescriptor {
- public:
-
- /**Default constructor - surfaceArray is not given */
- GenericOverlapDescriptor(){}
-
-
- /**Virtual destructor*/
- virtual ~GenericOverlapDescriptor(){}
-
- /**Pseudo-constructor*/
- GenericOverlapDescriptor* clone() const override { return new GenericOverlapDescriptor(); }
-
- /** get the compatible surfaces
- - return : a boolean indicating if an actual intersection had been tried
- - fill vector of intersections
- - primary bin surface : sf
- - position & direction : pos, dir
- */
- virtual bool reachableSurfaces(std::vector<const Surface*>& cSurfaces,
- const Surface& sf,
- const Vector3D& pos,
- const Vector3D& dir,
- int searchType) const override;
-
- };
-
+class Surface;
+
+/**
+@class GenericOverlapDescriptor
+
+Neighbour & bin member based overlap descriptor
+
+*/
+
+class GenericOverlapDescriptor : public OverlapDescriptor
+{
+public:
+ /**Default constructor - surfaceArray is not given */
+ GenericOverlapDescriptor() {}
+ /**Virtual destructor*/
+ virtual ~GenericOverlapDescriptor() {}
+ /**Pseudo-constructor*/
+ GenericOverlapDescriptor*
+ clone() const override
+ {
+ return new GenericOverlapDescriptor();
+ }
+
+ /** get the compatible surfaces
+ - return : a boolean indicating if an actual intersection had been tried
+ - fill vector of intersections
+ - primary bin surface : sf
+ - position & direction : pos, dir
+ */
+ virtual bool
+ reachableSurfaces(std::vector<const Surface*>& cSurfaces,
+ const Surface& sf,
+ const Vector3D& pos,
+ const Vector3D& dir,
+ int searchType) const override;
+};
}
-#endif // ACTS_DETECTOR_GENERICOVERLAPDESCRIPTOR_H
+#endif // ACTS_DETECTOR_GENERICOVERLAPDESCRIPTOR_H
diff --git a/Core/include/ACTS/Detector/GlueVolumesDescriptor.hpp b/Core/include/ACTS/Detector/GlueVolumesDescriptor.hpp
index 6bfe30b0d..08c9764b8 100644
--- a/Core/include/ACTS/Detector/GlueVolumesDescriptor.hpp
+++ b/Core/include/ACTS/Detector/GlueVolumesDescriptor.hpp
@@ -14,63 +14,72 @@
#define ACTS_DETECTOR_GLUEVOLUMESDESCRIPTOR_H 1
// Geometry module
-#include "ACTS/Volumes/BoundarySurfaceFace.hpp"
#include "ACTS/Utilities/BinnedArray.hpp"
+#include "ACTS/Volumes/BoundarySurfaceFace.hpp"
// STL
#include <map>
-#include <vector>
#include <memory>
+#include <vector>
namespace Acts {
- class TrackingVolume;
- typedef std::shared_ptr< const TrackingVolume > TrackingVolumePtr;
- typedef BinnedArray< TrackingVolumePtr > TrackingVolumeArray;
-
- /** @class GlueVolumesDescriptor
-
- Descriptor class to hold GlueVolumes of a TrackingGeometry object.
- Should ease the wrapping of a TrackingGeometry object describing one Detector
- by another one.
-
- */
-
- class GlueVolumesDescriptor {
-
- public:
- /**Constructor */
- GlueVolumesDescriptor(){}
-
- /**Constructor - with arguments*/
- GlueVolumesDescriptor(const std::map<BoundarySurfaceFace, std::shared_ptr<const TrackingVolumeArray> >& gvs);
-
- /**Desctructor */
- ~GlueVolumesDescriptor(){}
-
- /** register the volumes */
- void registerGlueVolumes(Acts::BoundarySurfaceFace bsf, std::shared_ptr<const TrackingVolumeArray> gvs) const;
-
- /** retrieve them again */
- std::shared_ptr<const TrackingVolumeArray> glueVolumes(BoundarySurfaceFace) const;
-
- /** retrieve the available Glue Faces */
- const std::vector<BoundarySurfaceFace>& glueFaces() const;
-
- /** dump it to the screen */
- std::string screenOutput() const;
-
- private:
- mutable std::map<BoundarySurfaceFace, std::shared_ptr<const TrackingVolumeArray> > m_glueVolumes;
- mutable std::vector<BoundarySurfaceFace> m_glueFaces;
-
- };
-
- inline const std::vector<BoundarySurfaceFace>& GlueVolumesDescriptor::glueFaces() const
- { return m_glueFaces; }
-
- /**Overload of << operator for std::ostream for debug output*/
- std::ostream& operator<<( std::ostream& sl, const GlueVolumesDescriptor& mprop);
+class TrackingVolume;
+typedef std::shared_ptr<const TrackingVolume> TrackingVolumePtr;
+typedef BinnedArray<TrackingVolumePtr> TrackingVolumeArray;
+
+/** @class GlueVolumesDescriptor
+
+ Descriptor class to hold GlueVolumes of a TrackingGeometry object.
+ Should ease the wrapping of a TrackingGeometry object describing one Detector
+ by another one.
+
+ */
+
+class GlueVolumesDescriptor
+{
+public:
+ /**Constructor */
+ GlueVolumesDescriptor() {}
+ /**Constructor - with arguments*/
+ GlueVolumesDescriptor(
+ const std::map<BoundarySurfaceFace,
+ std::shared_ptr<const TrackingVolumeArray>>& gvs);
+
+ /**Desctructor */
+ ~GlueVolumesDescriptor() {}
+ /** register the volumes */
+ void
+ registerGlueVolumes(Acts::BoundarySurfaceFace bsf,
+ std::shared_ptr<const TrackingVolumeArray> gvs) const;
+
+ /** retrieve them again */
+ std::shared_ptr<const TrackingVolumeArray>
+ glueVolumes(BoundarySurfaceFace) const;
+
+ /** retrieve the available Glue Faces */
+ const std::vector<BoundarySurfaceFace>&
+ glueFaces() const;
+
+ /** dump it to the screen */
+ std::string
+ screenOutput() const;
+
+private:
+ mutable std::map<BoundarySurfaceFace,
+ std::shared_ptr<const TrackingVolumeArray>>
+ m_glueVolumes;
+ mutable std::vector<BoundarySurfaceFace> m_glueFaces;
+};
+
+inline const std::vector<BoundarySurfaceFace>&
+GlueVolumesDescriptor::glueFaces() const
+{
+ return m_glueFaces;
+}
+/**Overload of << operator for std::ostream for debug output*/
+std::ostream&
+operator<<(std::ostream& sl, const GlueVolumesDescriptor& mprop);
}
#endif
diff --git a/Core/include/ACTS/Detector/TrackingGeometry.hpp b/Core/include/ACTS/Detector/TrackingGeometry.hpp
index 03e00fbed..93ee720c9 100644
--- a/Core/include/ACTS/Detector/TrackingGeometry.hpp
+++ b/Core/include/ACTS/Detector/TrackingGeometry.hpp
@@ -13,90 +13,109 @@
#ifndef ACTS_DETECTOR_TRACKINGGEOMETRY_H
#define ACTS_DETECTOR_TRACKINGGEOMETRY_H
-#include "ACTS/Utilities/GeometrySignature.hpp"
#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Utilities/GeometrySignature.hpp"
// STD
#include <map>
-#include <vector>
#include <memory>
+#include <vector>
namespace Acts {
-
- class TrackingVolume;
- class DetachedTrackingVolume;
- class PerigeeSurface;
- class Layer;
-
- typedef std::shared_ptr< const TrackingVolume> TrackingVolumePtr;
- typedef std::shared_ptr< const DetachedTrackingVolume> DetachedTrackingVolumePtr;
- typedef std::vector< DetachedTrackingVolumePtr > DetachedVolumeVector;
-
- /**
- @class TrackingGeometry
-
- The TrackingGeometry class is the owner of the constructed TrackingVolumes.
-
- It enables both, a global search for an asociatedVolume
- (respectively, if existing, a global search of an associated Layer or the next
- associated Layer), such as a continous navigation by BoundarySurfaces between
- the confined TrackingVolumes.
- */
-
- class TrackingGeometry {
-
- /** Give the GeometryBuilder friend rights */
- friend class TrackingGeometryBuilder;
-
- public :
- /** Constructor */
- TrackingGeometry(TrackingVolumePtr highestVolume);
-
- /** Destructor */
- ~TrackingGeometry();
-
- /** return the world */
- const TrackingVolume* highestTrackingVolume() const;
-
- /** return the lowest tracking Volume */
- const TrackingVolume* lowestTrackingVolume(const Vector3D& gp) const;
-
- /** return the vector of lowest detached tracking Volume(->overlaps) */
- const DetachedVolumeVector* lowestDetachedTrackingVolumes(const Vector3D& gp) const;
-
- /** return the lowest static tracking Volume */
- const TrackingVolume* lowestStaticTrackingVolume(const Vector3D& gp) const;
-
- /** return the tracking Volume by name, 0 if it doesn't exist */
- const TrackingVolume* trackingVolume(const std::string& name) const;
-
- /** Forward the associated Layer information */
- const Layer* associatedLayer(const Vector3D& gp) const;
-
- /** check position at volume boundary */
- bool atVolumeBoundary(const Vector3D& gp, const TrackingVolume* vol, double tol) const;
-
- /** check position at volume boundary + navigation link */
- bool atVolumeBoundary(const Vector3D& gp, const Vector3D& mom, const TrackingVolume* vol,
- const TrackingVolume*& nextVol, Acts::PropDirection dir, double tol) const;
- /** register the beam tube */
- void registerBeamTube(std::unique_ptr<const PerigeeSurface> beam) const;
-
- private:
- /** Geometry Builder busineess: the geometry builder has to sign*/
- void sign(GeometrySignature geosit, GeometryType geotype = Static) const;
-
- /** private method to register recursively the tracking volume & set the mother volume */
- void registerTrackingVolumes(const TrackingVolume& tvol, const TrackingVolume* mvol = nullptr, int lvl = 0);
-
- /** The known world - and the beamline */
- TrackingVolumePtr m_world;
- mutable std::unique_ptr<const PerigeeSurface> m_beam;
-
- /** The Volumes in a map for later finding */
- std::map<const std::string, const TrackingVolume*> m_trackingVolumes;
-
- };
-
-} // end of namespace
+
+class TrackingVolume;
+class DetachedTrackingVolume;
+class PerigeeSurface;
+class Layer;
+
+typedef std::shared_ptr<const TrackingVolume> TrackingVolumePtr;
+typedef std::shared_ptr<const DetachedTrackingVolume> DetachedTrackingVolumePtr;
+typedef std::vector<DetachedTrackingVolumePtr> DetachedVolumeVector;
+
+/**
+ @class TrackingGeometry
+
+ The TrackingGeometry class is the owner of the constructed TrackingVolumes.
+
+ It enables both, a global search for an asociatedVolume
+ (respectively, if existing, a global search of an associated Layer or the next
+ associated Layer), such as a continous navigation by BoundarySurfaces between
+ the confined TrackingVolumes.
+*/
+
+class TrackingGeometry
+{
+ /** Give the GeometryBuilder friend rights */
+ friend class TrackingGeometryBuilder;
+
+public:
+ /** Constructor */
+ TrackingGeometry(TrackingVolumePtr highestVolume);
+
+ /** Destructor */
+ ~TrackingGeometry();
+
+ /** return the world */
+ const TrackingVolume*
+ highestTrackingVolume() const;
+
+ /** return the lowest tracking Volume */
+ const TrackingVolume*
+ lowestTrackingVolume(const Vector3D& gp) const;
+
+ /** return the vector of lowest detached tracking Volume(->overlaps) */
+ const DetachedVolumeVector*
+ lowestDetachedTrackingVolumes(const Vector3D& gp) const;
+
+ /** return the lowest static tracking Volume */
+ const TrackingVolume*
+ lowestStaticTrackingVolume(const Vector3D& gp) const;
+
+ /** return the tracking Volume by name, 0 if it doesn't exist */
+ const TrackingVolume*
+ trackingVolume(const std::string& name) const;
+
+ /** Forward the associated Layer information */
+ const Layer*
+ associatedLayer(const Vector3D& gp) const;
+
+ /** check position at volume boundary */
+ bool
+ atVolumeBoundary(const Vector3D& gp,
+ const TrackingVolume* vol,
+ double tol) const;
+
+ /** check position at volume boundary + navigation link */
+ bool
+ atVolumeBoundary(const Vector3D& gp,
+ const Vector3D& mom,
+ const TrackingVolume* vol,
+ const TrackingVolume*& nextVol,
+ Acts::PropDirection dir,
+ double tol) const;
+ /** register the beam tube */
+ void
+ registerBeamTube(std::unique_ptr<const PerigeeSurface> beam) const;
+
+private:
+ /** Geometry Builder busineess: the geometry builder has to sign*/
+ void
+ sign(GeometrySignature geosit, GeometryType geotype = Static) const;
+
+ /** private method to register recursively the tracking volume & set the
+ * mother volume */
+ void
+ registerTrackingVolumes(const TrackingVolume& tvol,
+ const TrackingVolume* mvol = nullptr,
+ int lvl = 0);
+
+ /** The known world - and the beamline */
+ TrackingVolumePtr m_world;
+ mutable std::unique_ptr<const PerigeeSurface> m_beam;
+
+ /** The Volumes in a map for later finding */
+ std::map<const std::string, const TrackingVolume*> m_trackingVolumes;
+};
+
+} // end of namespace
#endif
diff --git a/Core/include/ACTS/Detector/TrackingVolume.hpp b/Core/include/ACTS/Detector/TrackingVolume.hpp
index 35cafd36f..adfb785f8 100644
--- a/Core/include/ACTS/Detector/TrackingVolume.hpp
+++ b/Core/include/ACTS/Detector/TrackingVolume.hpp
@@ -14,447 +14,591 @@
#define ACTS_DETECTOR_TRACKINGVOLUME_H 1
// Core module
-#include "ACTS/Surfaces/Surface.hpp"
-#include "ACTS/Surfaces/BoundaryCheck.hpp"
-#include "ACTS/Volumes/Volume.hpp"
-#include "ACTS/Volumes/BoundarySurface.hpp"
#include "ACTS/Layers/Layer.hpp"
+#include "ACTS/Surfaces/BoundaryCheck.hpp"
+#include "ACTS/Surfaces/Surface.hpp"
#include "ACTS/Utilities/BinnedArray.hpp"
-#include "ACTS/Utilities/GeometrySignature.hpp"
#include "ACTS/Utilities/Definitions.hpp"
-//STL
+#include "ACTS/Utilities/GeometrySignature.hpp"
+#include "ACTS/Volumes/BoundarySurface.hpp"
+#include "ACTS/Volumes/Volume.hpp"
+// STL
#include <string>
namespace Acts {
- // classes
- class TrackingVolume;
- class DetachedTrackingVolume;
- class GlueVolumesDescriptor;
- class VolumeBounds;
- class Material;
-
- // master typedefs
- typedef std::shared_ptr<const TrackingVolume> TrackingVolumePtr;
- typedef std::shared_ptr< const DetachedTrackingVolume> DetachedTrackingVolumePtr;
-
- // possible contained
- typedef BinnedArray< TrackingVolumePtr > TrackingVolumeArray;
- typedef std::vector< TrackingVolumePtr > TrackingVolumeVector;
- typedef BinnedArray< LayerPtr > LayerArray;
- typedef std::vector< LayerPtr > LayerVector;
- typedef std::vector< DetachedTrackingVolumePtr > DetachedVolumeVector;
-
- template <class T> using LayerIntersection = FullIntersection< Layer, Surface, T >;
- template <class T> using BoundaryIntersection = FullIntersection< BoundarySurface<TrackingVolume>, Surface, T >;
-
- /**
- @class TrackingVolume
-
- Full Volume description used in Tracking,
- it inherits from Volume to get the geometrical structure.
-
- A TrackingVolume at navigation level can provide the (layer) material information / internal navigation with in
- 5 different ways:
-
- --- a) Static confinement of Layers
- --- b) detached sub volumes
- --- b) unordered (arbitrarily oriented) layers
- --- d) unordered sub volumes
- --- e) unordered layers AND unordered subvolumes
-
- The TrackingVolume can also be a simple container of other TrackingVolumes
-
- In addition it is capable of holding a subarray of Layers and TrackingVolumes.
-
- */
-
- class TrackingVolume : public Volume {
-
- public:
- /** Destructor */
- ~TrackingVolume();
-
- /** Factory constructor for a conatiner TrackingVolume - by definition a Vacuum volume */
- static TrackingVolumePtr create(std::shared_ptr<Transform3D> htrans,
- VolumeBoundsPtr volumeBounds,
- std::shared_ptr<const TrackingVolumeArray> containedVolumes = nullptr,
- const std::string& volumeName="undefined")
- { return TrackingVolumePtr(new TrackingVolume(htrans, volumeBounds, containedVolumes, volumeName)); }
-
- /** Factory constructor for Tracking Volumes with content - can not be a container volume */
- static TrackingVolumePtr create(std::shared_ptr<Transform3D> htrans,
- VolumeBoundsPtr volumeBounds,
- std::shared_ptr<Material> matprop,
- std::unique_ptr<const LayerArray> cLayerArray = nullptr,
- const LayerVector cLayerVector = {},
- const TrackingVolumeVector cVolumeVector = {},
- const DetachedVolumeVector dVolumeVector = {},
- const std::string& volumeName="undefined")
- { return TrackingVolumePtr(new TrackingVolume(htrans,
- volumeBounds,
- matprop,
- std::move(cLayerArray),
- cLayerVector,
- nullptr,
- cVolumeVector,
- dVolumeVector,
- volumeName)); }
- /** Factory constructor with a shift */
- static TrackingVolumePtr create(const TrackingVolume& trVol,
- const Transform3D& shift,
- const std::string& volumeName="undefined" )
- { return TrackingVolumePtr(new TrackingVolume(trVol,shift,volumeName)); }
-
- /** Virtual constructor clone at new position */
- TrackingVolumePtr cloneWithShift(const Transform3D& shift, const std::string& volumeName="undefined") const
- { return TrackingVolume::create(*this,shift,volumeName); }
-
- /** Return the associated Layer */
- const Layer* associatedLayer(const Vector3D& gp) const;
-
- /** Return the material layers ordered based on straight line intersections:
- - startLayer and endLayer are included in the list */
- template <class T> std::vector< LayerIntersection<T> >
- layerCandidatesOrdered(const Layer* sLayer,
- const Layer* eLayer,
- const T& parameters,
- PropDirection pDir = alongMomentum,
- const BoundaryCheck& bchk = true,
- bool resolveMaterial = true,
- bool resolveSubSurfaces = false) const;
-
- /** Return the associated sub Volume, returns THIS if no subVolume exists */
- const TrackingVolume* associatedSubVolume(const Vector3D& gp) const;
-
- /** Return the next volume along the navigation stream */
- const TrackingVolume* nextVolume(const Vector3D& gp, const Vector3D& dir, PropDirection pDir = alongMomentum) const;
-
- /** Return the dynamically created vector of detached sub volumes */
- const DetachedVolumeVector* assocDetachedSubVolumes(const Vector3D& gp, double tol) const;
-
- /** Return the confined static layer array - if it exists */
- const LayerArray* confinedLayers() const;
-
- /** Return the arbitrary layer array - if it exists */
- const LayerVector confinedArbitraryLayers() const;
-
- /** Return the confined volumes of this container array - if it exists */
- std::shared_ptr<const TrackingVolumeArray> confinedVolumes() const;
-
- /** Return the confind volume array as a shared pointer - for glueing */
- std::shared_ptr<const TrackingVolumeArray> confinedVolumesSharedPtr() const;
-
- /** Return detached subVolumes - not the ownership */
- const DetachedVolumeVector confinedDetachedVolumes() const;
-
- /** Return unordered subVolumes - not the ownership */
- const TrackingVolumeVector confinedDenseVolumes() const;
-
- /** Returns the VolumeName - for debug reason, might be depreciated later */
- const std::string& volumeName() const;
-
- /** Method to return the BoundarySurfaces */
- const std::vector< std::shared_ptr<const BoundarySurface<TrackingVolume> > >& boundarySurfaces() const;
-
- /** Returns the boundary surfaces ordered in probability to hit them based on straight line intersection */
- template <class T> std::vector< BoundaryIntersection<T> >
- boundarySurfacesOrdered(const T& parameters,
- PropDirection pDir = alongMomentum,
- bool startOffBoundary = false) const;
-
- /** show if you are on a boundary surface */
- template <class T> bool onVolumeBoundary(const T& pars ) const;
-
-
- /** glue another tracking volume to this one
- - if common face is set the glued volumes are sharing the boundary, down to the last navigation volume
- */
- void glueTrackingVolume(BoundarySurfaceFace bsfMine,
- TrackingVolumePtr neighbor,
- BoundarySurfaceFace bsfNeighbor) const;
-
- /** glue another tracking volume to this one
- - if common face is set the glued volumes are sharing the boundary, down to the last navigation volume
- */
- void glueTrackingVolumes(BoundarySurfaceFace bsfMine,
- std::shared_ptr<const TrackingVolumeArray> neighbors,
- BoundarySurfaceFace bsfNeighbors) const;
-
- /** provide a new BoundarySurface from the glueing */
- void updateBoundarySurface(BoundarySurfaceFace bf, std::shared_ptr<const BoundarySurface<TrackingVolume> > bs) const;
-
- /** Register the outside glue volumes -
- ordering is in the TrackingVolume Frame:
- - negativeFaceXY
- - (faces YZ, ZY, radial faces)
- - positiveFaceXY */
-
- void registerGlueVolumeDescriptor(GlueVolumesDescriptor* gvd) const;
-
- /** Register the outside glue volumes -
- ordering is in the TrackingVolume Frame:
- - negativeFaceXY
- - (faces YZ, ZY, radial faces)
- - positiveFaceXY */
- const GlueVolumesDescriptor& glueVolumesDescriptor() const;
-
- /** sign the volume - the geometry builder has to do that */
- void sign(GeometrySignature signat, GeometryType gtype = Static) const;
-
- /** return the Signature */
- GeometrySignature geometrySignature() const;
-
- /** return the Signature */
- GeometryType geometryType() const;
-
- /** Register the color code */
- void registerColorCode(unsigned int icolor) const;
-
- /** Get the color code */
- unsigned int colorCode() const;
-
- /** Return the MotherVolume - if it exists */
- const TrackingVolume* motherVolume() const;
-
- /** Return the MotherVolume - if it exists */
- void setMotherVolume(const TrackingVolume* mvol) const;
-
- /** add Material */
- void addMaterial( std::shared_ptr<const Material> mat, float fact=1. );
-
- protected:
- /** Default constructor */
- TrackingVolume();
-
- /** Constructor for a container Volume
- - vacuum filled volume either as a for other tracking volumes */
- TrackingVolume(std::shared_ptr<Transform3D> htrans,
- VolumeBoundsPtr volbounds,
- const std::shared_ptr<const TrackingVolumeArray> subVolumes = nullptr,
- const std::string& volumeName="undefined");
-
- /** Constructor for a full equipped Tracking Volume */
- TrackingVolume(std::shared_ptr<Transform3D> htrans,
- VolumeBoundsPtr volbounds,
- std::shared_ptr<Material> matprop,
- std::unique_ptr<const LayerArray> cLayerArray = nullptr,
- const LayerVector cLayerVector = {},
- std::shared_ptr<const TrackingVolumeArray> cVolumeArray = nullptr,
- const TrackingVolumeVector cVolumeVector = {},
- const DetachedVolumeVector dVolumeVector = {},
- const std::string& volumeName="undefined");
-
- /** Copy Constructor with a shift */
- TrackingVolume(const TrackingVolume& tvol,
- const Transform3D& shift,
- const std::string& volumeName="undefined");
-
- private:
- /** Create Boundary Surface */
- void createBoundarySurfaces();
-
- /** method to synchronize the layers with potentially updated volume bounds:
- - adapts the layer dimensions to the new volumebounds + envelope */
- void synchronizeLayers(double envelope = 1.) const;
-
- /** interlink the layers in this TrackingVolume */
- void interlinkLayers();
-
- /** Forbidden copy constructor */
- TrackingVolume(const TrackingVolume&): Volume() {}
-
- /** Forbid assignment */
- TrackingVolume &operator=(const TrackingVolume&) { return *this; }
-
- std::shared_ptr<Material> m_material; //!< The Material the TrackingVolume consists of
-
- mutable const TrackingVolume* m_motherVolume; //!< mother volume of this volume
-
- mutable std::vector< std::shared_ptr<const BoundarySurface<TrackingVolume> > > m_boundarySurfaces; //!< boundary Surfaces
-
- //(a) static configuration ordered by Binned arrays
- mutable std::unique_ptr<const LayerArray> m_confinedLayers; //!< Array of Layers inside the Volume
- mutable std::shared_ptr<const TrackingVolumeArray> m_confinedVolumes; //!< Array of Volumes inside the Volume
- //(b) non-static setups
- const DetachedVolumeVector m_confinedDetachedVolumes; //!< Detached subvolumes
- const TrackingVolumeVector m_confinedDenseVolumes; //!< Unordered subvolumes
- const LayerVector m_confinedArbitraryLayers; //!< Unordered Layers inside the Volume
-
- mutable GlueVolumesDescriptor* m_glueVolumeDescriptor; //!< Volumes to glue Volumes from the outside
-
- mutable GeometrySignature m_geometrySignature; //!< The Signature done by the GeometryBuilder
- mutable GeometryType m_geometryType; //!< defines how the extrapolation type
-
- std::string m_name; //!< Volume name for debug reasons
- mutable unsigned int m_colorCode; //!< Color code for displaying
-
-
- };
-
- inline const std::string& TrackingVolume::volumeName() const { return m_name; }
-
- inline const LayerArray* TrackingVolume::confinedLayers() const
- { return m_confinedLayers.get(); }
-
- inline const LayerVector TrackingVolume::confinedArbitraryLayers() const
- { return m_confinedArbitraryLayers; }
-
- inline std::shared_ptr<const TrackingVolumeArray> TrackingVolume::confinedVolumes() const
- { return m_confinedVolumes; }
-
- inline std::shared_ptr<const TrackingVolumeArray> TrackingVolume::confinedVolumesSharedPtr() const
- { return m_confinedVolumes; }
-
- inline const DetachedVolumeVector TrackingVolume::confinedDetachedVolumes() const
- { return m_confinedDetachedVolumes; }
-
- inline const TrackingVolumeVector TrackingVolume::confinedDenseVolumes() const
- { return m_confinedDenseVolumes; }
-
- template <class T> bool TrackingVolume::onVolumeBoundary(const T& pars) const {
- // get the associated Surface
- const Surface* pSurface = &pars.associatedSurface();
- auto& bSurfaces = boundarySurfaces();
- // fast loop pointer comparison of the surfaces
- for (auto& bsIter : bSurfaces ){
- const BoundarySurface<TrackingVolume>* bSurface = bsIter.get();
- // pointer of the parameter surface is identical with one of the boundary surface pointers
- if (pSurface == &bSurface->surfaceRepresentation()) return true;
- }
- // slow loop - checking the onSurface (does pointer comparison as well)
- for (auto& bsIter : bSurfaces ){
- const BoundarySurface<TrackingVolume>* bSurface = bsIter.get();
- // pointer of the parameter surface is identical with one of the boundary surface pointers
- if (bSurface->onBoundary(pars)) return true;
- }
- // could not find an onSurface
- return false;
+// classes
+class TrackingVolume;
+class DetachedTrackingVolume;
+class GlueVolumesDescriptor;
+class VolumeBounds;
+class Material;
+
+// master typedefs
+typedef std::shared_ptr<const TrackingVolume> TrackingVolumePtr;
+typedef std::shared_ptr<const DetachedTrackingVolume> DetachedTrackingVolumePtr;
+
+// possible contained
+typedef BinnedArray<TrackingVolumePtr> TrackingVolumeArray;
+typedef std::vector<TrackingVolumePtr> TrackingVolumeVector;
+typedef BinnedArray<LayerPtr> LayerArray;
+typedef std::vector<LayerPtr> LayerVector;
+typedef std::vector<DetachedTrackingVolumePtr> DetachedVolumeVector;
+
+template <class T>
+using LayerIntersection = FullIntersection<Layer, Surface, T>;
+template <class T>
+using BoundaryIntersection
+ = FullIntersection<BoundarySurface<TrackingVolume>, Surface, T>;
+
+/**
+ @class TrackingVolume
+
+ Full Volume description used in Tracking,
+ it inherits from Volume to get the geometrical structure.
+
+ A TrackingVolume at navigation level can provide the (layer) material
+ information / internal navigation with in
+ 5 different ways:
+
+ --- a) Static confinement of Layers
+ --- b) detached sub volumes
+ --- b) unordered (arbitrarily oriented) layers
+ --- d) unordered sub volumes
+ --- e) unordered layers AND unordered subvolumes
+
+ The TrackingVolume can also be a simple container of other TrackingVolumes
+
+ In addition it is capable of holding a subarray of Layers and TrackingVolumes.
+
+ */
+
+class TrackingVolume : public Volume
+{
+public:
+ /** Destructor */
+ ~TrackingVolume();
+
+ /** Factory constructor for a conatiner TrackingVolume - by definition a
+ * Vacuum volume */
+ static TrackingVolumePtr
+ create(std::shared_ptr<Transform3D> htrans,
+ VolumeBoundsPtr volumeBounds,
+ std::shared_ptr<const TrackingVolumeArray> containedVolumes = nullptr,
+ const std::string& volumeName = "undefined")
+ {
+ return TrackingVolumePtr(
+ new TrackingVolume(htrans, volumeBounds, containedVolumes, volumeName));
}
-
- /** Return the material layers ordered based on straight line intersections
- - start and end layer are always part of it */
- template <class T> std::vector< LayerIntersection<T> >
- TrackingVolume::layerCandidatesOrdered(const Layer* sLayer,
- const Layer* eLayer,
- const T& pars,
- PropDirection pDir,
- const BoundaryCheck& bchk,
- bool resolveMaterial,
- bool resolveSensitive) const
+ /** Factory constructor for Tracking Volumes with content - can not be a
+ * container volume */
+ static TrackingVolumePtr
+ create(std::shared_ptr<Transform3D> htrans,
+ VolumeBoundsPtr volumeBounds,
+ std::shared_ptr<Material> matprop,
+ std::unique_ptr<const LayerArray> cLayerArray = nullptr,
+ const LayerVector cLayerVector = {},
+ const TrackingVolumeVector cVolumeVector = {},
+ const DetachedVolumeVector dVolumeVector = {},
+ const std::string& volumeName = "undefined")
{
- // get position and momentum from the parameters
- const Vector3D& gp = pars.position();
- const Vector3D& gm = pars.momentum();
-
- // the layer intersections
- std::vector< LayerIntersection<T> > lIntersections;
- // assign the direction
- const Vector3D& dir = ( pDir == alongMomentum ? gm.unit() : Vector3D(-1*gm.unit()));
- // the confinedLayers
- if (m_confinedLayers){
-
- // cache the longest path length to avoid punch-through to the other side
- Intersection sLayerIntersection(Vector3D(0.,0.,0),0.,true,0.);
- const Surface* sLayerSurface = 0;
- double validPathLength = 0.;
- // - get compatible layers back from the LayerArray simply because of the binning
- // start layer given or not - test layer
- const Layer* tLayer = sLayer ? sLayer : associatedLayer(gp);
- if (tLayer){
- do {
- // collect material or sensitive layers, usually ignore navigation layers, but
- // always provide the final layer for the navigation stop
- if ((resolveMaterial && tLayer->hasMaterial()) || (resolveSensitive && tLayer->hasSensitive()) || tLayer == eLayer){
- // taking the layer representation, not the approach surface, latter is resolved in the navigation stream
- const Surface& tSurface = tLayer->surfaceRepresentation();
- // intersect the layer @TODO should probably be surface on approach
- Intersection lIntersection = tSurface.intersectionEstimate(gp,dir,true,bchk);
- // (a) if the current layer is NOT the start layer - intersection is ok
- if (tLayer != sLayer && lIntersection.valid){
- lIntersections.push_back(LayerIntersection<T>(lIntersection,tLayer,&tSurface,0,pDir));
- validPathLength = lIntersection.pathLength;
- } else if (tLayer == sLayer) {
- // (b) the current layer is the start layer - we need to cache it and check with the path length
- // this avoids potential punch-through to other side of
- sLayerIntersection = lIntersection;
- sLayerSurface = &tSurface;
- } else if (tLayer == eLayer) {
- // (c) it is the end layer after all - provide it and break the loop
- lIntersections.push_back(LayerIntersection<T>(lIntersection,tLayer,&tSurface,0,pDir));
- break;
- }
- }
- // move to next one or break because you reached the end layer
- tLayer = (tLayer == eLayer ) ? nullptr : tLayer->nextLayer(gp,dir);
- } while (tLayer);
- }
-
- // final check for compatibility of the start layer in order to avoid punch-through
- if (sLayer && sLayerIntersection.valid && sLayerIntersection.pathLength < validPathLength)
- lIntersections.push_back(LayerIntersection<T>(sLayerIntersection,sLayer,sLayerSurface,0,pDir));
-
- }
- // and the arbitraray layers
- if (!m_confinedArbitraryLayers.empty()){
- // loop over the layers and intersect them
- for (auto& layer : m_confinedArbitraryLayers){
- // intersections
- Intersection lIntersection = layer->surfaceRepresentation().intersectionEstimate(gp,dir,true,bchk);
- if (lIntersection.valid)
- lIntersections.push_back(LayerIntersection<T>(lIntersection,layer.get(),&(layer->surfaceRepresentation()),0,pDir));
- }
- }
-
- // sort them accordingly to the path length
- std::sort(lIntersections.begin(),lIntersections.end());
- // and return
- return lIntersections;
+ return TrackingVolumePtr(new TrackingVolume(htrans,
+ volumeBounds,
+ matprop,
+ std::move(cLayerArray),
+ cLayerVector,
+ nullptr,
+ cVolumeVector,
+ dVolumeVector,
+ volumeName));
}
-
- /** Returns the boundary surfaces ordered in probability to hit them based on straight line intersection @TODO change hard-coded default */
- template <class T > std::vector< BoundaryIntersection<T> >
- TrackingVolume::boundarySurfacesOrdered(const T& pars,
- PropDirection pDir,
- bool) const
+ /** Factory constructor with a shift */
+ static TrackingVolumePtr
+ create(const TrackingVolume& trVol,
+ const Transform3D& shift,
+ const std::string& volumeName = "undefined")
{
-
- // assign the direction
- const Vector3D dir = ( pDir == alongMomentum ? pars.momentum().unit() : Vector3D(-1*pars.momentum().unit()));
- // loop over boundarySurfaces and calculate the intersection
- std::vector< BoundaryIntersection<T> > bIntersections;
- auto& bSurfaces = boundarySurfaces();
- for (auto& bsIter : bSurfaces ){
- const BoundarySurface<TrackingVolume>* bSurface = bsIter.get();
- Intersection bsIntersection = bSurface->surfaceRepresentation().intersectionEstimate(pars.position(),dir,true,false);
- if (bsIntersection.valid)
- bIntersections.push_back(BoundaryIntersection<T>(bsIntersection,bSurface,&(bSurface->surfaceRepresentation()),0,pDir));
- }
- // and now sort to get the closest
- std::sort(bIntersections.begin(),bIntersections.end());
- // and return
- return bIntersections;
+ return TrackingVolumePtr(new TrackingVolume(trVol, shift, volumeName));
}
- inline GeometrySignature TrackingVolume::geometrySignature() const
- { return m_geometrySignature; }
-
- inline GeometryType TrackingVolume::geometryType() const
- { return m_geometryType; }
-
- inline void TrackingVolume::registerColorCode(unsigned int icolor) const
- { m_colorCode = icolor; }
-
- inline unsigned int TrackingVolume::colorCode() const
- { return m_colorCode; }
-
- inline const TrackingVolume* TrackingVolume::motherVolume() const
- { return m_motherVolume; }
+ /** Virtual constructor clone at new position */
+ TrackingVolumePtr
+ cloneWithShift(const Transform3D& shift,
+ const std::string& volumeName = "undefined") const
+ {
+ return TrackingVolume::create(*this, shift, volumeName);
+ }
- inline void TrackingVolume::setMotherVolume(const TrackingVolume* mvol) const
- { m_motherVolume = mvol; }
+ /** Return the associated Layer */
+ const Layer*
+ associatedLayer(const Vector3D& gp) const;
+
+ /** Return the material layers ordered based on straight line intersections:
+ - startLayer and endLayer are included in the list */
+ template <class T>
+ std::vector<LayerIntersection<T>>
+ layerCandidatesOrdered(const Layer* sLayer,
+ const Layer* eLayer,
+ const T& parameters,
+ PropDirection pDir = alongMomentum,
+ const BoundaryCheck& bchk = true,
+ bool resolveMaterial = true,
+ bool resolveSubSurfaces = false) const;
+
+ /** Return the associated sub Volume, returns THIS if no subVolume exists */
+ const TrackingVolume*
+ associatedSubVolume(const Vector3D& gp) const;
+
+ /** Return the next volume along the navigation stream */
+ const TrackingVolume*
+ nextVolume(const Vector3D& gp,
+ const Vector3D& dir,
+ PropDirection pDir = alongMomentum) const;
+
+ /** Return the dynamically created vector of detached sub volumes */
+ const DetachedVolumeVector*
+ assocDetachedSubVolumes(const Vector3D& gp, double tol) const;
+
+ /** Return the confined static layer array - if it exists */
+ const LayerArray*
+ confinedLayers() const;
+
+ /** Return the arbitrary layer array - if it exists */
+ const LayerVector
+ confinedArbitraryLayers() const;
+
+ /** Return the confined volumes of this container array - if it exists */
+ std::shared_ptr<const TrackingVolumeArray>
+ confinedVolumes() const;
+
+ /** Return the confind volume array as a shared pointer - for glueing */
+ std::shared_ptr<const TrackingVolumeArray>
+ confinedVolumesSharedPtr() const;
+
+ /** Return detached subVolumes - not the ownership */
+ const DetachedVolumeVector
+ confinedDetachedVolumes() const;
+
+ /** Return unordered subVolumes - not the ownership */
+ const TrackingVolumeVector
+ confinedDenseVolumes() const;
+
+ /** Returns the VolumeName - for debug reason, might be depreciated later */
+ const std::string&
+ volumeName() const;
+
+ /** Method to return the BoundarySurfaces */
+ const std::vector<std::shared_ptr<const BoundarySurface<TrackingVolume>>>&
+ boundarySurfaces() const;
+
+ /** Returns the boundary surfaces ordered in probability to hit them based on
+ * straight line intersection */
+ template <class T>
+ std::vector<BoundaryIntersection<T>>
+ boundarySurfacesOrdered(const T& parameters,
+ PropDirection pDir = alongMomentum,
+ bool startOffBoundary = false) const;
+
+ /** show if you are on a boundary surface */
+ template <class T>
+ bool
+ onVolumeBoundary(const T& pars) const;
+
+ /** glue another tracking volume to this one
+ - if common face is set the glued volumes are sharing the boundary, down
+ to the last navigation volume
+ */
+ void
+ glueTrackingVolume(BoundarySurfaceFace bsfMine,
+ TrackingVolumePtr neighbor,
+ BoundarySurfaceFace bsfNeighbor) const;
+
+ /** glue another tracking volume to this one
+ - if common face is set the glued volumes are sharing the boundary, down
+ to the last navigation volume
+ */
+ void
+ glueTrackingVolumes(BoundarySurfaceFace bsfMine,
+ std::shared_ptr<const TrackingVolumeArray> neighbors,
+ BoundarySurfaceFace bsfNeighbors) const;
+
+ /** provide a new BoundarySurface from the glueing */
+ void
+ updateBoundarySurface(
+ BoundarySurfaceFace bf,
+ std::shared_ptr<const BoundarySurface<TrackingVolume>> bs) const;
+
+ /** Register the outside glue volumes -
+ ordering is in the TrackingVolume Frame:
+ - negativeFaceXY
+ - (faces YZ, ZY, radial faces)
+ - positiveFaceXY */
+
+ void
+ registerGlueVolumeDescriptor(GlueVolumesDescriptor* gvd) const;
+
+ /** Register the outside glue volumes -
+ ordering is in the TrackingVolume Frame:
+ - negativeFaceXY
+ - (faces YZ, ZY, radial faces)
+ - positiveFaceXY */
+ const GlueVolumesDescriptor&
+ glueVolumesDescriptor() const;
+
+ /** sign the volume - the geometry builder has to do that */
+ void
+ sign(GeometrySignature signat, GeometryType gtype = Static) const;
+
+ /** return the Signature */
+ GeometrySignature
+ geometrySignature() const;
+
+ /** return the Signature */
+ GeometryType
+ geometryType() const;
+
+ /** Register the color code */
+ void
+ registerColorCode(unsigned int icolor) const;
+
+ /** Get the color code */
+ unsigned int
+ colorCode() const;
+
+ /** Return the MotherVolume - if it exists */
+ const TrackingVolume*
+ motherVolume() const;
+
+ /** Return the MotherVolume - if it exists */
+ void
+ setMotherVolume(const TrackingVolume* mvol) const;
+
+ /** add Material */
+ void
+ addMaterial(std::shared_ptr<const Material> mat, float fact = 1.);
+
+protected:
+ /** Default constructor */
+ TrackingVolume();
+
+ /** Constructor for a container Volume
+ - vacuum filled volume either as a for other tracking volumes */
+ TrackingVolume(std::shared_ptr<Transform3D> htrans,
+ VolumeBoundsPtr volbounds,
+ const std::shared_ptr<const TrackingVolumeArray> subVolumes
+ = nullptr,
+ const std::string& volumeName = "undefined");
+
+ /** Constructor for a full equipped Tracking Volume */
+ TrackingVolume(std::shared_ptr<Transform3D> htrans,
+ VolumeBoundsPtr volbounds,
+ std::shared_ptr<Material> matprop,
+ std::unique_ptr<const LayerArray> cLayerArray = nullptr,
+ const LayerVector cLayerVector = {},
+ std::shared_ptr<const TrackingVolumeArray> cVolumeArray
+ = nullptr,
+ const TrackingVolumeVector cVolumeVector = {},
+ const DetachedVolumeVector dVolumeVector = {},
+ const std::string& volumeName = "undefined");
+
+ /** Copy Constructor with a shift */
+ TrackingVolume(const TrackingVolume& tvol,
+ const Transform3D& shift,
+ const std::string& volumeName = "undefined");
+
+private:
+ /** Create Boundary Surface */
+ void
+ createBoundarySurfaces();
+
+ /** method to synchronize the layers with potentially updated volume bounds:
+ - adapts the layer dimensions to the new volumebounds + envelope */
+ void
+ synchronizeLayers(double envelope = 1.) const;
+
+ /** interlink the layers in this TrackingVolume */
+ void
+ interlinkLayers();
+
+ /** Forbidden copy constructor */
+ TrackingVolume(const TrackingVolume&) : Volume() {}
+ /** Forbid assignment */
+ TrackingVolume&
+ operator=(const TrackingVolume&)
+ {
+ return *this;
+ }
-} // end of namespace
+ std::shared_ptr<Material>
+ m_material; //!< The Material the TrackingVolume consists of
+
+ mutable const TrackingVolume*
+ m_motherVolume; //!< mother volume of this volume
+
+ mutable std::vector<std::shared_ptr<const BoundarySurface<TrackingVolume>>>
+ m_boundarySurfaces; //!< boundary Surfaces
+
+ //(a) static configuration ordered by Binned arrays
+ mutable std::unique_ptr<const LayerArray>
+ m_confinedLayers; //!< Array of Layers inside the Volume
+ mutable std::shared_ptr<const TrackingVolumeArray>
+ m_confinedVolumes; //!< Array of Volumes inside the Volume
+ //(b) non-static setups
+ const DetachedVolumeVector
+ m_confinedDetachedVolumes; //!< Detached subvolumes
+ const TrackingVolumeVector m_confinedDenseVolumes; //!< Unordered subvolumes
+ const LayerVector
+ m_confinedArbitraryLayers; //!< Unordered Layers inside the Volume
+
+ mutable GlueVolumesDescriptor*
+ m_glueVolumeDescriptor; //!< Volumes to glue Volumes from the outside
+
+ mutable GeometrySignature
+ m_geometrySignature; //!< The Signature done by the GeometryBuilder
+ mutable GeometryType m_geometryType; //!< defines how the extrapolation type
+
+ std::string m_name; //!< Volume name for debug reasons
+ mutable unsigned int m_colorCode; //!< Color code for displaying
+};
+
+inline const std::string&
+TrackingVolume::volumeName() const
+{
+ return m_name;
+}
+
+inline const LayerArray*
+TrackingVolume::confinedLayers() const
+{
+ return m_confinedLayers.get();
+}
+
+inline const LayerVector
+TrackingVolume::confinedArbitraryLayers() const
+{
+ return m_confinedArbitraryLayers;
+}
+
+inline std::shared_ptr<const TrackingVolumeArray>
+TrackingVolume::confinedVolumes() const
+{
+ return m_confinedVolumes;
+}
+
+inline std::shared_ptr<const TrackingVolumeArray>
+TrackingVolume::confinedVolumesSharedPtr() const
+{
+ return m_confinedVolumes;
+}
+
+inline const DetachedVolumeVector
+TrackingVolume::confinedDetachedVolumes() const
+{
+ return m_confinedDetachedVolumes;
+}
+
+inline const TrackingVolumeVector
+TrackingVolume::confinedDenseVolumes() const
+{
+ return m_confinedDenseVolumes;
+}
+
+template <class T>
+bool
+TrackingVolume::onVolumeBoundary(const T& pars) const
+{
+ // get the associated Surface
+ const Surface* pSurface = &pars.associatedSurface();
+ auto& bSurfaces = boundarySurfaces();
+ // fast loop pointer comparison of the surfaces
+ for (auto& bsIter : bSurfaces) {
+ const BoundarySurface<TrackingVolume>* bSurface = bsIter.get();
+ // pointer of the parameter surface is identical with one of the boundary
+ // surface pointers
+ if (pSurface == &bSurface->surfaceRepresentation()) return true;
+ }
+ // slow loop - checking the onSurface (does pointer comparison as well)
+ for (auto& bsIter : bSurfaces) {
+ const BoundarySurface<TrackingVolume>* bSurface = bsIter.get();
+ // pointer of the parameter surface is identical with one of the boundary
+ // surface pointers
+ if (bSurface->onBoundary(pars)) return true;
+ }
+ // could not find an onSurface
+ return false;
+}
+
+/** Return the material layers ordered based on straight line intersections
+ - start and end layer are always part of it */
+template <class T>
+std::vector<LayerIntersection<T>>
+TrackingVolume::layerCandidatesOrdered(const Layer* sLayer,
+ const Layer* eLayer,
+ const T& pars,
+ PropDirection pDir,
+ const BoundaryCheck& bchk,
+ bool resolveMaterial,
+ bool resolveSensitive) const
+{
+ // get position and momentum from the parameters
+ const Vector3D& gp = pars.position();
+ const Vector3D& gm = pars.momentum();
+
+ // the layer intersections
+ std::vector<LayerIntersection<T>> lIntersections;
+ // assign the direction
+ const Vector3D& dir
+ = (pDir == alongMomentum ? gm.unit() : Vector3D(-1 * gm.unit()));
+ // the confinedLayers
+ if (m_confinedLayers) {
+ // cache the longest path length to avoid punch-through to the other side
+ Intersection sLayerIntersection(Vector3D(0., 0., 0), 0., true, 0.);
+ const Surface* sLayerSurface = 0;
+ double validPathLength = 0.;
+ // - get compatible layers back from the LayerArray simply because of the
+ // binning
+ // start layer given or not - test layer
+ const Layer* tLayer = sLayer ? sLayer : associatedLayer(gp);
+ if (tLayer) {
+ do {
+ // collect material or sensitive layers, usually ignore navigation
+ // layers, but
+ // always provide the final layer for the navigation stop
+ if ((resolveMaterial && tLayer->hasMaterial())
+ || (resolveSensitive && tLayer->hasSensitive())
+ || tLayer == eLayer) {
+ // taking the layer representation, not the approach surface, latter
+ // is resolved in the navigation stream
+ const Surface& tSurface = tLayer->surfaceRepresentation();
+ // intersect the layer @TODO should probably be surface on approach
+ Intersection lIntersection
+ = tSurface.intersectionEstimate(gp, dir, true, bchk);
+ // (a) if the current layer is NOT the start layer - intersection is
+ // ok
+ if (tLayer != sLayer && lIntersection.valid) {
+ lIntersections.push_back(LayerIntersection<T>(
+ lIntersection, tLayer, &tSurface, 0, pDir));
+ validPathLength = lIntersection.pathLength;
+ } else if (tLayer == sLayer) {
+ // (b) the current layer is the start layer - we need to cache it
+ // and check with the path length
+ // this avoids potential punch-through to other side of
+ sLayerIntersection = lIntersection;
+ sLayerSurface = &tSurface;
+ } else if (tLayer == eLayer) {
+ // (c) it is the end layer after all - provide it and break the loop
+ lIntersections.push_back(LayerIntersection<T>(
+ lIntersection, tLayer, &tSurface, 0, pDir));
+ break;
+ }
+ }
+ // move to next one or break because you reached the end layer
+ tLayer = (tLayer == eLayer) ? nullptr : tLayer->nextLayer(gp, dir);
+ } while (tLayer);
+ }
+
+ // final check for compatibility of the start layer in order to avoid
+ // punch-through
+ if (sLayer && sLayerIntersection.valid
+ && sLayerIntersection.pathLength < validPathLength)
+ lIntersections.push_back(LayerIntersection<T>(
+ sLayerIntersection, sLayer, sLayerSurface, 0, pDir));
+ }
+ // and the arbitraray layers
+ if (!m_confinedArbitraryLayers.empty()) {
+ // loop over the layers and intersect them
+ for (auto& layer : m_confinedArbitraryLayers) {
+ // intersections
+ Intersection lIntersection
+ = layer->surfaceRepresentation().intersectionEstimate(
+ gp, dir, true, bchk);
+ if (lIntersection.valid)
+ lIntersections.push_back(
+ LayerIntersection<T>(lIntersection,
+ layer.get(),
+ &(layer->surfaceRepresentation()),
+ 0,
+ pDir));
+ }
+ }
-#endif // ACTS_DETECTOR_TRACKINGVOLUME_H
+ // sort them accordingly to the path length
+ std::sort(lIntersections.begin(), lIntersections.end());
+ // and return
+ return lIntersections;
+}
+
+/** Returns the boundary surfaces ordered in probability to hit them based on
+ * straight line intersection @TODO change hard-coded default */
+template <class T>
+std::vector<BoundaryIntersection<T>>
+TrackingVolume::boundarySurfacesOrdered(const T& pars,
+ PropDirection pDir,
+ bool) const
+{
+ // assign the direction
+ const Vector3D dir
+ = (pDir == alongMomentum ? pars.momentum().unit()
+ : Vector3D(-1 * pars.momentum().unit()));
+ // loop over boundarySurfaces and calculate the intersection
+ std::vector<BoundaryIntersection<T>> bIntersections;
+ auto& bSurfaces = boundarySurfaces();
+ for (auto& bsIter : bSurfaces) {
+ const BoundarySurface<TrackingVolume>* bSurface = bsIter.get();
+ Intersection bsIntersection
+ = bSurface->surfaceRepresentation().intersectionEstimate(
+ pars.position(), dir, true, false);
+ if (bsIntersection.valid)
+ bIntersections.push_back(
+ BoundaryIntersection<T>(bsIntersection,
+ bSurface,
+ &(bSurface->surfaceRepresentation()),
+ 0,
+ pDir));
+ }
+ // and now sort to get the closest
+ std::sort(bIntersections.begin(), bIntersections.end());
+ // and return
+ return bIntersections;
+}
+
+inline GeometrySignature
+TrackingVolume::geometrySignature() const
+{
+ return m_geometrySignature;
+}
+
+inline GeometryType
+TrackingVolume::geometryType() const
+{
+ return m_geometryType;
+}
+
+inline void
+TrackingVolume::registerColorCode(unsigned int icolor) const
+{
+ m_colorCode = icolor;
+}
+
+inline unsigned int
+TrackingVolume::colorCode() const
+{
+ return m_colorCode;
+}
+
+inline const TrackingVolume*
+TrackingVolume::motherVolume() const
+{
+ return m_motherVolume;
+}
+
+inline void
+TrackingVolume::setMotherVolume(const TrackingVolume* mvol) const
+{
+ m_motherVolume = mvol;
+}
+
+} // end of namespace
+
+#endif // ACTS_DETECTOR_TRACKINGVOLUME_H
diff --git a/Core/include/ACTS/EventData/ChargePolicy.hpp b/Core/include/ACTS/EventData/ChargePolicy.hpp
index 23c843b2c..8b6bacce0 100644
--- a/Core/include/ACTS/EventData/ChargePolicy.hpp
+++ b/Core/include/ACTS/EventData/ChargePolicy.hpp
@@ -9,125 +9,135 @@
#ifndef ACTS_CHARGEDEFINITION_H
#define ACTS_CHARGEDEFINITION_H 1
-namespace Acts
+namespace Acts {
+/**
+ * @class ChargedPolicy
+ *
+ * @brief policy class for charged particles/tracks
+ *
+ * This type is meant to be used as template parameter to the
+ * SingleTrackParameters class
+ * and its derived classes in order to provide a distinction between charged and
+ * neutral
+ * track (parameters) at the C++ type level. This allows other class to employ
+ * optimized
+ * algorithms for either case by using template specializations.
+ */
+class ChargedPolicy
{
+public:
/**
- * @class ChargedPolicy
+ * @brief constructor with given charge
*
- * @brief policy class for charged particles/tracks
+ * @param charge electric charge of particle/track (parameters)
+ */
+ ChargedPolicy(double charge) : m_dCharge(charge) {}
+ /**
+ * @brief equality operator
*
- * This type is meant to be used as template parameter to the SingleTrackParameters class
- * and its derived classes in order to provide a distinction between charged and neutral
- * track (parameters) at the C++ type level. This allows other class to employ optimized
- * algorithms for either case by using template specializations.
+ * @return @c true if rhs has the same charge, otherwise @c false
*/
- class ChargedPolicy
+ bool
+ operator==(const ChargedPolicy& rhs) const
{
- public:
- /**
- * @brief constructor with given charge
- *
- * @param charge electric charge of particle/track (parameters)
- */
- ChargedPolicy(double charge):
- m_dCharge(charge)
- {}
+ return m_dCharge == rhs.m_dCharge;
+ }
- /**
- * @brief equality operator
- *
- * @return @c true if rhs has the same charge, otherwise @c false
- */
- bool operator==(const ChargedPolicy& rhs) const
- {
- return m_dCharge == rhs.m_dCharge;
- }
-
- /**
- * @brief inequality operator
- *
- * @return @c true if rhs has a different charge, otherwise @c false
- */
- bool operator!=(const ChargedPolicy& rhs) const
- {
- return !(*this == rhs);
- }
+ /**
+ * @brief inequality operator
+ *
+ * @return @c true if rhs has a different charge, otherwise @c false
+ */
+ bool
+ operator!=(const ChargedPolicy& rhs) const
+ {
+ return !(*this == rhs);
+ }
- /**
- * @brief retrieve stored value of the electric charge
- *
- * @return value for charge
- */
- double getCharge() const
- {
- return m_dCharge;
- }
+ /**
+ * @brief retrieve stored value of the electric charge
+ *
+ * @return value for charge
+ */
+ double
+ getCharge() const
+ {
+ return m_dCharge;
+ }
- /**
- * @brief sets charge
- *
- * @param charge new value for the electric charge
- */
- void setCharge(double charge)
- {
- m_dCharge = charge;
- }
+ /**
+ * @brief sets charge
+ *
+ * @param charge new value for the electric charge
+ */
+ void
+ setCharge(double charge)
+ {
+ m_dCharge = charge;
+ }
- /**
- * @brief flip sign of electric charge
- */
- void flipSign()
- {
- m_dCharge *= -1.;
- }
+ /**
+ * @brief flip sign of electric charge
+ */
+ void
+ flipSign()
+ {
+ m_dCharge *= -1.;
+ }
- private:
- double m_dCharge; ///< value of electric charge
- };
+private:
+ double m_dCharge; ///< value of electric charge
+};
+/**
+ * @class NeutralPolicy
+ *
+ * @brief policy class for neutral particles/tracks
+ *
+ * This type is meant to be used as template parameter to the
+ * SingleTrackParameters class
+ * and its derived classes in order to provide a distinction between charged and
+ * neutral
+ * track (parameters) at the C++ type level. This allows other class to employ
+ * optimized
+ * algorithms for either case by using template specializations.
+ */
+class NeutralPolicy
+{
+public:
/**
- * @class NeutralPolicy
- *
- * @brief policy class for neutral particles/tracks
+ * @brief equality operator
*
- * This type is meant to be used as template parameter to the SingleTrackParameters class
- * and its derived classes in order to provide a distinction between charged and neutral
- * track (parameters) at the C++ type level. This allows other class to employ optimized
- * algorithms for either case by using template specializations.
+ * @return always @c true
*/
- class NeutralPolicy
+ bool
+ operator==(const NeutralPolicy&) const
{
- public:
- /**
- * @brief equality operator
- *
- * @return always @c true
- */
- bool operator==(const NeutralPolicy&) const
- {
- return true;
- }
+ return true;
+ }
- /**
- * @brief inequality operator
- *
- * @return always @c false
- */
- bool operator!=(const NeutralPolicy& rhs) const
- {
- return !(*this == rhs);
- }
+ /**
+ * @brief inequality operator
+ *
+ * @return always @c false
+ */
+ bool
+ operator!=(const NeutralPolicy& rhs) const
+ {
+ return !(*this == rhs);
+ }
- /**
- * @brief get electric charge
- *
- * @return always 0
- */
- double getCharge() const
- {
- return 0.;
- }
- };
-} // end of namespace Acts
+ /**
+ * @brief get electric charge
+ *
+ * @return always 0
+ */
+ double
+ getCharge() const
+ {
+ return 0.;
+ }
+};
+} // end of namespace Acts
-#endif // ACTS_CHARGEPOLICY_H
+#endif // ACTS_CHARGEPOLICY_H
diff --git a/Core/include/ACTS/EventData/Measurement.hpp b/Core/include/ACTS/EventData/Measurement.hpp
index d787aa351..6f60762bd 100644
--- a/Core/include/ACTS/EventData/Measurement.hpp
+++ b/Core/include/ACTS/EventData/Measurement.hpp
@@ -10,268 +10,306 @@
#define ACTS_MEASUREMENT_H 1
// STL include(s)
+#include <memory>
#include <type_traits>
#include <utility>
-#include <memory>
// ACTS includes
-#include "ACTS/Utilities/ParameterDefinitions.hpp"
#include "ACTS/EventData/ParameterSet.hpp"
#include "ACTS/EventData/TrackParameters.hpp"
#include "ACTS/EventData/detail/fittable_type_generator.hpp"
+#include "ACTS/Utilities/ParameterDefinitions.hpp"
+
+namespace Acts {
+// forward declarations
+class Surface;
-namespace Acts
+/**
+ * @brief base class for Measurements
+ *
+ * This class describes the measurement of track parameters at a certain Surface
+ * in the
+ * TrackingGeometry.
+ *
+ * @note Identifier must be copy-constructible, move-constructible,
+ * copy-assignable and move-assignable.
+ *
+ * @test The behavior of this class is tested in the following unit test:
+ * - \link Acts::Test::BOOST_AUTO_TEST_CASE(measurement_initialization)
+ * initialization\endlink
+ *
+ * @tparam Identifier identification object for this measurement
+ * @tparam params parameter pack containing the measured parameters
+ */
+template <typename Identifier, ParID_t... params>
+class Measurement
{
- // forward declarations
- class Surface;
+ // check type conditions
+ static_assert(std::is_copy_constructible<Identifier>::value,
+ "'Identifier' must be copy-constructible");
+ static_assert(std::is_move_constructible<Identifier>::value,
+ "'Identifier' must be move-constructible");
+ static_assert(std::is_copy_assignable<Identifier>::value,
+ "'Identifier' must be copy-assignable");
+ static_assert(std::is_move_assignable<Identifier>::value,
+ "'Identifier' must be move-assignable");
+
+private:
+ // private typedef's
+ typedef ParameterSet<params...>
+ ParSet_t; ///< type of the underlying ParameterSet object
+
+public:
+ typedef typename ParSet_t::ParVector_t
+ ParVector_t; ///< type of the vector containing the parameter values
+ typedef typename ParSet_t::CovMatrix_t
+ CovMatrix_t; ///< type of the covariance matrix of the measurement
/**
- * @brief base class for Measurements
+ * @brief standard constructor
*
- * This class describes the measurement of track parameters at a certain Surface in the
- * TrackingGeometry.
+ * Interface class for all possible measurements.
*
- * @note Identifier must be copy-constructible, move-constructible, copy-assignable and move-assignable.
+ * @note Only a reference to the given surface is stored. The user must ensure
+ * that the lifetime of the @c Surface
+ * object surpasses the lifetime of this Measurement object.<br />
+ * The given parameter values are interpreted as values to the
+ * parameters as defined in the class template
+ * argument @c params.
*
- * @test The behavior of this class is tested in the following unit test:
- * - \link Acts::Test::BOOST_AUTO_TEST_CASE(measurement_initialization) initialization\endlink
+ * @attention The current design will fail if the in-memory location of the @c
+ * Surface object is changed (e.g.
+ * if it is stored in a container and this gets relocated).
*
- * @tparam Identifier identification object for this measurement
- * @tparam params parameter pack containing the measured parameters
+ * @param surface surface at which the measurement took place
+ * @param id identification object for this measurement
+ * @param cov covariance matrix of the measurement.
+ * @param head,values consistent number of parameter values of the measurement
*/
- template<typename Identifier,ParID_t... params>
- class Measurement
+ template <typename... Tail>
+ Measurement(const Surface& surface,
+ const Identifier& id,
+ CovMatrix_t cov,
+ typename std::enable_if<sizeof...(Tail) + 1 == sizeof...(params),
+ ParValue_t>::type head,
+ Tail... values)
+ : m_oParameters(std::make_unique<CovMatrix_t>(std::move(cov)),
+ head,
+ values...)
+ , m_pSurface(&surface)
+ , m_oIdentifier(id)
{
- // check type conditions
- static_assert(std::is_copy_constructible<Identifier>::value,"'Identifier' must be copy-constructible");
- static_assert(std::is_move_constructible<Identifier>::value,"'Identifier' must be move-constructible");
- static_assert(std::is_copy_assignable<Identifier>::value,"'Identifier' must be copy-assignable");
- static_assert(std::is_move_assignable<Identifier>::value,"'Identifier' must be move-assignable");
- private:
- // private typedef's
- typedef ParameterSet<params...> ParSet_t; ///< type of the underlying ParameterSet object
-
- public:
- typedef typename ParSet_t::ParVector_t ParVector_t; ///< type of the vector containing the parameter values
- typedef typename ParSet_t::CovMatrix_t CovMatrix_t; ///< type of the covariance matrix of the measurement
-
- /**
- * @brief standard constructor
- *
- * Interface class for all possible measurements.
- *
- * @note Only a reference to the given surface is stored. The user must ensure that the lifetime of the @c Surface
- * object surpasses the lifetime of this Measurement object.<br />
- * The given parameter values are interpreted as values to the parameters as defined in the class template
- * argument @c params.
- *
- * @attention The current design will fail if the in-memory location of the @c Surface object is changed (e.g.
- * if it is stored in a container and this gets relocated).
- *
- * @param surface surface at which the measurement took place
- * @param id identification object for this measurement
- * @param cov covariance matrix of the measurement.
- * @param head,values consistent number of parameter values of the measurement
- */
- template<typename ... Tail>
- Measurement(const Surface& surface,
- const Identifier& id,
- CovMatrix_t cov,
- typename std::enable_if<sizeof...(Tail) + 1 == sizeof...(params),ParValue_t>::type head,
- Tail... values):
- m_oParameters(std::make_unique<CovMatrix_t>(std::move(cov)),head,values...),
- m_pSurface(&surface),
- m_oIdentifier(id)
- {}
+ }
- /**
- * @brief virtual destructor
- */
- virtual ~Measurement() = default;
-
- /**
- * @brief copy constructor
- */
- Measurement(const Measurement<Identifier,params...>& copy):
- m_oParameters(copy.m_oParameters),
- m_pSurface(copy.m_pSurface),
- m_oIdentifier(copy.m_oIdentifier)
- {}
-
- /**
- * @brief move constructor
- */
- Measurement(Measurement<Identifier,params...>&& rhs):
- m_oParameters(std::move(rhs.m_oParameters)),
- m_pSurface(rhs.m_pSurface),
- m_oIdentifier(std::move(rhs.m_oIdentifier))
- {}
+ /**
+ * @brief virtual destructor
+ */
+ virtual ~Measurement() = default;
- /**
- * @brief copy assignment operator
- */
- Measurement<Identifier,params...>& operator=(const Measurement<Identifier,params...>& rhs)
- {
- m_oParameters = rhs.m_oParameters;
- m_pSurface = rhs.m_pSurface;
- m_oIdentifier = rhs.m_oIdentifier;
+ /**
+ * @brief copy constructor
+ */
+ Measurement(const Measurement<Identifier, params...>& copy)
+ : m_oParameters(copy.m_oParameters)
+ , m_pSurface(copy.m_pSurface)
+ , m_oIdentifier(copy.m_oIdentifier)
+ {
+ }
- return *this;
- }
+ /**
+ * @brief move constructor
+ */
+ Measurement(Measurement<Identifier, params...>&& rhs)
+ : m_oParameters(std::move(rhs.m_oParameters))
+ , m_pSurface(rhs.m_pSurface)
+ , m_oIdentifier(std::move(rhs.m_oIdentifier))
+ {
+ }
- /**
- * @brief move assignment operator
- */
- Measurement<Identifier,params...>& operator=(Measurement<Identifier,params...>&& rhs)
- {
- m_oParameters = std::move(rhs.m_oParameters);
- m_pSurface = rhs.m_pSurface;
- m_oIdentifier = std::move(rhs.m_oIdentifier);
+ /**
+ * @brief copy assignment operator
+ */
+ Measurement<Identifier, params...>&
+ operator=(const Measurement<Identifier, params...>& rhs)
+ {
+ m_oParameters = rhs.m_oParameters;
+ m_pSurface = rhs.m_pSurface;
+ m_oIdentifier = rhs.m_oIdentifier;
- return *this;
- }
+ return *this;
+ }
- /**
- * @brief retrieve stored value for given parameter
- *
- * @tparam parameter identifier for the parameter to be retrieved
- * @remark @c parameter must be part of the template parameter pack @c params. Otherwise a compile-time
- * error is generated.
- *
- * @return value of the stored parameter
- */
- template<ParID_t parameter>
- ParValue_t get() const
- {
- return m_oParameters.template getParameter<parameter>();
- }
+ /**
+ * @brief move assignment operator
+ */
+ Measurement<Identifier, params...>&
+ operator=(Measurement<Identifier, params...>&& rhs)
+ {
+ m_oParameters = std::move(rhs.m_oParameters);
+ m_pSurface = rhs.m_pSurface;
+ m_oIdentifier = std::move(rhs.m_oIdentifier);
- /**
- * @brief access vector with measured parameter values
- *
- * @return column vector whose size is equal to the dimensionality of this Measurement. The values are
- * given for the measured parameters in the order defined by the class template argument @c params.
- */
- ParVector_t parameters() const
- {
- return m_oParameters.getParameters();
- }
+ return *this;
+ }
- /**
- * @brief access covariance matrix of the measured parameter values
- *
- * @return covariance matrix of the measurement
- */
- CovMatrix_t covariance() const
- {
- return *m_oParameters.getCovariance();
- }
+ /**
+ * @brief retrieve stored value for given parameter
+ *
+ * @tparam parameter identifier for the parameter to be retrieved
+ * @remark @c parameter must be part of the template parameter pack @c params.
+ * Otherwise a compile-time
+ * error is generated.
+ *
+ * @return value of the stored parameter
+ */
+ template <ParID_t parameter>
+ ParValue_t
+ get() const
+ {
+ return m_oParameters.template getParameter<parameter>();
+ }
- /**
- * @brief retrieve stored uncertainty for given parameter
- *
- * @tparam parameter identifier for the parameter to be retrieved
- * @remark @c parameter must be part of the template parameter pack @c params. Otherwise a compile-time
- * error is generated.
- *
- * @return uncertainty \f$\sigma \ge 0\f$ for given parameter
- */
- template<ParID_t parameter>
- ParValue_t uncertainty() const
- {
- return m_oParameters.template uncertainty<parameter>();
- }
+ /**
+ * @brief access vector with measured parameter values
+ *
+ * @return column vector whose size is equal to the dimensionality of this
+ * Measurement. The values are
+ * given for the measured parameters in the order defined by the class
+ * template argument @c params.
+ */
+ ParVector_t
+ parameters() const
+ {
+ return m_oParameters.getParameters();
+ }
- /**
- * @brief number of measured parameters
- *
- * @return number of measured parameters
- */
- static constexpr unsigned int size()
- {
- return ParSet_t::size();
- }
+ /**
+ * @brief access covariance matrix of the measured parameter values
+ *
+ * @return covariance matrix of the measurement
+ */
+ CovMatrix_t
+ covariance() const
+ {
+ return *m_oParameters.getCovariance();
+ }
- /**
- * @brief access associated surface
- *
- * @pre The @c Surface object used to construct this @c Measurement object must still be valid
- * at the same memory location.
- *
- * @return reference to surface at which the measurement took place
- */
- const Acts::Surface& associatedSurface() const
- {
- return *m_pSurface;
- }
+ /**
+ * @brief retrieve stored uncertainty for given parameter
+ *
+ * @tparam parameter identifier for the parameter to be retrieved
+ * @remark @c parameter must be part of the template parameter pack @c params.
+ * Otherwise a compile-time
+ * error is generated.
+ *
+ * @return uncertainty \f$\sigma \ge 0\f$ for given parameter
+ */
+ template <ParID_t parameter>
+ ParValue_t
+ uncertainty() const
+ {
+ return m_oParameters.template uncertainty<parameter>();
+ }
- /**
- * @brief access to global measurement identifier
- *
- * @return identifier object
- */
- Identifier identifier() const
- {
- return m_oIdentifier;
- }
+ /**
+ * @brief number of measured parameters
+ *
+ * @return number of measured parameters
+ */
+ static constexpr unsigned int
+ size()
+ {
+ return ParSet_t::size();
+ }
- /**
- * @brief calculate residual with respect to given track parameters
- *
- * @note It is checked that the residual for non-local parameters are in valid range (e.g.
- * residuals in \f$\phi\f$ are corrected).
- *
- * @todo Implement check that TrackParameters are defined at the same Surface as the Measurement is.
- * @todo Implement validity check for residuals of local parameters.
- *
- * @param trackPars reference TrackParameters object
- *
- * @return vector with the residual parameter values (in valid range)
- *
- * @sa ParameterSet::residual
- */
- ParVector_t residual(const TrackParameters& trackPars) const
- {
- return m_oParameters.residual(trackPars.getParameterSet());
- }
+ /**
+ * @brief access associated surface
+ *
+ * @pre The @c Surface object used to construct this @c Measurement object
+ * must still be valid
+ * at the same memory location.
+ *
+ * @return reference to surface at which the measurement took place
+ */
+ const Acts::Surface&
+ associatedSurface() const
+ {
+ return *m_pSurface;
+ }
- /**
- * @brief equality operator
- *
- * @return @c true if parameter sets and associated surfaces compare equal, otherwise @c false
- */
- virtual bool operator==(const Measurement<Identifier,params...>& rhs) const
- {
- return ((m_oParameters == rhs.m_oParameters) &&
- (*m_pSurface == *rhs.m_pSurface) &&
- (m_oIdentifier == rhs.m_oIdentifier));
- }
+ /**
+ * @brief access to global measurement identifier
+ *
+ * @return identifier object
+ */
+ Identifier
+ identifier() const
+ {
+ return m_oIdentifier;
+ }
- /**
- * @brief inequality operator
- *
- * @return @c true if both objects are not equal, otherwise @c false
- *
- * @sa Measurement::operator==
- */
- bool operator!=(const Measurement<Identifier,params...>& rhs) const
- {
- return !(*this == rhs);
- }
+ /**
+ * @brief calculate residual with respect to given track parameters
+ *
+ * @note It is checked that the residual for non-local parameters are in valid
+ * range (e.g.
+ * residuals in \f$\phi\f$ are corrected).
+ *
+ * @todo Implement check that TrackParameters are defined at the same Surface
+ * as the Measurement is.
+ * @todo Implement validity check for residuals of local parameters.
+ *
+ * @param trackPars reference TrackParameters object
+ *
+ * @return vector with the residual parameter values (in valid range)
+ *
+ * @sa ParameterSet::residual
+ */
+ ParVector_t
+ residual(const TrackParameters& trackPars) const
+ {
+ return m_oParameters.residual(trackPars.getParameterSet());
+ }
- private:
- ParSet_t m_oParameters; ///< measured parameter set
- const Surface* m_pSurface; ///< surface at which the measurement took place
- Identifier m_oIdentifier; ///< identifier for this measurement
- };
+ /**
+ * @brief equality operator
+ *
+ * @return @c true if parameter sets and associated surfaces compare equal,
+ * otherwise @c false
+ */
+ virtual bool
+ operator==(const Measurement<Identifier, params...>& rhs) const
+ {
+ return ((m_oParameters == rhs.m_oParameters)
+ && (*m_pSurface == *rhs.m_pSurface)
+ && (m_oIdentifier == rhs.m_oIdentifier));
+ }
/**
- * @brief general type for any possible Measurement
+ * @brief inequality operator
+ *
+ * @return @c true if both objects are not equal, otherwise @c false
+ *
+ * @sa Measurement::operator==
*/
- template<typename Identifier>
- using FittableMeasurement = typename detail::fittable_type_generator<Identifier>::type;
-} // end of namespace Acts
+ bool
+ operator!=(const Measurement<Identifier, params...>& rhs) const
+ {
+ return !(*this == rhs);
+ }
-#endif // ACTS_MEASUREMENT_H
+private:
+ ParSet_t m_oParameters; ///< measured parameter set
+ const Surface* m_pSurface; ///< surface at which the measurement took place
+ Identifier m_oIdentifier; ///< identifier for this measurement
+};
+/**
+ * @brief general type for any possible Measurement
+ */
+template <typename Identifier>
+using FittableMeasurement =
+ typename detail::fittable_type_generator<Identifier>::type;
+} // end of namespace Acts
+#endif // ACTS_MEASUREMENT_H
diff --git a/Core/include/ACTS/EventData/NeutralParameters.hpp b/Core/include/ACTS/EventData/NeutralParameters.hpp
index 41e48f234..fdbd05233 100644
--- a/Core/include/ACTS/EventData/NeutralParameters.hpp
+++ b/Core/include/ACTS/EventData/NeutralParameters.hpp
@@ -9,16 +9,16 @@
#ifndef ACTS_NEUTRALPARAMETERS_H
#define ACTS_NEUTRALPARAMETERS_H 1
-#include "ACTS/EventData/SingleTrackParameters.hpp"
-#include "ACTS/EventData/SingleCurvilinearTrackParameters.hpp"
-#include "ACTS/EventData/SingleBoundTrackParameters.hpp"
#include "ACTS/EventData/ChargePolicy.hpp"
+#include "ACTS/EventData/SingleBoundTrackParameters.hpp"
+#include "ACTS/EventData/SingleCurvilinearTrackParameters.hpp"
+#include "ACTS/EventData/SingleTrackParameters.hpp"
-namespace Acts
-{
- typedef SingleTrackParameters<NeutralPolicy> NeutralParameters;
- typedef SingleCurvilinearTrackParameters<NeutralPolicy> NeutralCurvilinearParameters;
- typedef SingleBoundTrackParameters<NeutralPolicy> NeutralBoundParameters;
-} // end of namespace Acts
+namespace Acts {
+typedef SingleTrackParameters<NeutralPolicy> NeutralParameters;
+typedef SingleCurvilinearTrackParameters<NeutralPolicy>
+ NeutralCurvilinearParameters;
+typedef SingleBoundTrackParameters<NeutralPolicy> NeutralBoundParameters;
+} // end of namespace Acts
-#endif // ACTS_NEUTRALPARAMETERS_H
+#endif // ACTS_NEUTRALPARAMETERS_H
diff --git a/Core/include/ACTS/EventData/ParameterSet.hpp b/Core/include/ACTS/EventData/ParameterSet.hpp
index 959aa9e2c..a910fef92 100644
--- a/Core/include/ACTS/EventData/ParameterSet.hpp
+++ b/Core/include/ACTS/EventData/ParameterSet.hpp
@@ -15,10 +15,8 @@
#include <utility>
// ACTS includes
-#include "ACTS/Utilities/Definitions.hpp"
-#include "ACTS/Utilities/ParameterDefinitions.hpp"
-#include "ACTS/EventData/detail/are_within.hpp"
#include "ACTS/EventData/detail/are_sorted.hpp"
+#include "ACTS/EventData/detail/are_within.hpp"
#include "ACTS/EventData/detail/full_parameter_set.hpp"
#include "ACTS/EventData/detail/get_position.hpp"
#include "ACTS/EventData/detail/initialize_parameter_set.hpp"
@@ -26,433 +24,541 @@
#include "ACTS/EventData/detail/make_projection_matrix.hpp"
#include "ACTS/EventData/detail/residual_calculator.hpp"
#include "ACTS/EventData/detail/value_corrector.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Utilities/ParameterDefinitions.hpp"
-namespace Acts
+namespace Acts {
+/// @cond
+// forward type declaration for full parameter set
+typedef typename detail::full_parset::type FullParameterSet;
+/// @endcond
+
+/**
+ * @class ParameterSet
+ *
+ * @brief Description of a set of (local) parameters
+ *
+ * @pre
+ * The template parameter @c ParameterPolicy must fulfill the following
+ * requirements:
+ * -# It must contain a <tt>typedef #par_id_type</tt> specifying an integral
+ * type used to identify different
+ * parameters. This could for example be an @c enum, @c short, or
+ * <tt>unsigned int</tt>.
+ * This @c typedef must be convertible to an <tt>unsigned int</tt>
+ * -# It must contain a <tt>typedef #par_value_type</tt> specifying the type of
+ * the parameter values. This could for
+ * instance be @c double, or @c float.
+ * -# It must contain a definition of an integral constant named @c N which is
+ * assignable to an <tt>unsigned
+ * int</tt> and which is equal to the total number of parameters in the
+ * system.
+ * @pre
+ *
+ * The template parameter pack @c params must be given in a strictly ascending
+ * order. The parameter pack must
+ * be non-empty and it cannot contain more elements than
+ * <tt>Acts::NGlobalPars</tt>.
+ *
+ * @test The behavior of this class is tested in the following unit tests:
+ * - \link Acts::Test::BOOST_AUTO_TEST_CASE(parset_consistency_tests)
+ * general consistency\endlink
+ * - \link Acts::Test::BOOST_AUTO_TEST_CASE(parset_copy_assignment_tests)
+ * copy/assignment/swap\endlink
+ * - \link Acts::Test::BOOST_AUTO_TEST_CASE(parset_comparison_tests)
+ * comparison operators\endlink
+ * - \link Acts::Test::BOOST_AUTO_TEST_CASE(parset_projection_tests)
+ * projection matrices\endlink
+ * - \link Acts::Test::BOOST_AUTO_TEST_CASE(parset_residual_tests)
+ * residual calculation\endlink
+ *
+ * @tparam ParameterPolicy struct or class containing the parameter definitions
+ * (see above)
+ * @tparam params parameter pack containing the (local) parameters
+ * stored in this class
+ */
+template <ParID_t... params>
+class ParameterSet
{
+private:
+ // local typedefs and constants
+ typedef ParameterSet<params...> ParSet_t; ///< type of this parameter set
+ static constexpr unsigned int NPars
+ = sizeof...(params); ///< number of parameters stored in this class
+
+ // static assert to check that the template parameters are consistent
+ static_assert(detail::are_sorted<true, true, ParID_t, params...>::value,
+ "parameter identifiers are not sorted");
+ static_assert(
+ detail::are_within<unsigned int,
+ 0,
+ Acts::NGlobalPars,
+ static_cast<unsigned int>(params)...>::value,
+ "parameter identifiers must be greater or "
+ "equal to zero and smaller than the total number of parameters");
+ static_assert(NPars > 0, "number of stored parameters can not be zero");
+ static_assert(
+ NPars <= Acts::NGlobalPars,
+ "number of stored parameters can not exceed number of total parameters");
+
+public:
+ // public typedefs
+ typedef ActsMatrix<ParValue_t, NPars, Acts::NGlobalPars>
+ Projection_t; ///< matrix type for projecting full parameter vector onto
+ ///local parameter space
+ typedef ActsVector<ParValue_t, NPars>
+ ParVector_t; ///< vector type for stored parameters
+ typedef ActsSymMatrix<ParValue_t, NPars>
+ CovMatrix_t; ///< type of covariance matrix
+ typedef std::unique_ptr<CovMatrix_t>
+ CovPtr_t; ///< type for unique pointer to covariance matrix
+
+ /**
+ * @brief initialize values of stored parameters and their covariance matrix
+ *
+ * @note No validation of the given covariance matrix is performed (e.g. that
+ * it is symmetric).
+ *
+ * @param cov unique pointer to covariance matrix (nullptr is accepted)
+ * @param values parameter pack with values for the stored parameters
+ */
+ template <typename... Tail>
+ ParameterSet(CovPtr_t cov,
+ std::enable_if_t<sizeof...(Tail) + 1 == NPars, ParValue_t> head,
+ Tail... values)
+ : m_vValues(NPars), m_pCovariance(std::move(cov))
+ {
+ detail::initialize_parset<ParID_t, params...>::init(*this, head, values...);
+ }
+
+ /**
+ * @brief initialize parameter values from vector and set their covariance
+ * matrix
+ *
+ * @note The values in the passed vector are interpreted as parameter values
+ * in the order given
+ * by the class template @c params. No validation of the given
+ * covariance matrix is performed.
+ *
+ * @param cov unique pointer to covariance matrix (nullptr is accepted)
+ * @param values vector with parameter values
+ */
+ ParameterSet(CovPtr_t cov, const ParVector_t& values)
+ : m_vValues(NPars), m_pCovariance(std::move(cov))
+ {
+ detail::initialize_parset<ParID_t, params...>::init(*this, values);
+ }
+
+ /**
+ * @brief copy constructor
+ *
+ * @param copy object whose content is copied into the new @c ParameterSet
+ * object
+ */
+ ParameterSet(const ParSet_t& copy)
+ : m_vValues(copy.m_vValues), m_pCovariance(nullptr)
+ {
+ if (copy.m_pCovariance)
+ m_pCovariance = std::make_unique<CovMatrix_t>(*copy.m_pCovariance);
+ }
+
+ /**
+ * @brief move constructor
+ *
+ * @param copy object whose content is moved into the new @c ParameterSet
+ * object
+ */
+ ParameterSet(ParSet_t&& copy)
+ : m_vValues(std::move(copy.m_vValues))
+ , m_pCovariance(std::move(copy.m_pCovariance))
+ {
+ }
+
+ /**
+ * @brief standard destructor
+ */
+ ~ParameterSet() = default;
+
+ /**
+ * @brief assignment operator
+ *
+ * @param rhs object whose content is assigned to this @c ParameterSet object
+ */
+ ParSet_t&
+ operator=(const ParSet_t& rhs)
+ {
+ m_vValues = rhs.m_vValues;
+ m_pCovariance
+ = (rhs.m_pCovariance ? std::make_unique<CovMatrix_t>(*rhs.m_pCovariance)
+ : nullptr);
+ return *this;
+ }
+
+ /**
+ * @brief move assignment operator
+ *
+ * @param rhs object whose content is moved into this @c ParameterSet object
+ */
+ ParSet_t&
+ operator=(ParSet_t&& rhs)
+ {
+ m_vValues = std::move(rhs.m_vValues);
+ m_pCovariance = std::move(rhs.m_pCovariance);
+ return *this;
+ }
+
+ /**
+ * @brief swap two objects
+ */
+ friend void
+ swap(ParSet_t& first, ParSet_t& second) noexcept
+ {
+ using std::swap;
+ swap(first.m_vValues, second.m_vValues);
+ swap(first.m_pCovariance, second.m_pCovariance);
+ }
+
+ /**
+ * @brief retrieve stored value for given parameter
+ *
+ * @tparam parameter identifier for the parameter to be retrieved
+ * @remark @c parameter must be part of the template parameter pack @c params.
+ * Otherwise a compile-time
+ * error is generated.
+ *
+ * @return value of the stored parameter
+ */
+ template <ParID_t parameter>
+ ParValue_t
+ getParameter() const
+ {
+ return m_vValues(
+ detail::get_position<ParID_t, parameter, params...>::value);
+ }
+
+ /**
+ * @brief access vector with stored parameters
+ *
+ * @return column vector with @c #NPars rows
+ */
+ ParVector_t
+ getParameters() const
+ {
+ return m_vValues;
+ }
+
+ /**
+ * @brief sets value for given parameter
+ *
+ * @tparam parameter identifier for the parameter to be stored
+ * @remark @c parameter must be part of the template parameter pack @c params.
+ * Otherwise a compile-time
+ * error is generated.
+ *
+ * @return previously stored value of this parameter
+ */
+ template <ParID_t parameter>
+ void
+ setParameter(ParValue_t value)
+ {
+ typedef typename par_type<parameter>::type parameter_type;
+ m_vValues(detail::get_position<ParID_t, parameter, params...>::value)
+ = parameter_type::getValue(value);
+ }
+
+ /**
+ * @brief sets values of stored parameters
+ *
+ * The values of the given vector are interpreted as parameter values in the
+ * order
+ * of the class template `params...`.
+ *
+ * @param values vector of length #NPars
+ */
+ void
+ setParameters(const ParVector_t& values)
+ {
+ detail::initialize_parset<ParID_t, params...>::init(*this, values);
+ }
+
+ /**
+ * @brief checks whether a given parameter is included in this set of
+ parameters
+
+ * @tparam parameter identifier for the parameter to be retrieved
+ * @remark @c parameter must be part of the template parameter pack @c params.
+ Otherwise a compile-time
+ * error is generated.
+ *
+ * @return @c true if the parameter is stored in this set, otherwise @c false
+ */
+ template <ParID_t parameter>
+ bool
+ contains() const
+ {
+ return detail::is_contained<ParID_t, parameter, params...>::value;
+ }
+
+ /**
+ * @brief access covariance matrix for stored parameters
+ *
+ * @note The ownership of the covariance matrix is @b not transferred with
+ * this call.
+ *
+ * @return raw pointer to covariance matrix (can be a nullptr)
+ */
+ const CovMatrix_t*
+ getCovariance() const
+ {
+ return m_pCovariance.get();
+ }
+
+ /**
+ * @brief access uncertainty for individual parameter
+ *
+ * @tparam parameter identifier for the parameter to be retrieved
+ * @remark @c parameter must be part of the template parameter pack @c params.
+ * Otherwise a compile-time
+ * error is generated.
+ *
+ * @return uncertainty \f$\sigma \ge 0\f$ of given parameter, a negative value
+ * is returned if no
+ * covariance matrix is set
+ */
+ template <ParID_t parameter>
+ ParValue_t
+ uncertainty() const;
+
+ /**
+ * @brief update covariance matrix
+ *
+ * @note No validation of the given covariance matrix is performed.
+ *
+ * @param cov unique pointer to new covariance matrix (nullptr is accepted)
+ */
+ void
+ setCovariance(CovPtr_t cov)
+ {
+ m_pCovariance = std::move(cov);
+ }
+
+ /**
+ * @brief equality operator
+ *
+ * @return @c true if stored parameter values are equal and both covariance
+ * matrices are
+ * either identical or not set, otherwise @c false
+ */
+ bool
+ operator==(const ParSet_t& rhs) const
+ {
+ // shortcut comparison with myself
+ if (&rhs == this) return true;
+
+ // parameter values
+ if (m_vValues != rhs.m_vValues) return false;
+ // both have covariance matrices set
+ if ((m_pCovariance && rhs.m_pCovariance)
+ && (*m_pCovariance != *rhs.m_pCovariance))
+ return false;
+ // only one has a covariance matrix set
+ if ((m_pCovariance && !rhs.m_pCovariance)
+ || (!m_pCovariance && rhs.m_pCovariance))
+ return false;
+
+ return true;
+ }
+
+ /**
+ * @brief inequality operator
+ *
+ * @return @c true if both objects are not equal, otherwise @c false
+ *
+ * @sa ParameterSet::operator==
+ */
+ bool
+ operator!=(const ParSet_t& rhs) const
+ {
+ return !(*this == rhs);
+ }
+
+ /**
+ * @brief project vector of full parameter set onto parameter sub-space
+ *
+ * Let \f$ \left(p_1 \dots p_N \right)\f$ be the full set of parameters out of
+ * which the \f$m\f$
+ * parameters \f$ \left( p_{i_1} \dots p_{i_m} \right), i_1 < i_2 < \dots <
+ * i_m, m \le N, i_j \le N\f$
+ * are stored in this ParameterSet object. Let \f$ \left(v^0_1 \dots v^0_N
+ * \right)\f$ be the parameter
+ * values given in the full ParameterSet, then this methods applies the
+ * following mapping:
+ * \f[
+ * \mathbb{R}^{N \times 1} \mapsto \mathbb{R}^{m \times 1} : \left(
+ * \begin{array}{c} v_1^0 \\ \vdots \\ v_N^0 \end{array} \right) \mapsto
+ * \left( \begin{array}{c} v_{i_1}^0 \\ \vdots \\ v_{i_m}^0 \end{array}
+ * \right)
+ * \f]
+ *
+ * @param fullParSet ParameterSet object containing values for all defined
+ * parameters
+ *
+ * @return vector containing only the parameter values from the full parameter
+ * vector
+ * which are also defined for this ParameterSet object
+ */
+ ParVector_t
+ project(const FullParameterSet& fullParSet) const
+ {
+ return projector() * fullParSet.getParameters();
+ }
+
+ /**
+ * @brief calculate residual difference to full parameter vector
+ *
+ * Calculate the residual differences of the stored parameter values with
+ * respect to the corresponding
+ * parameter values in the full parameter vector. Hereby, the residual vector
+ * is defined as
+ *
+ * \f[
+ * \vec{r} = \left( \begin{array}{c} r_{i_1} \\ \vdots \\ r_{i_m} \end{array}
+ * \right)
+ * = \left( \begin{array}{c} v_{i_1} \\ \vdots \\ v_{i_m} \end{array} \right)
+ * - \mathrm{Proj} \left( \begin{array}{c} v^0_{1} \\ \vdots \\ v^0_{N}
+ * \end{array} \right)
+ * = \vec{v} - \mathrm{Proj} \left( \vec{v}^0 \right)
+ * \f]
+ *
+ * where \f$\mathrm{Proj}\f$ is the projection matrix, \f$\vec{v}\f$ is the
+ * vector of parameter values of
+ * this ParameterSet object and \f$\vec{v}^0\f$ is the full parameter value
+ * vector.
+ *
+ * @note Constraint and cyclic parameter value ranges are taken into account
+ * when calculating
+ * the residual values.
+ *
+ * @param fullParSet ParameterSet object containing the full set of parameters
+ *
+ * @return vector containing the residual parameter values of this
+ * ParameterSet object
+ * with respect to the given full parameter vector
+ *
+ * @sa ParameterSet::projector
+ */
/// @cond
- // forward type declaration for full parameter set
- typedef typename detail::full_parset::type FullParameterSet;
+ template <
+ typename T = ParSet_t,
+ std::enable_if_t<not std::is_same<T, FullParameterSet>::value, int> = 0>
/// @endcond
+ ParVector_t
+ residual(const FullParameterSet& fullParSet) const
+ {
+ return detail::residual_calculator<params...>::result(
+ m_vValues, projector() * fullParSet.getParameters());
+ }
/**
- * @class ParameterSet
- *
- * @brief Description of a set of (local) parameters
- *
- * @pre
- * The template parameter @c ParameterPolicy must fulfill the following requirements:
- * -# It must contain a <tt>typedef #par_id_type</tt> specifying an integral type used to identify different
- * parameters. This could for example be an @c enum, @c short, or <tt>unsigned int</tt>.
- * This @c typedef must be convertible to an <tt>unsigned int</tt>
- * -# It must contain a <tt>typedef #par_value_type</tt> specifying the type of the parameter values. This could for
- * instance be @c double, or @c float.
- * -# It must contain a definition of an integral constant named @c N which is assignable to an <tt>unsigned
- * int</tt> and which is equal to the total number of parameters in the system.
- * @pre
- *
- * The template parameter pack @c params must be given in a strictly ascending order. The parameter pack must
- * be non-empty and it cannot contain more elements than <tt>Acts::NGlobalPars</tt>.
- *
- * @test The behavior of this class is tested in the following unit tests:
- * - \link Acts::Test::BOOST_AUTO_TEST_CASE(parset_consistency_tests) general consistency\endlink
- * - \link Acts::Test::BOOST_AUTO_TEST_CASE(parset_copy_assignment_tests) copy/assignment/swap\endlink
- * - \link Acts::Test::BOOST_AUTO_TEST_CASE(parset_comparison_tests) comparison operators\endlink
- * - \link Acts::Test::BOOST_AUTO_TEST_CASE(parset_projection_tests) projection matrices\endlink
- * - \link Acts::Test::BOOST_AUTO_TEST_CASE(parset_residual_tests) residual calculation\endlink
- *
- * @tparam ParameterPolicy struct or class containing the parameter definitions (see above)
- * @tparam params parameter pack containing the (local) parameters stored in this class
+ * @brief calculate residual difference to other parameter vector
+ *
+ * Calculate the residual differences of the stored parameter values with
+ * respect to the values of
+ * another ParameterSet object containing the same set of parameters. Hereby,
+ * the residual vector is
+ * defined as
+ *
+ * \f[
+ * \vec{r} = \left( \begin{array}{c} r_{i_1} \\ \vdots \\ r_{i_m} \end{array}
+ * \right)
+ * = \left( \begin{array}{c} v_{i_1} \\ \vdots \\ v_{i_m} \end{array} \right)
+ * - \left( \begin{array}{c} v^0_{1} \\ \vdots \\ v^0_{N} \end{array} \right)
+ * = \vec{v} - \left( \vec{v}^0 \right)
+ * \f]
+ *
+ * where \f$\vec{v}\f$ is the vector of parameter values of this ParameterSet
+ * object and \f$\vec{v}^0\f$
+ * is the parameter value vector of the other ParameterSet object.
+ *
+ * @note Constraint and cyclic parameter value ranges are taken into account
+ * when calculating
+ * the residual values.
+ *
+ * @param otherParSet ParameterSet object with identical set of contained
+ * parameters
+ *
+ * @return vector containing the residual parameter values of this
+ * ParameterSet object
+ * with respect to the given other parameter set
+ */
+ ParVector_t
+ residual(const ParSet_t& otherParSet) const
+ {
+ return detail::residual_calculator<params...>::result(
+ m_vValues, otherParSet.m_vValues);
+ }
+
+ /**
+ * @brief get projection matrix
+ *
+ * The projection matrix performs a mapping of the full parameter space onto
+ * the sub-space
+ * spanned by the parameters defined in this ParameterSet object.
+ *
+ * @return constant matrix with @c #NPars rows and @c #Acts::NGlobalPars
+ * columns
+ */
+ static const ActsMatrix<ParValue_t, NPars, Acts::NGlobalPars>
+ projector()
+ {
+ return sProjector;
+ }
+
+ /**
+ * @brief number of stored parameters
+ *
+ * @return number of stored parameters
+ */
+ static constexpr unsigned int
+ size()
+ {
+ return NPars;
+ }
+
+ /**
+ * @brief correct given parameter values
+ *
+ * Check that the given values are within in a valid range for the
+ * corresponding parameter. If not, an
+ * in-place correction is applied. The values are interpreted as parameter
+ * values in the same order as
+ * specified in the class template @c params.
+ *
+ * @param values vector with parameter values to be checked and corrected if
+ * necessary
*/
- template<ParID_t ... params>
- class ParameterSet
+ static void
+ correctValues(ParVector_t& values)
{
- private:
- // local typedefs and constants
- typedef ParameterSet<params...> ParSet_t; ///< type of this parameter set
- static constexpr unsigned int NPars = sizeof...(params); ///< number of parameters stored in this class
-
- // static assert to check that the template parameters are consistent
- static_assert(detail::are_sorted<true,true,ParID_t,params...>::value,"parameter identifiers are not sorted");
- static_assert(detail::are_within<unsigned int,0,Acts::NGlobalPars,static_cast<unsigned int>(params)...>::value,"parameter identifiers must be greater or "
- "equal to zero and smaller than the total number of parameters");
- static_assert(NPars > 0,"number of stored parameters can not be zero");
- static_assert(NPars <= Acts::NGlobalPars,"number of stored parameters can not exceed number of total parameters");
-
- public:
- // public typedefs
- typedef ActsMatrix<ParValue_t,NPars,Acts::NGlobalPars> Projection_t; ///< matrix type for projecting full parameter vector onto local parameter space
- typedef ActsVector<ParValue_t,NPars> ParVector_t; ///< vector type for stored parameters
- typedef ActsSymMatrix<ParValue_t,NPars> CovMatrix_t; ///< type of covariance matrix
- typedef std::unique_ptr<CovMatrix_t> CovPtr_t; ///< type for unique pointer to covariance matrix
-
- /**
- * @brief initialize values of stored parameters and their covariance matrix
- *
- * @note No validation of the given covariance matrix is performed (e.g. that it is symmetric).
- *
- * @param cov unique pointer to covariance matrix (nullptr is accepted)
- * @param values parameter pack with values for the stored parameters
- */
- template<typename ... Tail>
- ParameterSet(CovPtr_t cov,std::enable_if_t<sizeof...(Tail) + 1 == NPars, ParValue_t> head, Tail ... values):
- m_vValues(NPars),
- m_pCovariance(std::move(cov))
- {
- detail::initialize_parset<ParID_t,params...>::init(*this,head,values...);
- }
-
- /**
- * @brief initialize parameter values from vector and set their covariance matrix
- *
- * @note The values in the passed vector are interpreted as parameter values in the order given
- * by the class template @c params. No validation of the given covariance matrix is performed.
- *
- * @param cov unique pointer to covariance matrix (nullptr is accepted)
- * @param values vector with parameter values
- */
- ParameterSet(CovPtr_t cov,const ParVector_t& values):
- m_vValues(NPars),
- m_pCovariance(std::move(cov))
- {
- detail::initialize_parset<ParID_t,params...>::init(*this,values);
- }
-
- /**
- * @brief copy constructor
- *
- * @param copy object whose content is copied into the new @c ParameterSet object
- */
- ParameterSet(const ParSet_t& copy):
- m_vValues(copy.m_vValues),
- m_pCovariance(nullptr)
- {
- if(copy.m_pCovariance)
- m_pCovariance = std::make_unique<CovMatrix_t>(*copy.m_pCovariance);
- }
-
- /**
- * @brief move constructor
- *
- * @param copy object whose content is moved into the new @c ParameterSet object
- */
- ParameterSet(ParSet_t&& copy):
- m_vValues(std::move(copy.m_vValues)),
- m_pCovariance(std::move(copy.m_pCovariance))
- {}
-
- /**
- * @brief standard destructor
- */
- ~ParameterSet() = default;
-
- /**
- * @brief assignment operator
- *
- * @param rhs object whose content is assigned to this @c ParameterSet object
- */
- ParSet_t& operator=(const ParSet_t& rhs)
- {
- m_vValues = rhs.m_vValues;
- m_pCovariance = (rhs.m_pCovariance ? std::make_unique<CovMatrix_t>(*rhs.m_pCovariance): nullptr);
- return *this;
- }
-
- /**
- * @brief move assignment operator
- *
- * @param rhs object whose content is moved into this @c ParameterSet object
- */
- ParSet_t& operator=(ParSet_t&& rhs)
- {
- m_vValues = std::move(rhs.m_vValues);
- m_pCovariance = std::move(rhs.m_pCovariance);
- return *this;
- }
-
- /**
- * @brief swap two objects
- */
- friend void swap(ParSet_t& first,ParSet_t& second) noexcept
- {
- using std::swap;
- swap(first.m_vValues,second.m_vValues);
- swap(first.m_pCovariance,second.m_pCovariance);
- }
-
- /**
- * @brief retrieve stored value for given parameter
- *
- * @tparam parameter identifier for the parameter to be retrieved
- * @remark @c parameter must be part of the template parameter pack @c params. Otherwise a compile-time
- * error is generated.
- *
- * @return value of the stored parameter
- */
- template<ParID_t parameter>
- ParValue_t getParameter() const
- {
- return m_vValues(detail::get_position<ParID_t, parameter, params...>::value);
- }
-
- /**
- * @brief access vector with stored parameters
- *
- * @return column vector with @c #NPars rows
- */
- ParVector_t getParameters() const
- {
- return m_vValues;
- }
-
- /**
- * @brief sets value for given parameter
- *
- * @tparam parameter identifier for the parameter to be stored
- * @remark @c parameter must be part of the template parameter pack @c params. Otherwise a compile-time
- * error is generated.
- *
- * @return previously stored value of this parameter
- */
- template<ParID_t parameter>
- void setParameter(ParValue_t value)
- {
- typedef typename par_type<parameter>::type parameter_type;
- m_vValues(detail::get_position<ParID_t, parameter, params...>::value) = parameter_type::getValue(value);
- }
-
- /**
- * @brief sets values of stored parameters
- *
- * The values of the given vector are interpreted as parameter values in the order
- * of the class template `params...`.
- *
- * @param values vector of length #NPars
- */
- void setParameters(const ParVector_t& values)
- {
- detail::initialize_parset<ParID_t,params...>::init(*this,values);
- }
-
- /**
- * @brief checks whether a given parameter is included in this set of parameters
-
- * @tparam parameter identifier for the parameter to be retrieved
- * @remark @c parameter must be part of the template parameter pack @c params. Otherwise a compile-time
- * error is generated.
- *
- * @return @c true if the parameter is stored in this set, otherwise @c false
- */
- template<ParID_t parameter>
- bool contains() const
- {
- return detail::is_contained<ParID_t, parameter, params...>::value;
- }
-
- /**
- * @brief access covariance matrix for stored parameters
- *
- * @note The ownership of the covariance matrix is @b not transferred with this call.
- *
- * @return raw pointer to covariance matrix (can be a nullptr)
- */
- const CovMatrix_t* getCovariance() const
- {
- return m_pCovariance.get();
- }
-
- /**
- * @brief access uncertainty for individual parameter
- *
- * @tparam parameter identifier for the parameter to be retrieved
- * @remark @c parameter must be part of the template parameter pack @c params. Otherwise a compile-time
- * error is generated.
- *
- * @return uncertainty \f$\sigma \ge 0\f$ of given parameter, a negative value is returned if no
- * covariance matrix is set
- */
- template<ParID_t parameter>
- ParValue_t uncertainty() const;
-
- /**
- * @brief update covariance matrix
- *
- * @note No validation of the given covariance matrix is performed.
- *
- * @param cov unique pointer to new covariance matrix (nullptr is accepted)
- */
- void setCovariance(CovPtr_t cov)
- {
- m_pCovariance = std::move(cov);
- }
-
- /**
- * @brief equality operator
- *
- * @return @c true if stored parameter values are equal and both covariance matrices are
- * either identical or not set, otherwise @c false
- */
- bool operator==(const ParSet_t& rhs) const
- {
- // shortcut comparison with myself
- if(&rhs == this)
- return true;
-
- // parameter values
- if(m_vValues != rhs.m_vValues)
- return false;
- // both have covariance matrices set
- if((m_pCovariance && rhs.m_pCovariance) && (*m_pCovariance != *rhs.m_pCovariance))
- return false;
- // only one has a covariance matrix set
- if((m_pCovariance && !rhs.m_pCovariance) || (!m_pCovariance && rhs.m_pCovariance))
- return false;
-
- return true;
- }
-
- /**
- * @brief inequality operator
- *
- * @return @c true if both objects are not equal, otherwise @c false
- *
- * @sa ParameterSet::operator==
- */
- bool operator!=(const ParSet_t& rhs) const
- {
- return !(*this == rhs);
- }
-
- /**
- * @brief project vector of full parameter set onto parameter sub-space
- *
- * Let \f$ \left(p_1 \dots p_N \right)\f$ be the full set of parameters out of which the \f$m\f$
- * parameters \f$ \left( p_{i_1} \dots p_{i_m} \right), i_1 < i_2 < \dots < i_m, m \le N, i_j \le N\f$
- * are stored in this ParameterSet object. Let \f$ \left(v^0_1 \dots v^0_N \right)\f$ be the parameter
- * values given in the full ParameterSet, then this methods applies the following mapping:
- * \f[
- * \mathbb{R}^{N \times 1} \mapsto \mathbb{R}^{m \times 1} : \left( \begin{array}{c} v_1^0 \\ \vdots \\ v_N^0 \end{array} \right) \mapsto \left( \begin{array}{c} v_{i_1}^0 \\ \vdots \\ v_{i_m}^0 \end{array} \right)
- * \f]
- *
- * @param fullParSet ParameterSet object containing values for all defined parameters
- *
- * @return vector containing only the parameter values from the full parameter vector
- * which are also defined for this ParameterSet object
- */
- ParVector_t project(const FullParameterSet& fullParSet) const
- {
- return projector() * fullParSet.getParameters();
- }
-
- /**
- * @brief calculate residual difference to full parameter vector
- *
- * Calculate the residual differences of the stored parameter values with respect to the corresponding
- * parameter values in the full parameter vector. Hereby, the residual vector is defined as
- *
- * \f[
- * \vec{r} = \left( \begin{array}{c} r_{i_1} \\ \vdots \\ r_{i_m} \end{array} \right)
- * = \left( \begin{array}{c} v_{i_1} \\ \vdots \\ v_{i_m} \end{array} \right) - \mathrm{Proj} \left( \begin{array}{c} v^0_{1} \\ \vdots \\ v^0_{N} \end{array} \right)
- * = \vec{v} - \mathrm{Proj} \left( \vec{v}^0 \right)
- * \f]
- *
- * where \f$\mathrm{Proj}\f$ is the projection matrix, \f$\vec{v}\f$ is the vector of parameter values of
- * this ParameterSet object and \f$\vec{v}^0\f$ is the full parameter value vector.
- *
- * @note Constraint and cyclic parameter value ranges are taken into account when calculating
- * the residual values.
- *
- * @param fullParSet ParameterSet object containing the full set of parameters
- *
- * @return vector containing the residual parameter values of this ParameterSet object
- * with respect to the given full parameter vector
- *
- * @sa ParameterSet::projector
- */
- /// @cond
- template<typename T = ParSet_t,std::enable_if_t<not std::is_same<T,FullParameterSet>::value,int> = 0>
- /// @endcond
- ParVector_t residual(const FullParameterSet& fullParSet) const
- {
- return detail::residual_calculator<params...>::result(m_vValues,projector() * fullParSet.getParameters());
- }
-
- /**
- * @brief calculate residual difference to other parameter vector
- *
- * Calculate the residual differences of the stored parameter values with respect to the values of
- * another ParameterSet object containing the same set of parameters. Hereby, the residual vector is
- * defined as
- *
- * \f[
- * \vec{r} = \left( \begin{array}{c} r_{i_1} \\ \vdots \\ r_{i_m} \end{array} \right)
- * = \left( \begin{array}{c} v_{i_1} \\ \vdots \\ v_{i_m} \end{array} \right) - \left( \begin{array}{c} v^0_{1} \\ \vdots \\ v^0_{N} \end{array} \right)
- * = \vec{v} - \left( \vec{v}^0 \right)
- * \f]
- *
- * where \f$\vec{v}\f$ is the vector of parameter values of this ParameterSet object and \f$\vec{v}^0\f$
- * is the parameter value vector of the other ParameterSet object.
- *
- * @note Constraint and cyclic parameter value ranges are taken into account when calculating
- * the residual values.
- *
- * @param otherParSet ParameterSet object with identical set of contained parameters
- *
- * @return vector containing the residual parameter values of this ParameterSet object
- * with respect to the given other parameter set
- */
- ParVector_t residual(const ParSet_t& otherParSet) const
- {
- return detail::residual_calculator<params...>::result(m_vValues,otherParSet.m_vValues);
- }
-
- /**
- * @brief get projection matrix
- *
- * The projection matrix performs a mapping of the full parameter space onto the sub-space
- * spanned by the parameters defined in this ParameterSet object.
- *
- * @return constant matrix with @c #NPars rows and @c #Acts::NGlobalPars columns
- */
- static const ActsMatrix<ParValue_t,NPars,Acts::NGlobalPars> projector()
- {
- return sProjector;
- }
-
- /**
- * @brief number of stored parameters
- *
- * @return number of stored parameters
- */
- static constexpr unsigned int size()
- {
- return NPars;
- }
-
- /**
- * @brief correct given parameter values
- *
- * Check that the given values are within in a valid range for the corresponding parameter. If not, an
- * in-place correction is applied. The values are interpreted as parameter values in the same order as
- * specified in the class template @c params.
- *
- * @param values vector with parameter values to be checked and corrected if necessary
- */
- static void correctValues(ParVector_t& values)
- {
- detail::value_corrector<params...>::result(values);
- }
-
- private:
- ParVector_t m_vValues; ///< column vector containing values of local parameters
- CovPtr_t m_pCovariance; ///< unique pointer to covariance matrix
-
- static const Projection_t sProjector; ///< matrix to project full parameter vector onto local parameter space
- };
-
- // initialize static class members
- template<ParID_t ... params>
- const typename ParameterSet<params...>::Projection_t
- ParameterSet<params...>::sProjector = detail::make_projection_matrix<Acts::NGlobalPars, static_cast<unsigned int>(params)...>::init();
-} // end of namespace Acts
-
-#endif // ACTS_PARAMETERSET_H
+ detail::value_corrector<params...>::result(values);
+ }
+
+private:
+ ParVector_t
+ m_vValues; ///< column vector containing values of local parameters
+ CovPtr_t m_pCovariance; ///< unique pointer to covariance matrix
+
+ static const Projection_t sProjector; ///< matrix to project full parameter
+ ///vector onto local parameter space
+};
+
+// initialize static class members
+template <ParID_t... params>
+const typename ParameterSet<params...>::Projection_t
+ ParameterSet<params...>::sProjector
+ = detail::make_projection_matrix<Acts::NGlobalPars,
+ static_cast<unsigned int>(
+ params)...>::init();
+} // end of namespace Acts
+
+#endif // ACTS_PARAMETERSET_H
diff --git a/Core/include/ACTS/EventData/ParticleDefinitions.hpp b/Core/include/ACTS/EventData/ParticleDefinitions.hpp
index 19850b09b..b91b7a9aa 100644
--- a/Core/include/ACTS/EventData/ParticleDefinitions.hpp
+++ b/Core/include/ACTS/EventData/ParticleDefinitions.hpp
@@ -13,7 +13,6 @@
#ifndef ACTS_EVENTUTILS_PARTICLEDEFINITIONS_H
#define ACTS_EVENTUTILS_PARTICLEDEFINITIONS_H
-
// ACTS
#include "ACTS/Utilities/Definitions.hpp"
// STL
@@ -29,313 +28,388 @@ typedef int pdg_type;
namespace Acts {
- /** @enum ParticleType
-
- Enumeration for Particle type respecting
- the interaction with the material
-
- */
- enum ParticleType { 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
- pion = 3, //!< reconstruction + fatras : type as pion hypothesis
- kaon = 4, //!< reconstruction + fatras : type as kaon hypothesis
- proton = 5, //!< reconstruction + fatras : type as proton hypothesis
- photon = 6, //!< for fatras usage
- 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
- noHypothesis = 99,
- undefined = 99};
-
- /** @struct ParticleMasses
- Mass declaration of particles covered
- in the ParticleType.
- Masses are given in MeV and taken from:
-
- Review of Particle Physics (2010)
- K. Nakamura et al. (Particle Data Group), J. Phys. G 37, 075021 (2010)
-
- */
-
- struct ParticleMasses {
-
- /** the vector of masses - in MeV */
- std::vector<double> mass;
-
- /**Default constructor*/
- ParticleMasses()
- {
- mass.reserve(PARTICLETYPES);
-
- mass.push_back(0.); // non interacting mass
- mass.push_back(0.51099891); // electron mass
- mass.push_back(105.658367); // muon mass
- mass.push_back(139.57018); // charged pion mass
- mass.push_back(493.677); // kaon mass
- mass.push_back(938.272013); // proton mass
- mass.push_back(0.); // photon rest mass
- mass.push_back(939.565346); // neutron rest mass
- mass.push_back(134.9766); // pi0 rest mass
- mass.push_back(497.614); // K0 rest mass
- mass.push_back(105.658367); // muon mass
-
- }
-
- };
-
-
- /** Static method : convert to ParticleType from pdg */
- static ParticleType convertToParticleType(pdg_type pdg, bool& stable, bool& exiting, double charge) {
-
- int pdgCode = abs(pdg);
-
- stable = false;
- exiting = false;
-
- ParticleType particleType;
-
- // try to follow number of appearance
- switch (pdgCode)
- {
- // leptons
- case 11: // e+/e-
- particleType = electron;
- stable = true;
- exiting = false;
- break;
- case 13: // mu+/mu-
- particleType = muon;
- stable = false;
- exiting = false;
- break;
- case 12: // e neutrino
- case 14: // mu neutrino
- case 16: // tau neutrino
- particleType = nonInteracting;
- stable = true;
- exiting = true;
- break;
- case 22: // gamma
- particleType = photon;
- stable = true;
- exiting = false;
- break;
- case 211: // pi+/pi-
- particleType = pion;
- stable = false;
- exiting = false;
- break;
- case 111: // pi0
- particleType = pi0;
- stable = false;
- exiting = false;
- break;
- case 2212: // proton
- particleType = proton;
- stable = true;
- exiting = false;
- break;
- case 2112: // neutron
- particleType = neutron;
- stable = true;
- exiting = true;
- break;
- case 321: // K
- particleType = kaon;
- stable = false;
- exiting = false;
- break;
- case 130: // K_long
- particleType = k0;
- stable = false;
- exiting = false;
- break;
- case 310: // K_short
- particleType = k0;
- stable = false;
- exiting = false;
- break;
- default: // treat mesons as pions
- particleType = charge != 0. ? pion : pi0 ;
- stable = false;
- exiting = false;
- }
-
- // and all baryons as proton hypo
- if (pdgCode > 999 && pdgCode!=2112 )
- {
- particleType = charge != 0. ? proton : neutron ;
- stable = false;
- exiting = false;
- }
-
- // ignore SUSY particles for now
- if (pdgCode > 1000000)
- {
- particleType = nonInteracting;
- stable = true;
- exiting = true;
- }
-
- return particleType;
- }
-
-
- /** Static method : convert to pdg from ParticleType */
- static int convertToPdg(ParticleType particleHypo, double charge, bool dist)
- {
-
- int pdg = 0;
-
- switch (particleHypo) {
- // the electron case
- case electron : { pdg = 11; pdg *= charge > 0. ? -1 : 1; } return pdg;
- // the muon case
- case muon : { pdg = 13; pdg *= charge > 0. ? -1 : 1; } return pdg;
- // the kaon case
- case kaon : { pdg = 321; pdg *= charge > 0. ? 1 : -1; } return pdg;
- // the proton case
- case proton : { pdg = 2212; pdg *= charge > 0. ? 1 : -1;
- if (charge*charge < 0.0001)
- pdg = dist ? 2112 : -2112; } return pdg;
- // the photon case
- case photon : { pdg = 22; } return pdg;
- // the neutron case
- case neutron : { pdg = 2112; } return pdg;
- // the neutral pion case
- case pi0 : { pdg = 111; } return pdg;
- // the neutral kaon case
- case k0 : { pdg = dist ? 130 : 310; } return pdg;
- // the pion case - is the default
- default : { pdg = 211; pdg *= charge > 0. ? 1 : -1;
- if (charge*charge < 0.0001)
- pdg = 111; };
- }
- return pdg;
- }
-
- /** @class ParticleProperties
-
- very simplistic class for particle properties,
- in order to be used in fast track simulation
-
- */
- class ParticleProperties {
- public :
- /** constructor */
- ParticleProperties(const Vector3D& momentum, double mass = 0., double charge = 0., pdg_type pID = 0., barcode_type barcode=0) :
- m_momentum(momentum),
- m_mass(mass),
- m_charge(charge),
- m_pdgID(pID),
- m_particleType(pion),
- m_barcode(barcode)
- {
- bool exiting, stable;
- m_particleType = convertToParticleType(pID, exiting, stable, charge);
- }
-
- /** constructor */
- ParticleProperties(const ParticleProperties& pProperties) :
- m_momentum(pProperties.m_momentum),
- m_mass(pProperties.m_mass),
- m_charge(pProperties.m_charge),
- m_pdgID(pProperties.m_pdgID),
- m_particleType(pProperties.m_particleType),
- m_barcode(pProperties.m_barcode)
- {}
-
- /** destructor */
- ~ParticleProperties()
- {}
-
- /** assignment operator */
- ParticleProperties& operator=(const ParticleProperties& pProperties)
- {
- if (this != &pProperties){
- m_momentum = pProperties.m_momentum;
- m_mass = pProperties.m_mass;
- m_charge = pProperties.m_charge;
- m_pdgID = pProperties.m_pdgID;
- m_particleType = pProperties.m_particleType;
- m_barcode = pProperties.m_barcode;
- }
- return (*this);
- }
-
- /** return the momentum */
- const Vector3D& momentum() const { return m_momentum; }
-
- /** return the mass */
- double mass() const { return m_mass; }
-
- /** return the charge */
- double charge() const { return m_charge; }
-
- /** return the particle ID */
- pdg_type pdgID() const { return m_pdgID; }
-
- /** return the particle type */
- ParticleType particleType() const { return m_particleType; }
-
- /** return the particle barcode */
- barcode_type barcode() const { return m_barcode; }
-
- private:
- Vector3D m_momentum;
- double m_mass;
- double m_charge;
- pdg_type m_pdgID;
- ParticleType m_particleType;
- barcode_type m_barcode;
- };
-
-
- /** @class ProcessVertex
-
- process vertex class for the fast track simulation
- */
-
- class ProcessVertex {
- public :
- /** constructor */
- ProcessVertex(const Vector3D& pVertex, double pTime, process_type pType, const std::vector<ParticleProperties>& pOutgoing) :
- m_vertex(pVertex),
- m_time(pTime),
- m_type(pType),
- m_outgoing(pOutgoing)
- {}
-
- /** destructor */
- ~ProcessVertex(){}
-
- /** Add a particle */
- void addOutgoing(const ParticleProperties& pProperties);
-
- /** Return the vertex position */
- const Vector3D& vertex() const { return m_vertex; }
-
- /** Return the time of production */
- double interactionTime() const { return m_time; }
-
- /** Return the type of production */
- process_type processType() const { return m_type; }
-
- /** Return the outgoing properties */
- const std::vector<ParticleProperties>& outgoingParticles() const { return m_outgoing; }
-
- private:
- Vector3D m_vertex;
- double m_time;
- process_type m_type;
- std::vector<ParticleProperties> m_outgoing;
+/** @enum ParticleType
+
+ Enumeration for Particle type respecting
+ the interaction with the material
+
+ */
+enum ParticleType {
+ 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
+ pion = 3, //!< reconstruction + fatras : type as pion hypothesis
+ kaon = 4, //!< reconstruction + fatras : type as kaon hypothesis
+ proton = 5, //!< reconstruction + fatras : type as proton hypothesis
+ photon = 6, //!< for fatras usage
+ 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
+ noHypothesis = 99,
+ undefined = 99
+};
+
+/** @struct ParticleMasses
+ Mass declaration of particles covered
+ in the ParticleType.
+ Masses are given in MeV and taken from:
+
+ Review of Particle Physics (2010)
+ K. Nakamura et al. (Particle Data Group), J. Phys. G 37, 075021 (2010)
+
+ */
+
+struct ParticleMasses
+{
+ /** the vector of masses - in MeV */
+ std::vector<double> mass;
+
+ /**Default constructor*/
+ ParticleMasses()
+ {
+ mass.reserve(PARTICLETYPES);
+
+ mass.push_back(0.); // non interacting mass
+ mass.push_back(0.51099891); // electron mass
+ mass.push_back(105.658367); // muon mass
+ mass.push_back(139.57018); // charged pion mass
+ mass.push_back(493.677); // kaon mass
+ mass.push_back(938.272013); // proton mass
+ mass.push_back(0.); // photon rest mass
+ mass.push_back(939.565346); // neutron rest mass
+ mass.push_back(134.9766); // pi0 rest mass
+ mass.push_back(497.614); // K0 rest mass
+ mass.push_back(105.658367); // muon mass
+ }
+};
+
+/** Static method : convert to ParticleType from pdg */
+static ParticleType
+convertToParticleType(pdg_type pdg, bool& stable, bool& exiting, double charge)
+{
+ int pdgCode = abs(pdg);
+
+ stable = false;
+ exiting = false;
+
+ ParticleType particleType;
+
+ // try to follow number of appearance
+ switch (pdgCode) {
+ // leptons
+ case 11: // e+/e-
+ particleType = electron;
+ stable = true;
+ exiting = false;
+ break;
+ case 13: // mu+/mu-
+ particleType = muon;
+ stable = false;
+ exiting = false;
+ break;
+ case 12: // e neutrino
+ case 14: // mu neutrino
+ case 16: // tau neutrino
+ particleType = nonInteracting;
+ stable = true;
+ exiting = true;
+ break;
+ case 22: // gamma
+ particleType = photon;
+ stable = true;
+ exiting = false;
+ break;
+ case 211: // pi+/pi-
+ particleType = pion;
+ stable = false;
+ exiting = false;
+ break;
+ case 111: // pi0
+ particleType = pi0;
+ stable = false;
+ exiting = false;
+ break;
+ case 2212: // proton
+ particleType = proton;
+ stable = true;
+ exiting = false;
+ break;
+ case 2112: // neutron
+ particleType = neutron;
+ stable = true;
+ exiting = true;
+ break;
+ case 321: // K
+ particleType = kaon;
+ stable = false;
+ exiting = false;
+ break;
+ case 130: // K_long
+ particleType = k0;
+ stable = false;
+ exiting = false;
+ break;
+ case 310: // K_short
+ particleType = k0;
+ stable = false;
+ exiting = false;
+ break;
+ default: // treat mesons as pions
+ particleType = charge != 0. ? pion : pi0;
+ stable = false;
+ exiting = false;
+ }
+
+ // and all baryons as proton hypo
+ if (pdgCode > 999 && pdgCode != 2112) {
+ particleType = charge != 0. ? proton : neutron;
+ stable = false;
+ exiting = false;
+ }
+
+ // ignore SUSY particles for now
+ if (pdgCode > 1000000) {
+ particleType = nonInteracting;
+ stable = true;
+ exiting = true;
+ }
+
+ return particleType;
+}
+
+/** Static method : convert to pdg from ParticleType */
+static int
+convertToPdg(ParticleType particleHypo, double charge, bool dist)
+{
+ int pdg = 0;
+
+ switch (particleHypo) {
+ // the electron case
+ case electron: {
+ pdg = 11;
+ pdg *= charge > 0. ? -1 : 1;
+ }
+ return pdg;
+ // the muon case
+ case muon: {
+ pdg = 13;
+ pdg *= charge > 0. ? -1 : 1;
+ }
+ return pdg;
+ // the kaon case
+ case kaon: {
+ pdg = 321;
+ pdg *= charge > 0. ? 1 : -1;
+ }
+ return pdg;
+ // the proton case
+ case proton: {
+ pdg = 2212;
+ pdg *= charge > 0. ? 1 : -1;
+ if (charge * charge < 0.0001) pdg = dist ? 2112 : -2112;
+ }
+ return pdg;
+ // the photon case
+ case photon: {
+ pdg = 22;
+ }
+ return pdg;
+ // the neutron case
+ case neutron: {
+ pdg = 2112;
+ }
+ return pdg;
+ // the neutral pion case
+ case pi0: {
+ pdg = 111;
+ }
+ return pdg;
+ // the neutral kaon case
+ case k0: {
+ pdg = dist ? 130 : 310;
+ }
+ return pdg;
+ // the pion case - is the default
+ default: {
+ pdg = 211;
+ pdg *= charge > 0. ? 1 : -1;
+ if (charge * charge < 0.0001) pdg = 111;
};
-
- inline void ProcessVertex::addOutgoing(const ParticleProperties& pProperties) { m_outgoing.push_back(pProperties); }
-
+ }
+ return pdg;
+}
+
+/** @class ParticleProperties
+
+ very simplistic class for particle properties,
+ in order to be used in fast track simulation
+
+*/
+class ParticleProperties
+{
+public:
+ /** constructor */
+ ParticleProperties(const Vector3D& momentum,
+ double mass = 0.,
+ double charge = 0.,
+ pdg_type pID = 0.,
+ barcode_type barcode = 0)
+ : m_momentum(momentum)
+ , m_mass(mass)
+ , m_charge(charge)
+ , m_pdgID(pID)
+ , m_particleType(pion)
+ , m_barcode(barcode)
+ {
+ bool exiting, stable;
+ m_particleType = convertToParticleType(pID, exiting, stable, charge);
+ }
+
+ /** constructor */
+ ParticleProperties(const ParticleProperties& pProperties)
+ : m_momentum(pProperties.m_momentum)
+ , m_mass(pProperties.m_mass)
+ , m_charge(pProperties.m_charge)
+ , m_pdgID(pProperties.m_pdgID)
+ , m_particleType(pProperties.m_particleType)
+ , m_barcode(pProperties.m_barcode)
+ {
+ }
+
+ /** destructor */
+ ~ParticleProperties() {}
+ /** assignment operator */
+ ParticleProperties&
+ operator=(const ParticleProperties& pProperties)
+ {
+ if (this != &pProperties) {
+ m_momentum = pProperties.m_momentum;
+ m_mass = pProperties.m_mass;
+ m_charge = pProperties.m_charge;
+ m_pdgID = pProperties.m_pdgID;
+ m_particleType = pProperties.m_particleType;
+ m_barcode = pProperties.m_barcode;
+ }
+ return (*this);
+ }
+
+ /** return the momentum */
+ const Vector3D&
+ momentum() const
+ {
+ return m_momentum;
+ }
+
+ /** return the mass */
+ double
+ mass() const
+ {
+ return m_mass;
+ }
+
+ /** return the charge */
+ double
+ charge() const
+ {
+ return m_charge;
+ }
+
+ /** return the particle ID */
+ pdg_type
+ pdgID() const
+ {
+ return m_pdgID;
+ }
+
+ /** return the particle type */
+ ParticleType
+ particleType() const
+ {
+ return m_particleType;
+ }
+
+ /** return the particle barcode */
+ barcode_type
+ barcode() const
+ {
+ return m_barcode;
+ }
+
+private:
+ Vector3D m_momentum;
+ double m_mass;
+ double m_charge;
+ pdg_type m_pdgID;
+ ParticleType m_particleType;
+ barcode_type m_barcode;
+};
+
+/** @class ProcessVertex
+
+ process vertex class for the fast track simulation
+*/
+
+class ProcessVertex
+{
+public:
+ /** constructor */
+ ProcessVertex(const Vector3D& pVertex,
+ double pTime,
+ process_type pType,
+ const std::vector<ParticleProperties>& pOutgoing)
+ : m_vertex(pVertex), m_time(pTime), m_type(pType), m_outgoing(pOutgoing)
+ {
+ }
+
+ /** destructor */
+ ~ProcessVertex() {}
+ /** Add a particle */
+ void
+ addOutgoing(const ParticleProperties& pProperties);
+
+ /** Return the vertex position */
+ const Vector3D&
+ vertex() const
+ {
+ return m_vertex;
+ }
+
+ /** Return the time of production */
+ double
+ interactionTime() const
+ {
+ return m_time;
+ }
+
+ /** Return the type of production */
+ process_type
+ processType() const
+ {
+ return m_type;
+ }
+
+ /** Return the outgoing properties */
+ const std::vector<ParticleProperties>&
+ outgoingParticles() const
+ {
+ return m_outgoing;
+ }
+
+private:
+ Vector3D m_vertex;
+ double m_time;
+ process_type m_type;
+ std::vector<ParticleProperties> m_outgoing;
+};
+
+inline void
+ProcessVertex::addOutgoing(const ParticleProperties& pProperties)
+{
+ m_outgoing.push_back(pProperties);
+}
}
#endif
diff --git a/Core/include/ACTS/EventData/SingleBoundTrackParameters.hpp b/Core/include/ACTS/EventData/SingleBoundTrackParameters.hpp
index e82493c32..d6391ed56 100644
--- a/Core/include/ACTS/EventData/SingleBoundTrackParameters.hpp
+++ b/Core/include/ACTS/EventData/SingleBoundTrackParameters.hpp
@@ -9,150 +9,180 @@
#ifndef ACTS_SINGLEBOUNDTRACKPARAMETERS_H
#define ACTS_SINGLEBOUNDTRACKPARAMETERS_H 1
-//ACTS includes
-#include "ACTS/Surfaces/Surface.hpp"
+// ACTS includes
#include "ACTS/EventData/SingleTrackParameters.hpp"
+#include "ACTS/Surfaces/Surface.hpp"
-namespace Acts
+namespace Acts {
+template <class ChargePolicy>
+class SingleBoundTrackParameters : public SingleTrackParameters<ChargePolicy>
{
- template<class ChargePolicy>
- class SingleBoundTrackParameters : public SingleTrackParameters<ChargePolicy>
+public:
+ typedef typename SingleTrackParameters<ChargePolicy>::ParVector_t ParVector_t;
+ typedef typename SingleTrackParameters<ChargePolicy>::CovPtr_t CovPtr_t;
+
+ template <typename T = ChargePolicy,
+ std::enable_if_t<std::is_same<T, ChargedPolicy>::value, int> = 0>
+ SingleBoundTrackParameters(CovPtr_t cov,
+ const ParVector_t& parValues,
+ const Surface& surface)
+ : SingleTrackParameters<ChargePolicy>(
+ std::move(cov),
+ parValues,
+ detail::coordinate_transformation::parameters2globalPosition(
+ parValues,
+ surface),
+ detail::coordinate_transformation::parameters2globalMomentum(
+ parValues))
+ , m_pSurface(surface.isFree() ? surface.clone() : &surface)
{
- public:
- typedef typename SingleTrackParameters<ChargePolicy>::ParVector_t ParVector_t;
- typedef typename SingleTrackParameters<ChargePolicy>::CovPtr_t CovPtr_t;
-
- template<typename T = ChargePolicy,std::enable_if_t<std::is_same<T,ChargedPolicy>::value,int> = 0>
- SingleBoundTrackParameters(CovPtr_t cov,
- const ParVector_t& parValues,
- const Surface& surface):
- SingleTrackParameters<ChargePolicy>(std::move(cov),
- parValues,
- detail::coordinate_transformation::parameters2globalPosition(parValues,surface),
- detail::coordinate_transformation::parameters2globalMomentum(parValues)),
- m_pSurface(surface.isFree() ? surface.clone() : &surface)
- {}
-
- template<typename T = ChargePolicy,std::enable_if_t<std::is_same<T,ChargedPolicy>::value,int> = 0>
- SingleBoundTrackParameters(CovPtr_t cov,
- const ActsVectorD<3>& position,
- const ActsVectorD<3>& momentum,
- double dCharge,
- const Surface& surface):
- SingleTrackParameters<ChargePolicy>(std::move(cov),
- detail::coordinate_transformation::global2parameters(position,momentum,dCharge,surface),
- position,
- momentum),
- m_pSurface(surface.isFree() ? surface.clone() : &surface)
- {}
-
- template<typename T = ChargePolicy,std::enable_if_t<std::is_same<T,NeutralPolicy>::value,int> = 0>
- SingleBoundTrackParameters(CovPtr_t cov,
- const ParVector_t& parValues,
- const Surface& surface):
- SingleTrackParameters<ChargePolicy>(std::move(cov),
- parValues,
- detail::coordinate_transformation::parameters2globalPosition(parValues,surface),
- detail::coordinate_transformation::parameters2globalMomentum(parValues)),
- m_pSurface(surface.isFree() ? surface.clone() : &surface)
- {}
-
- template<typename T = ChargePolicy,std::enable_if_t<std::is_same<T,NeutralPolicy>::value,int> = 0>
- SingleBoundTrackParameters(CovPtr_t cov,
- const ActsVectorD<3>& position,
- const ActsVectorD<3>& momentum,
- const Surface& surface):
- SingleTrackParameters<ChargePolicy>(std::move(cov),
- detail::coordinate_transformation::global2parameters(position,momentum,0,surface),
- position,
- momentum),
- m_pSurface(surface.isFree() ? surface.clone() : &surface)
- {}
-
- /**
- * @brief copy constructor
- */
- SingleBoundTrackParameters(const SingleBoundTrackParameters<ChargePolicy>& copy):
- SingleTrackParameters<ChargePolicy>(copy),
- m_pSurface(copy.m_pSurface->isFree() ? copy.m_pSurface->clone() : copy.m_pSurface)
- {}
-
- /**
- * @brief move constructor
- */
- SingleBoundTrackParameters(SingleBoundTrackParameters<ChargePolicy>&& copy):
- SingleTrackParameters<ChargePolicy>(std::move(copy)),
- m_pSurface(copy.m_pSurface)
- {
- copy.m_pSurface = 0;
- }
-
- virtual ~SingleBoundTrackParameters()
- {
- if(m_pSurface->isFree())
- delete m_pSurface;
- }
-
- /**
- * @brief copy assignment operator
- */
- SingleBoundTrackParameters<ChargePolicy>& operator=(const SingleBoundTrackParameters<ChargePolicy>& rhs)
- {
- // check for self-assignment
- if(this != &rhs)
- {
- SingleTrackParameters<ChargePolicy>::operator=(rhs);
+ }
+
+ template <typename T = ChargePolicy,
+ std::enable_if_t<std::is_same<T, ChargedPolicy>::value, int> = 0>
+ SingleBoundTrackParameters(CovPtr_t cov,
+ const ActsVectorD<3>& position,
+ const ActsVectorD<3>& momentum,
+ double dCharge,
+ const Surface& surface)
+ : SingleTrackParameters<ChargePolicy>(
+ std::move(cov),
+ detail::coordinate_transformation::global2parameters(position,
+ momentum,
+ dCharge,
+ surface),
+ position,
+ momentum)
+ , m_pSurface(surface.isFree() ? surface.clone() : &surface)
+ {
+ }
+
+ template <typename T = ChargePolicy,
+ std::enable_if_t<std::is_same<T, NeutralPolicy>::value, int> = 0>
+ SingleBoundTrackParameters(CovPtr_t cov,
+ const ParVector_t& parValues,
+ const Surface& surface)
+ : SingleTrackParameters<ChargePolicy>(
+ std::move(cov),
+ parValues,
+ detail::coordinate_transformation::parameters2globalPosition(
+ parValues,
+ surface),
+ detail::coordinate_transformation::parameters2globalMomentum(
+ parValues))
+ , m_pSurface(surface.isFree() ? surface.clone() : &surface)
+ {
+ }
+
+ template <typename T = ChargePolicy,
+ std::enable_if_t<std::is_same<T, NeutralPolicy>::value, int> = 0>
+ SingleBoundTrackParameters(CovPtr_t cov,
+ const ActsVectorD<3>& position,
+ const ActsVectorD<3>& momentum,
+ const Surface& surface)
+ : SingleTrackParameters<ChargePolicy>(
+ std::move(cov),
+ detail::coordinate_transformation::global2parameters(position,
+ momentum,
+ 0,
+ surface),
+ position,
+ momentum)
+ , m_pSurface(surface.isFree() ? surface.clone() : &surface)
+ {
+ }
+
+ /**
+ * @brief copy constructor
+ */
+ SingleBoundTrackParameters(
+ const SingleBoundTrackParameters<ChargePolicy>& copy)
+ : SingleTrackParameters<ChargePolicy>(copy)
+ , m_pSurface(copy.m_pSurface->isFree() ? copy.m_pSurface->clone()
+ : copy.m_pSurface)
+ {
+ }
+
+ /**
+ * @brief move constructor
+ */
+ SingleBoundTrackParameters(SingleBoundTrackParameters<ChargePolicy>&& copy)
+ : SingleTrackParameters<ChargePolicy>(std::move(copy))
+ , m_pSurface(copy.m_pSurface)
+ {
+ copy.m_pSurface = 0;
+ }
- if(m_pSurface->isFree())
- delete m_pSurface;
+ virtual ~SingleBoundTrackParameters()
+ {
+ if (m_pSurface->isFree()) delete m_pSurface;
+ }
+
+ /**
+ * @brief copy assignment operator
+ */
+ SingleBoundTrackParameters<ChargePolicy>&
+ operator=(const SingleBoundTrackParameters<ChargePolicy>& rhs)
+ {
+ // check for self-assignment
+ if (this != &rhs) {
+ SingleTrackParameters<ChargePolicy>::operator=(rhs);
- m_pSurface = rhs.m_pSurface->isFree() ? rhs.m_pSurface->clone() : rhs.m_pSurface;
- }
+ if (m_pSurface->isFree()) delete m_pSurface;
- return *this;
+ m_pSurface
+ = rhs.m_pSurface->isFree() ? rhs.m_pSurface->clone() : rhs.m_pSurface;
}
- /**
- * @brief move assignment operator
- */
- SingleBoundTrackParameters<ChargePolicy>& operator=(SingleBoundTrackParameters<ChargePolicy>&& rhs)
- {
- // check for self-assignment
- if(this != &rhs)
- {
- SingleTrackParameters<ChargePolicy>::operator=(std::move(rhs));
+ return *this;
+ }
- if(m_pSurface->isFree())
- delete m_pSurface;
+ /**
+ * @brief move assignment operator
+ */
+ SingleBoundTrackParameters<ChargePolicy>&
+ operator=(SingleBoundTrackParameters<ChargePolicy>&& rhs)
+ {
+ // check for self-assignment
+ if (this != &rhs) {
+ SingleTrackParameters<ChargePolicy>::operator=(std::move(rhs));
- m_pSurface = rhs.m_pSurface;
- rhs.m_pSurface = 0;
- }
+ if (m_pSurface->isFree()) delete m_pSurface;
- return *this;
+ m_pSurface = rhs.m_pSurface;
+ rhs.m_pSurface = 0;
}
- virtual SingleBoundTrackParameters<ChargePolicy>* clone() const override
- {
- return new SingleBoundTrackParameters<ChargePolicy>(*this);
- }
+ return *this;
+ }
- template<ParID_t par,std::enable_if_t<not std::is_same<typename par_type<par>::type,local_parameter>::value,int> = 0>
- void set(ParValue_t newValue)
- {
- this->getParameterSet().template setParameter<par>(newValue);
- this->updateGlobalCoordinates(typename par_type<par>::type());
- }
+ virtual SingleBoundTrackParameters<ChargePolicy>*
+ clone() const override
+ {
+ return new SingleBoundTrackParameters<ChargePolicy>(*this);
+ }
+
+ template <ParID_t par,
+ std::enable_if_t<not std::is_same<typename par_type<par>::type,
+ local_parameter>::value,
+ int> = 0>
+ void
+ set(ParValue_t newValue)
+ {
+ this->getParameterSet().template setParameter<par>(newValue);
+ this->updateGlobalCoordinates(typename par_type<par>::type());
+ }
- virtual const Surface& associatedSurface() const final
- {
- return *m_pSurface;
- }
+ virtual const Surface&
+ associatedSurface() const final
+ {
+ return *m_pSurface;
+ }
- private:
- const Surface* m_pSurface;
- };
+private:
+ const Surface* m_pSurface;
+};
} // end of namespace Acts
-#endif // ACTS_SINGLEBOUNDTRACKPARAMETERS_H
+#endif // ACTS_SINGLEBOUNDTRACKPARAMETERS_H
diff --git a/Core/include/ACTS/EventData/SingleCurvilinearTrackParameters.hpp b/Core/include/ACTS/EventData/SingleCurvilinearTrackParameters.hpp
index 1108d038d..98b1eb698 100644
--- a/Core/include/ACTS/EventData/SingleCurvilinearTrackParameters.hpp
+++ b/Core/include/ACTS/EventData/SingleCurvilinearTrackParameters.hpp
@@ -16,105 +16,125 @@
#include "ACTS/EventData/SingleTrackParameters.hpp"
#include "ACTS/Surfaces/PlaneSurface.hpp"
-namespace Acts
+namespace Acts {
+template <typename ChargePolicy>
+class SingleCurvilinearTrackParameters
+ : public SingleTrackParameters<ChargePolicy>
{
- template<typename ChargePolicy>
- class SingleCurvilinearTrackParameters : public SingleTrackParameters<ChargePolicy>
+public:
+ typedef typename SingleTrackParameters<ChargePolicy>::CovPtr_t
+ CovPtr_t; ///< type of covariance matrix
+
+ template <typename T = ChargePolicy,
+ std::enable_if_t<std::is_same<T, ChargedPolicy>::value, int> = 0>
+ SingleCurvilinearTrackParameters(CovPtr_t cov,
+ const ActsVectorD<3>& position,
+ const ActsVectorD<3>& momentum,
+ double dCharge)
+ : SingleTrackParameters<ChargePolicy>(
+ std::move(cov),
+ detail::coordinate_transformation::global2curvilinear(position,
+ momentum,
+ dCharge),
+ position,
+ momentum)
{
- public:
- typedef typename SingleTrackParameters<ChargePolicy>::CovPtr_t CovPtr_t; ///< type of covariance matrix
-
- template<typename T = ChargePolicy,std::enable_if_t<std::is_same<T,ChargedPolicy>::value,int> = 0>
- SingleCurvilinearTrackParameters(CovPtr_t cov,
- const ActsVectorD<3>& position,
- const ActsVectorD<3>& momentum,
- double dCharge):
- SingleTrackParameters<ChargePolicy>(std::move(cov),
- detail::coordinate_transformation::global2curvilinear(position,momentum,dCharge),
- position,
- momentum)
- {}
-
- template<typename T = ChargePolicy,std::enable_if_t<std::is_same<T,NeutralPolicy>::value,int> = 0>
- SingleCurvilinearTrackParameters(CovPtr_t cov,
- const ActsVectorD<3>& position,
- const ActsVectorD<3>& momentum):
- SingleTrackParameters<ChargePolicy>(std::move(cov),
- detail::coordinate_transformation::global2curvilinear(position,momentum,0),
- position,
- momentum)
- {}
-
- /**
- * @brief copy constructor
- */
- SingleCurvilinearTrackParameters(const SingleCurvilinearTrackParameters<ChargePolicy>& copy):
- SingleTrackParameters<ChargePolicy>(copy),
- m_upSurface()
- {}
-
- /**
- * @brief move constructor
- */
- SingleCurvilinearTrackParameters(SingleCurvilinearTrackParameters<ChargePolicy>&& copy):
- SingleTrackParameters<ChargePolicy>(std::move(copy)),
- m_upSurface(std::move(copy.m_upSurface))
- {}
-
- virtual ~SingleCurvilinearTrackParameters() = default;
-
- /**
- * @brief copy assignment operator
- */
- SingleCurvilinearTrackParameters<ChargePolicy>& operator=(const SingleCurvilinearTrackParameters<ChargePolicy>& rhs)
- {
- // check for self-assignment
- if(this != &rhs)
- {
- SingleTrackParameters<ChargePolicy>::operator=(rhs);
- m_upSurface.reset();
- }
-
- return *this;
- }
+ }
+
+ template <typename T = ChargePolicy,
+ std::enable_if_t<std::is_same<T, NeutralPolicy>::value, int> = 0>
+ SingleCurvilinearTrackParameters(CovPtr_t cov,
+ const ActsVectorD<3>& position,
+ const ActsVectorD<3>& momentum)
+ : SingleTrackParameters<ChargePolicy>(
+ std::move(cov),
+ detail::coordinate_transformation::global2curvilinear(position,
+ momentum,
+ 0),
+ position,
+ momentum)
+ {
+ }
+
+ /**
+ * @brief copy constructor
+ */
+ SingleCurvilinearTrackParameters(
+ const SingleCurvilinearTrackParameters<ChargePolicy>& copy)
+ : SingleTrackParameters<ChargePolicy>(copy), m_upSurface()
+ {
+ }
+
+ /**
+ * @brief move constructor
+ */
+ SingleCurvilinearTrackParameters(
+ SingleCurvilinearTrackParameters<ChargePolicy>&& copy)
+ : SingleTrackParameters<ChargePolicy>(std::move(copy))
+ , m_upSurface(std::move(copy.m_upSurface))
+ {
+ }
- /**
- * @brief move assignment operator
- */
- SingleCurvilinearTrackParameters<ChargePolicy>& operator=(SingleCurvilinearTrackParameters<ChargePolicy>&& rhs)
- {
- // check for self-assignment
- if(this != &rhs)
- {
- SingleTrackParameters<ChargePolicy>::operator=(std::move(rhs));
- m_upSurface = std::move(rhs.m_upSurface);
- }
-
- return *this;
- }
+ virtual ~SingleCurvilinearTrackParameters() = default;
- virtual SingleTrackParameters<ChargePolicy>* clone() const override
- {
- return new SingleCurvilinearTrackParameters<ChargePolicy>(*this);
+ /**
+ * @brief copy assignment operator
+ */
+ SingleCurvilinearTrackParameters<ChargePolicy>&
+ operator=(const SingleCurvilinearTrackParameters<ChargePolicy>& rhs)
+ {
+ // check for self-assignment
+ if (this != &rhs) {
+ SingleTrackParameters<ChargePolicy>::operator=(rhs);
+ m_upSurface.reset();
}
- template<ParID_t par,std::enable_if_t<not std::is_same<typename par_type<par>::type,local_parameter>::value,int> = 0>
- void set(ParValue_t newValue)
- {
- this->getParameterSet().template setParameter<par>(newValue);
- this->updateGlobalCoordinates(typename par_type<par>::type());
+ return *this;
+ }
+
+ /**
+ * @brief move assignment operator
+ */
+ SingleCurvilinearTrackParameters<ChargePolicy>&
+ operator=(SingleCurvilinearTrackParameters<ChargePolicy>&& rhs)
+ {
+ // check for self-assignment
+ if (this != &rhs) {
+ SingleTrackParameters<ChargePolicy>::operator=(std::move(rhs));
+ m_upSurface = std::move(rhs.m_upSurface);
}
- virtual const Surface& associatedSurface() const final
- {
- m_upSurface.reset(new PlaneSurface(this->position(),this->momentum()));
+ return *this;
+ }
- return *m_upSurface;
- }
+ virtual SingleTrackParameters<ChargePolicy>*
+ clone() const override
+ {
+ return new SingleCurvilinearTrackParameters<ChargePolicy>(*this);
+ }
+
+ template <ParID_t par,
+ std::enable_if_t<not std::is_same<typename par_type<par>::type,
+ local_parameter>::value,
+ int> = 0>
+ void
+ set(ParValue_t newValue)
+ {
+ this->getParameterSet().template setParameter<par>(newValue);
+ this->updateGlobalCoordinates(typename par_type<par>::type());
+ }
+
+ virtual const Surface&
+ associatedSurface() const final
+ {
+ m_upSurface.reset(new PlaneSurface(this->position(), this->momentum()));
+
+ return *m_upSurface;
+ }
- private:
- mutable std::unique_ptr<PlaneSurface> m_upSurface;
- };
+private:
+ mutable std::unique_ptr<PlaneSurface> m_upSurface;
+};
} // end of namespace Acts
-#endif // ACTS_SINGLECURVILINEARTRACKPARAMETERS_H
+#endif // ACTS_SINGLECURVILINEARTRACKPARAMETERS_H
diff --git a/Core/include/ACTS/EventData/SingleTrackParameters.hpp b/Core/include/ACTS/EventData/SingleTrackParameters.hpp
index 94727a0c1..76b9fc9f0 100644
--- a/Core/include/ACTS/EventData/SingleTrackParameters.hpp
+++ b/Core/include/ACTS/EventData/SingleTrackParameters.hpp
@@ -13,211 +13,242 @@
#include <type_traits>
// ACTS includes
-#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/EventData/TrackParametersBase.hpp"
#include "ACTS/EventData/detail/coordinate_transformations.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
-namespace Acts
+namespace Acts {
+/**
+ * @class SingleTrackParameters
+ *
+ * @brief base class for a single set of track parameters
+ *
+ * This class implements the interface for charged/neutral track parameters for
+ * the case that it
+ * represents a single set of track parameters (opposed to a list of different
+ * sets of track
+ * parameters as used by e.g. GSF or multi-track fitters).
+ *
+ * The track parameters and their uncertainty are defined in local reference
+ * frame which depends on
+ * the associated surface of the track parameters.
+ *
+ * @tparam ChargePolicy type for distinguishing charged and neutral
+ * tracks/particles
+ * (must be either ChargedPolicy or NeutralPolicy)
+ */
+template <class ChargePolicy>
+class SingleTrackParameters : public TrackParametersBase
{
+ static_assert(std::is_same<ChargePolicy, ChargedPolicy>::value
+ or std::is_same<ChargePolicy, NeutralPolicy>::value,
+ "ChargePolicy must either be 'Acts::ChargedPolicy' or "
+ "'Acts::NeutralPolicy");
+
+public:
+ // public typedef's
+ typedef typename TrackParametersBase::ParVector_t
+ ParVector_t; ///< vector type for stored track parameters
+ typedef typename TrackParametersBase::CovMatrix_t
+ CovMatrix_t; ///< type of covariance matrix
+ typedef std::unique_ptr<CovMatrix_t>
+ CovPtr_t; ///< type for unique pointer to covariance matrix
+
/**
- * @class SingleTrackParameters
- *
- * @brief base class for a single set of track parameters
- *
- * This class implements the interface for charged/neutral track parameters for the case that it
- * represents a single set of track parameters (opposed to a list of different sets of track
- * parameters as used by e.g. GSF or multi-track fitters).
+ * @brief default virtual destructor
+ */
+ virtual ~SingleTrackParameters() = default;
+
+ /**
+ * @brief virtual constructor
+ */
+ virtual SingleTrackParameters<ChargePolicy>*
+ clone() const override = 0;
+
+ /**
+ * @copydoc TrackParametersBase::position
+ */
+ virtual ActsVectorD<3>
+ position() const final
+ {
+ return m_vPosition;
+ }
+
+ /**
+ * @copydoc TrackParametersBase::momentum
+ */
+ virtual ActsVectorD<3>
+ momentum() const final
+ {
+ return m_vMomentum;
+ }
+
+ /**
+ * @brief equality operator
*
- * The track parameters and their uncertainty are defined in local reference frame which depends on
- * the associated surface of the track parameters.
+ * @return @c true of both objects have the same charge policy, parameter
+ * values,
+ * position and momentum, otherwise @c false
+ */
+ virtual bool
+ operator==(const TrackParametersBase& rhs) const override
+ {
+ auto casted = dynamic_cast<decltype(this)>(&rhs);
+ if (!casted) return false;
+
+ return (m_oChargePolicy == casted->m_oChargePolicy
+ && m_oParameters == casted->m_oParameters
+ && m_vPosition == casted->m_vPosition
+ && m_vMomentum == casted->m_vMomentum);
+ }
+
+ /**
+ * @copydoc TrackParametersBase::charge
+ */
+ virtual double
+ charge() const final
+ {
+ return m_oChargePolicy.getCharge();
+ }
+
+ /**
+ * @copydoc TrackParametersBase::getParameterSet
+ */
+ virtual const FullParameterSet&
+ getParameterSet() const final
+ {
+ return m_oParameters;
+ }
+
+protected:
+ /**
+ * @brief standard constructor for track parameters of charged particles
*
- * @tparam ChargePolicy type for distinguishing charged and neutral tracks/particles
- * (must be either ChargedPolicy or NeutralPolicy)
+ * @param cov unique pointer to covariance matrix (nullptr is accepted)
+ * @param parValues vector with parameter values
+ * @param position 3D vector with global position
+ * @param momentum 3D vector with global momentum
*/
- template<class ChargePolicy>
- class SingleTrackParameters : public TrackParametersBase
+ template <typename T = ChargePolicy,
+ std::enable_if_t<std::is_same<T, ChargedPolicy>::value, int> = 0>
+ SingleTrackParameters(CovPtr_t cov,
+ const ParVector_t& parValues,
+ const ActsVectorD<3>& position,
+ const ActsVectorD<3>& momentum)
+ : TrackParametersBase()
+ , m_oChargePolicy(
+ detail::coordinate_transformation::parameters2charge(parValues))
+ , m_oParameters(std::move(cov), parValues)
+ , m_vPosition(position)
+ , m_vMomentum(momentum)
{
- static_assert(std::is_same<ChargePolicy,ChargedPolicy>::value or std::is_same<ChargePolicy,NeutralPolicy>::value,
- "ChargePolicy must either be 'Acts::ChargedPolicy' or 'Acts::NeutralPolicy");
- public:
- // public typedef's
- typedef typename TrackParametersBase::ParVector_t ParVector_t; ///< vector type for stored track parameters
- typedef typename TrackParametersBase::CovMatrix_t CovMatrix_t; ///< type of covariance matrix
- typedef std::unique_ptr<CovMatrix_t> CovPtr_t; ///< type for unique pointer to covariance matrix
-
- /**
- * @brief default virtual destructor
- */
- virtual ~SingleTrackParameters() = default;
-
- /**
- * @brief virtual constructor
- */
- virtual SingleTrackParameters<ChargePolicy>* clone() const override = 0;
-
- /**
- * @copydoc TrackParametersBase::position
- */
- virtual ActsVectorD<3> position() const final
- {
- return m_vPosition;
- }
+ }
- /**
- * @copydoc TrackParametersBase::momentum
- */
- virtual ActsVectorD<3> momentum() const final
- {
- return m_vMomentum;
- }
+ /**
+ * @brief standard constructor for track parameters of neutral particles
+ *
+ * @param cov unique pointer to covariance matrix (nullptr is accepted)
+ * @param parValues vector with parameter values
+ * @param position 3D vector with global position
+ * @param momentum 3D vector with global momentum
+ */
+ template <typename T = ChargePolicy,
+ std::enable_if_t<std::is_same<T, NeutralPolicy>::value, int> = 0>
+ SingleTrackParameters(CovPtr_t cov,
+ const ParVector_t& parValues,
+ const ActsVectorD<3>& position,
+ const ActsVectorD<3>& momentum)
+ : TrackParametersBase()
+ , m_oChargePolicy()
+ , m_oParameters(std::move(cov), parValues)
+ , m_vPosition(position)
+ , m_vMomentum(momentum)
+ {
+ }
- /**
- * @brief equality operator
- *
- * @return @c true of both objects have the same charge policy, parameter values,
- * position and momentum, otherwise @c false
- */
- virtual bool operator==(const TrackParametersBase& rhs) const override
- {
- auto casted = dynamic_cast<decltype(this)>(&rhs);
- if(!casted)
- return false;
-
- return (m_oChargePolicy == casted->m_oChargePolicy && m_oParameters == casted->m_oParameters && m_vPosition == casted->m_vPosition && m_vMomentum == casted->m_vMomentum);
- }
+ /**
+ * @brief default copy constructor
+ */
+ SingleTrackParameters(const SingleTrackParameters<ChargePolicy>& copy)
+ = default;
- /**
- * @copydoc TrackParametersBase::charge
- */
- virtual double charge() const final
- {
- return m_oChargePolicy.getCharge();
- }
+ /**
+ * @brief default move constructor
+ */
+ SingleTrackParameters(SingleTrackParameters<ChargePolicy>&& copy) = default;
- /**
- * @copydoc TrackParametersBase::getParameterSet
- */
- virtual const FullParameterSet& getParameterSet() const final
- {
- return m_oParameters;
+ /**
+ * @brief copy assignment operator
+ *
+ * @param rhs object to be copied
+ */
+ SingleTrackParameters<ChargePolicy>&
+ operator=(const SingleTrackParameters<ChargePolicy>& rhs)
+ {
+ // check for self-assignment
+ if (this != &rhs) {
+ m_oChargePolicy = rhs.m_oChargePolicy;
+ m_oParameters = rhs.m_oParameters;
+ m_vPosition = rhs.m_vPosition;
+ m_vMomentum = rhs.m_vMomentum;
}
- protected:
- /**
- * @brief standard constructor for track parameters of charged particles
- *
- * @param cov unique pointer to covariance matrix (nullptr is accepted)
- * @param parValues vector with parameter values
- * @param position 3D vector with global position
- * @param momentum 3D vector with global momentum
- */
- template<typename T = ChargePolicy,std::enable_if_t<std::is_same<T,ChargedPolicy>::value,int> = 0>
- SingleTrackParameters(CovPtr_t cov,
- const ParVector_t& parValues,
- const ActsVectorD<3>& position,
- const ActsVectorD<3>& momentum):
- TrackParametersBase(),
- m_oChargePolicy(detail::coordinate_transformation::parameters2charge(parValues)),
- m_oParameters(std::move(cov),parValues),
- m_vPosition(position),
- m_vMomentum(momentum)
- {}
-
- /**
- * @brief standard constructor for track parameters of neutral particles
- *
- * @param cov unique pointer to covariance matrix (nullptr is accepted)
- * @param parValues vector with parameter values
- * @param position 3D vector with global position
- * @param momentum 3D vector with global momentum
- */
- template<typename T = ChargePolicy,std::enable_if_t<std::is_same<T,NeutralPolicy>::value,int> = 0>
- SingleTrackParameters(CovPtr_t cov,
- const ParVector_t& parValues,
- const ActsVectorD<3>& position,
- const ActsVectorD<3>& momentum):
- TrackParametersBase(),
- m_oChargePolicy(),
- m_oParameters(std::move(cov),parValues),
- m_vPosition(position),
- m_vMomentum(momentum)
- {}
-
- /**
- * @brief default copy constructor
- */
- SingleTrackParameters(const SingleTrackParameters<ChargePolicy>& copy) = default;
-
- /**
- * @brief default move constructor
- */
- SingleTrackParameters(SingleTrackParameters<ChargePolicy>&& copy) = default;
-
- /**
- * @brief copy assignment operator
- *
- * @param rhs object to be copied
- */
- SingleTrackParameters<ChargePolicy>& operator=(const SingleTrackParameters<ChargePolicy>& rhs)
- {
- // check for self-assignment
- if(this != &rhs)
- {
- m_oChargePolicy = rhs.m_oChargePolicy;
- m_oParameters = rhs.m_oParameters;
- m_vPosition = rhs.m_vPosition;
- m_vMomentum = rhs.m_vMomentum;
- }
-
- return *this;
- }
+ return *this;
+ }
- /**
- * @brief move assignment operator
- *
- * @param rhs object to be movied into `*this`
- */
- SingleTrackParameters<ChargePolicy>& operator=(SingleTrackParameters<ChargePolicy>&& rhs)
- {
- // check for self-assignment
- if(this != &rhs)
- {
- m_oChargePolicy = std::move(rhs.m_oChargePolicy);
- m_oParameters = std::move(rhs.m_oParameters);
- m_vPosition = std::move(rhs.m_vPosition);
- m_vMomentum = std::move(rhs.m_vMomentum);
- }
-
- return *this;
+ /**
+ * @brief move assignment operator
+ *
+ * @param rhs object to be movied into `*this`
+ */
+ SingleTrackParameters<ChargePolicy>&
+ operator=(SingleTrackParameters<ChargePolicy>&& rhs)
+ {
+ // check for self-assignment
+ if (this != &rhs) {
+ m_oChargePolicy = std::move(rhs.m_oChargePolicy);
+ m_oParameters = std::move(rhs.m_oParameters);
+ m_vPosition = std::move(rhs.m_vPosition);
+ m_vMomentum = std::move(rhs.m_vMomentum);
}
- /**
- * @brief update global momentum from current parameter values
- *
- * @note This function is triggered when called with an argument of a type
- * different from Acts::local_parameter
- */
- template<typename T>
- void updateGlobalCoordinates(const T&)
- {
- m_vMomentum = detail::coordinate_transformation::parameters2globalMomentum(getParameterSet().getParameters());
- }
+ return *this;
+ }
- /**
- * @brief update global position from current parameter values
- *
- * @note This function is triggered when called with an argument of a type Acts::local_parameter
- */
- void updateGlobalCoordinates(const local_parameter&)
- {
- m_vPosition = detail::coordinate_transformation::parameters2globalPosition(getParameterSet().getParameters(),this->associatedSurface());
- }
+ /**
+ * @brief update global momentum from current parameter values
+ *
+ * @note This function is triggered when called with an argument of a type
+ * different from Acts::local_parameter
+ */
+ template <typename T>
+ void
+ updateGlobalCoordinates(const T&)
+ {
+ m_vMomentum = detail::coordinate_transformation::parameters2globalMomentum(
+ getParameterSet().getParameters());
+ }
- ChargePolicy m_oChargePolicy; ///< charge policy object distinguishing between charged and neutral tracks
- FullParameterSet m_oParameters; ///< ParameterSet object holding the parameter values and covariance matrix
- ActsVectorD<3> m_vPosition; ///< 3D vector with global position
- ActsVectorD<3> m_vMomentum; ///< 3D vector with global momentum
- };
+ /**
+ * @brief update global position from current parameter values
+ *
+ * @note This function is triggered when called with an argument of a type
+ * Acts::local_parameter
+ */
+ void
+ updateGlobalCoordinates(const local_parameter&)
+ {
+ m_vPosition = detail::coordinate_transformation::parameters2globalPosition(
+ getParameterSet().getParameters(), this->associatedSurface());
+ }
+
+ ChargePolicy m_oChargePolicy; ///< charge policy object distinguishing
+ ///between charged and neutral tracks
+ FullParameterSet m_oParameters; ///< ParameterSet object holding the
+ ///parameter values and covariance matrix
+ ActsVectorD<3> m_vPosition; ///< 3D vector with global position
+ ActsVectorD<3> m_vMomentum; ///< 3D vector with global momentum
+};
} // end of namespace Acts
-#endif // ACTS_SINGLETRACKPARAMETERS_h
+#endif // ACTS_SINGLETRACKPARAMETERS_h
diff --git a/Core/include/ACTS/EventData/TrackParameters.hpp b/Core/include/ACTS/EventData/TrackParameters.hpp
index b9d4a8091..e23d49d5e 100644
--- a/Core/include/ACTS/EventData/TrackParameters.hpp
+++ b/Core/include/ACTS/EventData/TrackParameters.hpp
@@ -9,16 +9,15 @@
#ifndef ACTS_TRACKPARAMETERS_H
#define ACTS_TRACKPARAMETERS_H 1
-#include "ACTS/EventData/SingleCurvilinearTrackParameters.hpp"
+#include "ACTS/EventData/ChargePolicy.hpp"
#include "ACTS/EventData/SingleBoundTrackParameters.hpp"
+#include "ACTS/EventData/SingleCurvilinearTrackParameters.hpp"
#include "ACTS/EventData/SingleTrackParameters.hpp"
-#include "ACTS/EventData/ChargePolicy.hpp"
-namespace Acts
-{
- typedef SingleTrackParameters<ChargedPolicy> TrackParameters;
- typedef SingleCurvilinearTrackParameters<ChargedPolicy> CurvilinearParameters;
- typedef SingleBoundTrackParameters<ChargedPolicy> BoundParameters;
-} // end of namespace Acts
+namespace Acts {
+typedef SingleTrackParameters<ChargedPolicy> TrackParameters;
+typedef SingleCurvilinearTrackParameters<ChargedPolicy> CurvilinearParameters;
+typedef SingleBoundTrackParameters<ChargedPolicy> BoundParameters;
+} // end of namespace Acts
-#endif // ACTS_TRACKPARAMETERS_H
+#endif // ACTS_TRACKPARAMETERS_H
diff --git a/Core/include/ACTS/EventData/TrackParametersBase.hpp b/Core/include/ACTS/EventData/TrackParametersBase.hpp
index 6d6c836c9..13c6d150b 100644
--- a/Core/include/ACTS/EventData/TrackParametersBase.hpp
+++ b/Core/include/ACTS/EventData/TrackParametersBase.hpp
@@ -14,177 +14,198 @@
#include "ACTS/Utilities/Definitions.hpp"
// ACTS includes
-#include "ACTS/Utilities/ParameterDefinitions.hpp"
-#include "ACTS/EventData/ParameterSet.hpp"
#include "ACTS/EventData/ChargePolicy.hpp"
+#include "ACTS/EventData/ParameterSet.hpp"
+#include "ACTS/Utilities/ParameterDefinitions.hpp"
-namespace Acts
+namespace Acts {
+// forward declarations
+class Surface;
+
+/**
+ * @class ParametersBase
+ *
+ * @brief base class for track parameters
+ *
+ * This is a base class for neutral and charged track parameters. The position
+ * and the
+ * momentum are both given in the global coordinate system. The track parameters
+ * and their uncertainty are defined in local reference frame which depends on
+ * the associated surface of the track parameters.
+ */
+class TrackParametersBase
{
- // forward declarations
- class Surface;
+public:
+ // public typedef's
+ typedef ActsVector<ParValue_t, Acts::NGlobalPars>
+ ParVector_t; ///< vector type for stored track parameters
+ typedef ActsSymMatrix<ParValue_t, Acts::NGlobalPars>
+ CovMatrix_t; ///< type of covariance matrix
+
+ /**
+ * @brief virtual default destructor to allow for inheritance
+ */
+ virtual ~TrackParametersBase() = default;
+
+ /**
+ * @brief virtual constructor
+ */
+ virtual TrackParametersBase*
+ clone() const = 0;
+
+ /**
+ * @brief equality operator
+ */
+ virtual bool
+ operator==(const TrackParametersBase& rhs) const = 0;
+
+ /**
+ * @brief inequality operator
+ *
+ * @return `not (*this == rhs)`
+ */
+ bool
+ operator!=(const TrackParametersBase& rhs) const
+ {
+ return !(*this == rhs);
+ }
+
+ /**
+ * @brief access position in global coordinate system
+ *
+ * @return 3D vector with global position
+ */
+ virtual ActsVectorD<3>
+ position() const = 0;
+
+ /**
+ * @brief access momentum in global coordinate system
+ *
+ * @return 3D vector with global momentum
+ */
+ virtual ActsVectorD<3>
+ momentum() const = 0;
+
+ /**
+ * @brief access track parameters
+ *
+ * @return Eigen vector of dimension Acts::NGlobalPars with values of the
+ * track parameters
+ * (in the order as defined by the ParID_t enumeration)
+ */
+ ParVector_t
+ parameters() const
+ {
+ return getParameterSet().getParameters();
+ }
+
+ /**
+ * @brief access track parameter
+ *
+ * @tparam par identifier of track parameter which is to be retrieved
+ *
+ * @return value of the requested track parameter
+ *
+ * @sa ParameterSet::get
+ */
+ template <ParID_t par>
+ ParValue_t
+ get() const
+ {
+ return getParameterSet().template getParameter<par>();
+ }
+
+ template <ParID_t par>
+ ParValue_t
+ uncertainty() const
+ {
+ return getParameterSet().template uncertainty<par>();
+ }
+
+ /**
+ * @brief access covariance matrix of track parameters
+ *
+ * @note The ownership of the covariance matrix is @b not transferred with
+ * this call.
+ *
+ * @return raw pointer to covariance matrix (can be a nullptr)
+ *
+ * @sa ParameterSet::getCovariance
+ */
+ const CovMatrix_t*
+ covariance() const
+ {
+ return getParameterSet().getCovariance();
+ }
+
+ /**
+ * @brief convenience method to retrieve transverse momentum
+ */
+ double
+ pT() const
+ {
+ return momentum().perp();
+ }
+
+ /**
+ * @brief convenience method to retrieve pseudorapidity
+ */
+ double
+ eta() const
+ {
+ return momentum().eta();
+ }
+
+ /**
+ * @brief retrieve electric charge
+ *
+ * @return value of electric charge
+ */
+ virtual double
+ charge() const = 0;
+
+ /**
+ * @brief access associated surface defining the coordinate system for track
+ * parameters and their covariance
+ *
+ * @return associated surface
+ */
+ virtual const Surface&
+ associatedSurface() const = 0;
/**
- * @class ParametersBase
+ * @brief output stream operator
*
- * @brief base class for track parameters
+ * Prints information about this object to the output stream using the virtual
+ * TrackParameters::print method.
*
- * This is a base class for neutral and charged track parameters. The position and the
- * momentum are both given in the global coordinate system. The track parameters
- * and their uncertainty are defined in local reference frame which depends on
- * the associated surface of the track parameters.
+ * @return modified output stream object
*/
- class TrackParametersBase
+ friend std::ostream&
+ operator<<(std::ostream& out, const TrackParametersBase& tp)
{
- public:
- // public typedef's
- typedef ActsVector<ParValue_t,Acts::NGlobalPars> ParVector_t; ///< vector type for stored track parameters
- typedef ActsSymMatrix<ParValue_t,Acts::NGlobalPars> CovMatrix_t; ///< type of covariance matrix
-
- /**
- * @brief virtual default destructor to allow for inheritance
- */
- virtual ~TrackParametersBase() = default;
-
- /**
- * @brief virtual constructor
- */
- virtual TrackParametersBase* clone() const = 0;
-
- /**
- * @brief equality operator
- */
- virtual bool operator==(const TrackParametersBase& rhs) const = 0;
-
- /**
- * @brief inequality operator
- *
- * @return `not (*this == rhs)`
- */
- bool operator!=(const TrackParametersBase& rhs) const
- {
- return !(*this == rhs);
- }
-
- /**
- * @brief access position in global coordinate system
- *
- * @return 3D vector with global position
- */
- virtual ActsVectorD<3> position() const = 0;
-
- /**
- * @brief access momentum in global coordinate system
- *
- * @return 3D vector with global momentum
- */
- virtual ActsVectorD<3> momentum() const = 0;
-
- /**
- * @brief access track parameters
- *
- * @return Eigen vector of dimension Acts::NGlobalPars with values of the track parameters
- * (in the order as defined by the ParID_t enumeration)
- */
- ParVector_t parameters() const
- {
- return getParameterSet().getParameters();
- }
-
- /**
- * @brief access track parameter
- *
- * @tparam par identifier of track parameter which is to be retrieved
- *
- * @return value of the requested track parameter
- *
- * @sa ParameterSet::get
- */
- template<ParID_t par>
- ParValue_t get() const
- {
- return getParameterSet().template getParameter<par>();
- }
-
- template<ParID_t par>
- ParValue_t uncertainty() const
- {
- return getParameterSet().template uncertainty<par>();
- }
-
- /**
- * @brief access covariance matrix of track parameters
- *
- * @note The ownership of the covariance matrix is @b not transferred with this call.
- *
- * @return raw pointer to covariance matrix (can be a nullptr)
- *
- * @sa ParameterSet::getCovariance
- */
- const CovMatrix_t* covariance() const
- {
- return getParameterSet().getCovariance();
- }
-
- /**
- * @brief convenience method to retrieve transverse momentum
- */
- double pT() const
- {
- return momentum().perp();
- }
-
- /**
- * @brief convenience method to retrieve pseudorapidity
- */
- double eta() const
- {
- return momentum().eta();
- }
-
- /**
- * @brief retrieve electric charge
- *
- * @return value of electric charge
- */
- virtual double charge() const = 0;
-
- /**
- * @brief access associated surface defining the coordinate system for track
- * parameters and their covariance
- *
- * @return associated surface
- */
- virtual const Surface& associatedSurface() const = 0;
-
- /**
- * @brief output stream operator
- *
- * Prints information about this object to the output stream using the virtual
- * TrackParameters::print method.
- *
- * @return modified output stream object
- */
- friend std::ostream& operator<<(std::ostream& out,const TrackParametersBase& tp)
- {
- tp.print(out);
- return out;
- }
-
- /**
- * @brief access to the internally stored ParameterSet
- *
- * @return ParameterSet object holding parameter values and their covariance matrix
- */
- virtual const FullParameterSet& getParameterSet() const = 0;
-
- protected:
- /**
- * @brief print information to output stream
- *
- * @return modified output stream object
- */
- virtual std::ostream& print(std::ostream& out) const;
- };
-} // end of namespace Acts
-
-#endif // ACTS_PARAMETERSBASE_h
+ tp.print(out);
+ return out;
+ }
+
+ /**
+ * @brief access to the internally stored ParameterSet
+ *
+ * @return ParameterSet object holding parameter values and their covariance
+ * matrix
+ */
+ virtual const FullParameterSet&
+ getParameterSet() const = 0;
+
+protected:
+ /**
+ * @brief print information to output stream
+ *
+ * @return modified output stream object
+ */
+ virtual std::ostream&
+ print(std::ostream& out) const;
+};
+} // end of namespace Acts
+
+#endif // ACTS_PARAMETERSBASE_h
diff --git a/Core/include/ACTS/EventData/TransportJacobian.hpp b/Core/include/ACTS/EventData/TransportJacobian.hpp
index 1614a6202..e73b81dfe 100644
--- a/Core/include/ACTS/EventData/TransportJacobian.hpp
+++ b/Core/include/ACTS/EventData/TransportJacobian.hpp
@@ -17,43 +17,49 @@
namespace Acts {
- /** @class TransportJacobian
-
- This class represents the jacobian for transforming initial track parameters
- to new track parameters after propagation to new surface.
- Initial track parameters: loc1 ,loc2 ,Phi ,Theta ,qp
- Track parameters after propagation: lol1_n,loc2_n,Phi_n,Theta_n,qp_n
-
- Jacobian is matrix (5x5) with derivatives
-
- 0 1 2 3 4
- 0 d loc1_n /d loc1 d loc1_n /d loc2 d loc1_n /d Phi d loc1_n /d Theta d loc1_n /d qp
- 1 d loc2_n /d loc1 d loc2_n /d loc2 d loc2_n /d Phi d loc2_n /d Theta d loc2_n /d qp
- 2 d Phi_n /d loc1 d Phi_n /d loc2 d Phi_n /d Phi d Phi_n /d Theta d Phi_n /d qp
- 3 d Theta_n/d loc1 d Theta_n/d loc2 d Theta_n/d Phi d Theta_n/d Theta d Theta_n/d qp
- 4 d qp_n /d loc1 d qp_n /d loc2 d qp_n /d Phi d qp _n/d Theta d qp_n /d qp
-
- ^ ---> second index
- |
- | first index
-
- */
-
- class TransportJacobian : public ActsMatrixD<5,5>{
- public:
-
- /** Constructor */
- TransportJacobian(const double* );
- TransportJacobian(const ActsMatrixD<5,5>&);
-
- /** Destructor */
- virtual ~TransportJacobian(){};
-
- };
-
- /** Overload of << operator for std::ostream */
- std::ostream& operator << ( std::ostream& sl, const TransportJacobian& jac);
-
-} // end of namespace
-
-#endif // ACTS_EXTRAPOLATIONUTILS_TRANSPORTJACOBIAN_H
+/** @class TransportJacobian
+
+ This class represents the jacobian for transforming initial track
+ parameters
+ to new track parameters after propagation to new surface.
+ Initial track parameters: loc1 ,loc2 ,Phi ,Theta ,qp
+ Track parameters after propagation: lol1_n,loc2_n,Phi_n,Theta_n,qp_n
+
+ Jacobian is matrix (5x5) with derivatives
+
+ 0 1 2 3 4
+ 0 d loc1_n /d loc1 d loc1_n /d loc2 d loc1_n /d Phi d loc1_n /d Theta d
+ loc1_n /d qp
+ 1 d loc2_n /d loc1 d loc2_n /d loc2 d loc2_n /d Phi d loc2_n /d Theta d
+ loc2_n /d qp
+ 2 d Phi_n /d loc1 d Phi_n /d loc2 d Phi_n /d Phi d Phi_n /d Theta d
+ Phi_n /d qp
+ 3 d Theta_n/d loc1 d Theta_n/d loc2 d Theta_n/d Phi d Theta_n/d Theta d
+ Theta_n/d qp
+ 4 d qp_n /d loc1 d qp_n /d loc2 d qp_n /d Phi d qp _n/d Theta d
+ qp_n /d qp
+
+ ^ ---> second index
+ |
+ | first index
+
+*/
+
+class TransportJacobian : public ActsMatrixD<5, 5>
+{
+public:
+ /** Constructor */
+ TransportJacobian(const double*);
+ TransportJacobian(const ActsMatrixD<5, 5>&);
+
+ /** Destructor */
+ virtual ~TransportJacobian(){};
+};
+
+/** Overload of << operator for std::ostream */
+std::ostream&
+operator<<(std::ostream& sl, const TransportJacobian& jac);
+
+} // end of namespace
+
+#endif // ACTS_EXTRAPOLATIONUTILS_TRANSPORTJACOBIAN_H
diff --git a/Core/include/ACTS/EventData/detail/are_sorted.hpp b/Core/include/ACTS/EventData/detail/are_sorted.hpp
index cbfccedd3..33ad89d77 100644
--- a/Core/include/ACTS/EventData/detail/are_sorted.hpp
+++ b/Core/include/ACTS/EventData/detail/are_sorted.hpp
@@ -1,80 +1,66 @@
#ifndef ACTS_ARE_SORTED_H
#define ACTS_ARE_SORTED_H 1
-namespace Acts
-{
- /// @cond detail
- namespace detail
- {
- /**
- * @brief check whether integral values are sorted
- *
- * @tparam ascending boolean flag to check for ascending order (@c true) or descending order (@c false)
- * @tparam strict boolean flag whether strict ordering is required
- * @tparam T integral type of values whose order should be checked
- * @tparam values template parameter pack containing the list of values
- *
- * @test Unit tests are implemented \link Acts::Test::BOOST_AUTO_TEST_CASE(are_sorted_helper_tests) here\endlink.
- *
- * @return `are_sorted<asc,strict,T,values...>::value` is @c true if the given values are properly sorted,
- * otherwise @c false
- */
- template<bool ascending, bool strict, typename T, T ... values>
- struct are_sorted;
+namespace Acts {
+/// @cond detail
+namespace detail {
+ /**
+ * @brief check whether integral values are sorted
+ *
+ * @tparam ascending boolean flag to check for ascending order (@c true) or
+ * descending order (@c false)
+ * @tparam strict boolean flag whether strict ordering is required
+ * @tparam T integral type of values whose order should be checked
+ * @tparam values template parameter pack containing the list of values
+ *
+ * @test Unit tests are implemented \link
+ * Acts::Test::BOOST_AUTO_TEST_CASE(are_sorted_helper_tests) here\endlink.
+ *
+ * @return `are_sorted<asc,strict,T,values...>::value` is @c true if the given
+ * values are properly sorted,
+ * otherwise @c false
+ */
+ template <bool ascending, bool strict, typename T, T... values>
+ struct are_sorted;
- /// @cond
- // one value is always sorted
- template<bool ascending, bool strict, typename T, T v>
- struct are_sorted<ascending, strict, T, v>
- {
- enum
- {
- value = true
- };
- };
+ /// @cond
+ // one value is always sorted
+ template <bool ascending, bool strict, typename T, T v>
+ struct are_sorted<ascending, strict, T, v>
+ {
+ enum { value = true };
+ };
- // strict, ascending ordering
- template<typename T, T a, T b, T ... N>
- struct are_sorted<true, true, T, a, b, N...>
- {
- enum
- {
- value = ((a<b) && are_sorted < true, true, T, b, N...>::value)
- };
- };
+ // strict, ascending ordering
+ template <typename T, T a, T b, T... N>
+ struct are_sorted<true, true, T, a, b, N...>
+ {
+ enum { value = ((a < b) && are_sorted<true, true, T, b, N...>::value) };
+ };
- // weak, ascending ordering
- template<typename T, T a, T b, T ... N>
- struct are_sorted<true, false, T, a, b, N...>
- {
- enum
- {
- value = (a <= b && are_sorted<true, false, T, b, N...>::value)
- };
- };
+ // weak, ascending ordering
+ template <typename T, T a, T b, T... N>
+ struct are_sorted<true, false, T, a, b, N...>
+ {
+ enum { value = (a <= b && are_sorted<true, false, T, b, N...>::value) };
+ };
- // strict, descending ordering
- template<typename T, T a, T b, T ... N>
- struct are_sorted<false, true, T, a, b, N...>
- {
- enum
- {
- value = (a > b && are_sorted<false, true, T, b, N...>::value)
- };
- };
+ // strict, descending ordering
+ template <typename T, T a, T b, T... N>
+ struct are_sorted<false, true, T, a, b, N...>
+ {
+ enum { value = (a > b && are_sorted<false, true, T, b, N...>::value) };
+ };
- // weak, descending ordering
- template<typename T, T a, T b, T ... N>
- struct are_sorted<false, false, T, a, b, N...>
- {
- enum
- {
- value = (a >= b && are_sorted<false, false, T, b, N...>::value)
- };
- };
- /// @endcond
- } // end of namespace detail
+ // weak, descending ordering
+ template <typename T, T a, T b, T... N>
+ struct are_sorted<false, false, T, a, b, N...>
+ {
+ enum { value = (a >= b && are_sorted<false, false, T, b, N...>::value) };
+ };
/// @endcond
+} // end of namespace detail
+/// @endcond
} // end of namespace Acts
-#endif // ACTS_ARE_SORTED_H
+#endif // ACTS_ARE_SORTED_H
diff --git a/Core/include/ACTS/EventData/detail/are_within.hpp b/Core/include/ACTS/EventData/detail/are_within.hpp
index ca8a40af8..3dba38295 100644
--- a/Core/include/ACTS/EventData/detail/are_within.hpp
+++ b/Core/include/ACTS/EventData/detail/are_within.hpp
@@ -1,50 +1,47 @@
#ifndef ACTS_ARE_WITHIN_H
#define ACTS_ARE_WITHIN_H 1
-namespace Acts
-{
- /// @cond detail
- namespace detail
- {
- /**
- * @brief check whether integral values are within a given range
- *
- * @tparam T integral type of values whose range should be checked
- * @tparam MIN lower accepted bound of values (inclusive)
- * @tparam MAX upper accepted bound of values (exclusive)
- * @tparam values template parameter pack containing the list of values
- *
- * @test Unit tests are implemented \link Acts::Test::BOOST_AUTO_TEST_CASE(are_within_helper_tests) here\endlink.
- *
- * @return `are_within<T,MIN,MAX,values...>::value` is @c true if all given values are within the
- * interval [MIN,MAX), otherwise @c false
- */
- template<typename T, T MIN, T MAX, T... values>
- struct are_within;
+namespace Acts {
+/// @cond detail
+namespace detail {
+ /**
+ * @brief check whether integral values are within a given range
+ *
+ * @tparam T integral type of values whose range should be checked
+ * @tparam MIN lower accepted bound of values (inclusive)
+ * @tparam MAX upper accepted bound of values (exclusive)
+ * @tparam values template parameter pack containing the list of values
+ *
+ * @test Unit tests are implemented \link
+ * Acts::Test::BOOST_AUTO_TEST_CASE(are_within_helper_tests) here\endlink.
+ *
+ * @return `are_within<T,MIN,MAX,values...>::value` is @c true if all given
+ * values are within the
+ * interval [MIN,MAX), otherwise @c false
+ */
+ template <typename T, T MIN, T MAX, T... values>
+ struct are_within;
- /// @cond
- // check last parameter
- template<typename T, T MIN, T MAX, T a>
- struct are_within<T,MIN,MAX,a>
- {
- enum
- {
- value = (a >= MIN && a < MAX)
- };
- };
+ /// @cond
+ // check last parameter
+ template <typename T, T MIN, T MAX, T a>
+ struct are_within<T, MIN, MAX, a>
+ {
+ enum { value = (a >= MIN && a < MAX) };
+ };
- // recursive check
- template<typename T, T MIN, T MAX, T a, T... others>
- struct are_within<T,MIN,MAX,a,others...>
- {
- enum
- {
- value = ((a >= MIN) && (a < MAX) && are_within<T,MIN,MAX,others...>::value)
- };
+ // recursive check
+ template <typename T, T MIN, T MAX, T a, T... others>
+ struct are_within<T, MIN, MAX, a, others...>
+ {
+ enum {
+ value
+ = ((a >= MIN) && (a < MAX) && are_within<T, MIN, MAX, others...>::value)
};
- /// @endcond
- } // end of namespace detail
+ };
/// @endcond
+} // end of namespace detail
+/// @endcond
} // end of namespace Acts
-#endif // ACTS_ARE_WITHIN_H
+#endif // ACTS_ARE_WITHIN_H
diff --git a/Core/include/ACTS/EventData/detail/coordinate_transformations.hpp b/Core/include/ACTS/EventData/detail/coordinate_transformations.hpp
index 4987887d0..0a85deed2 100644
--- a/Core/include/ACTS/EventData/detail/coordinate_transformations.hpp
+++ b/Core/include/ACTS/EventData/detail/coordinate_transformations.hpp
@@ -11,61 +11,74 @@
#else
-namespace Acts
-{
- /// @cond detail
- namespace detail
+namespace Acts {
+/// @cond detail
+namespace detail {
+ /**
+ * @brief helper structure summarizing coordinate transformations
+ */
+ struct coordinate_transformation
{
- /**
- * @brief helper structure summarizing coordinate transformations
- */
- struct coordinate_transformation
- {
- typedef ActsVector<ParValue_t,Acts::NGlobalPars> ParVector_t;
+ typedef ActsVector<ParValue_t, Acts::NGlobalPars> ParVector_t;
- static ActsVectorD<3> parameters2globalPosition(const ParVector_t& pars,const Surface& s)
- {
- ActsVectorD<3> globalPosition;
- s.localToGlobal(ActsVectorD<2>(pars(Acts::eLOC_1),pars(Acts::eLOC_2)),parameters2globalMomentum(pars),globalPosition);
- return globalPosition;
- }
+ static ActsVectorD<3>
+ parameters2globalPosition(const ParVector_t& pars, const Surface& s)
+ {
+ ActsVectorD<3> globalPosition;
+ s.localToGlobal(ActsVectorD<2>(pars(Acts::eLOC_1), pars(Acts::eLOC_2)),
+ parameters2globalMomentum(pars),
+ globalPosition);
+ return globalPosition;
+ }
- static ActsVectorD<3> parameters2globalMomentum(const ParVector_t& pars)
- {
- ActsVectorD<3> momentum;
- double p = fabs(1./pars(Acts::eQOP));
- double phi = pars(Acts::ePHI);
- double theta = pars(Acts::eTHETA);
- momentum << p * sin(theta) * cos(phi), p * sin(theta) * sin(phi), p * cos(theta);
+ static ActsVectorD<3>
+ parameters2globalMomentum(const ParVector_t& pars)
+ {
+ ActsVectorD<3> momentum;
+ double p = fabs(1. / pars(Acts::eQOP));
+ double phi = pars(Acts::ePHI);
+ double theta = pars(Acts::eTHETA);
+ momentum << p * sin(theta) * cos(phi), p * sin(theta) * sin(phi),
+ p * cos(theta);
- return momentum;
- }
+ return momentum;
+ }
- static ParVector_t global2curvilinear(const ActsVectorD<3>&,const ActsVectorD<3>& mom,double charge)
- {
- ParVector_t parameters;
- parameters << 0, 0, mom.phi(), mom.theta(), ((fabs(charge) < 1e-4) ? 1. : charge) / mom.mag();
+ static ParVector_t
+ global2curvilinear(const ActsVectorD<3>&,
+ const ActsVectorD<3>& mom,
+ double charge)
+ {
+ ParVector_t parameters;
+ parameters << 0, 0, mom.phi(), mom.theta(),
+ ((fabs(charge) < 1e-4) ? 1. : charge) / mom.mag();
- return parameters;
- }
+ return parameters;
+ }
- static ParVector_t global2parameters(const ActsVectorD<3>& pos,const ActsVectorD<3>& mom,double charge,const Surface& s)
- {
- ActsVectorD<2> localPosition;
- s.globalToLocal(pos,mom,localPosition);
- ParVector_t result;
- result << localPosition(0),localPosition(1),mom.phi(),mom.theta(),((fabs(charge) < 1e-4) ? 1. : charge) / mom.mag();
- return result;
- }
+ static ParVector_t
+ global2parameters(const ActsVectorD<3>& pos,
+ const ActsVectorD<3>& mom,
+ double charge,
+ const Surface& s)
+ {
+ ActsVectorD<2> localPosition;
+ s.globalToLocal(pos, mom, localPosition);
+ ParVector_t result;
+ result << localPosition(0), localPosition(1), mom.phi(), mom.theta(),
+ ((fabs(charge) < 1e-4) ? 1. : charge) / mom.mag();
+ return result;
+ }
- static double parameters2charge(const ParVector_t& pars)
- {
- return (pars(Acts::eQOP) > 0) ? 1. : -1.;
- }
- };
- } // end of namespace detail
- /// @endcond
+ static double
+ parameters2charge(const ParVector_t& pars)
+ {
+ return (pars(Acts::eQOP) > 0) ? 1. : -1.;
+ }
+ };
+} // end of namespace detail
+/// @endcond
} // end of namespace Acts
-#endif // ACTS_COORDINATE_TRANSFORM_PLUGIN
+#endif // ACTS_COORDINATE_TRANSFORM_PLUGIN
-#endif // ACTS_COORDINATE_TRANSFORMATIONS_H
+#endif // ACTS_COORDINATE_TRANSFORMATIONS_H
diff --git a/Core/include/ACTS/EventData/detail/fittable_type_generator.hpp b/Core/include/ACTS/EventData/detail/fittable_type_generator.hpp
index 0d3c7c39f..6f6694f43 100644
--- a/Core/include/ACTS/EventData/detail/fittable_type_generator.hpp
+++ b/Core/include/ACTS/EventData/detail/fittable_type_generator.hpp
@@ -8,136 +8,150 @@
// ACTS include(s)
#include "ACTS/Utilities/ParameterDefinitions.hpp"
-namespace Acts
-{
- // forward declaration
- template<typename Identifier,ParID_t... params>
- class Measurement;
-
- /// @cond detail
- namespace detail
+namespace Acts {
+// forward declaration
+template <typename Identifier, ParID_t... params>
+class Measurement;
+
+/// @cond detail
+namespace detail {
+ /**
+ * @brief generate boost::variant type for all possible Measurement's
+ */
+ template <typename ID>
+ struct fittable_type_generator;
+
+ /// @cond
+ template <typename ID>
+ struct fittable_type_generator
{
- /**
- * @brief generate boost::variant type for all possible Measurement's
- */
- template<typename ID>
- struct fittable_type_generator;
-
- /// @cond
- template<typename ID>
- struct fittable_type_generator
+ template <typename... T>
+ struct container
{
- template<typename... T>
- struct container
- {};
-
- template<typename T,typename U>
- struct add_prepended;
-
- template<ParID_t first,typename... others>
- struct add_prepended<Measurement<ID,first>,container<others...> >
- {
- typedef container<typename add_prepended<Measurement<ID,first>,others>::type...,others...> type;
- };
-
- template<ParID_t first,ParID_t... others>
- struct add_prepended<Measurement<ID,first>,Measurement<ID,others...> >
- {
- typedef Measurement<ID,first,others...> type;
- };
-
- template<ParID_t... first>
- struct add_prepended<Measurement<ID,first...>,boost::mpl::na>
- {
- typedef Measurement<ID,first...> type;
- };
-
- template<typename T,typename C>
- struct add_to_container;
-
- template<typename T,typename... others>
- struct add_to_container<T,container<others...> >
- {
- typedef container<T,others...> type;
- };
-
- template<typename T>
- struct generator_impl;
-
- template<ParID_t first,ParID_t... others>
- struct generator_impl<container<Measurement<ID,first>, Measurement<ID,others...> > >
- {
- typedef container<Measurement<ID,first>,Measurement<ID,others...>,Measurement<ID,first,others...> > type;
- };
-
- template<ParID_t first,typename next,typename... others>
- struct generator_impl<container<Measurement<ID,first>, next, others...> >
- {
- typedef typename generator_impl<container<next, others...> >::type others_combined;
- typedef typename add_prepended<Measurement<ID,first>,others_combined>::type prepended;
- typedef typename add_to_container<Measurement<ID,first>,prepended>::type type;
- };
-
- template<ParID_t v,typename C>
- struct add_to_value_container;
-
- template<ParID_t v,ParID_t... others>
- struct add_to_value_container<v,std::integer_sequence<ParID_t,others...> >
- {
- typedef std::integer_sequence<ParID_t,others...,v> type;
- };
-
- template<typename T,unsigned int N>
- struct tparam_generator
- {
- typedef typename add_to_value_container<static_cast<ParID_t>(N),typename tparam_generator<T,N-1>::type>::type type;
- };
-
- template<typename T>
- struct tparam_generator<T,0>
- {
- typedef std::integer_sequence<T,static_cast<T>(0)> type;
- };
-
- template<typename T>
- struct converter;
-
- template<ParID_t... values>
- struct converter<std::integer_sequence<ParID_t,values...> >
- {
- typedef container<Measurement<ID,values>...> type;
- };
-
- template<typename... types>
- struct to_boost_vector;
-
- template<typename first,typename... rest>
- struct to_boost_vector<first,rest...>
- {
- typedef typename boost::mpl::push_front<typename to_boost_vector<rest...>::type,first>::type type;
- };
-
- template<typename last>
- struct to_boost_vector<last>
- {
- typedef boost::mpl::vector<last> type;
- };
-
- template<typename... MeasTypes>
- struct converter<container<MeasTypes...> >
- {
-
- typedef typename boost::make_variant_over<typename to_boost_vector<MeasTypes...>::type>::type type;
- };
-
- typedef typename tparam_generator<ParID_t,Acts::NGlobalPars-1>::type par_list;
- typedef typename converter<par_list>::type meas_list;
- typedef typename generator_impl<meas_list>::type permutations;
- typedef typename converter<permutations>::type type;
};
- /// @endcond
- } // end of namespace details
+
+ template <typename T, typename U>
+ struct add_prepended;
+
+ template <ParID_t first, typename... others>
+ struct add_prepended<Measurement<ID, first>, container<others...>>
+ {
+ typedef container<
+ typename add_prepended<Measurement<ID, first>, others>::type...,
+ others...>
+ type;
+ };
+
+ template <ParID_t first, ParID_t... others>
+ struct add_prepended<Measurement<ID, first>, Measurement<ID, others...>>
+ {
+ typedef Measurement<ID, first, others...> type;
+ };
+
+ template <ParID_t... first>
+ struct add_prepended<Measurement<ID, first...>, boost::mpl::na>
+ {
+ typedef Measurement<ID, first...> type;
+ };
+
+ template <typename T, typename C>
+ struct add_to_container;
+
+ template <typename T, typename... others>
+ struct add_to_container<T, container<others...>>
+ {
+ typedef container<T, others...> type;
+ };
+
+ template <typename T>
+ struct generator_impl;
+
+ template <ParID_t first, ParID_t... others>
+ struct generator_impl<container<Measurement<ID, first>,
+ Measurement<ID, others...>>>
+ {
+ typedef container<Measurement<ID, first>,
+ Measurement<ID, others...>,
+ Measurement<ID, first, others...>>
+ type;
+ };
+
+ template <ParID_t first, typename next, typename... others>
+ struct generator_impl<container<Measurement<ID, first>, next, others...>>
+ {
+ typedef typename generator_impl<container<next, others...>>::type
+ others_combined;
+ typedef typename add_prepended<Measurement<ID, first>,
+ others_combined>::type prepended;
+ typedef typename add_to_container<Measurement<ID, first>, prepended>::type
+ type;
+ };
+
+ template <ParID_t v, typename C>
+ struct add_to_value_container;
+
+ template <ParID_t v, ParID_t... others>
+ struct add_to_value_container<v, std::integer_sequence<ParID_t, others...>>
+ {
+ typedef std::integer_sequence<ParID_t, others..., v> type;
+ };
+
+ template <typename T, unsigned int N>
+ struct tparam_generator
+ {
+ typedef
+ typename add_to_value_container<static_cast<ParID_t>(N),
+ typename tparam_generator<T, N - 1>::
+ type>::type type;
+ };
+
+ template <typename T>
+ struct tparam_generator<T, 0>
+ {
+ typedef std::integer_sequence<T, static_cast<T>(0)> type;
+ };
+
+ template <typename T>
+ struct converter;
+
+ template <ParID_t... values>
+ struct converter<std::integer_sequence<ParID_t, values...>>
+ {
+ typedef container<Measurement<ID, values>...> type;
+ };
+
+ template <typename... types>
+ struct to_boost_vector;
+
+ template <typename first, typename... rest>
+ struct to_boost_vector<first, rest...>
+ {
+ typedef typename boost::mpl::
+ push_front<typename to_boost_vector<rest...>::type, first>::type type;
+ };
+
+ template <typename last>
+ struct to_boost_vector<last>
+ {
+ typedef boost::mpl::vector<last> type;
+ };
+
+ template <typename... MeasTypes>
+ struct converter<container<MeasTypes...>>
+ {
+ typedef typename boost::make_variant_over<
+ typename to_boost_vector<MeasTypes...>::type>::type type;
+ };
+
+ typedef typename tparam_generator<ParID_t, Acts::NGlobalPars - 1>::type
+ par_list;
+ typedef typename converter<par_list>::type meas_list;
+ typedef typename generator_impl<meas_list>::type permutations;
+ typedef typename converter<permutations>::type type;
+ };
/// @endcond
+} // end of namespace details
+/// @endcond
} // end of namespace Acts
-#endif // ACTS_FITTABLE_TYPE_GENERATOR_H
+#endif // ACTS_FITTABLE_TYPE_GENERATOR_H
diff --git a/Core/include/ACTS/EventData/detail/full_parameter_set.hpp b/Core/include/ACTS/EventData/detail/full_parameter_set.hpp
index b595cf704..c0536c564 100644
--- a/Core/include/ACTS/EventData/detail/full_parameter_set.hpp
+++ b/Core/include/ACTS/EventData/detail/full_parameter_set.hpp
@@ -8,59 +8,64 @@
// ACTS include(s)
#include "ACTS/Utilities/ParameterDefinitions.hpp"
-namespace Acts
-{
- /// @cond
- // forward declaration
- template<ParID_t... params>
- class ParameterSet;
- /// @endcond
+namespace Acts {
+/// @cond
+// forward declaration
+template <ParID_t... params>
+class ParameterSet;
+/// @endcond
- /// @cond detail
- namespace detail
+/// @cond detail
+namespace detail {
+ /**
+ * @brief generate ParameterSet type containing all defined parameters
+ *
+ * @return `full_parset<Policy>::type` is equivalent to
+ * `ParameterSet<Policy,ID_t(0),ID_t(1),...,ID_t(N-1)>`
+ * where @c ID_t is a @c typedef to `Policy::par_id_type` and @c N is
+ * the total number of parameters
+ */
+ struct full_parset
{
- /**
- * @brief generate ParameterSet type containing all defined parameters
- *
- * @return `full_parset<Policy>::type` is equivalent to `ParameterSet<Policy,ID_t(0),ID_t(1),...,ID_t(N-1)>`
- * where @c ID_t is a @c typedef to `Policy::par_id_type` and @c N is the total number of parameters
- */
- struct full_parset
- {
- template<ParID_t v,typename C>
- struct add_to_value_container;
-
- template<ParID_t v,ParID_t... others>
- struct add_to_value_container<v,std::integer_sequence<ParID_t,others...> >
- {
- typedef std::integer_sequence<ParID_t,others...,v> type;
- };
+ template <ParID_t v, typename C>
+ struct add_to_value_container;
- template<typename T,unsigned int N>
- struct tparam_generator
- {
- typedef typename add_to_value_container<static_cast<T>(N),typename tparam_generator<T,N-1>::type>::type type;
- };
+ template <ParID_t v, ParID_t... others>
+ struct add_to_value_container<v, std::integer_sequence<ParID_t, others...>>
+ {
+ typedef std::integer_sequence<ParID_t, others..., v> type;
+ };
- template<typename T>
- struct tparam_generator<T,0>
- {
- typedef std::integer_sequence<T,static_cast<T>(0)> type;
- };
+ template <typename T, unsigned int N>
+ struct tparam_generator
+ {
+ typedef
+ typename add_to_value_container<static_cast<T>(N),
+ typename tparam_generator<T, N - 1>::
+ type>::type type;
+ };
- template<typename T>
- struct converter;
+ template <typename T>
+ struct tparam_generator<T, 0>
+ {
+ typedef std::integer_sequence<T, static_cast<T>(0)> type;
+ };
- template<ParID_t... values>
- struct converter<std::integer_sequence<ParID_t,values...> >
- {
- typedef ParameterSet<values...> type;
- };
+ template <typename T>
+ struct converter;
- typedef typename converter<typename tparam_generator<ParID_t,Acts::NGlobalPars-1>::type>::type type;
+ template <ParID_t... values>
+ struct converter<std::integer_sequence<ParID_t, values...>>
+ {
+ typedef ParameterSet<values...> type;
};
- } // end of namespace detail
- /// @endcond
+
+ typedef typename converter<
+ typename tparam_generator<ParID_t, Acts::NGlobalPars - 1>::type>::type
+ type;
+ };
+} // end of namespace detail
+/// @endcond
} // end of namespace Acts
-#endif // ACTS_FULL_PARAMETER_SET_H
+#endif // ACTS_FULL_PARAMETER_SET_H
diff --git a/Core/include/ACTS/EventData/detail/get_position.hpp b/Core/include/ACTS/EventData/detail/get_position.hpp
index 653f3f15c..c5fc8590c 100644
--- a/Core/include/ACTS/EventData/detail/get_position.hpp
+++ b/Core/include/ACTS/EventData/detail/get_position.hpp
@@ -1,45 +1,40 @@
#ifndef ACTS_GET_POSITION_H
#define ACTS_GET_POSITION_H 1
-namespace Acts
-{
- /// @cond detail
- namespace detail
- {
- /**
- * @brief get position of integral constant in template parameter pack
- *
- * @tparam T integral type of the values to be investigated
- * @tparam target target value whose position in the template parameter pack should be determined
- * @tparam values template parameter pack containing the list of values
- *
- * @return `get_position<T,target,values...>::value` yields the position of `target` inside `values`.
- * If `target` is not in the list of `values`, a compile-time error is generated.
- */
- template<typename T, T target, T ... values>
- struct get_position;
+namespace Acts {
+/// @cond detail
+namespace detail {
+ /**
+ * @brief get position of integral constant in template parameter pack
+ *
+ * @tparam T integral type of the values to be investigated
+ * @tparam target target value whose position in the template parameter pack
+ * should be determined
+ * @tparam values template parameter pack containing the list of values
+ *
+ * @return `get_position<T,target,values...>::value` yields the position of
+ * `target` inside `values`.
+ * If `target` is not in the list of `values`, a compile-time error is
+ * generated.
+ */
+ template <typename T, T target, T... values>
+ struct get_position;
- /// @cond
- template<typename T, T target, T ... others>
- struct get_position<T, target, target, others...>
- {
- enum
- {
- value = 0
- };
- };
+ /// @cond
+ template <typename T, T target, T... others>
+ struct get_position<T, target, target, others...>
+ {
+ enum { value = 0 };
+ };
- template<typename T, T target, T next, T ... others>
- struct get_position<T, target, next, others...>
- {
- enum
- {
- value = get_position<T, target, others...>::value + 1
- };
- };
- /// @endcond
- } // end of namespace detail
+ template <typename T, T target, T next, T... others>
+ struct get_position<T, target, next, others...>
+ {
+ enum { value = get_position<T, target, others...>::value + 1 };
+ };
/// @endcond
+} // end of namespace detail
+/// @endcond
} // end of namespace Acts
-#endif // ACTS_GET_POSITION_H
+#endif // ACTS_GET_POSITION_H
diff --git a/Core/include/ACTS/EventData/detail/initialize_parameter_set.hpp b/Core/include/ACTS/EventData/detail/initialize_parameter_set.hpp
index 74c4a44ff..47888f9a6 100644
--- a/Core/include/ACTS/EventData/detail/initialize_parameter_set.hpp
+++ b/Core/include/ACTS/EventData/detail/initialize_parameter_set.hpp
@@ -1,64 +1,79 @@
#ifndef ACTS_INITIALIZE_PARAMETER_SET_H
#define ACTS_INITIALIZE_PARAMETER_SET_H 1
-namespace Acts
-{
- /// @cond detail
- namespace detail
- {
- /**
- * @brief initialize parameter set with given parameter values
- *
- * @note uses the templated ParameterSet::set method for assigning the individual components
- *
- * Possible invocations are:
- * * `initialize<T,params...>::init(parSet,values...)` where `parSet` is the ParameterSet object to be
- * initialized and `values` are a consistent number of parameter values (with compatible type)
- * * `initialize<T,params...>::init(parSet,values)` where `parSet` is the ParameterSet object to be
- * initialized and `values` is an Eigen vector of consistent size
- *
- * @tparam T type of the parameters stored in the corresponding @c ParameterSet class
- * @tparam params template parameter pack containing the multiple identifiers
- */
- template<typename T, T... params>
- struct initialize_parset;
+namespace Acts {
+/// @cond detail
+namespace detail {
+ /**
+ * @brief initialize parameter set with given parameter values
+ *
+ * @note uses the templated ParameterSet::set method for assigning the
+ * individual components
+ *
+ * Possible invocations are:
+ * * `initialize<T,params...>::init(parSet,values...)` where `parSet` is the
+ * ParameterSet object to be
+ * initialized and `values` are a consistent number of parameter values
+ * (with compatible type)
+ * * `initialize<T,params...>::init(parSet,values)` where `parSet` is the
+ * ParameterSet object to be
+ * initialized and `values` is an Eigen vector of consistent size
+ *
+ * @tparam T type of the parameters stored in the corresponding @c
+ * ParameterSet class
+ * @tparam params template parameter pack containing the multiple identifiers
+ */
+ template <typename T, T... params>
+ struct initialize_parset;
- /// @cond
- template<typename T,T first,T... others>
- struct initialize_parset<T,first,others...>
+ /// @cond
+ template <typename T, T first, T... others>
+ struct initialize_parset<T, first, others...>
+ {
+ template <typename ParSetType,
+ typename first_value_type,
+ typename... other_value_types>
+ static void
+ init(ParSetType& parSet,
+ const first_value_type& v1,
+ const other_value_types&... values)
{
- template<typename ParSetType,typename first_value_type,typename... other_value_types>
- static void init(ParSetType& parSet,const first_value_type& v1, const other_value_types&... values)
- {
- parSet.template setParameter<first>(v1);
- initialize_parset<T,others...>::init(parSet,values...);
- }
+ parSet.template setParameter<first>(v1);
+ initialize_parset<T, others...>::init(parSet, values...);
+ }
- template<typename ParSetType>
- static void init(ParSetType& parSet,const typename ParSetType::ParVector_t& values, const unsigned int& pos = 0)
- {
- parSet.template setParameter<first>(values(pos));
- initialize_parset<T,others...>::init(parSet,values,pos+1);
- }
- };
+ template <typename ParSetType>
+ static void
+ init(ParSetType& parSet,
+ const typename ParSetType::ParVector_t& values,
+ const unsigned int& pos = 0)
+ {
+ parSet.template setParameter<first>(values(pos));
+ initialize_parset<T, others...>::init(parSet, values, pos + 1);
+ }
+ };
- template<typename T,T last>
- struct initialize_parset<T,last>
+ template <typename T, T last>
+ struct initialize_parset<T, last>
+ {
+ template <typename ParSet_tType, typename last_value_type>
+ static void
+ init(ParSet_tType& ParSet_t, const last_value_type& v1)
{
- template<typename ParSet_tType,typename last_value_type>
- static void init(ParSet_tType& ParSet_t,const last_value_type& v1)
- {
- ParSet_t.template setParameter<last>(v1);
- }
+ ParSet_t.template setParameter<last>(v1);
+ }
- template<typename ParSetType>
- static void init(ParSetType& parSet,const typename ParSetType::ParVector_t& values, const unsigned int& pos = 0)
- {
- parSet.template setParameter<last>(values(pos));
- }
- };
- /// @endcond
- } // end of namespace detail
+ template <typename ParSetType>
+ static void
+ init(ParSetType& parSet,
+ const typename ParSetType::ParVector_t& values,
+ const unsigned int& pos = 0)
+ {
+ parSet.template setParameter<last>(values(pos));
+ }
+ };
/// @endcond
+} // end of namespace detail
+/// @endcond
} // end of namespace Acts
-#endif // ACTS_INITIALIZE_PARAMETER_SET_H
+#endif // ACTS_INITIALIZE_PARAMETER_SET_H
diff --git a/Core/include/ACTS/EventData/detail/is_contained.hpp b/Core/include/ACTS/EventData/detail/is_contained.hpp
index fd197564a..e8266245e 100644
--- a/Core/include/ACTS/EventData/detail/is_contained.hpp
+++ b/Core/include/ACTS/EventData/detail/is_contained.hpp
@@ -1,62 +1,50 @@
#ifndef ACTS_IS_CONTAINED_H
#define ACTS_IS_CONTAINED_H 1
-namespace Acts
-{
- /// @cond detail
- namespace detail
- {
- /**
- * @brief check whether given integral constant is contained in a template parameter pack
- *
- * @tparam T integral type of the values to be checked
- * @tparam target target value to be looked for
- * @tparam values template parameter pack containing the list of values
- *
- * @return `is_contained<T,target,values...>::value` is @c true if `target` is among `values`, otherwise @c false
- */
- template<typename T, T target, T... values>
- struct is_contained;
+namespace Acts {
+/// @cond detail
+namespace detail {
+ /**
+ * @brief check whether given integral constant is contained in a template
+ * parameter pack
+ *
+ * @tparam T integral type of the values to be checked
+ * @tparam target target value to be looked for
+ * @tparam values template parameter pack containing the list of values
+ *
+ * @return `is_contained<T,target,values...>::value` is @c true if `target` is
+ * among `values`, otherwise @c false
+ */
+ template <typename T, T target, T... values>
+ struct is_contained;
- /// @cond
- template<typename T, T target, T ... others>
- struct is_contained<T, target, target, others...>
- {
- enum
- {
- value = true
- };
- };
+ /// @cond
+ template <typename T, T target, T... others>
+ struct is_contained<T, target, target, others...>
+ {
+ enum { value = true };
+ };
- template<typename T, T target>
- struct is_contained<T, target, target>
- {
- enum
- {
- value = true
- };
- };
+ template <typename T, T target>
+ struct is_contained<T, target, target>
+ {
+ enum { value = true };
+ };
- template<typename T, T target, T next, T ... others>
- struct is_contained<T, target, next, others...>
- {
- enum
- {
- value = is_contained<T, target, others...>::value
- };
- };
+ template <typename T, T target, T next, T... others>
+ struct is_contained<T, target, next, others...>
+ {
+ enum { value = is_contained<T, target, others...>::value };
+ };
- template<typename T, T target, T next>
- struct is_contained<T, target, next>
- {
- enum
- {
- value = false
- };
- };
- /// @endcond
- } // end of namespace detail
+ template <typename T, T target, T next>
+ struct is_contained<T, target, next>
+ {
+ enum { value = false };
+ };
/// @endcond
+} // end of namespace detail
+/// @endcond
} // end of namespace Acts
-#endif // ACTS_IS_CONTAINED_H
+#endif // ACTS_IS_CONTAINED_H
diff --git a/Core/include/ACTS/EventData/detail/make_projection_matrix.hpp b/Core/include/ACTS/EventData/detail/make_projection_matrix.hpp
index a1cb9899b..ab571c16f 100644
--- a/Core/include/ACTS/EventData/detail/make_projection_matrix.hpp
+++ b/Core/include/ACTS/EventData/detail/make_projection_matrix.hpp
@@ -4,62 +4,68 @@
// ACTS include(s)
#include "ACTS/Utilities/Definitions.hpp"
-namespace Acts
-{
- /// @cond detail
- namespace detail
- {
- /**
- * @brief initialize projection matrices
- *
- * This struct provides an initialization method for a projection matrix M such that only
- * the entries with the given indices are selected from a full parameter vector. That means,
- * M is a mapping M: (Nx1) --> (Sx1) if N is the total number of parameters and S is the
- * number of given indices.
- *
- * @tparam columns number of columns (= dimension of full parameter space)
- * @tparam rows template parameter pack containing the indices of the parameters to be projected
- *
- * @return `make_projection_matrix<columns,rows...>::init()` returns a matrix with dimensions
- * (`sizeof...(rows)` x columns)
- */
- template<unsigned int columns, unsigned int... rows>
- struct make_projection_matrix;
+namespace Acts {
+/// @cond detail
+namespace detail {
+ /**
+ * @brief initialize projection matrices
+ *
+ * This struct provides an initialization method for a projection matrix M
+ * such that only
+ * the entries with the given indices are selected from a full parameter
+ * vector. That means,
+ * M is a mapping M: (Nx1) --> (Sx1) if N is the total number of parameters
+ * and S is the
+ * number of given indices.
+ *
+ * @tparam columns number of columns (= dimension of full parameter space)
+ * @tparam rows template parameter pack containing the indices of the
+ * parameters to be projected
+ *
+ * @return `make_projection_matrix<columns,rows...>::init()` returns a matrix
+ * with dimensions
+ * (`sizeof...(rows)` x columns)
+ */
+ template <unsigned int columns, unsigned int... rows>
+ struct make_projection_matrix;
- /// @cond
- // build projection matrix by iteratively stacking row vectors
- template<unsigned int columns, unsigned int i, unsigned int ... N>
- struct make_projection_matrix<columns, i, N...>
+ /// @cond
+ // build projection matrix by iteratively stacking row vectors
+ template <unsigned int columns, unsigned int i, unsigned int... N>
+ struct make_projection_matrix<columns, i, N...>
+ {
+ static ActsMatrixD<sizeof...(N) + 1, columns>
+ init()
{
- static ActsMatrixD<sizeof...(N) + 1, columns> init()
- {
- ActsRowVectorD < columns > v;
- v.setZero();
- v(i) = 1;
+ ActsRowVectorD<columns> v;
+ v.setZero();
+ v(i) = 1;
- ActsMatrixD < sizeof...(N) + 1, columns > m;
- m.row(0) << v;
- m.block(1, 0, sizeof...(N), columns) << make_projection_matrix<columns, N...>::init();
+ ActsMatrixD<sizeof...(N) + 1, columns> m;
+ m.row(0) << v;
+ m.block(1, 0, sizeof...(N), columns)
+ << make_projection_matrix<columns, N...>::init();
- return m;
- }
- };
+ return m;
+ }
+ };
- // projection matrix for a single local parameter is a simple row vector
- template<unsigned int columns, unsigned int i>
- struct make_projection_matrix<columns, i>
+ // projection matrix for a single local parameter is a simple row vector
+ template <unsigned int columns, unsigned int i>
+ struct make_projection_matrix<columns, i>
+ {
+ static ActsRowVectorD<columns>
+ init()
{
- static ActsRowVectorD<columns> init()
- {
- ActsRowVectorD<columns> v;
- v.setZero();
- v(i) = 1;
- return v;
- }
- };
- /// @endcond
- } // end of namespace detail
+ ActsRowVectorD<columns> v;
+ v.setZero();
+ v(i) = 1;
+ return v;
+ }
+ };
/// @endcond
+} // end of namespace detail
+/// @endcond
} // end of namespace Acts
-#endif // ACTS_MAKE_PROJECTION_MATRIX_H
+#endif // ACTS_MAKE_PROJECTION_MATRIX_H
diff --git a/Core/include/ACTS/EventData/detail/residual_calculator.hpp b/Core/include/ACTS/EventData/detail/residual_calculator.hpp
index 19e2f0f6d..8d32593eb 100644
--- a/Core/include/ACTS/EventData/detail/residual_calculator.hpp
+++ b/Core/include/ACTS/EventData/detail/residual_calculator.hpp
@@ -5,65 +5,71 @@
#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Utilities/ParameterDefinitions.hpp"
-namespace Acts
-{
- /// @cond detail
- namespace detail
- {
- /**
- * @brief calculate residuals from two parameter vectors
- *
- * Calculate the difference between the two given vectors with parameter values. Possible
- * corrections for bounded or cyclic parameters are applied.
- *
- * @tparam params template parameter pack containing the multiple parameter identifiers
- *
- * @return `residual_calculator<params...>::result(first,second)` yields the residuals of
- * `first` with respect to `second`
- */
- template<ParID_t... params>
- struct residual_calculator;
+namespace Acts {
+/// @cond detail
+namespace detail {
+ /**
+ * @brief calculate residuals from two parameter vectors
+ *
+ * Calculate the difference between the two given vectors with parameter
+ * values. Possible
+ * corrections for bounded or cyclic parameters are applied.
+ *
+ * @tparam params template parameter pack containing the multiple parameter
+ * identifiers
+ *
+ * @return `residual_calculator<params...>::result(first,second)` yields the
+ * residuals of
+ * `first` with respect to `second`
+ */
+ template <ParID_t... params>
+ struct residual_calculator;
- /// @cond
- template<typename R,ParID_t... params>
- struct residual_calculator_impl;
+ /// @cond
+ template <typename R, ParID_t... params>
+ struct residual_calculator_impl;
- template<ParID_t... params>
- struct residual_calculator
- {
- typedef ActsVector<ParValue_t,sizeof...(params)> ParVector_t;
+ template <ParID_t... params>
+ struct residual_calculator
+ {
+ typedef ActsVector<ParValue_t, sizeof...(params)> ParVector_t;
- static ParVector_t result(const ParVector_t& test,const ParVector_t& ref)
- {
- ParVector_t result;
- residual_calculator_impl<ParVector_t,params...>::calculate(result,test,ref,0);
- return result;
- }
- };
+ static ParVector_t
+ result(const ParVector_t& test, const ParVector_t& ref)
+ {
+ ParVector_t result;
+ residual_calculator_impl<ParVector_t, params...>::calculate(
+ result, test, ref, 0);
+ return result;
+ }
+ };
- template<typename R, ParID_t first,ParID_t... others>
- struct residual_calculator_impl<R,first,others...>
+ template <typename R, ParID_t first, ParID_t... others>
+ struct residual_calculator_impl<R, first, others...>
+ {
+ static void
+ calculate(R& result, const R& test, const R& ref, unsigned int pos)
{
- static void calculate(R& result,const R& test,const R& ref,unsigned int pos)
- {
- typedef typename par_type<first>::type parameter_type;
- result(pos) = parameter_type::getDifference(test(pos),ref(pos));
- residual_calculator_impl<R,others...>::calculate(result,test,ref,pos+1);
- }
- };
+ typedef typename par_type<first>::type parameter_type;
+ result(pos) = parameter_type::getDifference(test(pos), ref(pos));
+ residual_calculator_impl<R, others...>::calculate(
+ result, test, ref, pos + 1);
+ }
+ };
- template<typename R,ParID_t last>
- struct residual_calculator_impl<R,last>
+ template <typename R, ParID_t last>
+ struct residual_calculator_impl<R, last>
+ {
+ static void
+ calculate(R& result, const R& test, const R& ref, unsigned int pos)
{
- static void calculate(R& result,const R& test,const R& ref,unsigned int pos)
- {
- typedef typename par_type<last>::type parameter_type;
- result(pos) = parameter_type::getDifference(test(pos),ref(pos));
- }
- };
- /// @endcond
- } // end of namespace detail
+ typedef typename par_type<last>::type parameter_type;
+ result(pos) = parameter_type::getDifference(test(pos), ref(pos));
+ }
+ };
/// @endcond
+} // end of namespace detail
+/// @endcond
} // end of namespace Acts
-#endif // ACTS_RESIDUAL_CALCULATOR_H
+#endif // ACTS_RESIDUAL_CALCULATOR_H
diff --git a/Core/include/ACTS/EventData/detail/value_corrector.hpp b/Core/include/ACTS/EventData/detail/value_corrector.hpp
index d70600e13..cf60d57dc 100644
--- a/Core/include/ACTS/EventData/detail/value_corrector.hpp
+++ b/Core/include/ACTS/EventData/detail/value_corrector.hpp
@@ -5,68 +5,74 @@
#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Utilities/ParameterDefinitions.hpp"
-namespace Acts
-{
- /// @cond detail
- namespace detail
- {
- /**
- * @brief check and correct parameter values
- *
- * Values in the given vector are interpreted as values for the given parameters. As those
- * they are checked whether they are inside the allowed range and corrected if necessary.
- *
- * Invocation:
- * - `value_corrector<params...>::result(parVector)` where `parVector` contains
- * `sizeof...(params)` elements
- *
- * @post All values in the argument `parVector` are within the valid parameter range.
- *
- * @tparam params template parameter pack containing the multiple parameter identifiers
- */
- template<ParID_t... params>
- struct value_corrector;
+namespace Acts {
+/// @cond detail
+namespace detail {
+ /**
+ * @brief check and correct parameter values
+ *
+ * Values in the given vector are interpreted as values for the given
+ * parameters. As those
+ * they are checked whether they are inside the allowed range and corrected if
+ * necessary.
+ *
+ * Invocation:
+ * - `value_corrector<params...>::result(parVector)` where `parVector`
+ * contains
+ * `sizeof...(params)` elements
+ *
+ * @post All values in the argument `parVector` are within the valid parameter
+ * range.
+ *
+ * @tparam params template parameter pack containing the multiple parameter
+ * identifiers
+ */
+ template <ParID_t... params>
+ struct value_corrector;
- /// @cond
- template<typename R,ParID_t... params>
- struct value_corrector_impl;
+ /// @cond
+ template <typename R, ParID_t... params>
+ struct value_corrector_impl;
- template<ParID_t... params>
- struct value_corrector
- {
- typedef ActsVector<ParValue_t,sizeof...(params)> ParVector_t;
+ template <ParID_t... params>
+ struct value_corrector
+ {
+ typedef ActsVector<ParValue_t, sizeof...(params)> ParVector_t;
- static void result(ParVector_t& values)
- {
- value_corrector_impl<ParVector_t,params...>::calculate(values,0);
- }
- };
+ static void
+ result(ParVector_t& values)
+ {
+ value_corrector_impl<ParVector_t, params...>::calculate(values, 0);
+ }
+ };
- template<typename R, ParID_t first,ParID_t... others>
- struct value_corrector_impl<R,first,others...>
+ template <typename R, ParID_t first, ParID_t... others>
+ struct value_corrector_impl<R, first, others...>
+ {
+ static void
+ calculate(R& values, unsigned int pos)
{
- static void calculate(R& values,unsigned int pos)
- {
- typedef typename par_type<first>::type parameter_type;
- if(parameter_type::may_modify_value)
- values(pos) = parameter_type::getValue(values(pos));
- value_corrector_impl<R,others...>::calculate(values,pos+1);
- }
- };
+ typedef typename par_type<first>::type parameter_type;
+ if (parameter_type::may_modify_value)
+ values(pos) = parameter_type::getValue(values(pos));
+ value_corrector_impl<R, others...>::calculate(values, pos + 1);
+ }
+ };
- template<typename R,ParID_t last>
- struct value_corrector_impl<R,last>
+ template <typename R, ParID_t last>
+ struct value_corrector_impl<R, last>
+ {
+ static void
+ calculate(R& values, unsigned int pos)
{
- static void calculate(R& values,unsigned int pos)
- {
- typedef typename par_type<last>::type parameter_type;
- if(parameter_type::may_modify_value)
- values(pos) = parameter_type::getValue(values(pos));
- }
- };
- /// @endcond
- } // end of namespace detail
+ typedef typename par_type<last>::type parameter_type;
+ if (parameter_type::may_modify_value)
+ values(pos) = parameter_type::getValue(values(pos));
+ }
+ };
/// @endcond
+} // end of namespace detail
+/// @endcond
} // end of namespace Acts
-#endif // ACTS_VALUE_CORRECTOR_H
+#endif // ACTS_VALUE_CORRECTOR_H
diff --git a/Core/include/ACTS/Extrapolation/ExtrapolationCell.hpp b/Core/include/ACTS/Extrapolation/ExtrapolationCell.hpp
index 0ea2ef864..84e34f7f5 100644
--- a/Core/include/ACTS/Extrapolation/ExtrapolationCell.hpp
+++ b/Core/include/ACTS/Extrapolation/ExtrapolationCell.hpp
@@ -14,515 +14,659 @@
#define ACTS_EXTRAPOLATIONUTILS_EXTRAPOLATIONCELL_H 1
// Extrapolation moudle
-#include "ACTS/Extrapolation/MaterialUpdateMode.hpp"
-#include "ACTS/EventData/TransportJacobian.hpp"
#include "ACTS/EventData/ParticleDefinitions.hpp"
+#include "ACTS/EventData/TransportJacobian.hpp"
+#include "ACTS/Extrapolation/MaterialUpdateMode.hpp"
#include "ACTS/Material/MaterialProperties.hpp"
-#include "ACTS/Utilities/GeometrySignature.hpp"
-#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Surfaces/Surface.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Utilities/GeometrySignature.hpp"
#ifndef ACTS_EXTRAPOLATIONUTILSS_CHECKPATHMACRO
#define ACTS_EXTRAPOLATIONUTILSS_CHECKPATHMACRO 1
-#define reachedLimit(current, limit, tolerance) ( limit > 0 && ((current<limit) ? (current-limit)*(current-limit)/(limit*limit) < tolerance*tolerance : true))
+#define reachedLimit(current, limit, tolerance) \
+ (limit > 0 && ((current < limit) \
+ ? (current - limit) * (current - limit) / (limit * limit) \
+ < tolerance * tolerance \
+ : true))
#endif
namespace Acts {
-
- class TrackingVolume;
- class Layer;
-
- /** enumeration to decode - for Extrapolation steering
- - they are used as bits in the configuration integer */
- class ExtrapolationMode {
-
- public :
-
- enum eMode {
- Destination = 1, // try to hit the destination, if not other means to stop
- Propagation = 2, // any propagation filling by the propagator that is not the destination call
- StopWithPathLimit = 3, // stop when the path limit is reached
- StopWithMaterialLimitX0 = 4, // stop when the material limit is reached in X0
- StopWithMaterialLimitL0 = 5, // stop when the material limit is reached in L0
- StopAtBoundary = 6, // stop at the next ID / Calo / MS boundary
- CollectSensitive = 7, // collect parameters on sensitive elements
- CollectPassive = 8, // collect parameters on passive layers
- CollectBoundary = 9, // collect parameters on boundary parameters
- CollectMaterial = 10, // collect all material on the way
- CollectJacobians = 11, // collect the transport jacobians
- CollectPathSteps = 12, // collect the single path steps
- AvoidFallback = 13, // don't fallback to propagation
- FATRAS = 14 // force initial radialDirection to be outward
- };
-
- };
-
- /** @class ExtrapolationConfig
- - this is a collection of extrapolation modes and a simple check
- */
- class ExtrapolationConfig {
- public:
- /** Constructor */
- ExtrapolationConfig(unsigned int evalue=0) :
- value(evalue)
- {}
-
- /** Copy Constructor */
- ExtrapolationConfig(const ExtrapolationConfig& eConfig) :
- value(eConfig.value)
- {}
-
- /** add a configuration mode */
- void addMode(ExtrapolationMode::eMode em) {
- // set the bit corresponding to this mode
- value |= (1 << int(em));
- }
-
- /** check the configuration mode */
- bool checkMode(ExtrapolationMode::eMode em) const {
- // check if the bit is set or not
- return (value & (1 << int(em)));
- }
- private:
- unsigned int value;
-
- };
-
-
- /** @class ExtrapolationCode
- */
- class ExtrapolationCode {
-
- public :
-
- enum eCode {
- Unset = 0, // no code set yet
- InProgress = 1, // successful : extrapolation in process
- SuccessDestination = 2, // successful : destination reached
- SuccessBoundaryReached = 3, // successful : boundary reached & configured to do so
- SuccessPathLimit = 4, // successful : path limit reached & configured to do so
- SuccessMaterialLimit = 5, // successful : material limit reached & configured to do so
- Recovered = 6, // successful : recovered & configured to do so
- 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 ...
- };
-
- /** the actual code */
- eCode code;
-
- /* create a simple extrapolation code */
- ExtrapolationCode(eCode c) :
- code(c){}
-
- /** assigment operator - because we can */
- ExtrapolationCode& operator=(const eCode& ec){
- code = ec;
- return (*this);
- }
-
- /** == operator to eCode */
- bool operator==(const eCode& ec) const { return (ec==code); }
-
- /** != operator to eCode */
- bool operator!=(const eCode& ec) const { return (ec!=code); }
-
- /** return inProgress */
- bool inProgress() const { return (code == InProgress); }
-
- /** return success */
- bool isSuccess() const { return (code > InProgress && code < Recovered); }
-
- /** return sucess other than destination reached */
- bool isSuccessBeforeDestination() const { return (code > SuccessDestination && code < Recovered); }
-
- /** return success or recovered */
- bool isSuccessOrRecovered() const { return (code > InProgress && code <= FailureDestination); }
-
- /** return failure */
- bool isFailure() const { return (code > Recovered); }
-
- /** return failure or recovered */
- bool isFailureOrRecovered() const { return (code > SuccessMaterialLimit); };
-
- /** toString */
- const std::string& toString() const { return s_ecodeNames.at(code); }
-
- private :
- static std::vector<std::string> s_ecodeNames;
-
- };
-
- /** @class ExtrapolationStep
-
- templated class to record the different possible entities during extrapolation,
- the newly created objects are unique pointers and have to be checked out via std::move()
- by the client caller/
-
- */
- template <class T> class ExtrapolationStep {
- public:
- std::unique_ptr<const T> parameters; //!< the parameters of this step
- const Surface* surface; //!< the surface where the step is bound
- const Layer* layer; //!< the associatedLayer() or materialLayer() of the surface
- ExtrapolationConfig stepConfiguration; //!< sensitive, passive, boundary to name the parameters
- const MaterialProperties* material; //!< the associated material
- Vector3D materialPosition; //!< position from where the material is taken
- double materialScaling; //!< scale factor for the material as calculated
- std::unique_ptr<const TransportJacobian> transportJacobian; //!< the transport jacobian from the last step
- double pathLength; //!< the path length from the last step
- float time; //!< timing info
-
- ExtrapolationStep(std::unique_ptr<const T> pars = nullptr,
- const Surface* sf = nullptr,
- ExtrapolationConfig eConfig = ExtrapolationConfig(),
- const MaterialProperties* mprop = nullptr,
- std::unique_ptr<const TransportJacobian> tjac = nullptr,
- double pLength = -1.) :
- parameters(std::move(pars)),
- surface(sf),
- layer(nullptr),
- stepConfiguration(eConfig),
- material(mprop),
- materialPosition(Vector3D(0.,0.,0.)),
- materialScaling(1.),
- transportJacobian(std::move(tjac)),
- pathLength(pLength)
- {}
- };
-
- /** @class ExtrapolationCell
-
- templated class as an input-output object of the extrapolation,
- only public members, since it is a container class
-
+
+class TrackingVolume;
+class Layer;
+
+/** enumeration to decode - for Extrapolation steering
+ - they are used as bits in the configuration integer */
+class ExtrapolationMode
+{
+public:
+ enum eMode {
+ Destination = 1, // try to hit the destination, if not other means to stop
+ Propagation = 2, // any propagation filling by the propagator that is not
+ // the destination call
+ StopWithPathLimit = 3, // stop when the path limit is reached
+ StopWithMaterialLimitX0
+ = 4, // stop when the material limit is reached in X0
+ StopWithMaterialLimitL0
+ = 5, // stop when the material limit is reached in L0
+ StopAtBoundary = 6, // stop at the next ID / Calo / MS boundary
+ CollectSensitive = 7, // collect parameters on sensitive elements
+ CollectPassive = 8, // collect parameters on passive layers
+ CollectBoundary = 9, // collect parameters on boundary parameters
+ CollectMaterial = 10, // collect all material on the way
+ CollectJacobians = 11, // collect the transport jacobians
+ CollectPathSteps = 12, // collect the single path steps
+ AvoidFallback = 13, // don't fallback to propagation
+ FATRAS = 14 // force initial radialDirection to be outward
+ };
+};
+
+/** @class ExtrapolationConfig
+ - this is a collection of extrapolation modes and a simple check
+*/
+class ExtrapolationConfig
+{
+public:
+ /** Constructor */
+ ExtrapolationConfig(unsigned int evalue = 0) : value(evalue) {}
+ /** Copy Constructor */
+ ExtrapolationConfig(const ExtrapolationConfig& eConfig) : value(eConfig.value)
+ {
+ }
+
+ /** add a configuration mode */
+ void
+ addMode(ExtrapolationMode::eMode em)
+ {
+ // set the bit corresponding to this mode
+ value |= (1 << int(em));
+ }
+
+ /** check the configuration mode */
+ bool
+ checkMode(ExtrapolationMode::eMode em) const
+ {
+ // check if the bit is set or not
+ return (value & (1 << int(em)));
+ }
+
+private:
+ unsigned int value;
+};
+
+/** @class ExtrapolationCode
+*/
+class ExtrapolationCode
+{
+public:
+ enum eCode {
+ Unset = 0, // no code set yet
+ InProgress = 1, // successful : extrapolation in process
+ SuccessDestination = 2, // successful : destination reached
+ SuccessBoundaryReached
+ = 3, // successful : boundary reached & configured to do so
+ SuccessPathLimit
+ = 4, // successful : path limit reached & configured to do so
+ SuccessMaterialLimit
+ = 5, // successful : material limit reached & configured to do so
+ Recovered = 6, // successful : recovered & configured to do so
+ 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 ...
+ };
+
+ /** the actual code */
+ eCode code;
+
+ /* create a simple extrapolation code */
+ ExtrapolationCode(eCode c) : code(c) {}
+ /** assigment operator - because we can */
+ ExtrapolationCode&
+ operator=(const eCode& ec)
+ {
+ code = ec;
+ return (*this);
+ }
+
+ /** == operator to eCode */
+ bool
+ operator==(const eCode& ec) const
+ {
+ return (ec == code);
+ }
+
+ /** != operator to eCode */
+ bool
+ operator!=(const eCode& ec) const
+ {
+ return (ec != code);
+ }
+
+ /** return inProgress */
+ bool
+ inProgress() const
+ {
+ return (code == InProgress);
+ }
+
+ /** return success */
+ bool
+ isSuccess() const
+ {
+ return (code > InProgress && code < Recovered);
+ }
+
+ /** return sucess other than destination reached */
+ bool
+ isSuccessBeforeDestination() const
+ {
+ return (code > SuccessDestination && code < Recovered);
+ }
+
+ /** return success or recovered */
+ bool
+ isSuccessOrRecovered() const
+ {
+ return (code > InProgress && code <= FailureDestination);
+ }
+
+ /** return failure */
+ bool
+ isFailure() const
+ {
+ return (code > Recovered);
+ }
+
+ /** return failure or recovered */
+ bool
+ isFailureOrRecovered() const
+ {
+ return (code > SuccessMaterialLimit);
+ };
+
+ /** toString */
+ const std::string&
+ toString() const
+ {
+ return s_ecodeNames.at(code);
+ }
+
+private:
+ static std::vector<std::string> s_ecodeNames;
+};
+
+/** @class ExtrapolationStep
+
+ templated class to record the different possible entities during
+ extrapolation,
+ the newly created objects are unique pointers and have to be checked out via
+ std::move()
+ by the client caller/
+
*/
-
- template <class T> class ExtrapolationCell {
- public :
- const T& startParameters; //!< by reference - need to be defined
- const TrackingVolume* startVolume; //!< the start volume - needed for the volumeToVolume loop
- const Layer* startLayer; //!< the start layer - needed for layerToLayer loop
-
- std::unique_ptr<const T> endParameters; //!< by pointer - are newly created and can be optionally 0
- const TrackingVolume* endVolume; //!< the end Volume - can be optionally nullptr (needs other trigger to stop)
- const Layer* endLayer; //!< the end Layer - can be optionally nullptr (needs other trigger to stop)
- const Surface* endSurface; //!< keep track of the destination surface - can be optionally 0
-
- const T* leadParameters; //!< the one last truely valid parameter in the stream
- const TrackingVolume* leadVolume; //!< the lead Volume - carrying the navigation stream
- const Layer* leadLayer; //!< the lead Layer - carrying the navigation stream
- const Surface* leadLayerSurface; //!< if the lead layer has sub structure that is the first one to start with
-
- const T* lastBoundaryParameters; //!< this is the last boundary surface to prevent loops
- const Surface* lastBoundarySurface; //!< this is the last boundary surface to prevent loops
-
- const T* lastLeadParameters; //!< this is for caching the last valid parameters before the lead parameters
- PropDirection propDirection; //!< this is the propagation direction
- int radialDirection; //!< for checking if navigation is radially towards the IP, this has consequences for entering cylinders
-
- GeometrySignature nextGeometrySignature; //!< when a boundary is reached the geometry signature is updated to the next volume one
-
- int navigationStep; //!< a counter of the navigation Step
- double pathLength; //!< the path length accumulated
- double pathLimit; //!< the maximal limit of the extrapolation
-
- const Surface* materialSurface; //!< the surface for the next material update
- double materialX0; //!< collected material so far in units of X0
- double materialLimitX0; //!< given material limit in X0
- double materialL0; //!< collected material so far in units of L0
- double materialLimitL0; //!< given material limit in L0
-
- process_type interactionProcess; //!< the material process to be generated
- ParticleType particleType; //!< what particle hypothesis to be used, default : pion
- MaterialUpdateMode materialUpdateMode; //!< how to deal with the material effect, default: addNoise
- bool navigationCurvilinear; //!< stay in curvilinear parameters where possible, default : true
- bool sensitiveCurvilinear; //!< stay in curvilinear parameters even on the destination surface
- bool destinationCurvilinear; //!< return curvilinear parameters even on destination
- int searchMode; //!< the tupe of search being performed
-
- std::vector< ExtrapolationStep<T> > extrapolationSteps; //!< parameters on sensitive detector elements
-
- ExtrapolationConfig extrapolationConfiguration; //!< overall global configuration
-
- std::vector< ProcessVertex > interactionVertices; //!< interaction vertices
-
- float time; //!< timing info
- float zOaTrX; //!< z/A*rho*dInX0 (for average calculations)
- float zX; //!< z*dInX0 (for average calculations)
-
-
-
-
- /** start parameters are compulsory */
- ExtrapolationCell(const T& sParameters, PropDirection pDir=alongMomentum, unsigned int econfig=1) :
- startParameters(sParameters),
- startVolume(nullptr),
- startLayer(nullptr),
- endParameters(nullptr),
- endVolume(nullptr),
- endLayer(nullptr),
- endSurface(nullptr),
- leadParameters(&sParameters),
- leadVolume(nullptr),
- leadLayer(nullptr),
- leadLayerSurface(nullptr),
- lastBoundaryParameters(nullptr),
- lastBoundarySurface(nullptr),
- lastLeadParameters(&sParameters),
- propDirection(pDir),
- radialDirection(1),
- nextGeometrySignature(Acts::Unsigned),
- navigationStep(0),
- pathLength(0.),
- pathLimit(-1),
- materialSurface(nullptr),
- materialX0(0.),
- materialLimitX0(-1.),
- materialL0(0.),
- materialLimitL0(-1.),
- interactionProcess(0),
- particleType(Acts::pion),
- materialUpdateMode(Acts::addNoise),
- navigationCurvilinear(true),
- sensitiveCurvilinear(false),
- destinationCurvilinear(false),
- searchMode(0),
- extrapolationConfiguration(econfig),
- zOaTrX(0.),
- zX(0.)
- {
- // make a standard allocation of 50 possible steps
- extrapolationSteps.reserve(50);
- }
-
- /** add a configuration mode */
- void addConfigurationMode(ExtrapolationMode::eMode em) {
- // set the bit corresponding to this mode
- extrapolationConfiguration.addMode(em);
- }
-
- /** check the configuration mode */
- bool checkConfigurationMode(ExtrapolationMode::eMode em) const {
- // check if the bit is set or not
- return extrapolationConfiguration.checkMode(em);
- }
-
- /** check if you are still at the last boundary surface */
- bool onLastBoundary() const { return (leadParameters == lastBoundaryParameters); }
-
- /** turn the last step's parameters into the final parameters */
- void checkoutLastStep();
-
- /** fill or attach the parameters from a step */
- void step(std::unique_ptr<const T> stepParameters, ExtrapolationMode::eMode fillMode = ExtrapolationMode::Propagation);
-
- /** fill transport information - path length and TransportJacobian
- - jacobians need to be cleared */
- void stepTransport(const Surface& sf, double pathLength=0., std::unique_ptr<const TransportJacobian> tjac=nullptr);
-
- /** fill or attach material
- - material is just a pointer copy */
- void addMaterial(double sfactor, const MaterialProperties* mprop=nullptr);
-
- /** fill the material *
- - material is just a pointer copy */
- void addMaterial(double step, const Material* mat=nullptr);
-
- /** fill or attach material, jacobian, step length
- - material is just a pointer copy */
- void stepMaterial(const Surface& sf, const Layer* lay, const Vector3D& position, double sfactor, const MaterialProperties* mprop=nullptr);
-
- /** check if this is the initial volume */
- bool initialVolume() const { return (leadVolume==startVolume); }
-
- /** trigger for final volume */
- bool finalVolumeReached() const { return (leadVolume==endVolume && endVolume); }
-
- /** the materialLimitReached */
- bool pathLimitReached(double tolerance=0.001, bool checkout = true) {
- bool reached = checkConfigurationMode(Acts::ExtrapolationMode::StopWithPathLimit) && reachedLimit(pathLength,pathLimit,tolerance);
- if (reached && checkout)
- endParameters = std::move(extrapolationSteps.back().parameters);
- return reached;
- }
-
- /** the materialLimitReached */
- bool materialLimitReached(double tolerance=0.001) const {
- return ( (checkConfigurationMode(Acts::ExtrapolationMode::StopWithMaterialLimitX0) && reachedLimit(materialX0,materialLimitX0,tolerance) ) ||
- (checkConfigurationMode(Acts::ExtrapolationMode::StopWithMaterialLimitL0) && reachedLimit(materialL0,materialLimitL0,tolerance) ) );
- }
-
- /** prepare destination as new start point - optimised for Kalman filtering */
- void restartAtDestination();
-
- /** set ParticleType */
- void setParticleType(const ParticleType& hypo) {
- particleType = hypo;
- }
-
- /** estimate the radial direction of the extrapolation cell */
- void setRadialDirection() {
- // in FATRAS extrapolation mode force radial direction to be outwards (+1)
- if (checkConfigurationMode(ExtrapolationMode::FATRAS))
- radialDirection = 1;
- else {
- // if the endSurface is given, it is used to evaluate the radial direction
- // else the leadParamenters are used
- if ( leadParameters->position().perp() > (leadParameters->position() + propDirection*leadParameters->momentum().unit()).perp() )
- radialDirection = -1;
- }
- }
-
- /** check whether the propagation stays compatible with initial radial direction */
- bool checkRadialCompatibility () const {
- // this checks the radial compatibility - not needed for outwards moving
- if (radialDirection > 0) return true;
- // this was radially inwards moving and stays like this
- if (leadParameters->position().perp() > (leadParameters->position() + propDirection*leadParameters->momentum().unit()).perp())
- return true;
- // radial direction changed
- return false;
- }
-
- };
-
- template <class T> void ExtrapolationCell<T>::restartAtDestination() {
- /** set end to start - and reset the rest */
- startParameters = endParameters;
- startVolume = endVolume;
- startLayer = endLayer;
- endParameters = nullptr;
- endVolume = nullptr;
- endLayer = nullptr;
- endSurface = nullptr;
- leadParameters = startParameters;
- leadVolume = nullptr;
- leadLayer = nullptr;
- leadLayerSurface = nullptr;
- lastBoundaryParameters = startParameters;
- lastBoundarySurface = nullptr;
- lastLeadParameters = startParameters;
- navigationStep = 0;
- pathLength = 0.;
- materialX0 = 0.;
- materialL0 = 0.;
- // clear the vector
- extrapolationSteps.clear();
- }
-
-
- template <class T> void ExtrapolationCell<T>::step(std::unique_ptr<const T> stepParameters, Acts::ExtrapolationMode::eMode fillMode)
- {
-
- // move the step parameters into the step cache
- // and set them to the new lead parameters
- leadParameters = stepParameters.get();
- // current step surface
- const Surface* cssf = &(stepParameters->associatedSurface());
- // get the last step surface - if it is identical with the current one -> attach information
- const Surface* lssf = extrapolationSteps.size() ? extrapolationSteps.at(extrapolationSteps.size()-1).surface : nullptr;
- // create a new step
- if (cssf != lssf)
- extrapolationSteps.push_back(ExtrapolationStep<T>());
- // fill the parameters (memory membership goes to the steps), the surface and add the mode
- extrapolationSteps.back().parameters = std::move(stepParameters);
- extrapolationSteps.back().surface = cssf;
- extrapolationSteps.back().stepConfiguration.addMode(fillMode);
- }
-
- template <class T> void ExtrapolationCell<T>::stepTransport(const Surface& sf,
- double pLength,
- std::unique_ptr<const TransportJacobian> tjac)
- {
- // find out if you want to attach or you need a new one
- // current step surface
- const Surface* cssf = &sf;
- // get the last step surface - if it is identical with the current one -> attach information
- const Surface* lssf = extrapolationSteps.size() ? extrapolationSteps.at(extrapolationSteps.size()-1).surface : nullptr;
- // only create a new step for a transport jacobian
- if (tjac){
- // create a new step
- if (cssf != lssf)
- extrapolationSteps.push_back(ExtrapolationStep<T>());
- // set the surface
- extrapolationSteps.back().surface = cssf;
- // set the the transport information
- extrapolationSteps.back().transportJacobian = std::move(tjac);
- extrapolationSteps.back().stepConfiguration.addMode(Acts::ExtrapolationMode::CollectJacobians);
- // fill the step path length
- if (pLength > 0.){
- extrapolationSteps.back().pathLength = pLength;
- extrapolationSteps.back().stepConfiguration.addMode(Acts::ExtrapolationMode::CollectPathSteps);
- }
- }
- // also update the global pathLength information
- pathLength += pLength;
- }
-
-
- template <class T> void ExtrapolationCell<T>::addMaterial(double sfactor,
- const MaterialProperties* mprop)
- {
-
- // fill the material if there
- if (mprop){
- // the overal material
- materialX0 += sfactor * mprop->thicknessInX0();
- materialL0 += sfactor * mprop->thicknessInL0();
- zOaTrX += mprop->zOverAtimesRho()* sfactor * mprop->thicknessInX0();
- zX += mprop->averageZ()* sfactor * mprop->thicknessInX0();
- }
- }
-
- template <class T> void ExtrapolationCell<T>::addMaterial(double step,
- const Material* mat)
- {
-
- // fill the material if there
- if (mat && step>0.){
- // the overal material
- materialX0 += step/mat->X0;
- materialL0 += step/mat->L0;
- zOaTrX += mat->zOverAtimesRho()* step/mat->X0;
- zX += mat->averageZ()* step/mat->X0;
- }
+template <class T>
+class ExtrapolationStep
+{
+public:
+ std::unique_ptr<const T> parameters; //!< the parameters of this step
+ const Surface* surface; //!< the surface where the step is bound
+ const Layer*
+ layer; //!< the associatedLayer() or materialLayer() of the surface
+ ExtrapolationConfig stepConfiguration; //!< sensitive, passive, boundary to
+ //!name the parameters
+ const MaterialProperties* material; //!< the associated material
+ Vector3D materialPosition; //!< position from where the material is taken
+ double materialScaling; //!< scale factor for the material as calculated
+ std::unique_ptr<const TransportJacobian>
+ transportJacobian; //!< the transport jacobian from the last step
+ double pathLength; //!< the path length from the last step
+ float time; //!< timing info
+
+ ExtrapolationStep(std::unique_ptr<const T> pars = nullptr,
+ const Surface* sf = nullptr,
+ ExtrapolationConfig eConfig = ExtrapolationConfig(),
+ const MaterialProperties* mprop = nullptr,
+ std::unique_ptr<const TransportJacobian> tjac = nullptr,
+ double pLength = -1.)
+ : parameters(std::move(pars))
+ , surface(sf)
+ , layer(nullptr)
+ , stepConfiguration(eConfig)
+ , material(mprop)
+ , materialPosition(Vector3D(0., 0., 0.))
+ , materialScaling(1.)
+ , transportJacobian(std::move(tjac))
+ , pathLength(pLength)
+ {
+ }
+};
+
+/** @class ExtrapolationCell
+
+ templated class as an input-output object of the extrapolation,
+ only public members, since it is a container class
+
+*/
+
+template <class T>
+class ExtrapolationCell
+{
+public:
+ const T& startParameters; //!< by reference - need to be defined
+ const TrackingVolume*
+ startVolume; //!< the start volume - needed for the volumeToVolume loop
+ const Layer* startLayer; //!< the start layer - needed for layerToLayer loop
+
+ std::unique_ptr<const T> endParameters; //!< by pointer - are newly created
+ //!and can be optionally 0
+ const TrackingVolume* endVolume; //!< the end Volume - can be optionally
+ //!nullptr (needs other trigger to stop)
+ const Layer* endLayer; //!< the end Layer - can be optionally nullptr (needs
+ //!other trigger to stop)
+ const Surface* endSurface; //!< keep track of the destination surface - can
+ //!be optionally 0
+
+ const T*
+ leadParameters; //!< the one last truely valid parameter in the stream
+ const TrackingVolume*
+ leadVolume; //!< the lead Volume - carrying the navigation stream
+ const Layer* leadLayer; //!< the lead Layer - carrying the navigation stream
+ const Surface* leadLayerSurface; //!< if the lead layer has sub structure
+ //!that is the first one to start with
+
+ const T* lastBoundaryParameters; //!< this is the last boundary surface to
+ //!prevent loops
+ const Surface* lastBoundarySurface; //!< this is the last boundary surface to
+ //!prevent loops
+
+ const T* lastLeadParameters; //!< this is for caching the last valid
+ //!parameters before the lead parameters
+ PropDirection propDirection; //!< this is the propagation direction
+ int radialDirection; //!< for checking if navigation is radially towards the
+ //!IP, this has consequences for entering cylinders
+
+ GeometrySignature nextGeometrySignature; //!< when a boundary is reached the
+ //!geometry signature is updated to
+ //!the next volume one
+
+ int navigationStep; //!< a counter of the navigation Step
+ double pathLength; //!< the path length accumulated
+ double pathLimit; //!< the maximal limit of the extrapolation
+
+ const Surface* materialSurface; //!< the surface for the next material update
+ double materialX0; //!< collected material so far in units of X0
+ double materialLimitX0; //!< given material limit in X0
+ double materialL0; //!< collected material so far in units of L0
+ double materialLimitL0; //!< given material limit in L0
+
+ process_type interactionProcess; //!< the material process to be generated
+ ParticleType
+ particleType; //!< what particle hypothesis to be used, default : pion
+ MaterialUpdateMode materialUpdateMode; //!< how to deal with the material
+ //!effect, default: addNoise
+ bool navigationCurvilinear; //!< stay in curvilinear parameters where
+ //!possible, default : true
+ bool sensitiveCurvilinear; //!< stay in curvilinear parameters even on the
+ //!destination surface
+ bool destinationCurvilinear; //!< return curvilinear parameters even on
+ //!destination
+ int searchMode; //!< the tupe of search being performed
+
+ std::vector<ExtrapolationStep<T>>
+ extrapolationSteps; //!< parameters on sensitive detector elements
+
+ ExtrapolationConfig
+ extrapolationConfiguration; //!< overall global configuration
+
+ std::vector<ProcessVertex> interactionVertices; //!< interaction vertices
+
+ float time; //!< timing info
+ float zOaTrX; //!< z/A*rho*dInX0 (for average calculations)
+ float zX; //!< z*dInX0 (for average calculations)
+
+ /** start parameters are compulsory */
+ ExtrapolationCell(const T& sParameters,
+ PropDirection pDir = alongMomentum,
+ unsigned int econfig = 1)
+ : startParameters(sParameters)
+ , startVolume(nullptr)
+ , startLayer(nullptr)
+ , endParameters(nullptr)
+ , endVolume(nullptr)
+ , endLayer(nullptr)
+ , endSurface(nullptr)
+ , leadParameters(&sParameters)
+ , leadVolume(nullptr)
+ , leadLayer(nullptr)
+ , leadLayerSurface(nullptr)
+ , lastBoundaryParameters(nullptr)
+ , lastBoundarySurface(nullptr)
+ , lastLeadParameters(&sParameters)
+ , propDirection(pDir)
+ , radialDirection(1)
+ , nextGeometrySignature(Acts::Unsigned)
+ , navigationStep(0)
+ , pathLength(0.)
+ , pathLimit(-1)
+ , materialSurface(nullptr)
+ , materialX0(0.)
+ , materialLimitX0(-1.)
+ , materialL0(0.)
+ , materialLimitL0(-1.)
+ , interactionProcess(0)
+ , particleType(Acts::pion)
+ , materialUpdateMode(Acts::addNoise)
+ , navigationCurvilinear(true)
+ , sensitiveCurvilinear(false)
+ , destinationCurvilinear(false)
+ , searchMode(0)
+ , extrapolationConfiguration(econfig)
+ , zOaTrX(0.)
+ , zX(0.)
+ {
+ // make a standard allocation of 50 possible steps
+ extrapolationSteps.reserve(50);
+ }
+
+ /** add a configuration mode */
+ void
+ addConfigurationMode(ExtrapolationMode::eMode em)
+ {
+ // set the bit corresponding to this mode
+ extrapolationConfiguration.addMode(em);
+ }
+
+ /** check the configuration mode */
+ bool
+ checkConfigurationMode(ExtrapolationMode::eMode em) const
+ {
+ // check if the bit is set or not
+ return extrapolationConfiguration.checkMode(em);
+ }
+
+ /** check if you are still at the last boundary surface */
+ bool
+ onLastBoundary() const
+ {
+ return (leadParameters == lastBoundaryParameters);
+ }
+
+ /** turn the last step's parameters into the final parameters */
+ void
+ checkoutLastStep();
+
+ /** fill or attach the parameters from a step */
+ void
+ step(std::unique_ptr<const T> stepParameters,
+ ExtrapolationMode::eMode fillMode = ExtrapolationMode::Propagation);
+
+ /** fill transport information - path length and TransportJacobian
+ - jacobians need to be cleared */
+ void
+ stepTransport(const Surface& sf,
+ double pathLength = 0.,
+ std::unique_ptr<const TransportJacobian> tjac = nullptr);
+
+ /** fill or attach material
+ - material is just a pointer copy */
+ void
+ addMaterial(double sfactor, const MaterialProperties* mprop = nullptr);
+
+ /** fill the material *
+ - material is just a pointer copy */
+ void
+ addMaterial(double step, const Material* mat = nullptr);
+
+ /** fill or attach material, jacobian, step length
+ - material is just a pointer copy */
+ void
+ stepMaterial(const Surface& sf,
+ const Layer* lay,
+ const Vector3D& position,
+ double sfactor,
+ const MaterialProperties* mprop = nullptr);
+
+ /** check if this is the initial volume */
+ bool
+ initialVolume() const
+ {
+ return (leadVolume == startVolume);
+ }
+
+ /** trigger for final volume */
+ bool
+ finalVolumeReached() const
+ {
+ return (leadVolume == endVolume && endVolume);
+ }
+
+ /** the materialLimitReached */
+ bool
+ pathLimitReached(double tolerance = 0.001, bool checkout = true)
+ {
+ bool reached
+ = checkConfigurationMode(Acts::ExtrapolationMode::StopWithPathLimit)
+ && reachedLimit(pathLength, pathLimit, tolerance);
+ if (reached && checkout)
+ endParameters = std::move(extrapolationSteps.back().parameters);
+ return reached;
+ }
+
+ /** the materialLimitReached */
+ bool
+ materialLimitReached(double tolerance = 0.001) const
+ {
+ return ((checkConfigurationMode(
+ Acts::ExtrapolationMode::StopWithMaterialLimitX0)
+ && reachedLimit(materialX0, materialLimitX0, tolerance))
+ || (checkConfigurationMode(
+ Acts::ExtrapolationMode::StopWithMaterialLimitL0)
+ && reachedLimit(materialL0, materialLimitL0, tolerance)));
+ }
+
+ /** prepare destination as new start point - optimised for Kalman filtering */
+ void
+ restartAtDestination();
+
+ /** set ParticleType */
+ void
+ setParticleType(const ParticleType& hypo)
+ {
+ particleType = hypo;
+ }
+
+ /** estimate the radial direction of the extrapolation cell */
+ void
+ setRadialDirection()
+ {
+ // in FATRAS extrapolation mode force radial direction to be outwards (+1)
+ if (checkConfigurationMode(ExtrapolationMode::FATRAS))
+ radialDirection = 1;
+ else {
+ // if the endSurface is given, it is used to evaluate the radial direction
+ // else the leadParamenters are used
+ if (leadParameters->position().perp()
+ > (leadParameters->position()
+ + propDirection * leadParameters->momentum().unit())
+ .perp())
+ radialDirection = -1;
}
-
- template <class T> void ExtrapolationCell<T>::stepMaterial(const Surface& sf,
- const Layer* lay,
- const Vector3D& mposition,
- double sfactor,
- const MaterialProperties* mprop)
- {
-
- // add material to the global counter
- addMaterial(sfactor,mprop);
- // find out if you want to attach or you need a new one
- // current step surface
- const Surface* cssf = &sf;
- // get the last step surface - if it is identical with the current one -> attach information
- const Surface* lssf = extrapolationSteps.size() ? extrapolationSteps.at(extrapolationSteps.size()-1).surface : nullptr;
- // create a new step
- if (cssf != lssf)
- extrapolationSteps.push_back(ExtrapolationStep<T>());
- // set the surface
- extrapolationSteps.at(extrapolationSteps.size()-1).surface = cssf;
- extrapolationSteps.at(extrapolationSteps.size()-1).layer = lay;
- // fill the material if there
- if (mprop){
- // record the step information
- extrapolationSteps.at(extrapolationSteps.size()-1).material = mprop;
- extrapolationSteps.at(extrapolationSteps.size()-1).stepConfiguration.addMode(Acts::ExtrapolationMode::CollectMaterial);
- extrapolationSteps.at(extrapolationSteps.size()-1).materialPosition = mposition;
- extrapolationSteps.at(extrapolationSteps.size()-1).materialScaling = sfactor;
- }
+ }
+
+ /** check whether the propagation stays compatible with initial radial
+ * direction */
+ bool
+ checkRadialCompatibility() const
+ {
+ // this checks the radial compatibility - not needed for outwards moving
+ if (radialDirection > 0) return true;
+ // this was radially inwards moving and stays like this
+ if (leadParameters->position().perp()
+ > (leadParameters->position()
+ + propDirection * leadParameters->momentum().unit())
+ .perp())
+ return true;
+ // radial direction changed
+ return false;
+ }
+};
+
+template <class T>
+void
+ExtrapolationCell<T>::restartAtDestination()
+{
+ /** set end to start - and reset the rest */
+ startParameters = endParameters;
+ startVolume = endVolume;
+ startLayer = endLayer;
+ endParameters = nullptr;
+ endVolume = nullptr;
+ endLayer = nullptr;
+ endSurface = nullptr;
+ leadParameters = startParameters;
+ leadVolume = nullptr;
+ leadLayer = nullptr;
+ leadLayerSurface = nullptr;
+ lastBoundaryParameters = startParameters;
+ lastBoundarySurface = nullptr;
+ lastLeadParameters = startParameters;
+ navigationStep = 0;
+ pathLength = 0.;
+ materialX0 = 0.;
+ materialL0 = 0.;
+ // clear the vector
+ extrapolationSteps.clear();
+}
+
+template <class T>
+void
+ExtrapolationCell<T>::step(std::unique_ptr<const T> stepParameters,
+ Acts::ExtrapolationMode::eMode fillMode)
+{
+ // move the step parameters into the step cache
+ // and set them to the new lead parameters
+ leadParameters = stepParameters.get();
+ // current step surface
+ const Surface* cssf = &(stepParameters->associatedSurface());
+ // get the last step surface - if it is identical with the current one ->
+ // attach information
+ const Surface* lssf = extrapolationSteps.size()
+ ? extrapolationSteps.at(extrapolationSteps.size() - 1).surface
+ : nullptr;
+ // create a new step
+ if (cssf != lssf) extrapolationSteps.push_back(ExtrapolationStep<T>());
+ // fill the parameters (memory membership goes to the steps), the surface and
+ // add the mode
+ extrapolationSteps.back().parameters = std::move(stepParameters);
+ extrapolationSteps.back().surface = cssf;
+ extrapolationSteps.back().stepConfiguration.addMode(fillMode);
+}
+
+template <class T>
+void
+ExtrapolationCell<T>::stepTransport(
+ const Surface& sf,
+ double pLength,
+ std::unique_ptr<const TransportJacobian> tjac)
+{
+ // find out if you want to attach or you need a new one
+ // current step surface
+ const Surface* cssf = &sf;
+ // get the last step surface - if it is identical with the current one ->
+ // attach information
+ const Surface* lssf = extrapolationSteps.size()
+ ? extrapolationSteps.at(extrapolationSteps.size() - 1).surface
+ : nullptr;
+ // only create a new step for a transport jacobian
+ if (tjac) {
+ // create a new step
+ if (cssf != lssf) extrapolationSteps.push_back(ExtrapolationStep<T>());
+ // set the surface
+ extrapolationSteps.back().surface = cssf;
+ // set the the transport information
+ extrapolationSteps.back().transportJacobian = std::move(tjac);
+ extrapolationSteps.back().stepConfiguration.addMode(
+ Acts::ExtrapolationMode::CollectJacobians);
+ // fill the step path length
+ if (pLength > 0.) {
+ extrapolationSteps.back().pathLength = pLength;
+ extrapolationSteps.back().stepConfiguration.addMode(
+ Acts::ExtrapolationMode::CollectPathSteps);
}
+ }
+ // also update the global pathLength information
+ pathLength += pLength;
+}
+
+template <class T>
+void
+ExtrapolationCell<T>::addMaterial(double sfactor,
+ const MaterialProperties* mprop)
+{
+ // fill the material if there
+ if (mprop) {
+ // the overal material
+ materialX0 += sfactor * mprop->thicknessInX0();
+ materialL0 += sfactor * mprop->thicknessInL0();
+ zOaTrX += mprop->zOverAtimesRho() * sfactor * mprop->thicknessInX0();
+ zX += mprop->averageZ() * sfactor * mprop->thicknessInX0();
+ }
+}
+
+template <class T>
+void
+ExtrapolationCell<T>::addMaterial(double step, const Material* mat)
+{
+ // fill the material if there
+ if (mat && step > 0.) {
+ // the overal material
+ materialX0 += step / mat->X0;
+ materialL0 += step / mat->L0;
+ zOaTrX += mat->zOverAtimesRho() * step / mat->X0;
+ zX += mat->averageZ() * step / mat->X0;
+ }
+}
-} // end of namespace
+template <class T>
+void
+ExtrapolationCell<T>::stepMaterial(const Surface& sf,
+ const Layer* lay,
+ const Vector3D& mposition,
+ double sfactor,
+ const MaterialProperties* mprop)
+{
+ // add material to the global counter
+ addMaterial(sfactor, mprop);
+ // find out if you want to attach or you need a new one
+ // current step surface
+ const Surface* cssf = &sf;
+ // get the last step surface - if it is identical with the current one ->
+ // attach information
+ const Surface* lssf = extrapolationSteps.size()
+ ? extrapolationSteps.at(extrapolationSteps.size() - 1).surface
+ : nullptr;
+ // create a new step
+ if (cssf != lssf) extrapolationSteps.push_back(ExtrapolationStep<T>());
+ // set the surface
+ extrapolationSteps.at(extrapolationSteps.size() - 1).surface = cssf;
+ extrapolationSteps.at(extrapolationSteps.size() - 1).layer = lay;
+ // fill the material if there
+ if (mprop) {
+ // record the step information
+ extrapolationSteps.at(extrapolationSteps.size() - 1).material = mprop;
+ extrapolationSteps.at(extrapolationSteps.size() - 1)
+ .stepConfiguration.addMode(Acts::ExtrapolationMode::CollectMaterial);
+ extrapolationSteps.at(extrapolationSteps.size() - 1).materialPosition
+ = mposition;
+ extrapolationSteps.at(extrapolationSteps.size() - 1).materialScaling
+ = sfactor;
+ }
+}
-#endif // TRKEXUTILS_SOLUTIONSELECTOR_H
+} // end of namespace
+#endif // TRKEXUTILS_SOLUTIONSELECTOR_H
diff --git a/Core/include/ACTS/Extrapolation/ExtrapolationEngine.hpp b/Core/include/ACTS/Extrapolation/ExtrapolationEngine.hpp
index d39d742ea..067aeeba1 100644
--- a/Core/include/ACTS/Extrapolation/ExtrapolationEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/ExtrapolationEngine.hpp
@@ -13,121 +13,154 @@
#ifndef ACTS_EXTRAPOLATIONENGINE_EXTRAPOLATIONENGINE_H
#define ACTS_EXTRAPOLATIONENGINE_EXTRAPOLATIONENGINE_H 1
+#include "ACTS/EventData/NeutralParameters.hpp"
+#include "ACTS/EventData/TrackParameters.hpp"
#include "ACTS/Extrapolation/ExtrapolationCell.hpp"
-#include "ACTS/Extrapolation/detail/ExtrapolationMacros.hpp"
#include "ACTS/Extrapolation/IExtrapolationEngine.hpp"
-#include "ACTS/Extrapolation/IPropagationEngine.hpp"
#include "ACTS/Extrapolation/INavigationEngine.hpp"
-#include "ACTS/EventData/TrackParameters.hpp"
-#include "ACTS/EventData/NeutralParameters.hpp"
+#include "ACTS/Extrapolation/IPropagationEngine.hpp"
+#include "ACTS/Extrapolation/detail/ExtrapolationMacros.hpp"
#include "ACTS/Utilities/Logger.hpp"
namespace Acts {
-
- class TrackingGeometry;
- class Surface;
- class BoundaryCheck;
-
- /** @class ExtrapolationEngine
-
- Master extrapolation engine for extrapolation through the TrackingGeometry,
- it delegates the extrapolation to optimised engines, handing over the ExtrapolationCell
- as internal cache.
-
- There are identical interfaces for charged and neutral track parameters.
- Providing a destination surface is optional, if no destination surface is given the extrapolation
- process can be stopped by other directives, e.g. stopping at a certain path limit, material limit
- or with a change of detector signature.
-
- */
- class ExtrapolationEngine : virtual public IExtrapolationEngine {
- public:
-
- /** @struct Config
-
- Configuration struct to be used for this ExtrapolationEngine.
- This has to be prepared by the framework/main and can be either given to the ExtrapolationEngine at construction or
- with the setConfig method.
- */
- struct Config {
- std::shared_ptr<Logger> logger;
- std::shared_ptr<const TrackingGeometry> trackingGeometry; //!< the tracking geometry used by the navigator
- std::vector< std::shared_ptr<IExtrapolationEngine> > extrapolationEngines; //!< the extrapolation engines for different geometry layouts
- std::shared_ptr<IPropagationEngine> propagationEngine; //!< the used propagation engine for navigation initialization
- std::shared_ptr<INavigationEngine> navigationEngine; //!< access to tracking geometry (unique?)
- std::string prefix; //!< output prefix
- std::string postfix; //!< output postfix
- std::string name; //!< name of the tool
-
- Config() :
- logger(getDefaultLogger("ExtrapolationEngine",Logging::INFO)),
- trackingGeometry(nullptr),
- extrapolationEngines(),
- propagationEngine(nullptr),
- navigationEngine(nullptr),
- prefix("[ME] - "),
- postfix(" - "),
- name("Anonymous")
- {}
-
- };
-
- /** Constructor */
- ExtrapolationEngine(const Config& eeConfig);
-
- /** Destructor */
- ~ExtrapolationEngine();
-
- using IExtrapolationEngine::extrapolate;
-
- /** charged extrapolation - public interface */
- ExtrapolationCode extrapolate(ExCellCharged& ecCharged,
- const Surface* sf = nullptr,
- const BoundaryCheck& bcheck = true) const final;
-
- /** neutral extrapolation - public interface */
- ExtrapolationCode extrapolate(ExCellNeutral& ecNeutral,
- const Surface* sf = nullptr,
- const BoundaryCheck& bcheck = true) const final;
-
-
- /** define for which GeometrySignature this extrapolator is valid - this is GLOBAL */
- GeometryType geometryType() const final;
-
- /** Set configuration method */
- void setConfiguration(const Config& eeConfig);
-
- /** Get configuration method */
- Config getConfiguration() const;
-
- protected:
- /** ExtrapolationEngine config object */
- Config m_config;
-
- private:
- const Logger& logger() const {return *m_config.logger;}
- /** main extrapolation method, templated to chared/neutral */
- template <class T> ExtrapolationCode extrapolateT(ExtrapolationCell<T>& eCell,
- const Surface* sf = nullptr,
- PropDirection dir=alongMomentum,
- const BoundaryCheck& bcheck = true) const;
-
- /** initialization of mavigation method */
- template <class T> ExtrapolationCode initNavigation(ExtrapolationCell<T>& eCell,
- const Surface* sf = nullptr,
- PropDirection dir=alongMomentum) const;
- };
-
- /** Return the geometry type, it's the master */
- inline GeometryType ExtrapolationEngine::geometryType() const { return Acts::Master; }
-
- /** Return the configuration object */
- inline ExtrapolationEngine::Config ExtrapolationEngine::getConfiguration() const { return m_config; }
-
-} // end of namespace
-
-//!< define the templated function
-#include "ACTS/Extrapolation/detail/ExtrapolationEngine.ipp"
-
-#endif // ACTS_EXTRAPOLATIONENGINE_EXTRAPOLATIONENGINE_H
+class TrackingGeometry;
+class Surface;
+class BoundaryCheck;
+
+/** @class ExtrapolationEngine
+
+ Master extrapolation engine for extrapolation through the TrackingGeometry,
+ it delegates the extrapolation to optimised engines, handing over the
+ ExtrapolationCell
+ as internal cache.
+
+ There are identical interfaces for charged and neutral track parameters.
+ Providing a destination surface is optional, if no destination surface is
+ given the extrapolation
+ process can be stopped by other directives, e.g. stopping at a certain path
+ limit, material limit
+ or with a change of detector signature.
+
+*/
+class ExtrapolationEngine : virtual public IExtrapolationEngine
+{
+public:
+ /** @struct Config
+
+ Configuration struct to be used for this ExtrapolationEngine.
+ This has to be prepared by the framework/main and can be either given to
+ the ExtrapolationEngine at construction or
+ with the setConfig method.
+ */
+ struct Config
+ {
+ std::shared_ptr<Logger> logger;
+ std::shared_ptr<const TrackingGeometry>
+ trackingGeometry; //!< the tracking geometry used by the navigator
+ std::vector<std::shared_ptr<IExtrapolationEngine>>
+ extrapolationEngines; //!< the extrapolation engines for different
+ //!geometry layouts
+ std::shared_ptr<IPropagationEngine> propagationEngine; //!< the used
+ //!propagation
+ //!engine for
+ //!navigation
+ //!initialization
+ std::shared_ptr<INavigationEngine>
+ navigationEngine; //!< access to tracking geometry (unique?)
+ std::string prefix; //!< output prefix
+ std::string postfix; //!< output postfix
+ std::string name; //!< name of the tool
+
+ Config()
+ : logger(getDefaultLogger("ExtrapolationEngine", Logging::INFO))
+ , trackingGeometry(nullptr)
+ , extrapolationEngines()
+ , propagationEngine(nullptr)
+ , navigationEngine(nullptr)
+ , prefix("[ME] - ")
+ , postfix(" - ")
+ , name("Anonymous")
+ {
+ }
+ };
+
+ /** Constructor */
+ ExtrapolationEngine(const Config& eeConfig);
+
+ /** Destructor */
+ ~ExtrapolationEngine();
+
+ using IExtrapolationEngine::extrapolate;
+
+ /** charged extrapolation - public interface */
+ ExtrapolationCode
+ extrapolate(ExCellCharged& ecCharged,
+ const Surface* sf = nullptr,
+ const BoundaryCheck& bcheck = true) const final;
+
+ /** neutral extrapolation - public interface */
+ ExtrapolationCode
+ extrapolate(ExCellNeutral& ecNeutral,
+ const Surface* sf = nullptr,
+ const BoundaryCheck& bcheck = true) const final;
+
+ /** define for which GeometrySignature this extrapolator is valid - this is
+ * GLOBAL */
+ GeometryType
+ geometryType() const final;
+
+ /** Set configuration method */
+ void
+ setConfiguration(const Config& eeConfig);
+
+ /** Get configuration method */
+ Config
+ getConfiguration() const;
+
+protected:
+ /** ExtrapolationEngine config object */
+ Config m_config;
+
+private:
+ const Logger&
+ logger() const
+ {
+ return *m_config.logger;
+ }
+ /** main extrapolation method, templated to chared/neutral */
+ template <class T>
+ ExtrapolationCode
+ extrapolateT(ExtrapolationCell<T>& eCell,
+ const Surface* sf = nullptr,
+ PropDirection dir = alongMomentum,
+ const BoundaryCheck& bcheck = true) const;
+
+ /** initialization of mavigation method */
+ template <class T>
+ ExtrapolationCode
+ initNavigation(ExtrapolationCell<T>& eCell,
+ const Surface* sf = nullptr,
+ PropDirection dir = alongMomentum) const;
+};
+
+/** Return the geometry type, it's the master */
+inline GeometryType
+ExtrapolationEngine::geometryType() const
+{
+ return Acts::Master;
+}
+
+/** Return the configuration object */
+inline ExtrapolationEngine::Config
+ExtrapolationEngine::getConfiguration() const
+{
+ return m_config;
+}
+
+} // end of namespace
+
+//!< define the templated function
+#include "ACTS/Extrapolation/detail/ExtrapolationEngine.ipp"
+
+#endif // ACTS_EXTRAPOLATIONENGINE_EXTRAPOLATIONENGINE_H
diff --git a/Core/include/ACTS/Extrapolation/IExtrapolationEngine.hpp b/Core/include/ACTS/Extrapolation/IExtrapolationEngine.hpp
index c6a6085fd..0ee023c48 100644
--- a/Core/include/ACTS/Extrapolation/IExtrapolationEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/IExtrapolationEngine.hpp
@@ -13,59 +13,57 @@
#ifndef ACTS_EXTRAPOLATIONINTERFACES_IEXTRAPOLATIONENGINE_H
#define ACTS_EXTRAPOLATIONINTERFACES_IEXTRAPOLATIONENGINE_H 1
-#include "ACTS/Utilities/GeometrySignature.hpp"
-#include "ACTS/EventData/TrackParameters.hpp"
#include "ACTS/EventData/NeutralParameters.hpp"
+#include "ACTS/EventData/TrackParameters.hpp"
#include "ACTS/Extrapolation/ExtrapolationCell.hpp"
-
-namespace Acts {
-
- typedef ExtrapolationCell<TrackParameters> ExCellCharged;
- typedef ExtrapolationCell<NeutralParameters> ExCellNeutral;
-
- class Surface;
- class BoundaryCheck;
-
- /** @class IExtrapolationEngine
-
- Extrapolation engine interface for Charged and Neutral parameters,
- it serves as the Master extrapolation interface but also as the specialized
- extrapolation engine ones.
-
- The ExtrapolationEngine is desinged as a thread safe const-correct service,
- all used components need to follow this approach.
+#include "ACTS/Utilities/GeometrySignature.hpp"
- */
+namespace Acts {
- class IExtrapolationEngine {
- public:
+typedef ExtrapolationCell<TrackParameters> ExCellCharged;
+typedef ExtrapolationCell<NeutralParameters> ExCellNeutral;
- /** Virtual destructor */
- virtual ~IExtrapolationEngine(){}
+class Surface;
+class BoundaryCheck;
- /** charged extrapolation */
- virtual ExtrapolationCode extrapolate(ExCellCharged& ecCharged,
- const Surface* sf = 0,
- const BoundaryCheck& bcheck = true) const = 0;
+/** @class IExtrapolationEngine
+ Extrapolation engine interface for Charged and Neutral parameters,
+ it serves as the Master extrapolation interface but also as the specialized
+ extrapolation engine ones.
- /** neutral extrapolation */
- virtual ExtrapolationCode extrapolate(ExCellNeutral& ecNeutral,
- const Surface* sf = 0,
- const BoundaryCheck& bcheck = true) const = 0;
+ The ExtrapolationEngine is desinged as a thread safe const-correct service,
+ all used components need to follow this approach.
+*/
- /** define for which GeometrySignature this extrapolator is valid */
- virtual GeometryType geometryType() const = 0;
+class IExtrapolationEngine
+{
+public:
+ /** Virtual destructor */
+ virtual ~IExtrapolationEngine() {}
+ /** charged extrapolation */
+ virtual ExtrapolationCode
+ extrapolate(ExCellCharged& ecCharged,
+ const Surface* sf = 0,
+ const BoundaryCheck& bcheck = true) const = 0;
- protected:
- //!< SCREEN output formatting (SOP) - unify amongst extrapolation engines
- std::string m_sopPrefix; //!< prefix for screen output
- std::string m_sopPostfix; //!< prefix for screen output
+ /** neutral extrapolation */
+ virtual ExtrapolationCode
+ extrapolate(ExCellNeutral& ecNeutral,
+ const Surface* sf = 0,
+ const BoundaryCheck& bcheck = true) const = 0;
- };
+ /** define for which GeometrySignature this extrapolator is valid */
+ virtual GeometryType
+ geometryType() const = 0;
+protected:
+ //!< SCREEN output formatting (SOP) - unify amongst extrapolation engines
+ std::string m_sopPrefix; //!< prefix for screen output
+ std::string m_sopPostfix; //!< prefix for screen output
+};
-} // end of namespace
+} // end of namespace
-#endif // ACTS_TRKEXINTERFACES_IEXTRAPOLATIONENGINE_H
+#endif // ACTS_TRKEXINTERFACES_IEXTRAPOLATIONENGINE_H
diff --git a/Core/include/ACTS/Extrapolation/IMaterialEffectsEngine.hpp b/Core/include/ACTS/Extrapolation/IMaterialEffectsEngine.hpp
index 187ce5a2e..abb1f7d71 100644
--- a/Core/include/ACTS/Extrapolation/IMaterialEffectsEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/IMaterialEffectsEngine.hpp
@@ -13,50 +13,49 @@
#ifndef ACTS_EXTRAPOLATIONINTERFACES_IMATERIAKEFFECTSENGINE_H
#define ACTS_EXTRAPOLATIONINTERFACES_IMATERIAKEFFECTSENGINE_H 1
+#include "ACTS/EventData/NeutralParameters.hpp"
+#include "ACTS/EventData/TrackParameters.hpp"
#include "ACTS/Extrapolation/ExtrapolationCell.hpp"
#include "ACTS/Extrapolation/MaterialUpdateMode.hpp"
#include "ACTS/Utilities/Definitions.hpp"
-#include "ACTS/EventData/TrackParameters.hpp"
-#include "ACTS/EventData/NeutralParameters.hpp"
namespace Acts {
-
- typedef ExtrapolationCell<TrackParameters> ExCellCharged;
- typedef ExtrapolationCell<NeutralParameters> ExCellNeutral;
-
- /** @class IMaterialEffectsEngine
-
- Material effects engine interface for charged and neutral (fast track simulation) ,
- the update is alwyas on the:
- - eCell.leadParmaeters && eCell.leadLayer
- - if eCell.leadPameters == eCell.startParamters clone to new parameters
- else : update the new parameters
-
- */
- class IMaterialEffectsEngine {
- public:
-
- /** Virtual destructor */
- virtual ~IMaterialEffectsEngine(){}
-
- /** charged extrapolation */
- virtual ExtrapolationCode handleMaterial(ExCellCharged& ecCharged,
- PropDirection dir=alongMomentum,
- MaterialUpdateStage matupstage=fullUpdate ) const = 0;
-
-
- /** neutral extrapolation */
- virtual ExtrapolationCode handleMaterial(ExCellNeutral& ecNeutral,
- PropDirection dir=alongMomentum,
- MaterialUpdateStage matupstage=fullUpdate) const = 0;
-
- protected:
- std::string m_sopPrefix; //!< prefix for screen output
- std::string m_sopPostfix; //!< prefix for screen output
-
- };
-
-
-} // end of namespace
-#endif // ACTS_EXTRAPOLATIONINTERFACES_IMATERIAKEFFECTSENGINE_H
+typedef ExtrapolationCell<TrackParameters> ExCellCharged;
+typedef ExtrapolationCell<NeutralParameters> ExCellNeutral;
+
+/** @class IMaterialEffectsEngine
+
+ Material effects engine interface for charged and neutral (fast track
+ simulation) ,
+ the update is alwyas on the:
+ - eCell.leadParmaeters && eCell.leadLayer
+ - if eCell.leadPameters == eCell.startParamters clone to new parameters
+ else : update the new parameters
+
+*/
+class IMaterialEffectsEngine
+{
+public:
+ /** Virtual destructor */
+ virtual ~IMaterialEffectsEngine() {}
+ /** charged extrapolation */
+ virtual ExtrapolationCode
+ handleMaterial(ExCellCharged& ecCharged,
+ PropDirection dir = alongMomentum,
+ MaterialUpdateStage matupstage = fullUpdate) const = 0;
+
+ /** neutral extrapolation */
+ virtual ExtrapolationCode
+ handleMaterial(ExCellNeutral& ecNeutral,
+ PropDirection dir = alongMomentum,
+ MaterialUpdateStage matupstage = fullUpdate) const = 0;
+
+protected:
+ std::string m_sopPrefix; //!< prefix for screen output
+ std::string m_sopPostfix; //!< prefix for screen output
+};
+
+} // end of namespace
+
+#endif // ACTS_EXTRAPOLATIONINTERFACES_IMATERIAKEFFECTSENGINE_H
diff --git a/Core/include/ACTS/Extrapolation/IMultipleScatteringUpdator.hpp b/Core/include/ACTS/Extrapolation/IMultipleScatteringUpdator.hpp
index bbf611a22..bd42eeeee 100644
--- a/Core/include/ACTS/Extrapolation/IMultipleScatteringUpdator.hpp
+++ b/Core/include/ACTS/Extrapolation/IMultipleScatteringUpdator.hpp
@@ -1,11 +1,11 @@
-// This file is part of the ACTS project.
-//
-// Copyright (C) 2016 ACTS project team
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
+// This file is part of the ACTS project.
+//
+// Copyright (C) 2016 ACTS project team
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
///////////////////////////////////////////////////////////////////
// IMultipleScatteringUpdator.h, ACTS project
///////////////////////////////////////////////////////////////////
@@ -17,28 +17,26 @@
namespace Acts {
- class MaterialProperties;
-
- /**@class IMultipleScatteringUpdator
- Interface class IMultipleScatteringUpdator
-
- */
- class IMultipleScatteringUpdator {
-
- public:
- /**Virtual destructor*/
- virtual ~IMultipleScatteringUpdator(){}
-
-
- /** Calculate the sigma on theta introduced by multiple scatteringt */
- virtual double sigmaSquare(const MaterialProperties& mat,
- double p,
- double pathcorrection,
- ParticleType particle=pion,
- double deltaE=0.) const = 0;
- };
-
-
-} // end of namespace
-
-#endif // ACTS_EXTRAPOLATIONINTERFACES_IMULTIPLESCATTERINGUPDATOR_H
+class MaterialProperties;
+
+/**@class IMultipleScatteringUpdator
+ Interface class IMultipleScatteringUpdator
+
+ */
+class IMultipleScatteringUpdator
+{
+public:
+ /**Virtual destructor*/
+ virtual ~IMultipleScatteringUpdator() {}
+ /** Calculate the sigma on theta introduced by multiple scatteringt */
+ virtual double
+ sigmaSquare(const MaterialProperties& mat,
+ double p,
+ double pathcorrection,
+ ParticleType particle = pion,
+ double deltaE = 0.) const = 0;
+};
+
+} // end of namespace
+
+#endif // ACTS_EXTRAPOLATIONINTERFACES_IMULTIPLESCATTERINGUPDATOR_H
diff --git a/Core/include/ACTS/Extrapolation/INavigationEngine.hpp b/Core/include/ACTS/Extrapolation/INavigationEngine.hpp
index 8d75242d7..05391e283 100644
--- a/Core/include/ACTS/Extrapolation/INavigationEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/INavigationEngine.hpp
@@ -13,53 +13,58 @@
#ifndef ACTS_EXTRAPOLATIONINTERFACES_INAVIGATIONENGINE_H
#define ACTS_EXTRAPOLATIONINTERFACES_INAVIGATIONENGINE_H
-#include "ACTS/Extrapolation/ExtrapolationCell.hpp"
-#include "ACTS/EventData/TrackParameters.hpp"
#include "ACTS/EventData/NeutralParameters.hpp"
-
-namespace Acts {
-
- class TrackingGeometry;
-
- typedef ExtrapolationCell<TrackParameters> ExCellCharged;
- typedef ExtrapolationCell<NeutralParameters> ExCellNeutral;
-
- /** @class INavigationEngine
-
- Extrapolation engine interface for Charged and Neutral parameters,
- it serves as the Master extrapolation interface but also as the specialized
- extrapolation engine ones.
-
- */
+#include "ACTS/EventData/TrackParameters.hpp"
+#include "ACTS/Extrapolation/ExtrapolationCell.hpp"
- class INavigationEngine {
+namespace Acts {
- public:
+class TrackingGeometry;
- /** Virtual destructor */
- virtual ~INavigationEngine(){}
+typedef ExtrapolationCell<TrackParameters> ExCellCharged;
+typedef ExtrapolationCell<NeutralParameters> ExCellNeutral;
- /** resolve the boundary situation - for charged particles */
- virtual ExtrapolationCode resolveBoundary(ExCellCharged& ecCell, PropDirection dir=alongMomentum) const = 0;
+/** @class INavigationEngine
- /** resolve the boundary situation - for neutral particles */
- virtual ExtrapolationCode resolveBoundary(ExCellNeutral& enCell, PropDirection dir=alongMomentum) const = 0;
+ Extrapolation engine interface for Charged and Neutral parameters,
+ it serves as the Master extrapolation interface but also as the specialized
+ extrapolation engine ones.
- /** resolve the position - for charged particles */
- virtual ExtrapolationCode resolvePosition(ExCellCharged& ecCell, PropDirection dir=alongMomentum, bool noLoop=false) const = 0;
+*/
- /** resolve the position - for neutral particles */
- virtual ExtrapolationCode resolvePosition(ExCellNeutral& enCell, PropDirection dir=alongMomentum, bool noLoop=false) const = 0;
+class INavigationEngine
+{
+public:
+ /** Virtual destructor */
+ virtual ~INavigationEngine() {}
+ /** resolve the boundary situation - for charged particles */
+ virtual ExtrapolationCode
+ resolveBoundary(ExCellCharged& ecCell,
+ PropDirection dir = alongMomentum) const = 0;
- protected:
- //!< SCREEN output formatting (SOP) - unify amongst extrapolation engines
- std::string m_sopPrefix; //!< prefix for screen output
- std::string m_sopPostfix; //!< prefix for screen output
+ /** resolve the boundary situation - for neutral particles */
+ virtual ExtrapolationCode
+ resolveBoundary(ExCellNeutral& enCell,
+ PropDirection dir = alongMomentum) const = 0;
- };
+ /** resolve the position - for charged particles */
+ virtual ExtrapolationCode
+ resolvePosition(ExCellCharged& ecCell,
+ PropDirection dir = alongMomentum,
+ bool noLoop = false) const = 0;
+ /** resolve the position - for neutral particles */
+ virtual ExtrapolationCode
+ resolvePosition(ExCellNeutral& enCell,
+ PropDirection dir = alongMomentum,
+ bool noLoop = false) const = 0;
-} // end of namespace
+protected:
+ //!< SCREEN output formatting (SOP) - unify amongst extrapolation engines
+ std::string m_sopPrefix; //!< prefix for screen output
+ std::string m_sopPostfix; //!< prefix for screen output
+};
-#endif // ACTS_EXTRAPOLATIONINTERFACES_INAVIGATIONENGINE_H
+} // end of namespace
+#endif // ACTS_EXTRAPOLATIONINTERFACES_INAVIGATIONENGINE_H
diff --git a/Core/include/ACTS/Extrapolation/IPropagationEngine.hpp b/Core/include/ACTS/Extrapolation/IPropagationEngine.hpp
index 716712d36..94c0c0e56 100644
--- a/Core/include/ACTS/Extrapolation/IPropagationEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/IPropagationEngine.hpp
@@ -13,70 +13,71 @@
#ifndef ACTS_EXTRAPOLATIONINTERFACES_IPROPAGATIONENGINE_H
#define ACTS_EXTRAPOLATIONINTERFACES_IPROPAGATIONENGINE_H 1
-#include "ACTS/Extrapolation/ExtrapolationCell.hpp"
-#include "ACTS/EventData/TrackParameters.hpp"
#include "ACTS/EventData/NeutralParameters.hpp"
+#include "ACTS/EventData/TrackParameters.hpp"
+#include "ACTS/Extrapolation/ExtrapolationCell.hpp"
namespace Acts {
-
- typedef ExtrapolationCell<TrackParameters> ExCellCharged;
- typedef ExtrapolationCell<NeutralParameters> ExCellNeutral;
-
- /** @class IPropagationEngine
-
- A propagation engine wrapping the propagator algtool it respects the path limit
- to stop particles if needed.
-
- If the propagation is successful to the surface it will return SuccessfulDestination,
- the parameters will be attached to the ExtrapolationCell as leadParameters,
- such that the engine can chose.
- It also wraps the MultiTrackParameters (@TODO do this actually)
+typedef ExtrapolationCell<TrackParameters> ExCellCharged;
+typedef ExtrapolationCell<NeutralParameters> ExCellNeutral;
- */
-
- class IPropagationEngine {
-
- public:
-
- /** Virtual destructor */
- virtual ~IPropagationEngine(){}
+/** @class IPropagationEngine
- /** resolve the boundary situation - for charged particles
- Possible return codes :
- - SuccessPathLimit (path limit reached)
- - SucessDestination (surface hit, only when finalPropagation == true)
- - InProgress (surface hit, when finalPropagation == false)
- - Recovered (surface not hit, leadParameters stay untouched)
- */
- virtual ExtrapolationCode propagate(ExCellCharged& ecCell,
- const Surface& sf,
- PropDirection dir=alongMomentum,
- ExtrapolationMode::eMode purpose = ExtrapolationMode::Destination,
- const BoundaryCheck& bcheck = true,
- bool returnCurvilinear = true) const = 0;
+ A propagation engine wrapping the propagator algtool it respects the path
+ limit
+ to stop particles if needed.
- /** resolve the boundary situation - for neutral particles
- Possible return codes :
- - SuccessPathLimit (path limit reached)
- - SucessDestination (surface hit, only when finalPropagation == true)
- - InProgress (surface hit, when finalPropagation == false)
- - Recovered (surface not hit, leadParameters stay untouched)
- */
- virtual ExtrapolationCode propagate(ExCellNeutral& enCell,
- const Surface& sf,
- PropDirection dir=alongMomentum,
- ExtrapolationMode::eMode purpose = ExtrapolationMode::Destination,
- const BoundaryCheck& bcheck = true,
- bool returnCurvilinear = true) const = 0;
+ If the propagation is successful to the surface it will return
+ SuccessfulDestination,
+ the parameters will be attached to the ExtrapolationCell as leadParameters,
+ such that the engine can chose.
- protected:
- //!< SCREEN output formatting (SOP) - unify amongst extrapolation engines
- std::string m_sopPrefix; //!< prefix for screen output
- std::string m_sopPostfix; //!< prefix for screen output
+ It also wraps the MultiTrackParameters (@TODO do this actually)
- };
+*/
-} // end of namespace
-
-#endif // ACTS_EXTRAPOLATIONINTERFACES_IPROPAGATIONENGINE_H
+class IPropagationEngine
+{
+public:
+ /** Virtual destructor */
+ virtual ~IPropagationEngine() {}
+ /** resolve the boundary situation - for charged particles
+ Possible return codes :
+ - SuccessPathLimit (path limit reached)
+ - SucessDestination (surface hit, only when finalPropagation == true)
+ - InProgress (surface hit, when finalPropagation == false)
+ - Recovered (surface not hit, leadParameters stay untouched)
+ */
+ virtual ExtrapolationCode
+ propagate(ExCellCharged& ecCell,
+ const Surface& sf,
+ PropDirection dir = alongMomentum,
+ ExtrapolationMode::eMode purpose = ExtrapolationMode::Destination,
+ const BoundaryCheck& bcheck = true,
+ bool returnCurvilinear = true) const = 0;
+
+ /** resolve the boundary situation - for neutral particles
+ Possible return codes :
+ - SuccessPathLimit (path limit reached)
+ - SucessDestination (surface hit, only when finalPropagation == true)
+ - InProgress (surface hit, when finalPropagation == false)
+ - Recovered (surface not hit, leadParameters stay untouched)
+ */
+ virtual ExtrapolationCode
+ propagate(ExCellNeutral& enCell,
+ const Surface& sf,
+ PropDirection dir = alongMomentum,
+ ExtrapolationMode::eMode purpose = ExtrapolationMode::Destination,
+ const BoundaryCheck& bcheck = true,
+ bool returnCurvilinear = true) const = 0;
+
+protected:
+ //!< SCREEN output formatting (SOP) - unify amongst extrapolation engines
+ std::string m_sopPrefix; //!< prefix for screen output
+ std::string m_sopPostfix; //!< prefix for screen output
+};
+
+} // end of namespace
+
+#endif // ACTS_EXTRAPOLATIONINTERFACES_IPROPAGATIONENGINE_H
diff --git a/Core/include/ACTS/Extrapolation/MaterialEffectsEngine.hpp b/Core/include/ACTS/Extrapolation/MaterialEffectsEngine.hpp
index d60843c68..57426e744 100644
--- a/Core/include/ACTS/Extrapolation/MaterialEffectsEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/MaterialEffectsEngine.hpp
@@ -13,104 +13,117 @@
#ifndef ACTS_EXTRAPOLATIONENGINE_MATERIALEFFECTSENGINE_H
#define ACTS_EXTRAPOLATIONENGINE_MATERIALEFFECTSENGINE_H 1
-#include "ACTS/Extrapolation/IMaterialEffectsEngine.hpp"
+#include "ACTS/EventData/NeutralParameters.hpp"
+#include "ACTS/EventData/TrackParameters.hpp"
#include "ACTS/Extrapolation/ExtrapolationCell.hpp"
+#include "ACTS/Extrapolation/IMaterialEffectsEngine.hpp"
#include "ACTS/Extrapolation/MaterialUpdateMode.hpp"
#include "ACTS/Extrapolation/detail/ExtrapolationMacros.hpp"
#include "ACTS/Extrapolation/detail/MaterialInteraction.hpp"
-#include "ACTS/EventData/TrackParameters.hpp"
-#include "ACTS/EventData/NeutralParameters.hpp"
#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Utilities/Logger.hpp"
namespace Acts {
-
- class Layer;
-
- /** @class MaterialEffectsEngine
-
- Material effects engine interface for charged and neutral (fast track simulation) ,
- the update is alwyas on the:
- - eCell.leadParmaeters && eCell.leadLayer
- - if eCell.leadPameters == eCell.startParamters clone to new parameters
- else : update the new parameters
-
- */
- class MaterialEffectsEngine : virtual public IMaterialEffectsEngine {
-
- public:
- /** @struct Config
- Configuration struct for the MaterialEffectsEngine
- */
- struct Config {
- std::shared_ptr<Logger> logger;
- bool eLossCorrection; //!< apply the energy loss correction
- bool eLossMpv; //!< apply the energy loss correction as most probable value
- bool mscCorrection; //!< apply the multiple (coulomb) scattering correction
- std::string prefix; //!< screen output prefix
- std::string postfix; //!< screen output postfix
- std::string name; //!< the name of this engine
-
- Config() :
- logger(getDefaultLogger("MaterialEffectsEngine",Logging::INFO)),
- eLossCorrection(true),
- eLossMpv(true),
- mscCorrection(true),
- prefix("[ME] - "),
- postfix(" - "),
- name("Anonymous")
- {}
-
- };
-
- /** Constructor */
- MaterialEffectsEngine(const Config& meConfig);
-
- /** Destructor */
- ~MaterialEffectsEngine();
-
- /** charged extrapolation */
- ExtrapolationCode handleMaterial(ExCellCharged& ecCharged,
- PropDirection dir=alongMomentum,
- MaterialUpdateStage matupstage=fullUpdate) const final;
-
- /** neutral extrapolation - only for Fatras, dummy implementation here */
- ExtrapolationCode handleMaterial(ExCellNeutral& ecNeutral,
- PropDirection dir=alongMomentum,
- MaterialUpdateStage matupstage=fullUpdate) const final;
-
-
- /** Set configuration method */
- void setConfiguration(const Config& meConfig);
-
- /** Get configuration method */
- Config getConfiguration() const;
-
- protected:
- Config m_config; //!< configuration struct
-
- private:
- const Logger& logger() const {return *m_config.logger;}
- /** charged extrapolation
- depending on the MaterialUpdateStage:
- - postUpdate : creates a new unique_ptr and stores them as step parameters
- - preUpdate | fullUpdate : manipulates the parameters and returns a nullptr
- nothing to do (e.g. no material) : return nullptr */
- void updateTrackParameters(const TrackParameters& parameters,
- ExCellCharged& eCell,
- PropDirection dir,
- MaterialUpdateStage matupstage) const;
-
- MaterialInteraction m_interactionFormulae; //!< the formulas concentrated
- ParticleMasses m_particleMasses; //!< struct of Particle masses
-
+class Layer;
+
+/** @class MaterialEffectsEngine
+
+ Material effects engine interface for charged and neutral (fast track
+ simulation) ,
+ the update is alwyas on the:
+ - eCell.leadParmaeters && eCell.leadLayer
+ - if eCell.leadPameters == eCell.startParamters clone to new parameters
+ else : update the new parameters
+
+*/
+class MaterialEffectsEngine : virtual public IMaterialEffectsEngine
+{
+public:
+ /** @struct Config
+ Configuration struct for the MaterialEffectsEngine
+ */
+ struct Config
+ {
+ std::shared_ptr<Logger> logger;
+ bool eLossCorrection; //!< apply the energy loss correction
+ bool eLossMpv; //!< apply the energy loss correction as most probable value
+ bool mscCorrection; //!< apply the multiple (coulomb) scattering correction
+ std::string prefix; //!< screen output prefix
+ std::string postfix; //!< screen output postfix
+ std::string name; //!< the name of this engine
+
+ Config()
+ : logger(getDefaultLogger("MaterialEffectsEngine", Logging::INFO))
+ , eLossCorrection(true)
+ , eLossMpv(true)
+ , mscCorrection(true)
+ , prefix("[ME] - ")
+ , postfix(" - ")
+ , name("Anonymous")
+ {
+ }
};
-
- /** Return the configuration object */
- inline MaterialEffectsEngine::Config MaterialEffectsEngine::getConfiguration() const { return m_config; }
-
-} // end of namespace
-
-#endif // ACTS_EXTRAPOLATIONENGINE_MATERIAKEFFECTSENGINE_H
+ /** Constructor */
+ MaterialEffectsEngine(const Config& meConfig);
+
+ /** Destructor */
+ ~MaterialEffectsEngine();
+
+ /** charged extrapolation */
+ ExtrapolationCode
+ handleMaterial(ExCellCharged& ecCharged,
+ PropDirection dir = alongMomentum,
+ MaterialUpdateStage matupstage = fullUpdate) const final;
+
+ /** neutral extrapolation - only for Fatras, dummy implementation here */
+ ExtrapolationCode
+ handleMaterial(ExCellNeutral& ecNeutral,
+ PropDirection dir = alongMomentum,
+ MaterialUpdateStage matupstage = fullUpdate) const final;
+
+ /** Set configuration method */
+ void
+ setConfiguration(const Config& meConfig);
+
+ /** Get configuration method */
+ Config
+ getConfiguration() const;
+
+protected:
+ Config m_config; //!< configuration struct
+
+private:
+ const Logger&
+ logger() const
+ {
+ return *m_config.logger;
+ }
+ /** charged extrapolation
+ depending on the MaterialUpdateStage:
+ - postUpdate : creates a new unique_ptr and stores them as step
+ parameters
+ - preUpdate | fullUpdate : manipulates the parameters and returns a
+ nullptr
+ nothing to do (e.g. no material) : return nullptr */
+ void
+ updateTrackParameters(const TrackParameters& parameters,
+ ExCellCharged& eCell,
+ PropDirection dir,
+ MaterialUpdateStage matupstage) const;
+
+ MaterialInteraction m_interactionFormulae; //!< the formulas concentrated
+ ParticleMasses m_particleMasses; //!< struct of Particle masses
+};
+
+/** Return the configuration object */
+inline MaterialEffectsEngine::Config
+MaterialEffectsEngine::getConfiguration() const
+{
+ return m_config;
+}
+
+} // end of namespace
+
+#endif // ACTS_EXTRAPOLATIONENGINE_MATERIAKEFFECTSENGINE_H
diff --git a/Core/include/ACTS/Extrapolation/MaterialUpdateMode.hpp b/Core/include/ACTS/Extrapolation/MaterialUpdateMode.hpp
index e892cf082..2ea8b938e 100644
--- a/Core/include/ACTS/Extrapolation/MaterialUpdateMode.hpp
+++ b/Core/include/ACTS/Extrapolation/MaterialUpdateMode.hpp
@@ -11,19 +11,14 @@
namespace Acts {
- /** This is a steering enum to force the material update
- it can be:
- (1) addNoise
- (-1) removeNoise
- Second is mainly for vertex reconstruction, but potentially dangeraous.
- */
+/** This is a steering enum to force the material update
+ it can be:
+ (1) addNoise
+ (-1) removeNoise
+ Second is mainly for vertex reconstruction, but potentially dangeraous.
+ */
- enum MaterialUpdateMode
- {
- addNoise = 1,
- removeNoise = -1
- };
-
+enum MaterialUpdateMode { addNoise = 1, removeNoise = -1 };
}
#endif
diff --git a/Core/include/ACTS/Extrapolation/RungeKuttaEngine.hpp b/Core/include/ACTS/Extrapolation/RungeKuttaEngine.hpp
index 53e37536b..f5e0ae032 100644
--- a/Core/include/ACTS/Extrapolation/RungeKuttaEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/RungeKuttaEngine.hpp
@@ -13,282 +13,314 @@
#ifndef ACTS_RUNGEKUTTAENGINE_RUNGEKUTAENGINE_H
#define ACTS_RUNGEKUTTAENGINE_RUNGEKUTAENGINE_H 1
-#include "ACTS/Extrapolation/IPropagationEngine.hpp"
+#include "ACTS/EventData/NeutralParameters.hpp"
+#include "ACTS/EventData/TrackParameters.hpp"
#include "ACTS/Extrapolation/ExtrapolationCell.hpp"
+#include "ACTS/Extrapolation/IPropagationEngine.hpp"
#include "ACTS/Extrapolation/detail/ExtrapolationMacros.hpp"
#include "ACTS/Extrapolation/detail/RungeKuttaUtils.hpp"
-#include "ACTS/EventData/TrackParameters.hpp"
-#include "ACTS/EventData/NeutralParameters.hpp"
-#include "ACTS/Utilities/Definitions.hpp"
-#include "ACTS/Surfaces/Surface.hpp"
-#include "ACTS/Surfaces/CylinderSurface.hpp"
-#include "ACTS/Surfaces/ConeSurface.hpp"
-#include "ACTS/Surfaces/BoundaryCheck.hpp"
#include "ACTS/MagneticField/IMagneticFieldSvc.hpp"
+#include "ACTS/Surfaces/BoundaryCheck.hpp"
+#include "ACTS/Surfaces/ConeSurface.hpp"
+#include "ACTS/Surfaces/CylinderSurface.hpp"
+#include "ACTS/Surfaces/Surface.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Utilities/Logger.hpp"
namespace Acts {
- /**
- @struct PropagationCache
- Helper struct to allow state-less propagation.
- */
-
- struct PropagationCache {
-
- // configuration
- double direction;
- BoundaryCheck boundaryCheck;
- bool returnCurvilinear;
- bool useJacobian;
- double step;
- double maxPathLength;
- bool maxPathLimit;
- bool mcondition;
- bool needgradient;
- bool newfield;
- // internal parameters to be used
- double field[3] = {0.,0.,0.};
- double pVector[64];
- // result
- double parameters[5] = {0.,0.,0.,0.,0.};
- ActsSymMatrixD<5>* covariance;
- double jacobian[25];
-
-
- PropagationCache() :
- direction(alongMomentum),
- boundaryCheck(true),
- returnCurvilinear(false),
- useJacobian(false),
- step(0.),
- maxPathLength(0.),
- maxPathLimit(false),
- mcondition(false),
- needgradient(false),
- newfield(true),
- covariance(nullptr)
- {}
-
- };
-
- class Surface;
-
- /**
- @class RungeKuttaEngine
-
- RungeKuttaEngine is algorithm for track parameters propagation through
- magnetic field with or without jacobian of transformation. This algorithm
- contains three steps.
-
- 1.The first step of the algorithm is track parameters transformation from
- local presentation for given start surface to global Runge Kutta coordinates.
-
- 2.The second step is propagation through magnetic field with or without jacobian.
-
- 3.Third step is transformation from global Runge Kutta presentation to local
- presentation of given output surface.
-
-
- AtaPlane AtaStraightLine AtaDisc AtaCylinder Perigee
- | | | | |
- | | | | |
- V V V V V
- -----------------------------------------------------------------
- | Local->Global transformation
- V
- Global position (Runge Kutta presentation)
- |
- |
- Propagation to next surface with or without jacobian
- using Nystroem algorithm
- (See Handbook Net. Bur. of Standards, procedure 25.5.20)
- |
- V Global->Local transformation
- ----------------------------------------------------------------
- | | | | |
- | | | | |
- V V V V V
- PlaneSurface StraightLineSurface DiscSurface CylinderSurface PerigeeSurface
-
- For propagation using Runge Kutta method we use global coordinate, direction,
- inverse momentum and Jacobian of transformation. All this parameters we save
- in array P[42] called pVector
-
- /dL0 /dL1 /dPhi /dThe /dCM
- X ->P[0] dX / P[ 7] P[14] P[21] P[28] P[35]
- Y ->P[1] dY / P[ 8] P[15] P[22] P[29] P[36]
- Z ->P[2] dZ / P[ 9] P[16] P[23] P[30] P[37]
- Ax ->P[3] dAx/ P[10] P[17] P[24] P[31] P[38]
- Ay ->P[4] dAy/ P[11] P[18] P[25] P[32] P[39]
- Az ->P[5] dAz/ P[12] P[19] P[26] P[33] P[40]
- CM ->P[6] dCM/ P[13] P[20] P[27] P[34] P[41]
-
- where
- in case local presentation
-
- L0 - first local coordinate (surface dependent)
- L1 - second local coordinate (surface dependent)
- Phi - Azimuthal angle
- The - Polar angle
- CM - charge/momentum
-
- in case global presentation
-
- X - global x-coordinate = surface dependent
- Y - global y-coordinate = surface dependent
- Z - global z-coordinate = sutface dependent
- Ax - direction cosine to x-axis = Sin(The)*Cos(Phi)
- Ay - direction cosine to y-axis = Sin(The)*Sin(Phi)
- Az - direction cosine to z-axis = Cos(The)
- CM - charge/momentum = local CM
-
- Comment:
- if pointer to const * = 0 algorithm will propagate track
- parameters and jacobian of transformation according straight line model
-
-
+/**
+ @struct PropagationCache
+ Helper struct to allow state-less propagation.
*/
- class RungeKuttaEngine : virtual public IPropagationEngine {
-
- public:
-
- /** @struct Config
- Configuration struct for the RungeKuttaEngine
-
- @TODO explain parametr meanings (input from Igor needed)
- */
- struct Config {
- std::shared_ptr<Logger> logger;
-
- std::shared_ptr<IMagneticFieldSvc> fieldService ; //!< the field service
- double dlt ; //!< accuracy parameter
- double helixStep ; //!< max step whith helix model
- double straightStep ; //!< max step whith srtaight line model
- double maxPathLength ; //!< max overal path length
- bool usegradient ; //!< use magnetif field gradient
- std::string prefix ; //!< screen output prefix
- std::string postfix ; //!< screen output postfix
- std::string name; ; //!< name of the tool
-
- Config() :
- logger(getDefaultLogger("RungeKuttaEngine",Logging::INFO)),
- fieldService(nullptr),
- dlt(0.000200),
- helixStep(1.),
- straightStep(0.01),
- maxPathLength(25000.),
- usegradient(false),
- prefix("[RK] - "),
- postfix(" - "),
- name("Anonymous")
- {}
-
- };
-
- /** Constructor */
- RungeKuttaEngine(const Config& rkConfig);
-
- virtual ~RungeKuttaEngine();
-
- /** resolve the boundary situation - for charged particles */
- ExtrapolationCode propagate(ExCellCharged& ecCell,
- const Surface& sf,
- PropDirection dir=alongMomentum,
- ExtrapolationMode::eMode purpose = ExtrapolationMode::Destination,
- const BoundaryCheck& bcheck = true,
- bool returnCurvilinear = true) const final;
-
- /** resolve the boundary situation - for neutral particles */
- ExtrapolationCode propagate(ExCellNeutral& enCell,
- const Surface& sf,
- PropDirection dir=alongMomentum,
- ExtrapolationMode::eMode purpose = ExtrapolationMode::Destination,
- const BoundaryCheck& bcheck = true,
- bool returnCurvilinear = true) const final;
-
- /** Set configuration method */
- void setConfiguration(const Config& meConfig);
-
- /** Get configuration method */
- Config getConfiguration() const;
-
- protected:
- Config m_config; //!< configuration class
-
- RungeKuttaUtils m_rkUtils; //!< RungeKuttaUtils class
-
- private:
- const Logger& logger() const {return *m_config.logger;}
-
- /** Templated RungeKutta propagation method - charged/neutral */
- template <class T> bool propagateRungeKuttaT(ExtrapolationCell<T>& eCell,
- PropagationCache& pCache,
- const T& tParameters,
- const Surface& sf) const;
-
- /** Internal RungeKutta propagation method for propation with jacobian*/
- bool propagateWithJacobian(int navigationStep,
- PropagationCache& pCache,
- int surfaceType,
- double* sVector) const;
-
- /** Propagation methods runge kutta step - returns the step length */
- double rungeKuttaStep(int navigationStep,
- PropagationCache& pCache,
- double,
- bool&) const;
-
- /** Propagation methods runge kutta step - returns the step length*/
- double rungeKuttaStepWithGradient(int navigationStep,
- PropagationCache& pCache,
- double,
- bool& ) const;
-
- /** Propagation methods straight line step*/
- double straightLineStep(int navigationStep, PropagationCache& pCache, double) const;
-
- /** Step estimator with directions correction */
- double stepEstimatorWithCurvature(PropagationCache& pCache, int, double*, bool&) const;
-
- /** Build new track parameters without propagation */
- std::unique_ptr<const TrackParameters> buildTrackParametersWithoutPropagation(const TrackParameters &, double*) const;
-
- /** Build new track parameters without propagation */
- std::unique_ptr<const NeutralParameters> buildNeutralParametersWithoutPropagation(const NeutralParameters&, double*) const;
-
- /** Test new propagation to cylinder boundary */
- bool newCrossPoint(const CylinderSurface&, const double *, const double *) const;
-
- // get the field - with the fast option
- void getField (double*,double* ) const;
- void getFieldGradient(double*,double*,double*) const;
-
- };
-
- /////////////////////////////////////////////////////////////////////////////////
- // Inline methods for magnetic field information
- /////////////////////////////////////////////////////////////////////////////////
-
- inline void RungeKuttaEngine::getField(double* R,double* H) const
+struct PropagationCache
+{
+ // configuration
+ double direction;
+ BoundaryCheck boundaryCheck;
+ bool returnCurvilinear;
+ bool useJacobian;
+ double step;
+ double maxPathLength;
+ bool maxPathLimit;
+ bool mcondition;
+ bool needgradient;
+ bool newfield;
+ // internal parameters to be used
+ double field[3] = {0., 0., 0.};
+ double pVector[64];
+ // result
+ double parameters[5] = {0., 0., 0., 0., 0.};
+ ActsSymMatrixD<5>* covariance;
+ double jacobian[25];
+
+ PropagationCache()
+ : direction(alongMomentum)
+ , boundaryCheck(true)
+ , returnCurvilinear(false)
+ , useJacobian(false)
+ , step(0.)
+ , maxPathLength(0.)
+ , maxPathLimit(false)
+ , mcondition(false)
+ , needgradient(false)
+ , newfield(true)
+ , covariance(nullptr)
{
- m_config.fieldService->getField(R,H);
}
+};
+
+class Surface;
+
+/**
+@class RungeKuttaEngine
+
+ RungeKuttaEngine is algorithm for track parameters propagation through
+ magnetic field with or without jacobian of transformation. This algorithm
+ contains three steps.
+
+ 1.The first step of the algorithm is track parameters transformation from
+ local presentation for given start surface to global Runge Kutta
+coordinates.
+
+ 2.The second step is propagation through magnetic field with or without
+jacobian.
+
+ 3.Third step is transformation from global Runge Kutta presentation to local
+ presentation of given output surface.
+
+
+ AtaPlane AtaStraightLine AtaDisc AtaCylinder Perigee
+ | | | | |
+ | | | | |
+ V V V V V
+ -----------------------------------------------------------------
+ | Local->Global
+transformation
+ V
+ Global position (Runge Kutta presentation)
+ |
+ |
+ Propagation to next surface with or without jacobian
+ using Nystroem algorithm
+ (See Handbook Net. Bur. of Standards, procedure 25.5.20)
+ |
+ V Global->Local
+transformation
+ ----------------------------------------------------------------
+ | | | | |
+ | | | | |
+ V V V V V
+ PlaneSurface StraightLineSurface DiscSurface CylinderSurface PerigeeSurface
+
+ For propagation using Runge Kutta method we use global coordinate, direction,
+ inverse momentum and Jacobian of transformation. All this parameters we save
+ in array P[42] called pVector
+
+ /dL0 /dL1 /dPhi /dThe /dCM
+ X ->P[0] dX / P[ 7] P[14] P[21] P[28] P[35]
+ Y ->P[1] dY / P[ 8] P[15] P[22] P[29] P[36]
+ Z ->P[2] dZ / P[ 9] P[16] P[23] P[30] P[37]
+ Ax ->P[3] dAx/ P[10] P[17] P[24] P[31] P[38]
+ Ay ->P[4] dAy/ P[11] P[18] P[25] P[32] P[39]
+ Az ->P[5] dAz/ P[12] P[19] P[26] P[33] P[40]
+ CM ->P[6] dCM/ P[13] P[20] P[27] P[34] P[41]
+
+ where
+ in case local presentation
+
+ L0 - first local coordinate (surface dependent)
+ L1 - second local coordinate (surface dependent)
+ Phi - Azimuthal angle
+ The - Polar angle
+ CM - charge/momentum
+
+ in case global presentation
+
+ X - global x-coordinate = surface dependent
+ Y - global y-coordinate = surface dependent
+ Z - global z-coordinate = sutface dependent
+ Ax - direction cosine to x-axis = Sin(The)*Cos(Phi)
+ Ay - direction cosine to y-axis = Sin(The)*Sin(Phi)
+ Az - direction cosine to z-axis = Cos(The)
+ CM - charge/momentum = local CM
+
+ Comment:
+ if pointer to const * = 0 algorithm will propagate track
+ parameters and jacobian of transformation according straight line model
+
- inline void RungeKuttaEngine::getFieldGradient(double* R,double* H,double* dH) const
+*/
+
+class RungeKuttaEngine : virtual public IPropagationEngine
+{
+public:
+ /** @struct Config
+ Configuration struct for the RungeKuttaEngine
+
+ @TODO explain parametr meanings (input from Igor needed)
+ */
+ struct Config
+ {
+ std::shared_ptr<Logger> logger;
+
+ std::shared_ptr<IMagneticFieldSvc> fieldService; //!< the field service
+ double dlt; //!< accuracy parameter
+ double helixStep; //!< max step whith helix model
+ double straightStep; //!< max step whith srtaight line model
+ double maxPathLength; //!< max overal path length
+ bool usegradient; //!< use magnetif field gradient
+ std::string prefix; //!< screen output prefix
+ std::string postfix; //!< screen output postfix
+ std::string name;
+ ; //!< name of the tool
+
+ Config()
+ : logger(getDefaultLogger("RungeKuttaEngine", Logging::INFO))
+ , fieldService(nullptr)
+ , dlt(0.000200)
+ , helixStep(1.)
+ , straightStep(0.01)
+ , maxPathLength(25000.)
+ , usegradient(false)
+ , prefix("[RK] - ")
+ , postfix(" - ")
+ , name("Anonymous")
+ {
+ }
+ };
+
+ /** Constructor */
+ RungeKuttaEngine(const Config& rkConfig);
+
+ virtual ~RungeKuttaEngine();
+
+ /** resolve the boundary situation - for charged particles */
+ ExtrapolationCode
+ propagate(ExCellCharged& ecCell,
+ const Surface& sf,
+ PropDirection dir = alongMomentum,
+ ExtrapolationMode::eMode purpose = ExtrapolationMode::Destination,
+ const BoundaryCheck& bcheck = true,
+ bool returnCurvilinear = true) const final;
+
+ /** resolve the boundary situation - for neutral particles */
+ ExtrapolationCode
+ propagate(ExCellNeutral& enCell,
+ const Surface& sf,
+ PropDirection dir = alongMomentum,
+ ExtrapolationMode::eMode purpose = ExtrapolationMode::Destination,
+ const BoundaryCheck& bcheck = true,
+ bool returnCurvilinear = true) const final;
+
+ /** Set configuration method */
+ void
+ setConfiguration(const Config& meConfig);
+
+ /** Get configuration method */
+ Config
+ getConfiguration() const;
+
+protected:
+ Config m_config; //!< configuration class
+
+ RungeKuttaUtils m_rkUtils; //!< RungeKuttaUtils class
+
+private:
+ const Logger&
+ logger() const
{
- m_config.fieldService->getField(R,H,dH);
+ return *m_config.logger;
}
- /** Return the configuration object */
- inline RungeKuttaEngine::Config RungeKuttaEngine::getConfiguration() const { return m_config; }
+ /** Templated RungeKutta propagation method - charged/neutral */
+ template <class T>
+ bool
+ propagateRungeKuttaT(ExtrapolationCell<T>& eCell,
+ PropagationCache& pCache,
+ const T& tParameters,
+ const Surface& sf) const;
+
+ /** Internal RungeKutta propagation method for propation with jacobian*/
+ bool
+ propagateWithJacobian(int navigationStep,
+ PropagationCache& pCache,
+ int surfaceType,
+ double* sVector) const;
+
+ /** Propagation methods runge kutta step - returns the step length */
+ double
+ rungeKuttaStep(int navigationStep,
+ PropagationCache& pCache,
+ double,
+ bool&) const;
- ////////////////////////////////////////////////////////////////////////////////
- // Templated method
- ////////////////////////////////////////////////////////////////////////////////
+ /** Propagation methods runge kutta step - returns the step length*/
+ double
+ rungeKuttaStepWithGradient(int navigationStep,
+ PropagationCache& pCache,
+ double,
+ bool&) const;
+
+ /** Propagation methods straight line step*/
+ double
+ straightLineStep(int navigationStep, PropagationCache& pCache, double) const;
+
+ /** Step estimator with directions correction */
+ double
+ stepEstimatorWithCurvature(PropagationCache& pCache,
+ int,
+ double*,
+ bool&) const;
+
+ /** Build new track parameters without propagation */
+ std::unique_ptr<const TrackParameters>
+ buildTrackParametersWithoutPropagation(const TrackParameters&, double*) const;
+
+ /** Build new track parameters without propagation */
+ std::unique_ptr<const NeutralParameters>
+ buildNeutralParametersWithoutPropagation(const NeutralParameters&,
+ double*) const;
+
+ /** Test new propagation to cylinder boundary */
+ bool
+ newCrossPoint(const CylinderSurface&, const double*, const double*) const;
+
+ // get the field - with the fast option
+ void
+ getField(double*, double*) const;
+ void
+ getFieldGradient(double*, double*, double*) const;
+};
+
+/////////////////////////////////////////////////////////////////////////////////
+// Inline methods for magnetic field information
+/////////////////////////////////////////////////////////////////////////////////
+
+inline void
+RungeKuttaEngine::getField(double* R, double* H) const
+{
+ m_config.fieldService->getField(R, H);
+}
+
+inline void
+RungeKuttaEngine::getFieldGradient(double* R, double* H, double* dH) const
+{
+ m_config.fieldService->getField(R, H, dH);
+}
+
+/** Return the configuration object */
+inline RungeKuttaEngine::Config
+RungeKuttaEngine::getConfiguration() const
+{
+ return m_config;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Templated method
+////////////////////////////////////////////////////////////////////////////////
#include "ACTS/Extrapolation/detail/RungeKuttaEngine.ipp"
-
}
-
-#endif // ACTS_RUNGEKUTTAENGINE_RUNGEKUTAENGINE_H
+
+#endif // ACTS_RUNGEKUTTAENGINE_RUNGEKUTAENGINE_H
diff --git a/Core/include/ACTS/Extrapolation/StaticEngine.hpp b/Core/include/ACTS/Extrapolation/StaticEngine.hpp
index 9552760ab..01c4d5de7 100644
--- a/Core/include/ACTS/Extrapolation/StaticEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/StaticEngine.hpp
@@ -13,164 +13,191 @@
#ifndef ACTS_EXTRAPOLATIONENGING_STATICENGINE_H
#define ACTS_EXTRAPOLATIONENGING_STATICENGINE_H 1
-#ifndef ACTS_EXTRAPOLATIONENINGE_OUTPUTHELPER
+#ifndef ACTS_EXTRAPOLATIONENINGE_OUTPUTHELPER
#define ACTS_EXTRAPOLATIONENINGE_OUTPUTHELPER 1
-#define OH_CHECKFOUND(object) ( object ? "found" : "not found")
+#define OH_CHECKFOUND(object) (object ? "found" : "not found")
#endif
+#include "ACTS/EventData/NeutralParameters.hpp"
+#include "ACTS/EventData/TrackParameters.hpp"
+#include "ACTS/Extrapolation/ExtrapolationCell.hpp"
#include "ACTS/Extrapolation/IExtrapolationEngine.hpp"
-#include "ACTS/Extrapolation/IPropagationEngine.hpp"
#include "ACTS/Extrapolation/IMaterialEffectsEngine.hpp"
#include "ACTS/Extrapolation/INavigationEngine.hpp"
-#include "ACTS/Extrapolation/ExtrapolationCell.hpp"
+#include "ACTS/Extrapolation/IPropagationEngine.hpp"
#include "ACTS/Extrapolation/detail/ExtrapolationMacros.hpp"
-#include "ACTS/EventData/TrackParameters.hpp"
-#include "ACTS/EventData/NeutralParameters.hpp"
#include "ACTS/Utilities/Logger.hpp"
namespace Acts {
-
- /** @class StaticEngine
-
- Extrapolation engine for static layer & volume setup.
-
- This engine relies on the fact that every position in a static layer setup can be uniquely associated to a layer (NavigationLayer or real physical layer),
- and thus to a voume at navigation level. The extrapolation process within a fully static setup is then realised as a step from layer to layer within a volume,
- and from volume to volume at a higher level.
-
- The entire code is written as a template in either charged or neutral parameters.
-
-
- */
- class StaticEngine : virtual public IExtrapolationEngine {
-
- public:
-
- /** @enum ResolveLayerType
- - use for code readability
- */
- enum ResolveLayerType {
- StartLayer = 0,
- NavigationLayer = 1,
- PassThroughLayer = 2,
- SubStructureLayer = 3,
- DestinationLayer = 4,
- StartAndDestinationLayer = 6,
- UndefinedLayer = 5
- };
-
- /** @struct Config
- Configuration struct of the StaticEngine,
- holds the helper engines that can be configured
- */
- struct Config {
- std::shared_ptr<Logger> logger;
-
- std::shared_ptr<IPropagationEngine> propagationEngine; //!< the used propagation engine
- std::shared_ptr<INavigationEngine> navigationEngine; //!< the navigation engine to resolve the boundary
- std::shared_ptr<IMaterialEffectsEngine> materialEffectsEngine; //!< the material effects updated
-
- std::string prefix; //!< output prefix
- std::string postfix; //!< output postfix
- std::string name; //!< name of this engine
-
- Config() :
- logger(getDefaultLogger("StaticEngine",Logging::INFO)),
- propagationEngine(nullptr),
- navigationEngine(nullptr),
- materialEffectsEngine(nullptr),
- prefix("[SE] - "),
- postfix(" - "),
- name("Anonymous")
- {}
-
- };
-
- /** Constructor */
- StaticEngine(const Config& seConfig);
-
- /** Destructor */
- ~StaticEngine();
-
- using IExtrapolationEngine::extrapolate;
-
- /** charged extrapolation - public interface */
- ExtrapolationCode extrapolate(ExCellCharged& ecCharged,
- const Surface* sf = 0,
- const BoundaryCheck& bcheck = true) const final;
-
-
- /** neutral extrapolation - public interface */
- ExtrapolationCode extrapolate(ExCellNeutral& ecNeutral,
- const Surface* sf = 0,
- const BoundaryCheck& bcheck = true) const final;
-
- /** define for which GeometrySignature this extrapolator is valid - this is GLOBAL */
- GeometryType geometryType() const final;
-
- /** Set configuration method */
- void setConfiguration(const Config& meConfig);
-
- /** Get configuration method */
- Config getConfiguration() const;
-
- protected:
- /** Configuration struct */
- Config m_config;
-
- private:
- const Logger& logger() const {return *m_config.logger;}
-
- /** main loop extrapolation method */
- template <class T> ExtrapolationCode extrapolateT(ExtrapolationCell<T>& eCell,
- const Surface* sf = 0,
- PropDirection dir=alongMomentum,
- const BoundaryCheck& bcheck = true) const;
-
- /** init Navigation for static setup */
- template <class T> ExtrapolationCode initNavigationT(ExtrapolationCell<T>& eCell,
- const Surface* sf = 0,
- PropDirection dir=alongMomentum,
- const BoundaryCheck& bcheck = true) const;
-
- /** main static layer handling */
- template <class T> ExtrapolationCode handleLayerT(ExtrapolationCell<T>& eCell,
- const Surface* sf = 0,
- PropDirection dir=alongMomentum,
- const BoundaryCheck& bcheck = true) const;
-
- /** main sub structure layer handling */
- template <class T> ExtrapolationCode resolveLayerT(ExtrapolationCell<T>& eCell,
- const Acts::Surface* sf,
- PropDirection dir=alongMomentum,
- const BoundaryCheck& bcheck = true,
- bool hasSubStructure = false,
- bool isStartLayer = false,
- bool isDestinationLayer =false) const;
- /** handle the failure - as configured */
- template <class T> ExtrapolationCode handleReturnT(ExtrapolationCode eCode,
- ExtrapolationCell<T>& eCell,
- const Surface* sf = 0,
- PropDirection dir=alongMomentum,
- const BoundaryCheck& bcheck = true) const;
-
-
- };
-
- /** Return the geomtry type */
- inline GeometryType StaticEngine::geometryType() const
- { return Acts::Static; }
-
- /** Return the configuration object */
- inline StaticEngine::Config StaticEngine::getConfiguration() const { return m_config; }
-
-
-
-} // end of namespace
-
-//!< define the templated function
-#include "ACTS/Extrapolation/detail/StaticEngine.ipp"
-
-#endif // ACTS_EXTRAPOLATIONENGING_STATICENGINE_H
+/** @class StaticEngine
+
+ Extrapolation engine for static layer & volume setup.
+
+ This engine relies on the fact that every position in a static layer setup can
+ be uniquely associated to a layer (NavigationLayer or real physical layer),
+ and thus to a voume at navigation level. The extrapolation process within a
+ fully static setup is then realised as a step from layer to layer within a
+ volume,
+ and from volume to volume at a higher level.
+ The entire code is written as a template in either charged or neutral
+ parameters.
+
+
+*/
+class StaticEngine : virtual public IExtrapolationEngine
+{
+public:
+ /** @enum ResolveLayerType
+ - use for code readability
+ */
+ enum ResolveLayerType {
+ StartLayer = 0,
+ NavigationLayer = 1,
+ PassThroughLayer = 2,
+ SubStructureLayer = 3,
+ DestinationLayer = 4,
+ StartAndDestinationLayer = 6,
+ UndefinedLayer = 5
+ };
+
+ /** @struct Config
+ Configuration struct of the StaticEngine,
+ holds the helper engines that can be configured
+ */
+ struct Config
+ {
+ std::shared_ptr<Logger> logger;
+
+ std::shared_ptr<IPropagationEngine>
+ propagationEngine; //!< the used propagation engine
+ std::shared_ptr<INavigationEngine>
+ navigationEngine; //!< the navigation engine to resolve the boundary
+ std::shared_ptr<IMaterialEffectsEngine>
+ materialEffectsEngine; //!< the material effects updated
+
+ std::string prefix; //!< output prefix
+ std::string postfix; //!< output postfix
+ std::string name; //!< name of this engine
+
+ Config()
+ : logger(getDefaultLogger("StaticEngine", Logging::INFO))
+ , propagationEngine(nullptr)
+ , navigationEngine(nullptr)
+ , materialEffectsEngine(nullptr)
+ , prefix("[SE] - ")
+ , postfix(" - ")
+ , name("Anonymous")
+ {
+ }
+ };
+
+ /** Constructor */
+ StaticEngine(const Config& seConfig);
+
+ /** Destructor */
+ ~StaticEngine();
+
+ using IExtrapolationEngine::extrapolate;
+
+ /** charged extrapolation - public interface */
+ ExtrapolationCode
+ extrapolate(ExCellCharged& ecCharged,
+ const Surface* sf = 0,
+ const BoundaryCheck& bcheck = true) const final;
+
+ /** neutral extrapolation - public interface */
+ ExtrapolationCode
+ extrapolate(ExCellNeutral& ecNeutral,
+ const Surface* sf = 0,
+ const BoundaryCheck& bcheck = true) const final;
+
+ /** define for which GeometrySignature this extrapolator is valid - this is
+ * GLOBAL */
+ GeometryType
+ geometryType() const final;
+
+ /** Set configuration method */
+ void
+ setConfiguration(const Config& meConfig);
+
+ /** Get configuration method */
+ Config
+ getConfiguration() const;
+
+protected:
+ /** Configuration struct */
+ Config m_config;
+
+private:
+ const Logger&
+ logger() const
+ {
+ return *m_config.logger;
+ }
+
+ /** main loop extrapolation method */
+ template <class T>
+ ExtrapolationCode
+ extrapolateT(ExtrapolationCell<T>& eCell,
+ const Surface* sf = 0,
+ PropDirection dir = alongMomentum,
+ const BoundaryCheck& bcheck = true) const;
+
+ /** init Navigation for static setup */
+ template <class T>
+ ExtrapolationCode
+ initNavigationT(ExtrapolationCell<T>& eCell,
+ const Surface* sf = 0,
+ PropDirection dir = alongMomentum,
+ const BoundaryCheck& bcheck = true) const;
+
+ /** main static layer handling */
+ template <class T>
+ ExtrapolationCode
+ handleLayerT(ExtrapolationCell<T>& eCell,
+ const Surface* sf = 0,
+ PropDirection dir = alongMomentum,
+ const BoundaryCheck& bcheck = true) const;
+
+ /** main sub structure layer handling */
+ template <class T>
+ ExtrapolationCode
+ resolveLayerT(ExtrapolationCell<T>& eCell,
+ const Acts::Surface* sf,
+ PropDirection dir = alongMomentum,
+ const BoundaryCheck& bcheck = true,
+ bool hasSubStructure = false,
+ bool isStartLayer = false,
+ bool isDestinationLayer = false) const;
+ /** handle the failure - as configured */
+ template <class T>
+ ExtrapolationCode
+ handleReturnT(ExtrapolationCode eCode,
+ ExtrapolationCell<T>& eCell,
+ const Surface* sf = 0,
+ PropDirection dir = alongMomentum,
+ const BoundaryCheck& bcheck = true) const;
+};
+
+/** Return the geomtry type */
+inline GeometryType
+StaticEngine::geometryType() const
+{
+ return Acts::Static;
+}
+
+/** Return the configuration object */
+inline StaticEngine::Config
+StaticEngine::getConfiguration() const
+{
+ return m_config;
+}
+
+} // end of namespace
+
+//!< define the templated function
+#include "ACTS/Extrapolation/detail/StaticEngine.ipp"
+
+#endif // ACTS_EXTRAPOLATIONENGING_STATICENGINE_H
diff --git a/Core/include/ACTS/Extrapolation/StaticNavigationEngine.hpp b/Core/include/ACTS/Extrapolation/StaticNavigationEngine.hpp
index 4e93acbbe..bb44114f5 100644
--- a/Core/include/ACTS/Extrapolation/StaticNavigationEngine.hpp
+++ b/Core/include/ACTS/Extrapolation/StaticNavigationEngine.hpp
@@ -13,114 +13,142 @@
#ifndef ACTS_EXTRAPOLATIONENGINE_STATICNAVIGATIONENGINE_H
#define ACTS_EXTRAPOLATIONENGINE_STATICNAVIGATIONENGINE_H 1
-#include "ACTS/Extrapolation/INavigationEngine.hpp"
+#include "ACTS/EventData/NeutralParameters.hpp"
+#include "ACTS/EventData/TrackParameters.hpp"
#include "ACTS/Extrapolation/ExtrapolationCell.hpp"
#include "ACTS/Extrapolation/IMaterialEffectsEngine.hpp"
+#include "ACTS/Extrapolation/INavigationEngine.hpp"
#include "ACTS/Extrapolation/IPropagationEngine.hpp"
#include "ACTS/Extrapolation/detail/ExtrapolationMacros.hpp"
-#include "ACTS/Volumes/BoundarySurface.hpp"
-#include "ACTS/EventData/TrackParameters.hpp"
-#include "ACTS/EventData/NeutralParameters.hpp"
#include "ACTS/Utilities/Logger.hpp"
+#include "ACTS/Volumes/BoundarySurface.hpp"
namespace Acts {
- class TrackingGeometry;
-
- /** @class StaticNavigationEntine
-
- The static navigation engine for finding the next volume,
- propagate to the boundary, can be shared with other engines that have a static frame.
-
- */
- class StaticNavigationEngine : virtual public INavigationEngine {
-
- public:
-
- /** @struct Config
- configuration struct for the StaticNavigationEngine
- */
- struct Config {
- std::shared_ptr<Logger> logger;
-
- std::shared_ptr<IPropagationEngine> propagationEngine; //!< the used propagation engine
- std::shared_ptr<IMaterialEffectsEngine> materialEffectsEngine; //!< the material effects updated
- std::shared_ptr<const TrackingGeometry> trackingGeometry; //!< the tracking geometry used by the navigator
-
- std::string prefix; //!< output prefix
- std::string postfix; //!< output postfix
- std::string name; //!< name of this engine
-
- Config() :
- logger(getDefaultLogger("StaticNavigationEngine",Logging::INFO)),
- propagationEngine(nullptr),
- materialEffectsEngine(nullptr),
- trackingGeometry(nullptr),
- prefix("[SN] - "),
- postfix(" - "),
- name("Anonymous")
- {}
-
- };
-
- /** Constructor */
- StaticNavigationEngine(const Config& snConfig);
-
- /** Destructor */
- ~StaticNavigationEngine();
-
- /** avoid method shaddowing */
- using INavigationEngine::resolveBoundary;
- using INavigationEngine::resolvePosition;
-
- /** resolve the boundary situation - for charged particles */
- ExtrapolationCode resolveBoundary(ExCellCharged& eCell, PropDirection dir=alongMomentum) const final;
-
- /** resolve the boundary situation - for neutral particles */
- ExtrapolationCode resolveBoundary(ExCellNeutral& eCelll, PropDirection dir=alongMomentum) const final;
-
- /** resolve the boundary situation - for charged particles */
- ExtrapolationCode resolvePosition(ExCellCharged& eCell, PropDirection dir=alongMomentum, bool noLoop=false) const final;
-
- /** resolve the boundary situation - for neutral particles */
- ExtrapolationCode resolvePosition(ExCellNeutral& eCelll, PropDirection dir=alongMomentum, bool noLoop=false) const final;
-
- /** Set configuration method */
- void setConfiguration(const Config& meConfig);
-
- /** Get configuration method */
- Config getConfiguration() const;
-
- protected:
- /** the configuration member of the static navigation engine */
- Config m_config;
-
- private:
- const Logger& logger() const {return *m_config.logger;}
- /** resolve the boundary situation */
- template <class T> ExtrapolationCode resolveBoundaryT(ExtrapolationCell<T>& eCell,
- PropDirection dir=alongMomentum) const;
-
- /** resolve position */
- template <class T> ExtrapolationCode resolvePositionT(ExtrapolationCell<T>& eCell,
- PropDirection dir=alongMomentum,
- bool noLoop=false) const;
-
- /** deal with the boundary Surface - called by resolveBoundary */
- template <class T> ExtrapolationCode handleBoundaryT(ExtrapolationCell<T>& eCell,
- const BoundarySurface<TrackingVolume>& bSurfaceTV,
- PropDirection dir=alongMomentum,
- bool stepout=false) const;
-
- };
-
- /** Return the configuration object */
- inline StaticNavigationEngine::Config StaticNavigationEngine::getConfiguration() const { return m_config; }
-
-} // end of namespace
+class TrackingGeometry;
+
+/** @class StaticNavigationEntine
+
+ The static navigation engine for finding the next volume,
+ propagate to the boundary, can be shared with other engines that have a
+ static frame.
+
+ */
+class StaticNavigationEngine : virtual public INavigationEngine
+{
+public:
+ /** @struct Config
+ configuration struct for the StaticNavigationEngine
+ */
+ struct Config
+ {
+ std::shared_ptr<Logger> logger;
+
+ std::shared_ptr<IPropagationEngine>
+ propagationEngine; //!< the used propagation engine
+ std::shared_ptr<IMaterialEffectsEngine>
+ materialEffectsEngine; //!< the material effects updated
+ std::shared_ptr<const TrackingGeometry>
+ trackingGeometry; //!< the tracking geometry used by the navigator
+
+ std::string prefix; //!< output prefix
+ std::string postfix; //!< output postfix
+ std::string name; //!< name of this engine
+
+ Config()
+ : logger(getDefaultLogger("StaticNavigationEngine", Logging::INFO))
+ , propagationEngine(nullptr)
+ , materialEffectsEngine(nullptr)
+ , trackingGeometry(nullptr)
+ , prefix("[SN] - ")
+ , postfix(" - ")
+ , name("Anonymous")
+ {
+ }
+ };
+
+ /** Constructor */
+ StaticNavigationEngine(const Config& snConfig);
+
+ /** Destructor */
+ ~StaticNavigationEngine();
+
+ /** avoid method shaddowing */
+ using INavigationEngine::resolveBoundary;
+ using INavigationEngine::resolvePosition;
+
+ /** resolve the boundary situation - for charged particles */
+ ExtrapolationCode
+ resolveBoundary(ExCellCharged& eCell,
+ PropDirection dir = alongMomentum) const final;
+
+ /** resolve the boundary situation - for neutral particles */
+ ExtrapolationCode
+ resolveBoundary(ExCellNeutral& eCelll,
+ PropDirection dir = alongMomentum) const final;
+
+ /** resolve the boundary situation - for charged particles */
+ ExtrapolationCode
+ resolvePosition(ExCellCharged& eCell,
+ PropDirection dir = alongMomentum,
+ bool noLoop = false) const final;
+
+ /** resolve the boundary situation - for neutral particles */
+ ExtrapolationCode
+ resolvePosition(ExCellNeutral& eCelll,
+ PropDirection dir = alongMomentum,
+ bool noLoop = false) const final;
+
+ /** Set configuration method */
+ void
+ setConfiguration(const Config& meConfig);
+
+ /** Get configuration method */
+ Config
+ getConfiguration() const;
+
+protected:
+ /** the configuration member of the static navigation engine */
+ Config m_config;
+
+private:
+ const Logger&
+ logger() const
+ {
+ return *m_config.logger;
+ }
+ /** resolve the boundary situation */
+ template <class T>
+ ExtrapolationCode
+ resolveBoundaryT(ExtrapolationCell<T>& eCell,
+ PropDirection dir = alongMomentum) const;
+
+ /** resolve position */
+ template <class T>
+ ExtrapolationCode
+ resolvePositionT(ExtrapolationCell<T>& eCell,
+ PropDirection dir = alongMomentum,
+ bool noLoop = false) const;
+
+ /** deal with the boundary Surface - called by resolveBoundary */
+ template <class T>
+ ExtrapolationCode
+ handleBoundaryT(ExtrapolationCell<T>& eCell,
+ const BoundarySurface<TrackingVolume>& bSurfaceTV,
+ PropDirection dir = alongMomentum,
+ bool stepout = false) const;
+};
+
+/** Return the configuration object */
+inline StaticNavigationEngine::Config
+StaticNavigationEngine::getConfiguration() const
+{
+ return m_config;
+}
+
+} // end of namespace
//!< define the templated function
#include "ACTS/Extrapolation/detail/StaticNavigationEngine.ipp"
-#endif // ACTS_EXTRAPOLATIONENGINE_STATICNAVIGATIONENGINE_H
-
+#endif // ACTS_EXTRAPOLATIONENGINE_STATICNAVIGATIONENGINE_H
diff --git a/Core/include/ACTS/Extrapolation/detail/ExtrapolationEngine.ipp b/Core/include/ACTS/Extrapolation/detail/ExtrapolationEngine.ipp
index f4a8060ed..4d5f5ac73 100644
--- a/Core/include/ACTS/Extrapolation/detail/ExtrapolationEngine.ipp
+++ b/Core/include/ACTS/Extrapolation/detail/ExtrapolationEngine.ipp
@@ -2,130 +2,211 @@
// ExtrapolationEngine.ipp, ACTS project
///////////////////////////////////////////////////////////////////
-#include "ACTS/Surfaces/Surface.hpp"
-#include "ACTS/Layers/Layer.hpp"
-#include "ACTS/Volumes/BoundarySurface.hpp"
#include "ACTS/Detector/TrackingGeometry.hpp"
#include "ACTS/Detector/TrackingVolume.hpp"
+#include "ACTS/Layers/Layer.hpp"
+#include "ACTS/Surfaces/Surface.hpp"
+#include "ACTS/Volumes/BoundarySurface.hpp"
// STD
-#include <iostream>
#include <iomanip>
+#include <iostream>
-template <class T> Acts::ExtrapolationCode Acts::ExtrapolationEngine::extrapolateT(Acts::ExtrapolationCell<T>& eCell,
- const Acts::Surface* sf,
- Acts::PropDirection dir,
- const Acts::BoundaryCheck& bcheck) const
+template <class T>
+Acts::ExtrapolationCode
+Acts::ExtrapolationEngine::extrapolateT(Acts::ExtrapolationCell<T>& eCell,
+ const Acts::Surface* sf,
+ Acts::PropDirection dir,
+ const Acts::BoundaryCheck& bcheck) const
{
- EX_MSG_DEBUG(eCell.navigationStep, "extrapolate", "", "starting extrapolation sequence.");
- // initialize the navigation
- ExtrapolationCode eCode = initNavigation<T>(eCell,sf,dir);
- EX_MSG_VERBOSE(eCell.navigationStep, "extrapolate", "", "initialize navigation with return code : " << eCode.toString() );
- // main loop over volumes
- while (eCell.leadVolume && eCode == ExtrapolationCode::InProgress ){
- // give output that you are in the master volume loop
- EX_MSG_VERBOSE(eCell.navigationStep, "extrapolate", "loop", "processing volume : " << eCell.leadVolume->volumeName() );
- // get the appropriate IExtrapolationEngine
- GeometryType geoType = eCell.leadVolume->geometrySignature() > 2 ? Dense : Static;
-
- std::shared_ptr<const IExtrapolationEngine> iee = (m_config.extrapolationEngines.size() > eCell.leadVolume->geometrySignature()) ?
- m_config.extrapolationEngines[geoType] : nullptr;
- eCode = iee ? iee->extrapolate(eCell, sf, bcheck) : ExtrapolationCode::FailureConfiguration;
- // give a message about what you have
- EX_MSG_VERBOSE(eCell.navigationStep, "extrapolate", "", "returned from volume with return code : " << eCode.toString() << " and geoType:"<< geoType );
- }
- EX_MSG_DEBUG(eCell.navigationStep, "extrapolate", "", "extrapolation finished with return code : " << eCode.toString() );
- // return the code
- return eCode;
-}
+ EX_MSG_DEBUG(eCell.navigationStep,
+ "extrapolate",
+ "",
+ "starting extrapolation sequence.");
+ // initialize the navigation
+ ExtrapolationCode eCode = initNavigation<T>(eCell, sf, dir);
+ EX_MSG_VERBOSE(
+ eCell.navigationStep,
+ "extrapolate",
+ "",
+ "initialize navigation with return code : " << eCode.toString());
+ // main loop over volumes
+ while (eCell.leadVolume && eCode == ExtrapolationCode::InProgress) {
+ // give output that you are in the master volume loop
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "extrapolate",
+ "loop",
+ "processing volume : " << eCell.leadVolume->volumeName());
+ // get the appropriate IExtrapolationEngine
+ GeometryType geoType
+ = eCell.leadVolume->geometrySignature() > 2 ? Dense : Static;
+ std::shared_ptr<const IExtrapolationEngine> iee
+ = (m_config.extrapolationEngines.size()
+ > eCell.leadVolume->geometrySignature())
+ ? m_config.extrapolationEngines[geoType]
+ : nullptr;
+ eCode = iee ? iee->extrapolate(eCell, sf, bcheck)
+ : ExtrapolationCode::FailureConfiguration;
+ // give a message about what you have
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "extrapolate",
+ "",
+ "returned from volume with return code : "
+ << eCode.toString()
+ << " and geoType:"
+ << geoType);
+ }
+ EX_MSG_DEBUG(
+ eCell.navigationStep,
+ "extrapolate",
+ "",
+ "extrapolation finished with return code : " << eCode.toString());
+ // return the code
+ return eCode;
+}
-template <class T> Acts::ExtrapolationCode Acts::ExtrapolationEngine::initNavigation(Acts::ExtrapolationCell<T>& eCell,
- const Acts::Surface* sf,
- Acts::PropDirection dir) const
+template <class T>
+Acts::ExtrapolationCode
+Acts::ExtrapolationEngine::initNavigation(Acts::ExtrapolationCell<T>& eCell,
+ const Acts::Surface* sf,
+ Acts::PropDirection dir) const
{
- // initialize the Navigation stream ----------------------------------------------------------------------------------------
- //
- // this is the global initialization, it only associated direct objects
- // detailed navigation search needs to be done by the sub engines (since they know best)
- EX_MSG_DEBUG(++eCell.navigationStep, "navigation", "", "initialize the navigation stream.");
- // initialization of the navigation requires that leadParameters to be the startParameters
- eCell.leadParameters = &(eCell.startParameters);
- // now check the tracking geometry and retrieve it if not existing
- if (!m_config.trackingGeometry){
- EX_MSG_WARNING(eCell.navigationStep, "navigation", "", "could not retrieve geometry. Stopping.");
- // configuration error
- return ExtrapolationCode::FailureConfiguration;
- } else
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "geometry ready to use.");
- // ---------- START initialization -----------------------------------------------------------------------------------------
- // initialize the start parameters - try association first
- eCell.startLayer = eCell.startLayer ? eCell.startLayer : eCell.leadParameters->associatedSurface().associatedLayer();
- eCell.startVolume = eCell.startVolume ? eCell.startVolume : ( eCell.startLayer ? eCell.startLayer->enclosingTrackingVolume() : nullptr );
- // check if you are at the volume boundary
- //!< @TODO do not use hard coded number of atVolumeBoundary, check with ST
- if (!eCell.startVolume || m_config.trackingGeometry->atVolumeBoundary(eCell.startParameters.position(),eCell.startVolume,0.001) ) {
- ExtrapolationCode ecVol = m_config.navigationEngine->resolvePosition(eCell,dir,true);
- if (!ecVol.isSuccessOrRecovered() && !ecVol.inProgress())
- return ecVol;
- // the volume is found and assigned as start volume
- eCell.startVolume = eCell.leadVolume;
- } else {
- // we have a start volume, set is as lead volume also
- eCell.leadVolume = eCell.startVolume;
+ // initialize the Navigation stream
+ // ----------------------------------------------------------------------------------------
+ //
+ // this is the global initialization, it only associated direct objects
+ // detailed navigation search needs to be done by the sub engines (since they
+ // know best)
+ EX_MSG_DEBUG(++eCell.navigationStep,
+ "navigation",
+ "",
+ "initialize the navigation stream.");
+ // initialization of the navigation requires that leadParameters to be the
+ // startParameters
+ eCell.leadParameters = &(eCell.startParameters);
+ // now check the tracking geometry and retrieve it if not existing
+ if (!m_config.trackingGeometry) {
+ EX_MSG_WARNING(eCell.navigationStep,
+ "navigation",
+ "",
+ "could not retrieve geometry. Stopping.");
+ // configuration error
+ return ExtrapolationCode::FailureConfiguration;
+ } else
+ EX_MSG_VERBOSE(
+ eCell.navigationStep, "navigation", "", "geometry ready to use.");
+ // ---------- START initialization
+ // -----------------------------------------------------------------------------------------
+ // initialize the start parameters - try association first
+ eCell.startLayer = eCell.startLayer
+ ? eCell.startLayer
+ : eCell.leadParameters->associatedSurface().associatedLayer();
+ eCell.startVolume = eCell.startVolume
+ ? eCell.startVolume
+ : (eCell.startLayer ? eCell.startLayer->enclosingTrackingVolume()
+ : nullptr);
+ // check if you are at the volume boundary
+ //!< @TODO do not use hard coded number of atVolumeBoundary, check with ST
+ if (!eCell.startVolume
+ || m_config.trackingGeometry->atVolumeBoundary(
+ eCell.startParameters.position(), eCell.startVolume, 0.001)) {
+ ExtrapolationCode ecVol
+ = m_config.navigationEngine->resolvePosition(eCell, dir, true);
+ if (!ecVol.isSuccessOrRecovered() && !ecVol.inProgress()) return ecVol;
+ // the volume is found and assigned as start volume
+ eCell.startVolume = eCell.leadVolume;
+ } else {
+ // we have a start volume, set is as lead volume also
+ eCell.leadVolume = eCell.startVolume;
+ }
+ // bail out of the start volume can not be resolved
+ if (!eCell.startVolume) return ExtrapolationCode::FailureNavigation;
+ // screen output
+ EX_MSG_VERBOSE(
+ eCell.navigationStep,
+ "navigation",
+ "",
+ "start volume termined as : " << eCell.startVolume->volumeName());
+ // check layer association
+ eCell.startLayer = eCell.startLayer
+ ? eCell.startLayer
+ : eCell.startVolume->associatedLayer(eCell.leadParameters->position());
+ if (eCell.startLayer)
+ EX_MSG_VERBOSE(
+ eCell.navigationStep,
+ "navigation",
+ "",
+ "start layer termined with index : " << eCell.startLayer->geoID());
+ // the radial direction flags outwards or inwards moving directions w.r.t to
+ // (0.,0.,0,)
+ eCell.setRadialDirection();
+ // ---------- END initialization
+ // -----------------------------------------------------------------------------------------
+ if (sf) {
+ // stop at the end surface if configured
+ eCell.endSurface = sf;
+ // re-evaluate the radial direction if the end surface is given
+ // should not happen in FATRAS extrapolation mode, usually Fatras has no end
+ // surface though
+ if (!eCell.checkConfigurationMode(ExtrapolationMode::FATRAS))
+ eCell.setRadialDirection();
+ // trying association via the layer : associated layer of material layer
+ eCell.endLayer = sf->associatedLayer();
+ eCell.endVolume
+ = eCell.endLayer ? eCell.endLayer->enclosingTrackingVolume() : nullptr;
+ // check if you found layer and volume
+ if (!eCell.endVolume) {
+ EX_MSG_VERBOSE(
+ eCell.navigationStep,
+ "navigation",
+ "",
+ "end volume needs to be determinded by surface intersection.");
+ // use a propagation to find the endVolume and endLayer
+ // @TODO can be opmisied (straight line for high momentum - use directly )
+ ExtrapolationCell<T> navCell(*eCell.leadParameters, dir);
+ // screen output
+ ExtrapolationCode eCode = m_config.propagationEngine->propagate(
+ navCell,
+ *eCell.endSurface,
+ anyDirection,
+ ExtrapolationMode::Destination,
+ false,
+ eCell.navigationCurvilinear);
+ // check for sucess to the destination
+ //@TODO check what this is
+ CHECK_ECODE_SUCCESS_NODEST(navCell, eCode);
+ // screen output
+ EX_MSG_VERBOSE(
+ eCell.navigationStep,
+ "navigation",
+ "",
+ "found endVolume and andLayer through propagation - return code : "
+ << eCode.toString());
+ // take the lead parameters to find end volume and end layer
+ eCell.endVolume = m_config.trackingGeometry->lowestTrackingVolume(
+ navCell.endParameters->position());
+ eCell.endLayer = m_config.trackingGeometry->associatedLayer(
+ navCell.endParameters->position());
}
- // bail out of the start volume can not be resolved
- if (!eCell.startVolume)
- return ExtrapolationCode::FailureNavigation;
- // screen output
- EX_MSG_VERBOSE( eCell.navigationStep, "navigation", "", "start volume termined as : " << eCell.startVolume->volumeName() );
- // check layer association
- eCell.startLayer = eCell.startLayer ? eCell.startLayer : eCell.startVolume->associatedLayer(eCell.leadParameters->position());
- if (eCell.startLayer)
- EX_MSG_VERBOSE( eCell.navigationStep, "navigation", "", "start layer termined with index : " << eCell.startLayer->geoID());
- // the radial direction flags outwards or inwards moving directions w.r.t to (0.,0.,0,)
- eCell.setRadialDirection();
- // ---------- END initialization -----------------------------------------------------------------------------------------
- if (sf){
- // stop at the end surface if configured
- eCell.endSurface = sf;
- // re-evaluate the radial direction if the end surface is given
- // should not happen in FATRAS extrapolation mode, usually Fatras has no end surface though
- if ( !eCell.checkConfigurationMode(ExtrapolationMode::FATRAS) )
- eCell.setRadialDirection();
- // trying association via the layer : associated layer of material layer
- eCell.endLayer = sf->associatedLayer();
- eCell.endVolume = eCell.endLayer ? eCell.endLayer->enclosingTrackingVolume() : nullptr;
- // check if you found layer and volume
- if (!eCell.endVolume){
- EX_MSG_VERBOSE( eCell.navigationStep, "navigation", "", "end volume needs to be determinded by surface intersection." );
- // use a propagation to find the endVolume and endLayer
- // @TODO can be opmisied (straight line for high momentum - use directly )
- ExtrapolationCell<T> navCell(*eCell.leadParameters, dir);
- // screen output
- ExtrapolationCode eCode = m_config.propagationEngine->propagate(navCell,
- *eCell.endSurface,
- anyDirection,
- ExtrapolationMode::Destination,
- false,
- eCell.navigationCurvilinear);
- // check for sucess to the destination
- //@TODO check what this is
- CHECK_ECODE_SUCCESS_NODEST(navCell, eCode);
- // screen output
- EX_MSG_VERBOSE (eCell.navigationStep, "navigation", "", "found endVolume and andLayer through propagation - return code : " << eCode.toString() );
- // take the lead parameters to find end volume and end layer
- eCell.endVolume = m_config.trackingGeometry->lowestTrackingVolume(navCell.endParameters->position());
- eCell.endLayer = m_config.trackingGeometry->associatedLayer(navCell.endParameters->position());
- }
- // check the final end volume configuraiton - screen output
- if (eCell.endVolume)
- EX_MSG_VERBOSE( eCell.navigationStep, "navigation", "", "end volume termined as : " << eCell.endVolume->volumeName());
- if (eCell.endLayer)
- EX_MSG_VERBOSE( eCell.navigationStep, "navigation", "", "end layer termined with index : " << eCell.endLayer->geoID());
- } else
- EX_MSG_VERBOSE( eCell.navigationStep, "navigation", "", "no destination surface nor end volume provided, extrapolation has to stop by other means." );
- // return the progress call
- return ExtrapolationCode::InProgress;
+ // check the final end volume configuraiton - screen output
+ if (eCell.endVolume)
+ EX_MSG_VERBOSE(
+ eCell.navigationStep,
+ "navigation",
+ "",
+ "end volume termined as : " << eCell.endVolume->volumeName());
+ if (eCell.endLayer)
+ EX_MSG_VERBOSE(
+ eCell.navigationStep,
+ "navigation",
+ "",
+ "end layer termined with index : " << eCell.endLayer->geoID());
+ } else
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "navigation",
+ "",
+ "no destination surface nor end volume provided, "
+ "extrapolation has to stop by other means.");
+ // return the progress call
+ return ExtrapolationCode::InProgress;
}
-
-
diff --git a/Core/include/ACTS/Extrapolation/detail/ExtrapolationMacros.hpp b/Core/include/ACTS/Extrapolation/detail/ExtrapolationMacros.hpp
index 680786c22..d6ed8c701 100644
--- a/Core/include/ACTS/Extrapolation/detail/ExtrapolationMacros.hpp
+++ b/Core/include/ACTS/Extrapolation/detail/ExtrapolationMacros.hpp
@@ -15,22 +15,82 @@
#ifndef EXSCREENOUTPUTDEFS
#define EXSCREENOUTPUTDEFS 1
-#define EX_MSG_INFO(navstep, step, idx, x) ACTS_INFO ( m_sopPrefix << std::setw(4) << navstep << m_sopPostfix << std::setw(12) << step << m_sopPostfix << std::setw(4) << idx << m_sopPostfix << x)
-#define EX_MSG_DEBUG(navstep, step, idx, x) ACTS_DEBUG ( m_sopPrefix << std::setw(4) << navstep << m_sopPostfix << std::setw(12) << step << m_sopPostfix << std::setw(4) << idx << m_sopPostfix << x)
-#define EX_MSG_VERBOSE(navstep, step, idx, x) ACTS_VERBOSE(m_sopPrefix << std::setw(4) << navstep << m_sopPostfix << std::setw(12) << step << m_sopPostfix << std::setw(4) << idx << m_sopPostfix << x)
-#define EX_MSG_WARNING(navstep, step, idx, x) ACTS_WARNING( m_sopPrefix << std::setw(4) << navstep << m_sopPostfix << std::setw(12) << step << m_sopPostfix << std::setw(4) << idx << m_sopPostfix << x)
-#define EX_MSG_FATAL(navstep, step, idx, x) ACTS_FATAL ( m_sopPrefix << std::setw(4) << navstep << m_sopPostfix << std::setw(12) << step << m_sopPostfix << std::setw(4) << idx << m_sopPostfix << x)
+#define EX_MSG_INFO(navstep, step, idx, x) \
+ ACTS_INFO(m_sopPrefix << std::setw(4) << navstep << m_sopPostfix \
+ << std::setw(12) \
+ << step \
+ << m_sopPostfix \
+ << std::setw(4) \
+ << idx \
+ << m_sopPostfix \
+ << x)
+#define EX_MSG_DEBUG(navstep, step, idx, x) \
+ ACTS_DEBUG(m_sopPrefix << std::setw(4) << navstep << m_sopPostfix \
+ << std::setw(12) \
+ << step \
+ << m_sopPostfix \
+ << std::setw(4) \
+ << idx \
+ << m_sopPostfix \
+ << x)
+#define EX_MSG_VERBOSE(navstep, step, idx, x) \
+ ACTS_VERBOSE(m_sopPrefix << std::setw(4) << navstep << m_sopPostfix \
+ << std::setw(12) \
+ << step \
+ << m_sopPostfix \
+ << std::setw(4) \
+ << idx \
+ << m_sopPostfix \
+ << x)
+#define EX_MSG_WARNING(navstep, step, idx, x) \
+ ACTS_WARNING(m_sopPrefix << std::setw(4) << navstep << m_sopPostfix \
+ << std::setw(12) \
+ << step \
+ << m_sopPostfix \
+ << std::setw(4) \
+ << idx \
+ << m_sopPostfix \
+ << x)
+#define EX_MSG_FATAL(navstep, step, idx, x) \
+ ACTS_FATAL(m_sopPrefix << std::setw(4) << navstep << m_sopPostfix \
+ << std::setw(12) \
+ << step \
+ << m_sopPostfix \
+ << std::setw(4) \
+ << idx \
+ << m_sopPostfix \
+ << x)
#endif
#ifndef EXENINGE_OUTPUTHELPER
#define TRKEXENINGE_OUTPUTHELPER 1
-#define OH_CHECKFOUND(object) ( object ? "found" : "not found")
+#define OH_CHECKFOUND(object) (object ? "found" : "not found")
#endif
#ifndef EXENGINE_EXCODECHECKS
#define TRKEXENGINE_EXCODECHECKS 1
-#define CHECK_ECODE_CONTINUE(ecell, ecode) if (!ecode.inProgress()) { EX_MSG_VERBOSE(ecell.navigationStep, "continue", "", ecode.toString() << " triggers cotinue."); return ecode; }
-#define CHECK_ECODE_SUCCESS_NODEST(ecell, ecode) if (ecode.isSuccessBeforeDestination()) { EX_MSG_VERBOSE(ecell.navigationStep, "return", "", ecode.toString() << " stops extrapolation sequence."); return ecode; }
-#define CHECK_ECODE_SUCCESS(ecell, ecode) if (ecode.isSuccess()) { EX_MSG_VERBOSE(ecell.navigationStep, "return", "", ecode.toString() << " stops extrapolation sequence."); return ecode; }
+#define CHECK_ECODE_CONTINUE(ecell, ecode) \
+ if (!ecode.inProgress()) { \
+ EX_MSG_VERBOSE(ecell.navigationStep, \
+ "continue", \
+ "", \
+ ecode.toString() << " triggers cotinue."); \
+ return ecode; \
+ }
+#define CHECK_ECODE_SUCCESS_NODEST(ecell, ecode) \
+ if (ecode.isSuccessBeforeDestination()) { \
+ EX_MSG_VERBOSE(ecell.navigationStep, \
+ "return", \
+ "", \
+ ecode.toString() << " stops extrapolation sequence."); \
+ return ecode; \
+ }
+#define CHECK_ECODE_SUCCESS(ecell, ecode) \
+ if (ecode.isSuccess()) { \
+ EX_MSG_VERBOSE(ecell.navigationStep, \
+ "return", \
+ "", \
+ ecode.toString() << " stops extrapolation sequence."); \
+ return ecode; \
+ }
#endif
-
diff --git a/Core/include/ACTS/Extrapolation/detail/MaterialInteraction.hpp b/Core/include/ACTS/Extrapolation/detail/MaterialInteraction.hpp
index 468f3a800..8d8c94497 100644
--- a/Core/include/ACTS/Extrapolation/detail/MaterialInteraction.hpp
+++ b/Core/include/ACTS/Extrapolation/detail/MaterialInteraction.hpp
@@ -13,200 +13,248 @@
#ifndef ACTS_EXTRAPOLATIONUTILS_MATERIALINTERACTION_H
#define ACTS_EXTRAPOLATIONUTILS_MATERIALINTERACTION_H 1
-#include "ACTS/Material/Material.hpp"
#include "ACTS/EventData/ParticleDefinitions.hpp"
+#include "ACTS/Material/Material.hpp"
#include "ACTS/Utilities/Definitions.hpp"
namespace Acts {
- /** @class MaterialInteraction
-
- Collection of parametrizations used in the Tracking realm
-
- */
-
- class MaterialInteraction {
- public :
-
- /** Default Constructor needed for POOL */
- MaterialInteraction(){}
-
- /** Descructor */
- ~MaterialInteraction() {}
-
- /** dE/dl ionization energy loss per path unit */
- double dEdl_ionization(double p, const Material* mat, ParticleType particle, double& sigma, double& kazL) const;
- /** ionization energy loss from PDG */
- double PDG_energyLoss_ionization(double p, const Acts::Material* mat, Acts::ParticleType particle, double& sigma, double& kazL, double path) const;
-
- /** dE/dl radiation energy loss per path unit */
- double dEdl_radiation(double p, const Material* mat, ParticleType particle, double& sigma) const;
-
- /** multiple scattering as function of dInX0 */
- double sigmaMS(double dInX0, double p, double beta) const;
-
- private :
-
- static ParticleMasses s_particleMasses; //!< Struct of Particle masses
-
- };
-
+/** @class MaterialInteraction
+
+ Collection of parametrizations used in the Tracking realm
+
+*/
+
+class MaterialInteraction
+{
+public:
+ /** Default Constructor needed for POOL */
+ MaterialInteraction() {}
+ /** Descructor */
+ ~MaterialInteraction() {}
/** dE/dl ionization energy loss per path unit */
- inline double Acts::MaterialInteraction::dEdl_ionization(double p, const Acts::Material* mat, Acts::ParticleType particle, double& sigma, double& kazL) const {
-
- //
- // calculate mean ionization that is pathlentgh INDEPENDENT
- //
- // sigma = sigmaL = landau sigma is pathlentgh DEPENDENT (here calculated for 1 mm)
- // sigma(length) = sigma - kazL*log(pathlength)
- // kazL is calculated in this function for later use.
- //
- // For a Landau: MOP value = Mean + 3.59524*sigmaL
- //
- const double factor = (1./3.59524); // the compiler will evaulate this
-
- double path = 1.; // this is a scaling factor for the landau convolution
-
- sigma = 0.;
- if ( mat->averageZ()<1 ) return 0.;
-
- double Ionization = 0.;
-
- // kinetic variables
- // and the electron mass in MeV
- double me = s_particleMasses.mass[Acts::electron];
- double m = s_particleMasses.mass[particle];
- double mfrac = me/m;
- double E = sqrt(p*p+m*m);
- double beta = p/E;
- double gamma = E/m;
-
- //Ionization - Bethe-Bloch
- double I = 16.e-6 * std::pow(mat->averageZ(),0.9); //16 eV * Z**0.9 - bring to MeV
-
- //K/A*Z = 0.5 * 30.7075MeV/(g/mm2) * Z/A * rho[g/mm3] / scale to mm by this
- double kaz = 0.5*30.7075*mat->zOverAtimesRho();
-
- // sigmaL of Landau
- sigma = 4*kaz*beta/beta; // dsigma/dl
- kazL = 0.;
-
- double MOP = 0.;
- if (particle == Acts::electron){
- // for electrons use slightly different BetheBloch adaption
- // see Stampfer, et al, "Track Fitting With Energy Loss", Comp. Pyhs. Comm. 79 (1994), 157-164
- Ionization = -kaz*(2.*log(2.*me/I)+3.*log(gamma) - 1.95);
- } else {
-
- double eta2 = beta*gamma; eta2 *= eta2;
- // density effect, only valid for high energies (gamma > 10 -> p > 1GeV for muons)
- double delta = 0.;
- if (gamma > 10.) {
- double eplasma = 28.816e-6 * sqrt(1000.*mat->zOverAtimesRho());
- delta = 2.*log(eplasma/I) + log(eta2) - 1.;
- }
- // tmax - cut off energy
- double tMax = 2.*eta2*me/(1.+2.*gamma*mfrac+mfrac*mfrac);
- // divide by beta^2 for non-electrons
- kaz /= beta*beta;
- Ionization = -kaz*(log(2.*me*eta2*tMax/(I*I)) - 2.*(beta*beta) - delta);
- //
- // the landau sigmaL is path length dependent - take what's given
- //
- // PDG formula 27.11 for MOP value from http://pdg.lbl.gov/2011/reviews/rpp2011-rev-passage-particles-matter.pdf
- //
- MOP = -kaz*(log(2.*me*eta2/I) + log(path*kaz/I) + 0.2 - (beta*beta) - delta);
- sigma = -(Ionization - MOP)*factor;
- kazL = kaz*factor;
- }
- // return mean or mop
- return Ionization;
- }
+ double
+ dEdl_ionization(double p,
+ const Material* mat,
+ ParticleType particle,
+ double& sigma,
+ double& kazL) const;
+ /** ionization energy loss from PDG */
+ double
+ PDG_energyLoss_ionization(double p,
+ const Acts::Material* mat,
+ Acts::ParticleType particle,
+ double& sigma,
+ double& kazL,
+ double path) const;
/** dE/dl radiation energy loss per path unit */
- inline double Acts::MaterialInteraction::dEdl_radiation(double p, const Acts::Material* mat, Acts::ParticleType particle, double& sigma) const{
- sigma = 0.;
- if ( mat->x0()==0. ) return 0.;
-
- // preparation of kinetic constants
- double m = s_particleMasses.mass[particle];
- double me = s_particleMasses.mass[Acts::electron];
- double mfrac = me/m;
- double E = sqrt(p*p+m*m);
-
- //Bremsstrahlung - Bethe-Heitler
- double Radiation = -E*mfrac*mfrac;
- // sigma is rms of steep exponential part of radiation
- sigma = -Radiation;
-
- //Add e+e- pair production and photonuclear effect for muons at energies above 8 GeV
- // Radiation gives mean Eloss including the long tail from 'catastrophic' Eloss
- // sigma the rms of steep exponential
- if ((particle == Acts::muon) && (E > 8000.)) {
- if (E < 1.e6) {
- Radiation += 0.5345 - 6.803e-5*E - 2.278e-11*E*E + 9.899e-18*E*E*E; //E below 1 TeV
- sigma += (0.1828 -3.966e-3*sqrt(E) + 2.151e-5*E ); // idem
- } else {
- Radiation += 2.986 - 9.253e-5*E; //E above 1 TeV
- sigma += 17.73 + 2.409e-5*(E-1000000.); // idem
- }
- }
-
- sigma = sigma/mat->x0();
-
- return Radiation/mat->x0();
- }
+ double
+ dEdl_radiation(double p,
+ const Material* mat,
+ ParticleType particle,
+ double& sigma) const;
/** multiple scattering as function of dInX0 */
- inline double Acts::MaterialInteraction::sigmaMS(double dInX0, double p, double beta) const{
-
- if ( dInX0==0. || p==0. || beta==0.) return 0.;
-
- // Highland formula - projected sigma_s
- double sig_ms = 13.6*sqrt(dInX0)/(beta*p) * (1.+0.038*log(dInX0/(beta*beta)));
- return sig_ms;
- }
-
- /** Ionization energy loss from the PDG */
- /** PDG formula 32.11 for MOP value from http://http://pdg.lbl.gov/2014/reviews/rpp2014-rev-passage-particles-matter.pdf */
- inline double Acts::MaterialInteraction::PDG_energyLoss_ionization(double p, const Acts::Material* mat, Acts::ParticleType particle, double& sigma, double& kazL, double path) const {
- // kinetic variables
- // and the electron mass in MeV
-
- double m = s_particleMasses.mass[particle];
- double E = sqrt(p*p+m*m);
- double me = s_particleMasses.mass[Acts::electron];
- double beta = p/E;
- double gamma = E/m;
-
- //Ionization - Bethe-Bloch
- double I = 16.e-6 * std::pow(mat->averageZ(),0.9); //16 eV * Z**0.9 - bring to MeV
-
- //K/A*Z = 0.5 * 30.7075MeV/(g/mm2) * Z/A * rho[g/mm3] / scale to mm by this
- double kaz = 0.5*30.7075*mat->zOverAtimesRho();
- double eta2 = beta*gamma; eta2 *= eta2;
- // density effect, only valid for high energies (gamma > 10 -> p > 1GeV for muons)
+ double
+ sigmaMS(double dInX0, double p, double beta) const;
+
+private:
+ static ParticleMasses s_particleMasses; //!< Struct of Particle masses
+};
+
+/** dE/dl ionization energy loss per path unit */
+inline double
+Acts::MaterialInteraction::dEdl_ionization(double p,
+ const Acts::Material* mat,
+ Acts::ParticleType particle,
+ double& sigma,
+ double& kazL) const
+{
+ //
+ // calculate mean ionization that is pathlentgh INDEPENDENT
+ //
+ // sigma = sigmaL = landau sigma is pathlentgh DEPENDENT (here calculated for
+ // 1 mm)
+ // sigma(length) = sigma - kazL*log(pathlength)
+ // kazL is calculated in this function for later use.
+ //
+ // For a Landau: MOP value = Mean + 3.59524*sigmaL
+ //
+ const double factor = (1. / 3.59524); // the compiler will evaulate this
+
+ double path = 1.; // this is a scaling factor for the landau convolution
+
+ sigma = 0.;
+ if (mat->averageZ() < 1) return 0.;
+
+ double Ionization = 0.;
+
+ // kinetic variables
+ // and the electron mass in MeV
+ double me = s_particleMasses.mass[Acts::electron];
+ double m = s_particleMasses.mass[particle];
+ double mfrac = me / m;
+ double E = sqrt(p * p + m * m);
+ double beta = p / E;
+ double gamma = E / m;
+
+ // Ionization - Bethe-Bloch
+ double I = 16.e-6
+ * std::pow(mat->averageZ(), 0.9); // 16 eV * Z**0.9 - bring to MeV
+
+ // K/A*Z = 0.5 * 30.7075MeV/(g/mm2) * Z/A * rho[g/mm3] / scale to mm by this
+ double kaz = 0.5 * 30.7075 * mat->zOverAtimesRho();
+
+ // sigmaL of Landau
+ sigma = 4 * kaz * beta / beta; // dsigma/dl
+ kazL = 0.;
+
+ double MOP = 0.;
+ if (particle == Acts::electron) {
+ // for electrons use slightly different BetheBloch adaption
+ // see Stampfer, et al, "Track Fitting With Energy Loss", Comp. Pyhs. Comm.
+ // 79 (1994), 157-164
+ Ionization = -kaz * (2. * log(2. * me / I) + 3. * log(gamma) - 1.95);
+ } else {
+ double eta2 = beta * gamma;
+ eta2 *= eta2;
+ // density effect, only valid for high energies (gamma > 10 -> p > 1GeV for
+ // muons)
double delta = 0.;
if (gamma > 10.) {
- double eplasma = 28.816e-6 * sqrt(1000.*mat->zOverAtimesRho());
- delta = 2.*log(eplasma/I) + log(eta2) - 1.;
+ double eplasma = 28.816e-6 * sqrt(1000. * mat->zOverAtimesRho());
+ delta = 2. * log(eplasma / I) + log(eta2) - 1.;
}
-
+ // tmax - cut off energy
+ double tMax = 2. * eta2 * me / (1. + 2. * gamma * mfrac + mfrac * mfrac);
// divide by beta^2 for non-electrons
- kaz /= beta*beta;
- kazL = kaz*path;
-
+ kaz /= beta * beta;
+ Ionization = -kaz
+ * (log(2. * me * eta2 * tMax / (I * I)) - 2. * (beta * beta) - delta);
//
- // the landau sigmaL is path length dependent
- // PDG formula 32.11 for MOP value from http://http://pdg.lbl.gov/2014/reviews/rpp2014-rev-passage-particles-matter.pdf
+ // the landau sigmaL is path length dependent - take what's given
//
- double MOP = -kazL*(log(2.*me*eta2/I) + log(kazL/I) + 0.2 - (beta*beta) - delta);
- sigma = 0.424*4.*kazL; //0.424: scale factor from sigma to FWHM
-
- return MOP;
-
+ // PDG formula 27.11 for MOP value from
+ // http://pdg.lbl.gov/2011/reviews/rpp2011-rev-passage-particles-matter.pdf
+ //
+ MOP = -kaz
+ * (log(2. * me * eta2 / I) + log(path * kaz / I) + 0.2 - (beta * beta)
+ - delta);
+ sigma = -(Ionization - MOP) * factor;
+ kazL = kaz * factor;
+ }
+ // return mean or mop
+ return Ionization;
+}
+
+/** dE/dl radiation energy loss per path unit */
+inline double
+Acts::MaterialInteraction::dEdl_radiation(double p,
+ const Acts::Material* mat,
+ Acts::ParticleType particle,
+ double& sigma) const
+{
+ sigma = 0.;
+ if (mat->x0() == 0.) return 0.;
+
+ // preparation of kinetic constants
+ double m = s_particleMasses.mass[particle];
+ double me = s_particleMasses.mass[Acts::electron];
+ double mfrac = me / m;
+ double E = sqrt(p * p + m * m);
+
+ // Bremsstrahlung - Bethe-Heitler
+ double Radiation = -E * mfrac * mfrac;
+ // sigma is rms of steep exponential part of radiation
+ sigma = -Radiation;
+
+ // Add e+e- pair production and photonuclear effect for muons at energies
+ // above 8 GeV
+ // Radiation gives mean Eloss including the long tail from 'catastrophic'
+ // Eloss
+ // sigma the rms of steep exponential
+ if ((particle == Acts::muon) && (E > 8000.)) {
+ if (E < 1.e6) {
+ Radiation += 0.5345 - 6.803e-5 * E - 2.278e-11 * E * E
+ + 9.899e-18 * E * E * E; // E below 1 TeV
+ sigma += (0.1828 - 3.966e-3 * sqrt(E) + 2.151e-5 * E); // idem
+ } else {
+ Radiation += 2.986 - 9.253e-5 * E; // E above 1 TeV
+ sigma += 17.73 + 2.409e-5 * (E - 1000000.); // idem
+ }
}
-
+
+ sigma = sigma / mat->x0();
+
+ return Radiation / mat->x0();
+}
+
+/** multiple scattering as function of dInX0 */
+inline double
+Acts::MaterialInteraction::sigmaMS(double dInX0, double p, double beta) const
+{
+ if (dInX0 == 0. || p == 0. || beta == 0.) return 0.;
+
+ // Highland formula - projected sigma_s
+ double sig_ms = 13.6 * sqrt(dInX0) / (beta * p)
+ * (1. + 0.038 * log(dInX0 / (beta * beta)));
+ return sig_ms;
+}
+
+/** Ionization energy loss from the PDG */
+/** PDG formula 32.11 for MOP value from
+ * http://http://pdg.lbl.gov/2014/reviews/rpp2014-rev-passage-particles-matter.pdf
+ */
+inline double
+Acts::MaterialInteraction::PDG_energyLoss_ionization(
+ double p,
+ const Acts::Material* mat,
+ Acts::ParticleType particle,
+ double& sigma,
+ double& kazL,
+ double path) const
+{
+ // kinetic variables
+ // and the electron mass in MeV
+
+ double m = s_particleMasses.mass[particle];
+ double E = sqrt(p * p + m * m);
+ double me = s_particleMasses.mass[Acts::electron];
+ double beta = p / E;
+ double gamma = E / m;
+
+ // Ionization - Bethe-Bloch
+ double I = 16.e-6
+ * std::pow(mat->averageZ(), 0.9); // 16 eV * Z**0.9 - bring to MeV
+
+ // K/A*Z = 0.5 * 30.7075MeV/(g/mm2) * Z/A * rho[g/mm3] / scale to mm by this
+ double kaz = 0.5 * 30.7075 * mat->zOverAtimesRho();
+ double eta2 = beta * gamma;
+ eta2 *= eta2;
+ // density effect, only valid for high energies (gamma > 10 -> p > 1GeV for
+ // muons)
+ double delta = 0.;
+ if (gamma > 10.) {
+ double eplasma = 28.816e-6 * sqrt(1000. * mat->zOverAtimesRho());
+ delta = 2. * log(eplasma / I) + log(eta2) - 1.;
+ }
+
+ // divide by beta^2 for non-electrons
+ kaz /= beta * beta;
+ kazL = kaz * path;
+
+ //
+ // the landau sigmaL is path length dependent
+ // PDG formula 32.11 for MOP value from
+ // http://http://pdg.lbl.gov/2014/reviews/rpp2014-rev-passage-particles-matter.pdf
+ //
+ double MOP = -kazL
+ * (log(2. * me * eta2 / I) + log(kazL / I) + 0.2 - (beta * beta) - delta);
+ sigma = 0.424 * 4. * kazL; // 0.424: scale factor from sigma to FWHM
+
+ return MOP;
+}
}
#endif
diff --git a/Core/include/ACTS/Extrapolation/detail/RealQuadraticEquation.hpp b/Core/include/ACTS/Extrapolation/detail/RealQuadraticEquation.hpp
index 2b39bd912..68780d59e 100644
--- a/Core/include/ACTS/Extrapolation/detail/RealQuadraticEquation.hpp
+++ b/Core/include/ACTS/Extrapolation/detail/RealQuadraticEquation.hpp
@@ -13,55 +13,64 @@
#ifndef ACTS_EXTRAPOLATIONUTILS_REALQUADRATICEQUATION_H
#define ACTS_EXTRAPOLATIONUTILS_REALQUADRATICEQUATION_H 1
-#include <utility>
#include <cmath>
+#include <utility>
namespace Acts {
- /** @enum RQESolutionType
- */
-
- enum RQESolutionType { none=0, one=1, two=2 };
-
- /** @struct RealQuadradicEquation
- Mathematic struct for solving real quadratic equations
-
- <b>Mathematical motivation</b>:<br>
- The equation is given by:<br>
- @f$ \alpha x^{2} + \beta x + \gamma = 0 @f$
- and has therefore the analytical solution:<br>
- @f$ x_{1, 2} = - \frac{\beta \pm \sqrt{\beta^{2}-4\alpha\gamma}}{2\alpha}@f$ <br>
- <br>
- - case @f$ \beta > 0 @f$:<br>
- @f$ x_{1} = - \frac{\beta + \sqrt{\beta^{2}-4\alpha\gamma}}{2\alpha} := \frac{q}{\alpha}@f$, <br>
- so that @f$ q= -\frac{1}{2}(\beta+sqrt{\beta^{2}-4\alpha\gamma})@f$.
- @f$ x_{2} @f$ can now be written as: @f$ x_{2} = \frac{\gamma}{q} = -\frac{2\gamma}{\beta+sqrt{\beta^{2}-4\alpha\gamma}}@f$, since: <br>
- @f$ -\frac{2\gamma}{\beta+sqrt{\beta^{2}-4\alpha\gamma}} = -\frac{2\gamma}{\beta}\frac{1}{1+\sqrt{1-4\alpha\gamma/\beta^{2}}}@f$, and <br>
- @f$ x_{2}\frac{1}{1-\sqrt{1-4\alpha\gamma/\beta^{2}}} = -\frac{2\gamma}{\beta}\frac{1}{1-1+4\alpha\gamma/\beta^{2}}=-\frac{\beta}{2\alpha}.@f$<br>
- Hence,@f$ -\frac{\beta(1-\sqrt{1-4\alpha\gamma/\beta^{2}}}{2\alpha} = - \frac{\beta - \sqrt{\beta^{2}-4\alpha\gamma}}{2\alpha} @f$.<br>
- - case @f$ \beta > 0 @f$ is similar.
-
- */
-
- struct RealQuadraticEquation {
+/** @enum RQESolutionType
+ */
- double first;
- double second;
- RQESolutionType solutions;
+enum RQESolutionType { none = 0, one = 1, two = 2 };
- RealQuadraticEquation( double alpha, double beta, double gamma):first{},second{} {
- double discriminant = beta*beta - 4*alpha*gamma;
- if (discriminant<0) solutions = none;
- else {
- solutions = (discriminant==0) ? one : two;
- double q = -0.5*(beta + (beta>0 ? sqrt(discriminant) : -sqrt(discriminant)));
- first = q/alpha;
- second = gamma/q;
- }
- }
+/** @struct RealQuadradicEquation
+ Mathematic struct for solving real quadratic equations
- };
+ <b>Mathematical motivation</b>:<br>
+ The equation is given by:<br>
+ @f$ \alpha x^{2} + \beta x + \gamma = 0 @f$
+ and has therefore the analytical solution:<br>
+ @f$ x_{1, 2} = - \frac{\beta \pm \sqrt{\beta^{2}-4\alpha\gamma}}{2\alpha}@f$
+ <br>
+ <br>
+ - case @f$ \beta > 0 @f$:<br>
+ @f$ x_{1} = - \frac{\beta + \sqrt{\beta^{2}-4\alpha\gamma}}{2\alpha} :=
+ \frac{q}{\alpha}@f$, <br>
+ so that @f$ q= -\frac{1}{2}(\beta+sqrt{\beta^{2}-4\alpha\gamma})@f$.
+ @f$ x_{2} @f$ can now be written as: @f$ x_{2} = \frac{\gamma}{q} =
+ -\frac{2\gamma}{\beta+sqrt{\beta^{2}-4\alpha\gamma}}@f$, since: <br>
+ @f$ -\frac{2\gamma}{\beta+sqrt{\beta^{2}-4\alpha\gamma}} =
+ -\frac{2\gamma}{\beta}\frac{1}{1+\sqrt{1-4\alpha\gamma/\beta^{2}}}@f$, and
+ <br>
+ @f$ x_{2}\frac{1}{1-\sqrt{1-4\alpha\gamma/\beta^{2}}} =
+ -\frac{2\gamma}{\beta}\frac{1}{1-1+4\alpha\gamma/\beta^{2}}=-\frac{\beta}{2\alpha}.@f$<br>
+ Hence,@f$ -\frac{\beta(1-\sqrt{1-4\alpha\gamma/\beta^{2}}}{2\alpha} = -
+ \frac{\beta - \sqrt{\beta^{2}-4\alpha\gamma}}{2\alpha} @f$.<br>
+ - case @f$ \beta > 0 @f$ is similar.
-} // end of namespace
+ */
-#endif // TRKEXUTILS_REALQUADRATICEQUATION_H 1
+struct RealQuadraticEquation
+{
+ double first;
+ double second;
+ RQESolutionType solutions;
+ RealQuadraticEquation(double alpha, double beta, double gamma)
+ : first{}, second{}
+ {
+ double discriminant = beta * beta - 4 * alpha * gamma;
+ if (discriminant < 0)
+ solutions = none;
+ else {
+ solutions = (discriminant == 0) ? one : two;
+ double q = -0.5
+ * (beta + (beta > 0 ? sqrt(discriminant) : -sqrt(discriminant)));
+ first = q / alpha;
+ second = gamma / q;
+ }
+ }
+};
+
+} // end of namespace
+
+#endif // TRKEXUTILS_REALQUADRATICEQUATION_H 1
diff --git a/Core/include/ACTS/Extrapolation/detail/RungeKuttaEngine.ipp b/Core/include/ACTS/Extrapolation/detail/RungeKuttaEngine.ipp
index 1d874716b..9e0635014 100644
--- a/Core/include/ACTS/Extrapolation/detail/RungeKuttaEngine.ipp
+++ b/Core/include/ACTS/Extrapolation/detail/RungeKuttaEngine.ipp
@@ -1,111 +1,156 @@
-template <class T> bool Acts::RungeKuttaEngine::propagateRungeKuttaT(ExtrapolationCell<T>& eCell,
- PropagationCache& pCache,
- const T& parametersT,
- const Surface& dSurface) const
+template <class T>
+bool
+Acts::RungeKuttaEngine::propagateRungeKuttaT(ExtrapolationCell<T>& eCell,
+ PropagationCache& pCache,
+ 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(pCache.useJacobian,parametersT,pCache.pVector)) return false;
+ // bail out if you can't transform into global frame
+ if (!m_rkUtils.transformLocalToGlobal(
+ pCache.useJacobian, parametersT, pCache.pVector))
+ return false;
+
+ // get the surface transform
+ const Transform3D& sTransform = dSurface.transform();
- // get the surface transform
- const Transform3D& sTransform = dSurface.transform();
-
// now switch the surface type (defines local parameters)
- Surface::SurfaceType sType = dSurface.type();
+ Surface::SurfaceType sType = dSurface.type();
// propaate with different surface types
- if (sType == Surface::Plane || sType == Surface::Disc ){
- // (i) planar surface types
- double s[4],d = sTransform(0,3)*sTransform(0,2)+sTransform(1,3)*sTransform(1,2)+sTransform(2,3)*sTransform(2,2);
- if(d>=0.) {s[0]= sTransform(0,2); s[1]= sTransform(1,2); s[2]= sTransform(2,2); s[3]= d;}
- else {s[0]=-sTransform(0,2); s[1]=-sTransform(1,2); s[2]=-sTransform(2,2); s[3]=-d;}
- // check for propagation failure
- if (!propagateWithJacobian(eCell.navigationStep,pCache,1,s))
- return false;
- } else if (sType == Surface::Line || sType == Surface::Perigee){
- // (ii) line-type surfaces
- double s[6] ={sTransform(0,3),sTransform(1,3),sTransform(2,3),sTransform(0,2),sTransform(1,2),sTransform(2,2)};
+ if (sType == Surface::Plane || sType == Surface::Disc) {
+ // (i) planar surface types
+ double s[4], d = sTransform(0, 3) * sTransform(0, 2)
+ + sTransform(1, 3) * sTransform(1, 2)
+ + sTransform(2, 3) * sTransform(2, 2);
+ if (d >= 0.) {
+ s[0] = sTransform(0, 2);
+ s[1] = sTransform(1, 2);
+ s[2] = sTransform(2, 2);
+ s[3] = d;
+ } else {
+ s[0] = -sTransform(0, 2);
+ s[1] = -sTransform(1, 2);
+ s[2] = -sTransform(2, 2);
+ s[3] = -d;
+ }
+ // check for propagation failure
+ if (!propagateWithJacobian(eCell.navigationStep, pCache, 1, s))
+ return false;
+ } else if (sType == Surface::Line || sType == Surface::Perigee) {
+ // (ii) line-type surfaces
+ double s[6] = {sTransform(0, 3),
+ sTransform(1, 3),
+ sTransform(2, 3),
+ sTransform(0, 2),
+ sTransform(1, 2),
+ sTransform(2, 2)};
+ // check for propagation failure
+ if (!propagateWithJacobian(eCell.navigationStep, pCache, 0, s))
+ return false;
+ } else if (sType == Surface::Cylinder) {
+ // (iii) cylinder surface:
+ // - cast to CylinderSurface for checking the cross point
+ const CylinderSurface* cyl = static_cast<const CylinderSurface*>(&dSurface);
+ double r0[3] = {pCache.pVector[0], pCache.pVector[1], pCache.pVector[2]};
+ double s[9] = {sTransform(0, 3),
+ sTransform(1, 3),
+ sTransform(2, 3),
+ sTransform(0, 2),
+ sTransform(1, 2),
+ sTransform(2, 2),
+ dSurface.bounds().r(),
+ pCache.direction,
+ 0.};
+ // check for propagation failure
+ if (!propagateWithJacobian(eCell.navigationStep, pCache, 2, s))
+ return false;
+ // For cylinder we do test for next cross point
+ if (cyl->bounds().halfPhiSector() < 3.1
+ && newCrossPoint(*cyl, r0, pCache.pVector)) {
+ s[8] = 0.;
// check for propagation failure
- if (!propagateWithJacobian(eCell.navigationStep,pCache,0,s))
- return false;
- } else if (sType == Surface::Cylinder){
- // (iii) cylinder surface:
- // - cast to CylinderSurface for checking the cross point
- const CylinderSurface* cyl = static_cast<const CylinderSurface*>(&dSurface);
- double r0[3] = {pCache.pVector[0],pCache.pVector[1],pCache.pVector[2]};
- double s [9] = {sTransform(0,3),sTransform(1,3),sTransform(2,3),sTransform(0,2),sTransform(1,2),sTransform(2,2),dSurface.bounds().r(),pCache.direction,0.};
- // check for propagation failure
- if (!propagateWithJacobian(eCell.navigationStep,pCache,2,s))
- return false;
- // For cylinder we do test for next cross point
- if (cyl->bounds().halfPhiSector() < 3.1 && newCrossPoint(*cyl,r0,pCache.pVector)) {
- s[8] = 0.;
- // check for propagation failure
- if (!propagateWithJacobian(eCell.navigationStep,pCache,2,s))
- return false;
- }
- } else if (sType == Surface::Cone){
- // (iv) cone surface
- // - need to access the tangent of alpha
- double k = static_cast<const ConeSurface*>(&dSurface)->bounds().tanAlpha(); k = k*k+1.;
- double s[9] = {sTransform(0,3),sTransform(1,3),sTransform(2,3),sTransform(0,2),sTransform(1,2),sTransform(2,2),k,pCache.direction,0.};
- // check for propagation failure
- if (!propagateWithJacobian(eCell.navigationStep,pCache,3,s))
- return false;
- } else
- return false; // there was no surface that did fit
+ if (!propagateWithJacobian(eCell.navigationStep, pCache, 2, s))
+ return false;
+ }
+ } else if (sType == Surface::Cone) {
+ // (iv) cone surface
+ // - need to access the tangent of alpha
+ double k = static_cast<const ConeSurface*>(&dSurface)->bounds().tanAlpha();
+ k = k * k + 1.;
+ double s[9] = {sTransform(0, 3),
+ sTransform(1, 3),
+ sTransform(2, 3),
+ sTransform(0, 2),
+ sTransform(1, 2),
+ sTransform(2, 2),
+ k,
+ pCache.direction,
+ 0.};
+ // check for propagation failure
+ if (!propagateWithJacobian(eCell.navigationStep, pCache, 3, s))
+ return false;
+ } else
+ return false; // there was no surface that did fit
- EX_MSG_VERBOSE(eCell.navigationStep, "propagate", "<T> ", "surface type determined and localToGlobal performed.");
-
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "propagate",
+ "<T> ",
+ "surface type determined and localToGlobal performed.");
// check if the direction solution was ok
- if (pCache.direction != 0. && (pCache.direction*pCache.step) < 0.) return false;
+ if (pCache.direction != 0. && (pCache.direction * pCache.step) < 0.)
+ return false;
// Common transformation for all surfaces (angles and momentum)
if (pCache.useJacobian) {
- double p=1./pCache.pVector[6];
- pCache.pVector[35]*=p;
- pCache.pVector[36]*=p;
- pCache.pVector[37]*=p;
- pCache.pVector[38]*=p;
- pCache.pVector[39]*=p;
- pCache.pVector[40]*=p;
+ double p = 1. / pCache.pVector[6];
+ pCache.pVector[35] *= p;
+ pCache.pVector[36] *= p;
+ pCache.pVector[37] *= p;
+ pCache.pVector[38] *= p;
+ pCache.pVector[39] *= p;
+ pCache.pVector[40] *= p;
}
- // return curvilinear when the path limit is met
+ // return curvilinear when the path limit is met
if (pCache.maxPathLimit) pCache.returnCurvilinear = true;
// use the jacobian for tranformation
- bool uJ = pCache.useJacobian; if (pCache.returnCurvilinear) uJ = false;
+ bool uJ = pCache.useJacobian;
+ if (pCache.returnCurvilinear) uJ = false;
// create the return track parameters from Global to Local
- m_rkUtils.transformGlobalToLocal(&dSurface,uJ,pCache.pVector,pCache.parameters,pCache.jacobian);
+ m_rkUtils.transformGlobalToLocal(
+ &dSurface, uJ, pCache.pVector, pCache.parameters, pCache.jacobian);
if (pCache.boundaryCheck) {
- // create a local position and check for inside
- Vector2D lPosition(pCache.parameters[0],pCache.parameters[1]);
- if (!dSurface.insideBounds(lPosition,pCache.boundaryCheck)) return false;
+ // create a local position and check for inside
+ Vector2D lPosition(pCache.parameters[0], pCache.parameters[1]);
+ if (!dSurface.insideBounds(lPosition, pCache.boundaryCheck)) return false;
}
// Transformation to curvilinear presentation
- if (pCache.returnCurvilinear)
- m_rkUtils.transformGlobalToCurvilinear(pCache.useJacobian,
- pCache.pVector,
- pCache.parameters,
- pCache.jacobian);
+ if (pCache.returnCurvilinear)
+ m_rkUtils.transformGlobalToCurvilinear(
+ pCache.useJacobian, pCache.pVector, pCache.parameters, pCache.jacobian);
- if (pCache.useJacobian){
- // create a new covariance matrix using the utils
- pCache.covariance = m_rkUtils.newCovarianceMatrix(pCache.jacobian,*parametersT.covariance());
- auto& cov = (*pCache.covariance);
- // check for positive finite elements
- if (cov(0,0)<=0. || cov(1,1)<=0. || cov(2,2)<=0. || cov(3,3)<=0. || cov(4,4)<=0.) {
- delete pCache.covariance; pCache.covariance = nullptr;
- return false;
- }
+ if (pCache.useJacobian) {
+ // create a new covariance matrix using the utils
+ pCache.covariance = m_rkUtils.newCovarianceMatrix(
+ pCache.jacobian, *parametersT.covariance());
+ auto& cov = (*pCache.covariance);
+ // check for positive finite elements
+ if (cov(0, 0) <= 0. || cov(1, 1) <= 0. || cov(2, 2) <= 0. || cov(3, 3) <= 0.
+ || cov(4, 4) <= 0.) {
+ delete pCache.covariance;
+ pCache.covariance = nullptr;
+ return false;
+ }
}
- // everything worked, return true
+ // everything worked, return true
return true;
}
-
diff --git a/Core/include/ACTS/Extrapolation/detail/RungeKuttaUtils.hpp b/Core/include/ACTS/Extrapolation/detail/RungeKuttaUtils.hpp
index eb8620ff5..ed2053e89 100644
--- a/Core/include/ACTS/Extrapolation/detail/RungeKuttaUtils.hpp
+++ b/Core/include/ACTS/Extrapolation/detail/RungeKuttaUtils.hpp
@@ -13,166 +13,192 @@
#ifndef ACTS_EXTRAPOLATIONUTILS_RUNGEKUTTAUTILS_H
#define ACTS_EXTRAPOLATIONUTILS_RUNGEKUTTAUTILS_H 1
-#include "ACTS/EventData/TrackParameters.hpp"
#include "ACTS/EventData/NeutralParameters.hpp"
+#include "ACTS/EventData/TrackParameters.hpp"
#include "ACTS/Surfaces/BoundaryCheck.hpp"
// STD
-#include <vector>
#include <map>
+#include <vector>
namespace Acts {
- class ConeSurface ;
- class DiscSurface ;
- class PlaneSurface ;
- class CylinderSurface ;
- class StraightLineSurface ;
-
- /**
- @class RungeKuttaUtils
-
- Acts::RungeKuttaUtils is set algorithms for track parameters transformation
-
- from local to global and global to local system coordinate and step
- estimation to surface.
-
- AtaPlane AtaStraightLine AtaDisc AtaCylinder Perigee
- | | | | |
- | | | | |
- V V V V V
- -----------------------------------------------------------------
- | Local->Global transformation
- V
- Global position (Runge Kutta presentation)
- |
- V Global->Local transformation
- ----------------------------------------------------------------
- | | | | |
- | | | | |
- V V V V V
- PlaneSurface StraightLineSurface DiscSurface CylinderSurface PerigeeSurface
-
- For using Runge Kutta method we use global coordinate, direction,
- inverse momentum and Jacobian of transformation. All this parameters we save
- in array P[42].
- /dL0 /dL1 /dPhi /dThe /dCM
- X ->P[0] dX / P[ 7] P[14] P[21] P[28] P[35]
- Y ->P[1] dY / P[ 8] P[15] P[22] P[29] P[36]
- Z ->P[2] dZ / P[ 9] P[16] P[23] P[30] P[37]
- Ax ->P[3] dAx/ P[10] P[17] P[24] P[31] P[38]
- Ay ->P[4] dAy/ P[11] P[18] P[25] P[32] P[39]
- Az ->P[5] dAz/ P[12] P[19] P[26] P[33] P[40]
- CM ->P[6] dCM/ P[13] P[20] P[27] P[34] P[41]
-
- where
- in case local presentation
-
- L0 - first local coordinate (surface dependent)
- L1 - second local coordinate (surface dependent)
- Phi - Azimuthal angle
- The - Polar angle
- CM - charge/momentum
-
- in case global presentation
-
- X - global x-coordinate = surface dependent
- Y - global y-coordinate = surface dependent
- Z - global z-coordinate = sutface dependent
- Ax - direction cosine to x-axis = Sin(The)*Cos(Phi)
- Ay - direction cosine to y-axis = Sin(The)*Sin(Phi)
- Az - direction cosine to z-axis = Cos(The)
- CM - charge/momentum = local CM
-
- **/
-
- class RungeKuttaUtils
- {
- /////////////////////////////////////////////////////////////////////////////////
- // Public methods:
- /////////////////////////////////////////////////////////////////////////////////
-
- public:
-
- RungeKuttaUtils(){};
- virtual ~RungeKuttaUtils (){};
-
- /////////////////////////////////////////////////////////////////////////////////
- // Step estimators to surface
- /////////////////////////////////////////////////////////////////////////////////
-
- double stepEstimator (int,double*,const double*,bool&) const;
- double stepEstimatorToCone (double*,const double*,bool&) const;
- double stepEstimatorToPlane (double*,const double*,bool&) const;
- double stepEstimatorToCylinder (double*,const double*,bool&) const;
- double stepEstimatorToStraightLine (double*,const double*,bool&) const;
-
-
- /////////////////////////////////////////////////////////////////////////////////
- // Transformations from local to global system coordinates
- // for TrackParameters and NeutralParameters
- /////////////////////////////////////////////////////////////////////////////////
-
- bool transformLocalToGlobal(bool,const TrackParameters&, double*) const;
-
- bool transformLocalToGlobal(bool,const NeutralParameters&, double*) const;
-
- /////////////////////////////////////////////////////////////////////////////////
- // Transformations from local to global system coordinates
- // for different surfaces
- /////////////////////////////////////////////////////////////////////////////////
-
- void transformDiscToGlobal(bool,const Surface*,const double*,double*) const;
- void transformPlaneToGlobal(bool,const Surface*,const double*,double*) const;
- void transformCylinderToGlobal(bool,const Surface*,const double*,double*) const;
- void transformLineToGlobal(bool,const Surface*,const double*,double*) const;
-
- /////////////////////////////////////////////////////////////////////////////////
- // Transformations from global to local system coordinates
- /////////////////////////////////////////////////////////////////////////////////
-
- void transformGlobalToLocal(double*,double*) const;
- void transformGlobalToLocal(const Surface*,bool,double*,double*,double*) const;
- void transformGlobalToCone(const Surface*,bool,double*,double*,double*) const;
- void transformGlobalToDisc(const Surface*,bool,double*,double*,double*) const;
- void transformGlobalToPlane(const Surface*,bool,double*,double*,double*) const;
- void transformGlobalToCylinder(const Surface*,bool,double*,double*,double*) const;
- void transformGlobalToLine(const Surface*,bool,double*,double*,double*) const;
-
- /////////////////////////////////////////////////////////////////////////////////
- // Covariance matrix production for TrackParameters
- /////////////////////////////////////////////////////////////////////////////////
- ActsSymMatrixD<5>* newCovarianceMatrix(double*,const ActsSymMatrixD<5>&) const;
-
- /////////////////////////////////////////////////////////////////////////////////
- // Transformations from curvilinear to global system coordinates
- // covariance matrix only
- /////////////////////////////////////////////////////////////////////////////////
- void transformCurvilinearToGlobal(double* ,double*) const;
-
- /////////////////////////////////////////////////////////////////////////////////
- // Transformations from global to curvilinear system coordinates
- // covariance matrix only
- /////////////////////////////////////////////////////////////////////////////////
- void transformGlobalToCurvilinear(bool,double*,double*,double*) const;
-
- /////////////////////////////////////////////////////////////////////////////////
- // Jacobian of transformations from curvilinear to local system coordinates
- /////////////////////////////////////////////////////////////////////////////////
- void jacobianTransformCurvilinearToLocal(const TrackParameters&,double*);
- void jacobianTransformCurvilinearToLocal(double*,const Surface*,double*);
- void jacobianTransformCurvilinearToDisc (double*,double*) const;
- void jacobianTransformCurvilinearToPlane (double*,double*) const;
- void jacobianTransformCurvilinearToCylinder (double*,double*) const;
- void jacobianTransformCurvilinearToStraightLine(double*,double*) const;
-
- private:
-
- /////////////////////////////////////////////////////////////////////////////////
- // Private methods:
- /////////////////////////////////////////////////////////////////////////////////
-
- bool transformLocalToGlobal(bool,const Surface*,const double*,double*) const;
- };
-} // end of namespace
-
-#endif // ACTS_EXTRAPOLATIONUTILS_RUNGEKUTTAUTILS_H
+class ConeSurface;
+class DiscSurface;
+class PlaneSurface;
+class CylinderSurface;
+class StraightLineSurface;
+
+/**
+@class RungeKuttaUtils
+
+Acts::RungeKuttaUtils is set algorithms for track parameters transformation
+
+from local to global and global to local system coordinate and step
+estimation to surface.
+
+ AtaPlane AtaStraightLine AtaDisc AtaCylinder Perigee
+ | | | | |
+ | | | | |
+ V V V V V
+ -----------------------------------------------------------------
+ | Local->Global transformation
+ V
+ Global position (Runge Kutta presentation)
+ |
+ V Global->Local transformation
+ ----------------------------------------------------------------
+ | | | | |
+ | | | | |
+ V V V V V
+ PlaneSurface StraightLineSurface DiscSurface CylinderSurface PerigeeSurface
+
+For using Runge Kutta method we use global coordinate, direction,
+inverse momentum and Jacobian of transformation. All this parameters we save
+in array P[42].
+ /dL0 /dL1 /dPhi /dThe /dCM
+X ->P[0] dX / P[ 7] P[14] P[21] P[28] P[35]
+Y ->P[1] dY / P[ 8] P[15] P[22] P[29] P[36]
+Z ->P[2] dZ / P[ 9] P[16] P[23] P[30] P[37]
+Ax ->P[3] dAx/ P[10] P[17] P[24] P[31] P[38]
+Ay ->P[4] dAy/ P[11] P[18] P[25] P[32] P[39]
+Az ->P[5] dAz/ P[12] P[19] P[26] P[33] P[40]
+CM ->P[6] dCM/ P[13] P[20] P[27] P[34] P[41]
+
+where
+ in case local presentation
+
+ L0 - first local coordinate (surface dependent)
+ L1 - second local coordinate (surface dependent)
+ Phi - Azimuthal angle
+ The - Polar angle
+ CM - charge/momentum
+
+ in case global presentation
+
+ X - global x-coordinate = surface dependent
+ Y - global y-coordinate = surface dependent
+ Z - global z-coordinate = sutface dependent
+ Ax - direction cosine to x-axis = Sin(The)*Cos(Phi)
+ Ay - direction cosine to y-axis = Sin(The)*Sin(Phi)
+ Az - direction cosine to z-axis = Cos(The)
+ CM - charge/momentum = local CM
+
+**/
+
+class RungeKuttaUtils
+{
+ /////////////////////////////////////////////////////////////////////////////////
+ // Public methods:
+ /////////////////////////////////////////////////////////////////////////////////
+
+public:
+ RungeKuttaUtils(){};
+ virtual ~RungeKuttaUtils(){};
+
+ /////////////////////////////////////////////////////////////////////////////////
+ // Step estimators to surface
+ /////////////////////////////////////////////////////////////////////////////////
+
+ double
+ stepEstimator(int, double*, const double*, bool&) const;
+ double
+ stepEstimatorToCone(double*, const double*, bool&) const;
+ double
+ stepEstimatorToPlane(double*, const double*, bool&) const;
+ double
+ stepEstimatorToCylinder(double*, const double*, bool&) const;
+ double
+ stepEstimatorToStraightLine(double*, const double*, bool&) const;
+
+ /////////////////////////////////////////////////////////////////////////////////
+ // Transformations from local to global system coordinates
+ // for TrackParameters and NeutralParameters
+ /////////////////////////////////////////////////////////////////////////////////
+
+ bool
+ transformLocalToGlobal(bool, const TrackParameters&, double*) const;
+
+ bool
+ transformLocalToGlobal(bool, const NeutralParameters&, double*) const;
+
+ /////////////////////////////////////////////////////////////////////////////////
+ // Transformations from local to global system coordinates
+ // for different surfaces
+ /////////////////////////////////////////////////////////////////////////////////
+
+ void
+ transformDiscToGlobal(bool, const Surface*, const double*, double*) const;
+ void
+ transformPlaneToGlobal(bool, const Surface*, const double*, double*) const;
+ void
+ transformCylinderToGlobal(bool, const Surface*, const double*, double*) const;
+ void
+ transformLineToGlobal(bool, const Surface*, const double*, double*) const;
+
+ /////////////////////////////////////////////////////////////////////////////////
+ // Transformations from global to local system coordinates
+ /////////////////////////////////////////////////////////////////////////////////
+
+ void
+ transformGlobalToLocal(double*, double*) const;
+ void
+ transformGlobalToLocal(const Surface*, bool, double*, double*, double*) const;
+ void
+ transformGlobalToCone(const Surface*, bool, double*, double*, double*) const;
+ void
+ transformGlobalToDisc(const Surface*, bool, double*, double*, double*) const;
+ void
+ transformGlobalToPlane(const Surface*, bool, double*, double*, double*) const;
+ void
+ transformGlobalToCylinder(const Surface*, bool, double*, double*, double*)
+ const;
+ void
+ transformGlobalToLine(const Surface*, bool, double*, double*, double*) const;
+
+ /////////////////////////////////////////////////////////////////////////////////
+ // Covariance matrix production for TrackParameters
+ /////////////////////////////////////////////////////////////////////////////////
+ ActsSymMatrixD<5>*
+ newCovarianceMatrix(double*, const ActsSymMatrixD<5>&) const;
+
+ /////////////////////////////////////////////////////////////////////////////////
+ // Transformations from curvilinear to global system coordinates
+ // covariance matrix only
+ /////////////////////////////////////////////////////////////////////////////////
+ void
+ transformCurvilinearToGlobal(double*, double*) const;
+
+ /////////////////////////////////////////////////////////////////////////////////
+ // Transformations from global to curvilinear system coordinates
+ // covariance matrix only
+ /////////////////////////////////////////////////////////////////////////////////
+ void
+ transformGlobalToCurvilinear(bool, double*, double*, double*) const;
+
+ /////////////////////////////////////////////////////////////////////////////////
+ // Jacobian of transformations from curvilinear to local system coordinates
+ /////////////////////////////////////////////////////////////////////////////////
+ void
+ jacobianTransformCurvilinearToLocal(const TrackParameters&, double*);
+ void
+ jacobianTransformCurvilinearToLocal(double*, const Surface*, double*);
+ void
+ jacobianTransformCurvilinearToDisc(double*, double*) const;
+ void
+ jacobianTransformCurvilinearToPlane(double*, double*) const;
+ void
+ jacobianTransformCurvilinearToCylinder(double*, double*) const;
+ void
+ jacobianTransformCurvilinearToStraightLine(double*, double*) const;
+
+private:
+ /////////////////////////////////////////////////////////////////////////////////
+ // Private methods:
+ /////////////////////////////////////////////////////////////////////////////////
+
+ bool
+ transformLocalToGlobal(bool, const Surface*, const double*, double*) const;
+};
+} // end of namespace
+
+#endif // ACTS_EXTRAPOLATIONUTILS_RUNGEKUTTAUTILS_H
diff --git a/Core/include/ACTS/Extrapolation/detail/StaticEngine.ipp b/Core/include/ACTS/Extrapolation/detail/StaticEngine.ipp
index 25f505bd5..5c8a05f31 100644
--- a/Core/include/ACTS/Extrapolation/detail/StaticEngine.ipp
+++ b/Core/include/ACTS/Extrapolation/detail/StaticEngine.ipp
@@ -3,411 +3,647 @@
///////////////////////////////////////////////////////////////////
// Extrapolation module
-#include "ACTS/Extrapolation/INavigationEngine.hpp"
-#include "ACTS/Extrapolation/IPropagationEngine.hpp"
-#include "ACTS/Extrapolation/IMaterialEffectsEngine.hpp"
-#include "ACTS/Surfaces/Surface.hpp"
#include "ACTS/Detector/TrackingGeometry.hpp"
#include "ACTS/Detector/TrackingVolume.hpp"
+#include "ACTS/Extrapolation/IMaterialEffectsEngine.hpp"
+#include "ACTS/Extrapolation/INavigationEngine.hpp"
+#include "ACTS/Extrapolation/IPropagationEngine.hpp"
#include "ACTS/Layers/Layer.hpp"
+#include "ACTS/Surfaces/Surface.hpp"
// STD
-#include <iostream>
#include <iomanip>
+#include <iostream>
-template <class T> Acts::ExtrapolationCode Acts::StaticEngine::extrapolateT(Acts::ExtrapolationCell<T>& eCell,
- const Acts::Surface* sf,
- Acts::PropDirection pDir,
- const Acts::BoundaryCheck& bcheck) const
+template <class T>
+Acts::ExtrapolationCode
+Acts::StaticEngine::extrapolateT(Acts::ExtrapolationCell<T>& eCell,
+ const Acts::Surface* sf,
+ Acts::PropDirection pDir,
+ const Acts::BoundaryCheck& bcheck) const
{
- Acts::ExtrapolationCode eCode = Acts::ExtrapolationCode::InProgress;
- // ---- [0] check the direct propagation exit
- //
- // obviously need a surface to exercise the fallback & need to be configured to do so
- if (sf && eCell.checkConfigurationMode(Acts::ExtrapolationMode::Destination)){
- EX_MSG_DEBUG(++eCell.navigationStep, "extrapolate", "", "direct extapolation in volume : " << eCell.leadVolume->volumeName());
- // propagate to the surface, possible return codes are : SuccessPathLimit, SucessDestination, FailureDestination
- eCode = m_config.propagationEngine->propagate(eCell,*sf,pDir,ExtrapolationMode::Destination,bcheck,eCell.destinationCurvilinear);
- // eCode can be directly returned
- return eCode;
- }
- EX_MSG_DEBUG(++eCell.navigationStep, "extrapolate", "", "extrapolation in static environment in volume : " << eCell.leadVolume->volumeName());
- // evoke or finish the navigation initialization, possible return codes are:
- // - InProgress : everything is fine, extrapolation in static volume is in progress
- // - FailureNavigation : navigation setup could not be resolved, but reovery was not configured
- // - Recovered : navigation setup could not be resolved, recovery by fallback to directly kicked in (and worked)
- eCode = initNavigationT<T>(eCell,sf,pDir,bcheck);
- CHECK_ECODE_CONTINUE(eCell, eCode);
- // ----- [1] handle the ( leadLayer == endLayer )case :
- //
- // - this case does not need a layer to layer loop
- if (sf && eCell.leadLayer == eCell.endLayer && eCell.initialVolume()){
- // screen output for startLayer == endLayer
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", eCell.leadLayer->geoID().value(), "start and destination layer are identical -> jumping to final propagation.");
- // set the leadLayerSurface to the parameters surface
- eCell.leadLayerSurface = &(eCell.leadParameters->associatedSurface());
- // resolve the layer, it is the final extrapolation
- // - InProgress : layer resolving went without problem
- // - SuccessPathLimit : path limit reached & configured to stop (rather unlikely within a layer)
- // - SuccessMaterialLimit : material limit reached & configured to stop there
- // if the lead layer is also the startLayer found by initialization -> no material handling
- eCode = resolveLayerT<T>(eCell,
- sf,
- pDir,
- bcheck,
- eCell.leadLayer->hasSubStructure(eCell.checkConfigurationMode(Acts::ExtrapolationMode::CollectSensitive)),
- (eCell.leadLayer == eCell.startLayer && eCell.leadVolume == eCell.startVolume),
- true);
- // Success triggers a return
- CHECK_ECODE_SUCCESS_NODEST(eCell, eCode);
- // extrapolation to destination was not successful
- // - handle the return as configured (e.g. fallback)
- return handleReturnT<T>(eCode, eCell, sf, pDir, bcheck);
- }
- // ----- [2] now do the layer-to-layer loop
- //
- // the volume returns the layers ordered by distance :
- // - give potential start and end layer (latter only for the final volume)
- // - start and end layer will be part of the loop
- // - surface on approach is not yet resolved
- const Acts::Layer* fLayer = eCell.finalVolumeReached() ? eCell.endLayer : nullptr;
- auto layerIntersections = eCell.leadVolume->layerCandidatesOrdered(eCell.leadLayer, fLayer,
- *eCell.leadParameters,
- pDir,
- true);
-
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", "loop", "found " << layerIntersections.size() << " layers for the layer-to-layer loop.");
- // layer-to-layer loop starts here
- for (auto& layerCandidate : layerIntersections ) {
- // assign the leadLayer
- eCell.leadLayer = layerCandidate.object;
- // screen output for layer-to-layer loop
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", "loop", "processing layer with index : " << eCell.leadLayer->geoID().value());
- // resolve the approach surface situation
- // - it is the approaching surface for all layers but the very first one (where it's the parameter surface)
- eCell.leadLayerSurface = (eCell.leadLayer == eCell.startLayer) ? &(eCell.leadParameters->associatedSurface()) :
- (eCell.leadLayer->surfaceOnApproach(eCell.leadParameters->position(),
- eCell.leadParameters->momentum(),
- pDir,
- true,
- true)).object;
- // handle the layer, possible returns are :
- // - InProgress : fine, whatever happened on the lead layer, may also be missed
- // - SuccessWithPathLimit : propagation towards layer exceeded path limit
- // - SuccessWithMaterialLimit : material interaction killed track
- // - FailureDestination : destination was not hit appropriately
- eCode = handleLayerT<T>(eCell, sf, pDir, bcheck);
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", layerCandidate.object->geoID().value(), "handleLayerT returned extrapolation code : " << eCode.toString());
- // Possibilities are:
- // - SuccessX -> return (via handleReturnT)
- // - FailureX -> return (via handleReturnT that might evoke a fallback)
- // - InProgess -> continue layer-to-layer loop
- if (!eCode.inProgress()) return handleReturnT<T>(eCode, eCell, sf, pDir, bcheck);
- }
- // the layer 2 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
- //
- // the navigaiton engine ca trigger different return codes
- // - InProgress : fine, boundary surface has been found
- // - SuccessWithPathLimit : propagation towards boundary surface exceeded path limit
- // - FailureLoop/Navigation : problem in boundary resolving
- eCode = m_config.navigationEngine->resolveBoundary(eCell, pDir);
- // SuccessX and FailureX trigger a return
+ Acts::ExtrapolationCode eCode = Acts::ExtrapolationCode::InProgress;
+ // ---- [0] check the direct propagation exit
+ //
+ // obviously need a surface to exercise the fallback & need to be configured
+ // to do so
+ if (sf
+ && eCell.checkConfigurationMode(Acts::ExtrapolationMode::Destination)) {
+ EX_MSG_DEBUG(
+ ++eCell.navigationStep,
+ "extrapolate",
+ "",
+ "direct extapolation in volume : " << eCell.leadVolume->volumeName());
+ // propagate to the surface, possible return codes are : SuccessPathLimit,
+ // SucessDestination, FailureDestination
+ eCode
+ = m_config.propagationEngine->propagate(eCell,
+ *sf,
+ pDir,
+ ExtrapolationMode::Destination,
+ bcheck,
+ eCell.destinationCurvilinear);
+ // eCode can be directly returned
+ return eCode;
+ }
+ EX_MSG_DEBUG(++eCell.navigationStep,
+ "extrapolate",
+ "",
+ "extrapolation in static environment in volume : "
+ << eCell.leadVolume->volumeName());
+ // evoke or finish the navigation initialization, possible return codes are:
+ // - InProgress : everything is fine, extrapolation in static volume is
+ // in progress
+ // - FailureNavigation : navigation setup could not be resolved, but reovery
+ // was not configured
+ // - Recovered : navigation setup could not be resolved, recovery by
+ // fallback to directly kicked in (and worked)
+ eCode = initNavigationT<T>(eCell, sf, pDir, bcheck);
+ CHECK_ECODE_CONTINUE(eCell, eCode);
+ // ----- [1] handle the ( leadLayer == endLayer )case :
+ //
+ // - this case does not need a layer to layer loop
+ if (sf && eCell.leadLayer == eCell.endLayer && eCell.initialVolume()) {
+ // screen output for startLayer == endLayer
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "layer",
+ eCell.leadLayer->geoID().value(),
+ "start and destination layer are identical -> jumping to "
+ "final propagation.");
+ // set the leadLayerSurface to the parameters surface
+ eCell.leadLayerSurface = &(eCell.leadParameters->associatedSurface());
+ // resolve the layer, it is the final extrapolation
+ // - InProgress : layer resolving went without problem
+ // - SuccessPathLimit : path limit reached & configured to stop (rather
+ // unlikely within a layer)
+ // - SuccessMaterialLimit : material limit reached & configured to stop
+ // there
+ // if the lead layer is also the startLayer found by initialization -> no
+ // material handling
+ eCode = resolveLayerT<T>(
+ eCell,
+ sf,
+ pDir,
+ bcheck,
+ eCell.leadLayer->hasSubStructure(eCell.checkConfigurationMode(
+ Acts::ExtrapolationMode::CollectSensitive)),
+ (eCell.leadLayer == eCell.startLayer
+ && eCell.leadVolume == eCell.startVolume),
+ true);
+ // Success triggers a return
CHECK_ECODE_SUCCESS_NODEST(eCell, eCode);
- // handle the return of the boudnary resolving
- return handleReturnT<T>(eCode, eCell, sf, pDir, bcheck);
+ // extrapolation to destination was not successful
+ // - handle the return as configured (e.g. fallback)
+ return handleReturnT<T>(eCode, eCell, sf, pDir, bcheck);
+ }
+ // ----- [2] now do the layer-to-layer loop
+ //
+ // the volume returns the layers ordered by distance :
+ // - give potential start and end layer (latter only for the final volume)
+ // - start and end layer will be part of the loop
+ // - surface on approach is not yet resolved
+ const Acts::Layer* fLayer
+ = eCell.finalVolumeReached() ? eCell.endLayer : nullptr;
+ auto layerIntersections = eCell.leadVolume->layerCandidatesOrdered(
+ eCell.leadLayer, fLayer, *eCell.leadParameters, pDir, true);
+
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "layer",
+ "loop",
+ "found " << layerIntersections.size()
+ << " layers for the layer-to-layer loop.");
+ // layer-to-layer loop starts here
+ for (auto& layerCandidate : layerIntersections) {
+ // assign the leadLayer
+ eCell.leadLayer = layerCandidate.object;
+ // screen output for layer-to-layer loop
+ EX_MSG_VERBOSE(
+ eCell.navigationStep,
+ "layer",
+ "loop",
+ "processing layer with index : " << eCell.leadLayer->geoID().value());
+ // resolve the approach surface situation
+ // - it is the approaching surface for all layers but the very first one
+ // (where it's the parameter surface)
+ eCell.leadLayerSurface = (eCell.leadLayer == eCell.startLayer)
+ ? &(eCell.leadParameters->associatedSurface())
+ : (eCell.leadLayer->surfaceOnApproach(eCell.leadParameters->position(),
+ eCell.leadParameters->momentum(),
+ pDir,
+ true,
+ true))
+ .object;
+ // handle the layer, possible returns are :
+ // - InProgress : fine, whatever happened on the lead layer,
+ // may also be missed
+ // - SuccessWithPathLimit : propagation towards layer exceeded path
+ // limit
+ // - SuccessWithMaterialLimit : material interaction killed track
+ // - FailureDestination : destination was not hit appropriately
+ eCode = handleLayerT<T>(eCell, sf, pDir, bcheck);
+ EX_MSG_VERBOSE(
+ eCell.navigationStep,
+ "layer",
+ layerCandidate.object->geoID().value(),
+ "handleLayerT returned extrapolation code : " << eCode.toString());
+ // Possibilities are:
+ // - SuccessX -> return (via handleReturnT)
+ // - FailureX -> return (via handleReturnT that might evoke a fallback)
+ // - InProgess -> continue layer-to-layer loop
+ if (!eCode.inProgress())
+ return handleReturnT<T>(eCode, eCell, sf, pDir, bcheck);
+ }
+ // the layer 2 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
+ //
+ // the navigaiton engine ca trigger different return codes
+ // - InProgress : fine, boundary surface has been found
+ // - SuccessWithPathLimit : propagation towards boundary surface
+ // exceeded path limit
+ // - FailureLoop/Navigation : problem in boundary resolving
+ eCode = m_config.navigationEngine->resolveBoundary(eCell, pDir);
+ // SuccessX and FailureX trigger a return
+ CHECK_ECODE_SUCCESS_NODEST(eCell, eCode);
+ // handle the return of the boudnary resolving
+ return handleReturnT<T>(eCode, eCell, sf, pDir, bcheck);
}
-template <class T> Acts::ExtrapolationCode Acts::StaticEngine::initNavigationT(Acts::ExtrapolationCell<T>& eCell,
- const Acts::Surface* sf,
- Acts::PropDirection pDir,
- const Acts::BoundaryCheck& bcheck) const
+template <class T>
+Acts::ExtrapolationCode
+Acts::StaticEngine::initNavigationT(Acts::ExtrapolationCell<T>& eCell,
+ const Acts::Surface* sf,
+ Acts::PropDirection pDir,
+ const Acts::BoundaryCheck& bcheck) const
{
- // initialize the Navigation stream ----------------------------------------------------------------------------------------
- //
- // this is the global initialization, it only associated direct objects
- // detailed navigation search needs to be done by the sub engines (since they know best)
- EX_MSG_DEBUG(++eCell.navigationStep, "navigation", "", "complete for static environment.");
- // [A] the initial volume
- if (eCell.startVolume == eCell.leadVolume && eCell.startLayer) {
- // - found the initial start layer through association
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "this is the initial volume, everything set up already.");
- // assigning it to the leadLayer
- eCell.leadLayer = eCell.startLayer;
- // return progress
- return Acts::ExtrapolationCode::InProgress;
- }
- // [B] any volume if we don't have a leadLayer
- if (!eCell.leadLayer){
- // - finding it through global search, never a boundary layer ... convention says that you update by exit
- eCell.leadLayer = eCell.leadVolume->associatedLayer(eCell.leadParameters->position());
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "no start layer found yet, looking for it ..." << OH_CHECKFOUND(eCell.leadLayer) );
- }
- // [C] the final volume - everything's fine
- if (eCell.leadVolume == eCell.endVolume && sf) {
- if (eCell.endLayer) {
- // the end layer had been found already by association
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "this is the final volume, everything set up already.");
- return Acts::ExtrapolationCode::InProgress;
- } else {
- // make a straight line intersection
- Acts::Intersection sfI = sf->intersectionEstimate(eCell.leadParameters->position(), pDir*eCell.leadParameters->momentum(), true);
- // use this to find endVolume and endLayer
- eCell.endLayer = eCell.leadVolume->associatedLayer(sfI.position);
- // if you have a surface you need to require an end layer for the validation, otherwise you need to do a fallbac
- return eCell.endLayer ? Acts::ExtrapolationCode::InProgress : handleReturnT<T>(Acts::ExtrapolationCode::FailureNavigation, eCell, sf, pDir, bcheck);
- }
- }
- // return that you're in progress
- return Acts::ExtrapolationCode::InProgress;
+ // initialize the Navigation stream
+ // ----------------------------------------------------------------------------------------
+ //
+ // this is the global initialization, it only associated direct objects
+ // detailed navigation search needs to be done by the sub engines (since they
+ // know best)
+ EX_MSG_DEBUG(++eCell.navigationStep,
+ "navigation",
+ "",
+ "complete for static environment.");
+ // [A] the initial volume
+ if (eCell.startVolume == eCell.leadVolume && eCell.startLayer) {
+ // - found the initial start layer through association
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "navigation",
+ "",
+ "this is the initial volume, everything set up already.");
+ // assigning it to the leadLayer
+ eCell.leadLayer = eCell.startLayer;
+ // return progress
+ return Acts::ExtrapolationCode::InProgress;
+ }
+ // [B] any volume if we don't have a leadLayer
+ if (!eCell.leadLayer) {
+ // - finding it through global search, never a boundary layer ... convention
+ // says that you update by exit
+ eCell.leadLayer
+ = eCell.leadVolume->associatedLayer(eCell.leadParameters->position());
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "navigation",
+ "",
+ "no start layer found yet, looking for it ..."
+ << OH_CHECKFOUND(eCell.leadLayer));
+ }
+ // [C] the final volume - everything's fine
+ if (eCell.leadVolume == eCell.endVolume && sf) {
+ if (eCell.endLayer) {
+ // the end layer had been found already by association
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "navigation",
+ "",
+ "this is the final volume, everything set up already.");
+ return Acts::ExtrapolationCode::InProgress;
+ } else {
+ // make a straight line intersection
+ Acts::Intersection sfI
+ = sf->intersectionEstimate(eCell.leadParameters->position(),
+ pDir * eCell.leadParameters->momentum(),
+ true);
+ // use this to find endVolume and endLayer
+ eCell.endLayer = eCell.leadVolume->associatedLayer(sfI.position);
+ // if you have a surface you need to require an end layer for the
+ // validation, otherwise you need to do a fallbac
+ return eCell.endLayer
+ ? Acts::ExtrapolationCode::InProgress
+ : handleReturnT<T>(Acts::ExtrapolationCode::FailureNavigation,
+ eCell,
+ sf,
+ pDir,
+ bcheck);
+ }
+ }
+ // return that you're in progress
+ return Acts::ExtrapolationCode::InProgress;
}
/** handle the layer */
-template <class T> Acts::ExtrapolationCode Acts::StaticEngine::handleLayerT(Acts::ExtrapolationCell<T>& eCell,
- const Acts::Surface* sf,
- Acts::PropDirection pDir,
- const Acts::BoundaryCheck& bcheck) const
-{
- Acts::ExtrapolationCode eCode = Acts::ExtrapolationCode::InProgress;
- EX_MSG_DEBUG(++eCell.navigationStep, "layer", eCell.leadLayer->geoID().value(), "handle this layer" );
- // layer has sub structure - this can be (and the layer will tell you):
- // - sensitive surface which should be tried to hit
- // - material sub structure to be resolved (independent of sensitive surface)
- bool hasSubStructure = eCell.leadLayer->hasSubStructure(eCell.checkConfigurationMode(Acts::ExtrapolationMode::CollectSensitive));
- // [A] layer is a pure navigation layer and has no sub structure -> skip it, but only if it is not the final layer
- if (!hasSubStructure && !eCell.leadLayer->geoID().value() && eCell.leadLayer != eCell.endLayer){
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", eCell.leadLayer->geoID().value(), "layer is a navigation layer -> skipping it ...");
- return Acts::ExtrapolationCode::InProgress;
- }
- // [B] layer resolving is necessary -> resolve it
- // - (a) layer has sub structure - this can be (and the layer will tell you):
- // - sensitive surface which should be tried to hit
- // - material sub structure to be resolved (independent of sensitive surface)
- // - (b) layer is start layer (can not be if there was a volume switch)
- bool isStartLayer = eCell.initialVolume() && eCell.leadLayer->onLayer(*eCell.leadParameters);
- // - (c) layer is destination layer
- // - final propagation to the layer and update if necessary
- bool isDestinationLayer = (sf && eCell.leadLayer == eCell.endLayer);
- // sub structure, start and destination need resolving of the layer setp
- if (hasSubStructure || isStartLayer || isDestinationLayer ){
- // screen output for sub strucutred layer
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", eCell.leadLayer->geoID().value(), "has sub structure, is start layer, or destination layer -> resolving it ..." );
- // resolve the layer, it handles all possible return types and gives them directly to extrapolateT<T>
- // - InProgress : layer resolving went without problem
- // - SuccessPathLimit : path limit reached & configured to stop
- // - SuccessMaterialLimit : material limit reached & configured to stop there
- // - SuccessDestination : destination reached & everything is fine
- return resolveLayerT<T>(eCell,sf,pDir,bcheck,hasSubStructure,isStartLayer,isDestinationLayer);
- }
- // [C] layer is a material layer without sub structure but material -> pass through
- // no resolving ob sub structure to be done, an intermediate layer to be crossed
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", eCell.leadLayer->geoID().value(), "intermediate layer without sub structure -> passing through ...");
- // propagate to it, possible return codes ( with the default of finalPropagation = false):
- // - SuccessPathLimit : propagation to layer exceeded path limit
- // - InProgress : layer was hit successfuly, try to handle the material and sub structure, these are new parameters
- // - Recovered : layer was not hit, so can be ignored in the layer to layer loop
- eCode = m_config.propagationEngine->propagate(eCell,*eCell.leadLayerSurface,pDir,ExtrapolationMode::CollectPassive,true,eCell.navigationCurvilinear);
- CHECK_ECODE_SUCCESS_NODEST(eCell, eCode);
- // check if the layer was actually hit
- if (eCode.inProgress()){
- // successful layer hit
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", eCell.leadLayer->geoID().value(), "has been succesful hit, handling material update.");
- // layer has no sub-structure : it is an intermediate layer that just needs pass-throgh
- // return possbilities:
- // - InProgress : material update performed or not (depending on material)
- // - SuccessMaterialLimit : material limit reached & configured to stop there
- eCode = m_config.materialEffectsEngine->handleMaterial(eCell,pDir,Acts::fullUpdate);
- CHECK_ECODE_CONTINUE(eCell, eCode);
- // return the progress eCode back to the extrapolateT
- return eCode;
- }
- // hit or not hit : it's always in progress since we are in the layer to layer loop
- return Acts::ExtrapolationCode::InProgress;
-}
-
+template <class T>
+Acts::ExtrapolationCode
+Acts::StaticEngine::handleLayerT(Acts::ExtrapolationCell<T>& eCell,
+ const Acts::Surface* sf,
+ Acts::PropDirection pDir,
+ const Acts::BoundaryCheck& bcheck) const
+{
+ Acts::ExtrapolationCode eCode = Acts::ExtrapolationCode::InProgress;
+ EX_MSG_DEBUG(++eCell.navigationStep,
+ "layer",
+ eCell.leadLayer->geoID().value(),
+ "handle this layer");
+ // layer has sub structure - this can be (and the layer will tell you):
+ // - sensitive surface which should be tried to hit
+ // - material sub structure to be resolved (independent of sensitive
+ // surface)
+ bool hasSubStructure = eCell.leadLayer->hasSubStructure(
+ eCell.checkConfigurationMode(Acts::ExtrapolationMode::CollectSensitive));
+ // [A] layer is a pure navigation layer and has no sub structure -> skip it,
+ // but only if it is not the final layer
+ if (!hasSubStructure && !eCell.leadLayer->geoID().value()
+ && eCell.leadLayer != eCell.endLayer) {
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "layer",
+ eCell.leadLayer->geoID().value(),
+ "layer is a navigation layer -> skipping it ...");
+ return Acts::ExtrapolationCode::InProgress;
+ }
+ // [B] layer resolving is necessary -> resolve it
+ // - (a) layer has sub structure - this can be (and the layer will tell you):
+ // - sensitive surface which should be tried to hit
+ // - material sub structure to be resolved (independent of sensitive
+ // surface)
+ // - (b) layer is start layer (can not be if there was a volume switch)
+ bool isStartLayer = eCell.initialVolume()
+ && eCell.leadLayer->onLayer(*eCell.leadParameters);
+ // - (c) layer is destination layer
+ // - final propagation to the layer and update if necessary
+ bool isDestinationLayer = (sf && eCell.leadLayer == eCell.endLayer);
+ // sub structure, start and destination need resolving of the layer setp
+ if (hasSubStructure || isStartLayer || isDestinationLayer) {
+ // screen output for sub strucutred layer
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "layer",
+ eCell.leadLayer->geoID().value(),
+ "has sub structure, is start layer, or destination layer -> "
+ "resolving it ...");
+ // resolve the layer, it handles all possible return types and gives them
+ // directly to extrapolateT<T>
+ // - InProgress : layer resolving went without problem
+ // - SuccessPathLimit : path limit reached & configured to stop
+ // - SuccessMaterialLimit : material limit reached & configured to stop
+ // there
+ // - SuccessDestination : destination reached & everything is fine
+ return resolveLayerT<T>(eCell,
+ sf,
+ pDir,
+ bcheck,
+ hasSubStructure,
+ isStartLayer,
+ isDestinationLayer);
+ }
+ // [C] layer is a material layer without sub structure but material -> pass
+ // through
+ // no resolving ob sub structure to be done, an intermediate layer to be
+ // crossed
+ EX_MSG_VERBOSE(
+ eCell.navigationStep,
+ "layer",
+ eCell.leadLayer->geoID().value(),
+ "intermediate layer without sub structure -> passing through ...");
+ // propagate to it, possible return codes ( with the default of
+ // finalPropagation = false):
+ // - SuccessPathLimit : propagation to layer exceeded path limit
+ // - InProgress : layer was hit successfuly, try to handle the
+ // material and sub structure, these are new parameters
+ // - Recovered : layer was not hit, so can be ignored in the
+ // layer to layer loop
+ eCode
+ = m_config.propagationEngine->propagate(eCell,
+ *eCell.leadLayerSurface,
+ pDir,
+ ExtrapolationMode::CollectPassive,
+ true,
+ eCell.navigationCurvilinear);
+ CHECK_ECODE_SUCCESS_NODEST(eCell, eCode);
+ // check if the layer was actually hit
+ if (eCode.inProgress()) {
+ // successful layer hit
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "layer",
+ eCell.leadLayer->geoID().value(),
+ "has been succesful hit, handling material update.");
+ // layer has no sub-structure : it is an intermediate layer that just needs
+ // pass-throgh
+ // return possbilities:
+ // - InProgress : material update performed or not (depending on
+ // material)
+ // - SuccessMaterialLimit : material limit reached & configured to stop
+ // there
+ eCode = m_config.materialEffectsEngine->handleMaterial(
+ eCell, pDir, Acts::fullUpdate);
+ CHECK_ECODE_CONTINUE(eCell, eCode);
+ // return the progress eCode back to the extrapolateT
+ return eCode;
+ }
+ // hit or not hit : it's always in progress since we are in the layer to layer
+ // loop
+ return Acts::ExtrapolationCode::InProgress;
+}
-/** main sub structure layer handling */
-template <class T> Acts::ExtrapolationCode Acts::StaticEngine::resolveLayerT(Acts::ExtrapolationCell<T>& eCell,
- const Acts::Surface* sf,
- Acts::PropDirection pDir,
- const Acts::BoundaryCheck& bcheck,
- bool hasSubStructure,
- bool isStartLayer,
- bool isDestinationLayer) const
+/** main sub structure layer handling */
+template <class T>
+Acts::ExtrapolationCode
+Acts::StaticEngine::resolveLayerT(Acts::ExtrapolationCell<T>& eCell,
+ const Acts::Surface* sf,
+ Acts::PropDirection pDir,
+ const Acts::BoundaryCheck& bcheck,
+ bool hasSubStructure,
+ bool isStartLayer,
+ bool isDestinationLayer) const
{
- Acts::ExtrapolationCode eCode = Acts::ExtrapolationCode::InProgress;
- EX_MSG_DEBUG(++eCell.navigationStep, "layer", eCell.leadLayer->geoID().value(), "resolve it with" << (hasSubStructure ? " " : "out ") << "sub structure"
- << (isDestinationLayer ? " -> destination layer." : (isStartLayer ? " -> start layer." : "") ) );
-
- // cache the leadLayer - this is needed for the layer-to-layer loop not to be broken
- const Acts::Layer* initialLayer = eCell.leadLayer;
- // ----- [0] the start situation on the layer needs to be resolved:
- // - either for sensitive parameters
- // - or for material substructure
- // [A] the layer is not the start layer and not the destination layer
- // - the surfaceOnApproach() call should have sorted out that this is actually an approaching representation
- // - the destination layer is excluded from the propagation because it can lead to punch-through to the other side of layers
- if (!isStartLayer && !isDestinationLayer){
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", eCell.leadLayer->geoID().value(), "not the start layer (with sub structue), propagate to it.");
- // propagate to the representing surface of this layer
- // - InProgress : propagation to approaching surface worked - check material update
- // - SuccessPathLimit : propagation to approaching surface reached the path limit
- // - Recovered : layer was not hit, so can be ignored in the layer to layer loop
- eCode = m_config.propagationEngine->propagate(eCell,*eCell.leadLayerSurface,pDir,ExtrapolationMode::CollectPassive,true,eCell.sensitiveCurvilinear);
- CHECK_ECODE_SUCCESS_NODEST(eCell,eCode);
- // the extrapolation to the initial layer did not succeed - skip this layer in the layer-to-layer loop
- if (eCode == Acts::ExtrapolationCode::Recovered) {
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", eCell.leadLayer->geoID().value(), "has not been hit, skipping it.");
- return Acts::ExtrapolationCode::InProgress;
- }
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", eCell.leadLayer->geoID().value(), "successfuly hit.");
- // the correct material layer needs to be assigned - in case of the approach surface not being hit, his can be the layer surface
- if (eCell.leadLayerSurface->surfaceMaterial() ){
- // set the material surface for the update
- eCell.materialSurface = eCell.leadLayerSurface;
- // now handle the material (full update when passing approach surface), return codes are:
- // - SuccessMaterialLimit : material limit reached, return back
- // - InProgress : material update done or not (depending on the material description)
- eCode = m_config.materialEffectsEngine->handleMaterial(eCell,pDir,Acts::fullUpdate);
- CHECK_ECODE_CONTINUE(eCell, eCode);
- }
- } else if (isStartLayer) {
- // [B] the layer is the start layer
- // - let's check if a post update on the start surface has to be done
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", eCell.leadLayer->geoID().value(), "start layer (with sub structure), no propagation to be done.");
- // the start surface could have a material layer attached
- if (eCell.leadParameters->associatedSurface().surfaceMaterial()){
- // set the material surface
- eCell.materialSurface = &(eCell.leadParameters->associatedSurface());
- // now handle the material (post update on start layer), return codes are:
- // - SuccessMaterialLimit : material limit reached, return back
- // - InProgress : material update done or not (depending on the material description)
- eCode = m_config.materialEffectsEngine->handleMaterial(eCell,pDir,Acts::postUpdate);
- CHECK_ECODE_CONTINUE(eCell, eCode);
- // let's reset the lead layer
- eCell.leadLayer = initialLayer;
- }
- }
- // ----- [1] the sub structure of the layer needs to be resolved:
- // resolve the substructure
- std::vector<Acts::SurfaceIntersection> cSurfaces;
- // this will give you the compatible surfaces of the layer : provided start and destination surface are excluded
- // - surfaces without material are only provided if they are active and CollectSensitive is configured
- // - surfaces with material are provided in order to make the necessary material update
- bool orderedSurfaces = eCell.leadLayer->compatibleSurfaces(cSurfaces,
- *eCell.leadParameters,
- pDir,
- bcheck,
- eCell.checkConfigurationMode(ExtrapolationMode::CollectSensitive),
- eCell.checkConfigurationMode(ExtrapolationMode::CollectPassive),
- eCell.searchMode,
- (isStartLayer ? &(eCell.leadParameters->associatedSurface()) : eCell.leadLayerSurface),
- (isDestinationLayer ? sf : 0) );
- // how many test surfaces do we have
- size_t ncSurfaces = cSurfaces.size();
- // some screen output for the sub structure
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", eCell.leadLayer->geoID().value(), "found " << ncSurfaces << " sub structure surfaces to test.");
- // check if you have to do something
- if (ncSurfaces){
+ Acts::ExtrapolationCode eCode = Acts::ExtrapolationCode::InProgress;
+ EX_MSG_DEBUG(
+ ++eCell.navigationStep,
+ "layer",
+ eCell.leadLayer->geoID().value(),
+ "resolve it with" << (hasSubStructure ? " " : "out ") << "sub structure"
+ << (isDestinationLayer
+ ? " -> destination layer."
+ : (isStartLayer ? " -> start layer." : "")));
+
+ // cache the leadLayer - this is needed for the layer-to-layer loop not to be
+ // broken
+ const Acts::Layer* initialLayer = eCell.leadLayer;
+ // ----- [0] the start situation on the layer needs to be resolved:
+ // - either for sensitive parameters
+ // - or for material substructure
+ // [A] the layer is not the start layer and not the destination layer
+ // - the surfaceOnApproach() call should have sorted out that this is actually
+ // an approaching representation
+ // - the destination layer is excluded from the propagation because it can
+ // lead to punch-through to the other side of layers
+ if (!isStartLayer && !isDestinationLayer) {
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "layer",
+ eCell.leadLayer->geoID().value(),
+ "not the start layer (with sub structue), propagate to it.");
+ // propagate to the representing surface of this layer
+ // - InProgress : propagation to approaching surface worked - check
+ // material update
+ // - SuccessPathLimit : propagation to approaching surface reached the path
+ // limit
+ // - Recovered : layer was not hit, so can be ignored in the layer to
+ // layer loop
+ eCode = m_config.propagationEngine->propagate(
+ eCell,
+ *eCell.leadLayerSurface,
+ pDir,
+ ExtrapolationMode::CollectPassive,
+ true,
+ eCell.sensitiveCurvilinear);
+ CHECK_ECODE_SUCCESS_NODEST(eCell, eCode);
+ // the extrapolation to the initial layer did not succeed - skip this layer
+ // in the layer-to-layer loop
+ if (eCode == Acts::ExtrapolationCode::Recovered) {
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "layer",
+ eCell.leadLayer->geoID().value(),
+ "has not been hit, skipping it.");
+ return Acts::ExtrapolationCode::InProgress;
+ }
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "layer",
+ eCell.leadLayer->geoID().value(),
+ "successfuly hit.");
+ // the correct material layer needs to be assigned - in case of the approach
+ // surface not being hit, his can be the layer surface
+ if (eCell.leadLayerSurface->surfaceMaterial()) {
+ // set the material surface for the update
+ eCell.materialSurface = eCell.leadLayerSurface;
+ // now handle the material (full update when passing approach surface),
+ // return codes are:
+ // - SuccessMaterialLimit : material limit reached, return back
+ // - InProgress : material update done or not (depending on the
+ // material description)
+ eCode = m_config.materialEffectsEngine->handleMaterial(
+ eCell, pDir, Acts::fullUpdate);
+ CHECK_ECODE_CONTINUE(eCell, eCode);
+ }
+ } else if (isStartLayer) {
+ // [B] the layer is the start layer
+ // - let's check if a post update on the start surface has to be done
+ EX_MSG_VERBOSE(
+ eCell.navigationStep,
+ "layer",
+ eCell.leadLayer->geoID().value(),
+ "start layer (with sub structure), no propagation to be done.");
+ // the start surface could have a material layer attached
+ if (eCell.leadParameters->associatedSurface().surfaceMaterial()) {
+ // set the material surface
+ eCell.materialSurface = &(eCell.leadParameters->associatedSurface());
+ // now handle the material (post update on start layer), return codes are:
+ // - SuccessMaterialLimit : material limit reached, return back
+ // - InProgress : material update done or not (depending on the
+ // material description)
+ eCode = m_config.materialEffectsEngine->handleMaterial(
+ eCell, pDir, Acts::postUpdate);
+ CHECK_ECODE_CONTINUE(eCell, eCode);
+ // let's reset the lead layer
+ eCell.leadLayer = initialLayer;
+ }
+ }
+ // ----- [1] the sub structure of the layer needs to be resolved:
+ // resolve the substructure
+ std::vector<Acts::SurfaceIntersection> cSurfaces;
+ // this will give you the compatible surfaces of the layer : provided start
+ // and destination surface are excluded
+ // - surfaces without material are only provided if they are active and
+ // CollectSensitive is configured
+ // - surfaces with material are provided in order to make the necessary
+ // material update
+ bool orderedSurfaces = eCell.leadLayer->compatibleSurfaces(
+ cSurfaces,
+ *eCell.leadParameters,
+ pDir,
+ bcheck,
+ eCell.checkConfigurationMode(ExtrapolationMode::CollectSensitive),
+ eCell.checkConfigurationMode(ExtrapolationMode::CollectPassive),
+ eCell.searchMode,
+ (isStartLayer ? &(eCell.leadParameters->associatedSurface())
+ : eCell.leadLayerSurface),
+ (isDestinationLayer ? sf : 0));
+ // how many test surfaces do we have
+ size_t ncSurfaces = cSurfaces.size();
+ // some screen output for the sub structure
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "layer",
+ eCell.leadLayer->geoID().value(),
+ "found " << ncSurfaces << " sub structure surfaces to test.");
+ // check if you have to do something
+ if (ncSurfaces) {
+ // if the search mode returns unordered surfaces :
+ // - it needs to cache the initial lead parameters
+ // - ATTENTION this invalidates the correct material estimate
+ const T* dbgLeadParameters = eCell.leadParameters;
+ // now loop over the surfaces:
+ // the surfaces will be sorted
+ for (auto& csf : cSurfaces) {
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "layer",
+ eCell.leadLayer->geoID().value(),
+ "trying candidate surfaces with straight line path length "
+ << csf.intersection.pathLength);
+ // record the parameters as sensitive or passive depending on the surface
+ Acts::ExtrapolationMode::eMode emode = csf.object->isActive()
+ ? Acts::ExtrapolationMode::CollectSensitive
+ : Acts::ExtrapolationMode::CollectPassive;
+ // propagate to the compatible surface, return types are
+ // - InProgress : propagation to compatible surface worked
+ // - Recovered : propagation to compatible surface did not work,
+ // leadParameters stay the same
+ // - SuccessPathLimit : propagation to compatible surface reached the path
+ // limit
+ eCode = m_config.propagationEngine->propagate(eCell,
+ *(csf.object),
+ pDir,
+ emode,
+ bcheck,
+ eCell.sensitiveCurvilinear);
+ CHECK_ECODE_SUCCESS_NODEST(eCell, eCode);
+ // check if the propagation was successful
+ if (eCode.inProgress()) {
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "layer",
+ eCell.leadLayer->geoID().value(),
+ "successfully hit sub structure surface.");
+ // check if the surface holds material and hence needs to be processed
+ if (csf.object->surfaceMaterial()) {
+ // set the material surface
+ eCell.materialSurface = csf.object;
+ // now handle the material, return codes are:
+ // - SuccessMaterialLimit : material limit reached,return back
+ // - InProgress : material update done or not (depending on
+ // the material description)
+ eCode = m_config.materialEffectsEngine->handleMaterial(
+ eCell, pDir, Acts::fullUpdate);
+ CHECK_ECODE_CONTINUE(eCell, eCode);
+ }
// if the search mode returns unordered surfaces :
- // - it needs to cache the initial lead parameters
// - ATTENTION this invalidates the correct material estimate
- const T* dbgLeadParameters = eCell.leadParameters;
- // now loop over the surfaces:
- // the surfaces will be sorted
- for (auto& csf : cSurfaces ) {
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", eCell.leadLayer->geoID().value(), "trying candidate surfaces with straight line path length " << csf.intersection.pathLength);
- // record the parameters as sensitive or passive depending on the surface
- Acts::ExtrapolationMode::eMode emode = csf.object->isActive() ? Acts::ExtrapolationMode::CollectSensitive : Acts::ExtrapolationMode::CollectPassive;
- // propagate to the compatible surface, return types are
- // - InProgress : propagation to compatible surface worked
- // - Recovered : propagation to compatible surface did not work, leadParameters stay the same
- // - SuccessPathLimit : propagation to compatible surface reached the path limit
- eCode = m_config.propagationEngine->propagate(eCell,*(csf.object),pDir,emode,bcheck,eCell.sensitiveCurvilinear);
- CHECK_ECODE_SUCCESS_NODEST(eCell,eCode);
- // check if the propagation was successful
- if (eCode.inProgress()){
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", eCell.leadLayer->geoID().value(), "successfully hit sub structure surface.");
- // check if the surface holds material and hence needs to be processed
- if ( csf.object->surfaceMaterial() ) {
- // set the material surface
- eCell.materialSurface = csf.object;
- // now handle the material, return codes are:
- // - SuccessMaterialLimit : material limit reached,return back
- // - InProgress : material update done or not (depending on the material description)
- eCode = m_config.materialEffectsEngine->handleMaterial(eCell,pDir,Acts::fullUpdate);
- CHECK_ECODE_CONTINUE(eCell, eCode);
- }
- // if the search mode returns unordered surfaces :
- // - ATTENTION this invalidates the correct material estimate
- if (!orderedSurfaces)
- eCell.leadParameters = dbgLeadParameters;
- }
-
- } // loop over test surfaces done
- } // there are compatible surfaces
+ if (!orderedSurfaces) eCell.leadParameters = dbgLeadParameters;
+ }
+
+ } // loop over test surfaces done
+ } // there are compatible surfaces
- // ----- [3] the destination situation on the layer needs to be resolved:
- // the layer is a destination layer
- // - the final propagation call is indepenent of whether sub structure was resolved or not
- // - the eCell.leadParameters are at the last possible parameters
- if (sf && isDestinationLayer) {
- // [B] the layer is start and destination layer but has no sub-structure
- // -> propagation to destination surface
- // (a) the starting layer is the same layer :
- // - neither preUpdate nore postUpdate to be done, this is old-style within-layer extrapolation
- // - material will be taken into account either when the layer was reached from another layer
- // or when the layer is left to another destination
- // (b) the starting layer is not the same layer :
- // - apply the preUpdate on the parameters whein they reached the surface
- // Possible return types:
- // - SuccessDestination : great, desintation surface hit - but post-update needs to be done
- // - SuccessPathLimit : pathlimit was reached on the way to the destination surface
- eCode = m_config.propagationEngine->propagate(eCell,*sf,pDir,ExtrapolationMode::Destination,false,eCell.destinationCurvilinear);
- // check for success return path limit
- CHECK_ECODE_SUCCESS_NODEST(eCell,eCode);
- EX_MSG_VERBOSE(eCell.navigationStep, "layer", eCell.leadLayer->geoID().value(), "attempt to hit destination surface resulted in " << eCode.toString() );
- // check for a potential preUpdate
- // - in case teh destination surface has material and the surface was hit
- if ( sf->surfaceMaterial() && eCode.isSuccess() ){
- // set the material surface for the update
- eCell.materialSurface = sf;
- // finally do the material update, but even as this is the final call
- // - still check for SuccessMaterialLimit
- m_config.materialEffectsEngine->handleMaterial(eCell,pDir,Acts::preUpdate);
- // check if success was triggered through path limit reached on the way to the layer
- CHECK_ECODE_SUCCESS(eCell,eCode);
- }
- // return what you have handleLayerT or extrapolateT will resolve that
- return eCode;
+ // ----- [3] the destination situation on the layer needs to be resolved:
+ // the layer is a destination layer
+ // - the final propagation call is indepenent of whether sub structure was
+ // resolved or not
+ // - the eCell.leadParameters are at the last possible parameters
+ if (sf && isDestinationLayer) {
+ // [B] the layer is start and destination layer but has no sub-structure
+ // -> propagation to destination surface
+ // (a) the starting layer is the same layer :
+ // - neither preUpdate nore postUpdate to be done, this is old-style
+ // within-layer extrapolation
+ // - material will be taken into account either when the layer was reached
+ // from another layer
+ // or when the layer is left to another destination
+ // (b) the starting layer is not the same layer :
+ // - apply the preUpdate on the parameters whein they reached the surface
+ // Possible return types:
+ // - SuccessDestination : great, desintation surface hit - but post-update
+ // needs to be done
+ // - SuccessPathLimit : pathlimit was reached on the way to the
+ // destination surface
+ eCode
+ = m_config.propagationEngine->propagate(eCell,
+ *sf,
+ pDir,
+ ExtrapolationMode::Destination,
+ false,
+ eCell.destinationCurvilinear);
+ // check for success return path limit
+ CHECK_ECODE_SUCCESS_NODEST(eCell, eCode);
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "layer",
+ eCell.leadLayer->geoID().value(),
+ "attempt to hit destination surface resulted in "
+ << eCode.toString());
+ // check for a potential preUpdate
+ // - in case teh destination surface has material and the surface was hit
+ if (sf->surfaceMaterial() && eCode.isSuccess()) {
+ // set the material surface for the update
+ eCell.materialSurface = sf;
+ // finally do the material update, but even as this is the final call
+ // - still check for SuccessMaterialLimit
+ m_config.materialEffectsEngine->handleMaterial(
+ eCell, pDir, Acts::preUpdate);
+ // check if success was triggered through path limit reached on the way to
+ // the layer
+ CHECK_ECODE_SUCCESS(eCell, eCode);
}
- // reset the lead layer to ensure the layer-to-layer loop
- eCell.leadLayer = initialLayer;
- // return the code:
- // - if it came until here, return InProgress to not break the layer-to-layer loop
- return Acts::ExtrapolationCode::InProgress;
-}
+ // return what you have handleLayerT or extrapolateT will resolve that
+ return eCode;
+ }
+ // reset the lead layer to ensure the layer-to-layer loop
+ eCell.leadLayer = initialLayer;
+ // return the code:
+ // - if it came until here, return InProgress to not break the layer-to-layer
+ // loop
+ return Acts::ExtrapolationCode::InProgress;
+}
/** handle the failure - as configured */
-template <class T> Acts::ExtrapolationCode Acts::StaticEngine::handleReturnT(Acts::ExtrapolationCode eCode,
- Acts::ExtrapolationCell<T>& eCell,
- const Acts::Surface* sf,
- Acts::PropDirection pDir,
- const Acts::BoundaryCheck& bcheck) const
-{
- EX_MSG_DEBUG(++eCell.navigationStep, "return", "", "handleReturnT with code " << eCode.toString() << " called." );
- if (eCode.isSuccessOrRecovered() || eCode.inProgress() ){
- EX_MSG_VERBOSE(eCell.navigationStep, "return", "", "leaving static extrapolator successfully with code " << eCode.toString());
- return eCode;
- }
- EX_MSG_VERBOSE(eCell.navigationStep, "return", "", "failure detected as " << eCode.toString() << " - checking fallback configuration.");
- // obviously we need a surface to exercise the fallback
- if (sf && !eCell.checkConfigurationMode(Acts::ExtrapolationMode::AvoidFallback)){
- EX_MSG_VERBOSE(eCell.navigationStep, "return", "", "fallback configured. Trying to hit destination surface from last valid parameters.");
- // check if you hit the surface, could still be stopped by PathLimit, but would also count as recovered
- eCode = m_config.propagationEngine->propagate(eCell,*sf,pDir,ExtrapolationMode::Propagation, bcheck,eCell.destinationCurvilinear);
- }
-
- return eCode;
+template <class T>
+Acts::ExtrapolationCode
+Acts::StaticEngine::handleReturnT(Acts::ExtrapolationCode eCode,
+ Acts::ExtrapolationCell<T>& eCell,
+ const Acts::Surface* sf,
+ Acts::PropDirection pDir,
+ const Acts::BoundaryCheck& bcheck) const
+{
+ EX_MSG_DEBUG(++eCell.navigationStep,
+ "return",
+ "",
+ "handleReturnT with code " << eCode.toString() << " called.");
+ if (eCode.isSuccessOrRecovered() || eCode.inProgress()) {
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "return",
+ "",
+ "leaving static extrapolator successfully with code "
+ << eCode.toString());
+ return eCode;
+ }
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "return",
+ "",
+ "failure detected as "
+ << eCode.toString()
+ << " - checking fallback configuration.");
+ // obviously we need a surface to exercise the fallback
+ if (sf
+ && !eCell.checkConfigurationMode(
+ Acts::ExtrapolationMode::AvoidFallback)) {
+ EX_MSG_VERBOSE(
+ eCell.navigationStep, "return", "", "fallback configured. Trying to "
+ "hit destination surface from last "
+ "valid parameters.");
+ // check if you hit the surface, could still be stopped by PathLimit, but
+ // would also count as recovered
+ eCode
+ = m_config.propagationEngine->propagate(eCell,
+ *sf,
+ pDir,
+ ExtrapolationMode::Propagation,
+ bcheck,
+ eCell.destinationCurvilinear);
+ }
+
+ return eCode;
}
-
-
diff --git a/Core/include/ACTS/Extrapolation/detail/StaticNavigationEngine.ipp b/Core/include/ACTS/Extrapolation/detail/StaticNavigationEngine.ipp
index 92a38681c..7039f774a 100644
--- a/Core/include/ACTS/Extrapolation/detail/StaticNavigationEngine.ipp
+++ b/Core/include/ACTS/Extrapolation/detail/StaticNavigationEngine.ipp
@@ -2,226 +2,357 @@
// StaticNavigationEngine.ipp, ACTS project
///////////////////////////////////////////////////////////////////
-#include "ACTS/Extrapolation/IPropagationEngine.hpp"
-#include "ACTS/Extrapolation/IMaterialEffectsEngine.hpp"
-#include "ACTS/Detector/TrackingVolume.hpp"
#include "ACTS/Detector/TrackingGeometry.hpp"
-#include "ACTS/Volumes/BoundarySurface.hpp"
+#include "ACTS/Detector/TrackingVolume.hpp"
+#include "ACTS/Extrapolation/IMaterialEffectsEngine.hpp"
+#include "ACTS/Extrapolation/IPropagationEngine.hpp"
#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Volumes/BoundarySurface.hpp"
/** handle the failure - as configured */
-template <class T> Acts::ExtrapolationCode Acts::StaticNavigationEngine::resolveBoundaryT(Acts::ExtrapolationCell<T>& eCell,
- Acts::PropDirection pDir) const
-{
- EX_MSG_DEBUG(++eCell.navigationStep, "navigation", "", "resolve boundary situation leaving '"<< eCell.leadVolume->volumeName()
- << (int(pDir) > 0 ? "' along momentum." : "' opposite momentum.") );
- // initialize the extrapolation code to progress
- ExtrapolationCode eCode = ExtrapolationCode::InProgress;
- // [1] ------------------------ fast boundary access : take straight line estimates as navigation guide --------------
- auto boundaryIntersections = eCell.leadVolume->boundarySurfacesOrdered(*eCell.leadParameters,
- pDir,
- eCell.onLastBoundary() );
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "found " << boundaryIntersections.size() << " boundary surfaces to try"
- << ( eCell.onLastBoundary() ? " - starting from last boundary." : "." ) );
- // remember them for the slow acces
- std::map< const BoundarySurface<TrackingVolume>*, bool > bSurfacesTried;
-
- for (auto& boundaryCandidate : boundaryIntersections){
- // the surface of the
- const BoundarySurface<TrackingVolume>* bSurfaceTV = boundaryCandidate.object;
- // skip if it's the last boundary surface
- if ( eCell.onLastBoundary() && &bSurfaceTV->surfaceRepresentation() == eCell.lastBoundarySurface ) continue;
- // check this boudnary, possible return codes are:
- // - SuccessPathLimit : propagation to boundary caused PathLimit to be fail @TODO implement protection againg far of tries
- // - SuccessMaterialLimit : boundary was reached and material update on boundary reached limit
- // - InProgress : boundary was reached and ready for continueing the navigation
- // - UnSet : boundary was not reached, try the next one
- // - FailureLoop : next Volume was previous Volume
- eCode = handleBoundaryT<T>(eCell,*bSurfaceTV,pDir);
- CHECK_ECODE_SUCCESS(eCell, eCode);
- // Failure or Unset are not triggering a return, try more sophisticated navigation
- if (!eCode.inProgress()){
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "boundary surface not reached with " << eCode.toString() << ", skipping.");
- // book keeping for the slow access not to try again the same stuff
- bSurfacesTried[bSurfaceTV] = false;
- // skip to the next surface if there's one
- continue;
- }
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "boundary surface handling yielded code " << eCode.toString());
- // set that this was the last boundary surface
- eCell.lastBoundarySurface = &bSurfaceTV->surfaceRepresentation();
- // and return the code yielded by the handleBoundaryT
- return eCode;
+template <class T>
+Acts::ExtrapolationCode
+Acts::StaticNavigationEngine::resolveBoundaryT(
+ Acts::ExtrapolationCell<T>& eCell,
+ Acts::PropDirection pDir) const
+{
+ EX_MSG_DEBUG(
+ ++eCell.navigationStep,
+ "navigation",
+ "",
+ "resolve boundary situation leaving '"
+ << eCell.leadVolume->volumeName()
+ << (int(pDir) > 0 ? "' along momentum." : "' opposite momentum."));
+ // initialize the extrapolation code to progress
+ ExtrapolationCode eCode = ExtrapolationCode::InProgress;
+ // [1] ------------------------ fast boundary access : take straight line
+ // estimates as navigation guide --------------
+ auto boundaryIntersections = eCell.leadVolume->boundarySurfacesOrdered(
+ *eCell.leadParameters, pDir, eCell.onLastBoundary());
+ EX_MSG_VERBOSE(
+ eCell.navigationStep,
+ "navigation",
+ "",
+ "found " << boundaryIntersections.size() << " boundary surfaces to try"
+ << (eCell.onLastBoundary() ? " - starting from last boundary."
+ : "."));
+ // remember them for the slow acces
+ std::map<const BoundarySurface<TrackingVolume>*, bool> bSurfacesTried;
+
+ for (auto& boundaryCandidate : boundaryIntersections) {
+ // the surface of the
+ const BoundarySurface<TrackingVolume>* bSurfaceTV
+ = boundaryCandidate.object;
+ // skip if it's the last boundary surface
+ if (eCell.onLastBoundary()
+ && &bSurfaceTV->surfaceRepresentation() == eCell.lastBoundarySurface)
+ continue;
+ // check this boudnary, possible return codes are:
+ // - SuccessPathLimit : propagation to boundary caused PathLimit to be
+ // fail @TODO implement protection againg far of tries
+ // - SuccessMaterialLimit : boundary was reached and material update on
+ // boundary reached limit
+ // - InProgress : boundary was reached and ready for continueing
+ // the navigation
+ // - UnSet : boundary was not reached, try the next one
+ // - FailureLoop : next Volume was previous Volume
+ eCode = handleBoundaryT<T>(eCell, *bSurfaceTV, pDir);
+ CHECK_ECODE_SUCCESS(eCell, eCode);
+ // Failure or Unset are not triggering a return, try more sophisticated
+ // navigation
+ if (!eCode.inProgress()) {
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "navigation",
+ "",
+ "boundary surface not reached with " << eCode.toString()
+ << ", skipping.");
+ // book keeping for the slow access not to try again the same stuff
+ bSurfacesTried[bSurfaceTV] = false;
+ // skip to the next surface if there's one
+ continue;
}
- // [2] ------------------------ slow boundary access : take all boundary surfaces and simply try --------------
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "fast boundary navigation did not succeeed - trying slow navigation now.");
- // ignore the ones you have tried already
- for (auto& bSurface : eCell.leadVolume->boundarySurfaces() ){
- // we tried this one already, no point to do it again
- if ( bSurfacesTried.size() && bSurfacesTried.find(bSurface.get()) != bSurfacesTried.end() ) continue;
- // skip if it's the last boundary surface
- if ( &bSurface->surfaceRepresentation() == eCell.lastBoundarySurface ) continue;
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "trying a boundary surface.");
- // there is now loop protection in the slow access, needs to be done by hand
- // check this boudnary, possible return codes are:
- // - SuccessPathLimit : propagation to boundary caused PathLimit to be fail @TODO implement protection againg far of tries
- // - SuccessMaterialLimit : boundary was reached and material update on boundary reached limit
- // - InProgress : boundary was reached and ready for continueing the navigation
- // - UnSet : boundary was not reached, try the next one
- eCode = handleBoundaryT<T>(eCell,*bSurface.get(),pDir);
- CHECK_ECODE_SUCCESS(eCell, eCode);
- // Failure or Unset are not triggering a return, try more sophisticated navigation
- if (!eCode.inProgress()){
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "boundary surface not reached with " << eCode.toString() << ", skipping.");
- // skip to the next surface if there's one
- continue;
- }
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "boundary surface handling yielded code " << eCode.toString());
- // set that this was the last boundary surface
- eCell.lastBoundarySurface = &bSurface->surfaceRepresentation();
- // and return the code yielded by the handleBoundaryT
- return eCode;
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "navigation",
+ "",
+ "boundary surface handling yielded code "
+ << eCode.toString());
+ // set that this was the last boundary surface
+ eCell.lastBoundarySurface = &bSurfaceTV->surfaceRepresentation();
+ // and return the code yielded by the handleBoundaryT
+ return eCode;
+ }
+ // [2] ------------------------ slow boundary access : take all boundary
+ // surfaces and simply try --------------
+ EX_MSG_VERBOSE(
+ eCell.navigationStep, "navigation", "", "fast boundary navigation did "
+ "not succeeed - trying slow "
+ "navigation now.");
+ // ignore the ones you have tried already
+ for (auto& bSurface : eCell.leadVolume->boundarySurfaces()) {
+ // we tried this one already, no point to do it again
+ if (bSurfacesTried.size()
+ && bSurfacesTried.find(bSurface.get()) != bSurfacesTried.end())
+ continue;
+ // skip if it's the last boundary surface
+ if (&bSurface->surfaceRepresentation() == eCell.lastBoundarySurface)
+ continue;
+ EX_MSG_VERBOSE(
+ eCell.navigationStep, "navigation", "", "trying a boundary surface.");
+ // there is now loop protection in the slow access, needs to be done by hand
+ // check this boudnary, possible return codes are:
+ // - SuccessPathLimit : propagation to boundary caused PathLimit to be
+ // fail @TODO implement protection againg far of tries
+ // - SuccessMaterialLimit : boundary was reached and material update on
+ // boundary reached limit
+ // - InProgress : boundary was reached and ready for continueing
+ // the navigation
+ // - UnSet : boundary was not reached, try the next one
+ eCode = handleBoundaryT<T>(eCell, *bSurface.get(), pDir);
+ CHECK_ECODE_SUCCESS(eCell, eCode);
+ // Failure or Unset are not triggering a return, try more sophisticated
+ // navigation
+ if (!eCode.inProgress()) {
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "navigation",
+ "",
+ "boundary surface not reached with " << eCode.toString()
+ << ", skipping.");
+ // skip to the next surface if there's one
+ continue;
}
- // [3] ------------------------ slowest boundary access : step-out-of-volume approach -------------------------
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "slow boundary navigation did not succeeed - trying step-out-of-volume approach now");
- for (auto& boundaryCandidate : boundaryIntersections){
- // the surface of the
- const BoundarySurface<TrackingVolume>* bSurfaceTV = boundaryCandidate.object;
- // check this boudnary, possible return codes are:
- // - SuccessPathLimit : propagation to boundary caused PathLimit to be fail @TODO implement protection againg far of tries
- // - SuccessMaterialLimit : boundary was reached and material update on boundary reached limit
- // - InProgress : boundary was reached and ready for continueing the navigation
- // - UnSet : boundary was not reached, try the next one
- // - FailureLoop : next Volume was previous Volume
- eCode = handleBoundaryT<T>(eCell,*bSurfaceTV,pDir,true);
- CHECK_ECODE_SUCCESS(eCell, eCode);
- // Failure or Unset are not triggering a return, try more sophisticated navigation
- if (!eCode.inProgress()){
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "boundary surface not reached with " << eCode.toString() << ", skipping.");
- // skip to the next surface if there's one
- continue;
- }
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "boundary surface handling yielded code " << eCode.toString());
- // set that this was the last boundary surface
- eCell.lastBoundarySurface = &bSurfaceTV->surfaceRepresentation();
- // and return the code yielded by the handleBoundaryT
- return eCode;
- }
- // return it back
- EX_MSG_DEBUG(eCell.navigationStep, "navigation", "", "could not resolve the boundary situation. Exiting.");
-
- return ExtrapolationCode::FailureNavigation;
-}
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "navigation",
+ "",
+ "boundary surface handling yielded code "
+ << eCode.toString());
+ // set that this was the last boundary surface
+ eCell.lastBoundarySurface = &bSurface->surfaceRepresentation();
+ // and return the code yielded by the handleBoundaryT
+ return eCode;
+ }
+ // [3] ------------------------ slowest boundary access : step-out-of-volume
+ // approach -------------------------
+ EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "slow boundary "
+ "navigation did not "
+ "succeeed - trying "
+ "step-out-of-volume "
+ "approach now");
+ for (auto& boundaryCandidate : boundaryIntersections) {
+ // the surface of the
+ const BoundarySurface<TrackingVolume>* bSurfaceTV
+ = boundaryCandidate.object;
+ // check this boudnary, possible return codes are:
+ // - SuccessPathLimit : propagation to boundary caused PathLimit to be
+ // fail @TODO implement protection againg far of tries
+ // - SuccessMaterialLimit : boundary was reached and material update on
+ // boundary reached limit
+ // - InProgress : boundary was reached and ready for continueing
+ // the navigation
+ // - UnSet : boundary was not reached, try the next one
+ // - FailureLoop : next Volume was previous Volume
+ eCode = handleBoundaryT<T>(eCell, *bSurfaceTV, pDir, true);
+ CHECK_ECODE_SUCCESS(eCell, eCode);
+ // Failure or Unset are not triggering a return, try more sophisticated
+ // navigation
+ if (!eCode.inProgress()) {
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "navigation",
+ "",
+ "boundary surface not reached with " << eCode.toString()
+ << ", skipping.");
+ // skip to the next surface if there's one
+ continue;
+ }
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "navigation",
+ "",
+ "boundary surface handling yielded code "
+ << eCode.toString());
+ // set that this was the last boundary surface
+ eCell.lastBoundarySurface = &bSurfaceTV->surfaceRepresentation();
+ // and return the code yielded by the handleBoundaryT
+ return eCode;
+ }
+ // return it back
+ EX_MSG_DEBUG(eCell.navigationStep,
+ "navigation",
+ "",
+ "could not resolve the boundary situation. Exiting.");
+
+ return ExtrapolationCode::FailureNavigation;
+}
/** handle the failure - as configured */
-template <class T> Acts::ExtrapolationCode Acts::StaticNavigationEngine::handleBoundaryT(Acts::ExtrapolationCell<T>& eCell,
- const Acts::BoundarySurface<Acts::TrackingVolume>& bSurfaceTV,
- Acts::PropDirection pDir,
- bool stepout) const
+template <class T>
+Acts::ExtrapolationCode
+Acts::StaticNavigationEngine::handleBoundaryT(
+ Acts::ExtrapolationCell<T>& eCell,
+ const Acts::BoundarySurface<Acts::TrackingVolume>& bSurfaceTV,
+ Acts::PropDirection pDir,
+ bool stepout) const
{
- // get the bondary surface and compare with last one to prevent loops
- const Surface& bSurface = bSurfaceTV.surfaceRepresentation();
- // propagate the parameters to the boundary (force boundaryCheck to true in case it is not a step-out trial), possible return codes :
- // - SuccessPathLimit : pathLimit reached during propagation
- // - InProgress : boundary reached
- // - Recovered : boundary not reached
- ExtrapolationCode eCode = m_config.propagationEngine->propagate(eCell,
- bSurface,
- pDir,
- ExtrapolationMode::CollectBoundary,
- !stepout,
- eCell.destinationCurvilinear);
- CHECK_ECODE_SUCCESS(eCell, eCode);
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "handleBoundaryT", "propagation with eCode " << eCode.toString());
- // check for progress
- if (eCode.inProgress()){
- // check if the boundary solution is compatible with the radial direciton of the extrapolation
- if (!eCell.checkRadialCompatibility()) {
- // screen output for the radial compatibility check
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "handleBoundaryT", "radial compatbility check failed, radial direction is: " << eCell.radialDirection);
- // if it's not jump back to the last valid lead parameters and return Unset as a trigger
- eCell.leadParameters = eCell.lastLeadParameters;
- return ExtrapolationCode::Unset;
- }
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "parameters on boundary surface created, moving to next volume.");
- // get the nextVolume - modify the position in case you have a step out trial, take attachment otherwise
- const TrackingVolume* nextVolume = stepout ?
- m_config.trackingGeometry->lowestTrackingVolume(Vector3D(eCell.leadParameters->position()+pDir*eCell.leadParameters->momentum().unit())) :
- bSurfaceTV.attachedVolume(eCell.leadParameters->position(), eCell.leadParameters->momentum(), pDir);
- // check if we have no nextVolume : boundary rechaed @TODO it's not really a success
- if (!nextVolume) {
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "No next volume found attached to this TrackingVolume. End of known world ?");
- return ExtrapolationCode::SuccessBoundaryReached;
- }
- // check if it is a boundary reached case
- // - geometrySignature change and configuration to stop then triggers a Success
- bool stopAtThisBoundary = eCell.checkConfigurationMode(ExtrapolationMode::StopAtBoundary)
- && (nextVolume->geometrySignature() != eCell.leadVolume->geometrySignature());
- // fill the boundary into the cache if successfully hit boundary surface
- // loop protection - relaxed for the cases where you start from the boundary
- if (eCell.leadVolume == nextVolume ) {
- // the start parameters where on the boundary already give a relaxed return code
- if (&bSurface == eCell.lastBoundarySurface) return ExtrapolationCode::Unset;
- // give some screen output as of why this happens
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "loop detected while trying to leave TrackingVolume '" << nextVolume->volumeName() << ".");
- // return a loop failure, parameter deletion will be done by cache
- return ExtrapolationCode::FailureLoop;
- }
- // update the with the information of the layer material - will change the leadParameters
- if (bSurface.surfaceMaterial()) {
- // now handle the material, possible return codes:
- // - InProgress : material update performed or not (depending on material)
- // - SuccessMaterialLimit : material limit reached & configured to stop there
- eCode = m_config.materialEffectsEngine->handleMaterial(eCell,pDir,fullUpdate);
- CHECK_ECODE_SUCCESS(eCell, eCode);
- }
- // break if configured to break at volume boundary and signature change
- if (stopAtThisBoundary){
- EX_MSG_VERBOSE(eCell.navigationStep, "navigation", "", "geometry signature change from " << eCell.leadVolume->geometrySignature() << " to " << nextVolume->geometrySignature());
- eCell.nextGeometrySignature = nextVolume->geometrySignature();
- // return the boundary reached : the navigation resolved already
- eCell.leadVolume = nextVolume;
- return ExtrapolationCode::SuccessBoundaryReached;
- }
- // remember the last boundary surface for loop protection
- eCell.lastBoundarySurface = &bSurface;
- eCell.lastBoundaryParameters = eCell.leadParameters;
- // set next volume and reset lead layer
- eCell.leadVolume = nextVolume;
- eCell.leadLayer = 0;
- // we have bParameters -> break the loop over boundaryIntersections
- return ExtrapolationCode::InProgress;
- }
-
- // you need to keep on trying
- return ExtrapolationCode::Unset;
- }
+ // get the bondary surface and compare with last one to prevent loops
+ const Surface& bSurface = bSurfaceTV.surfaceRepresentation();
+ // propagate the parameters to the boundary (force boundaryCheck to true in
+ // case it is not a step-out trial), possible return codes :
+ // - SuccessPathLimit : pathLimit reached during propagation
+ // - InProgress : boundary reached
+ // - Recovered : boundary not reached
+ ExtrapolationCode eCode = m_config.propagationEngine->propagate(
+ eCell,
+ bSurface,
+ pDir,
+ ExtrapolationMode::CollectBoundary,
+ !stepout,
+ eCell.destinationCurvilinear);
+ CHECK_ECODE_SUCCESS(eCell, eCode);
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "navigation",
+ "handleBoundaryT",
+ "propagation with eCode " << eCode.toString());
+ // check for progress
+ if (eCode.inProgress()) {
+ // check if the boundary solution is compatible with the radial direciton of
+ // the extrapolation
+ if (!eCell.checkRadialCompatibility()) {
+ // screen output for the radial compatibility check
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "navigation",
+ "handleBoundaryT",
+ "radial compatbility check failed, radial direction is: "
+ << eCell.radialDirection);
+ // if it's not jump back to the last valid lead parameters and return
+ // Unset as a trigger
+ eCell.leadParameters = eCell.lastLeadParameters;
+ return ExtrapolationCode::Unset;
+ }
+ EX_MSG_VERBOSE(
+ eCell.navigationStep,
+ "navigation",
+ "",
+ "parameters on boundary surface created, moving to next volume.");
+ // get the nextVolume - modify the position in case you have a step out
+ // trial, take attachment otherwise
+ const TrackingVolume* nextVolume = stepout
+ ? m_config.trackingGeometry->lowestTrackingVolume(
+ Vector3D(eCell.leadParameters->position()
+ + pDir * eCell.leadParameters->momentum().unit()))
+ : bSurfaceTV.attachedVolume(eCell.leadParameters->position(),
+ eCell.leadParameters->momentum(),
+ pDir);
+ // check if we have no nextVolume : boundary rechaed @TODO it's not really a
+ // success
+ if (!nextVolume) {
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "navigation",
+ "",
+ "No next volume found attached to this TrackingVolume. "
+ "End of known world ?");
+ return ExtrapolationCode::SuccessBoundaryReached;
+ }
+ // check if it is a boundary reached case
+ // - geometrySignature change and configuration to stop then triggers a
+ // Success
+ bool stopAtThisBoundary
+ = eCell.checkConfigurationMode(ExtrapolationMode::StopAtBoundary)
+ && (nextVolume->geometrySignature()
+ != eCell.leadVolume->geometrySignature());
+ // fill the boundary into the cache if successfully hit boundary surface
+ // loop protection - relaxed for the cases where you start from the boundary
+ if (eCell.leadVolume == nextVolume) {
+ // the start parameters where on the boundary already give a relaxed
+ // return code
+ if (&bSurface == eCell.lastBoundarySurface)
+ return ExtrapolationCode::Unset;
+ // give some screen output as of why this happens
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "navigation",
+ "",
+ "loop detected while trying to leave TrackingVolume '"
+ << nextVolume->volumeName()
+ << ".");
+ // return a loop failure, parameter deletion will be done by cache
+ return ExtrapolationCode::FailureLoop;
+ }
+ // update the with the information of the layer material - will change the
+ // leadParameters
+ if (bSurface.surfaceMaterial()) {
+ // now handle the material, possible return codes:
+ // - InProgress : material update performed or not (depending
+ // on material)
+ // - SuccessMaterialLimit : material limit reached & configured to stop
+ // there
+ eCode = m_config.materialEffectsEngine->handleMaterial(
+ eCell, pDir, fullUpdate);
+ CHECK_ECODE_SUCCESS(eCell, eCode);
+ }
+ // break if configured to break at volume boundary and signature change
+ if (stopAtThisBoundary) {
+ EX_MSG_VERBOSE(eCell.navigationStep,
+ "navigation",
+ "",
+ "geometry signature change from "
+ << eCell.leadVolume->geometrySignature()
+ << " to "
+ << nextVolume->geometrySignature());
+ eCell.nextGeometrySignature = nextVolume->geometrySignature();
+ // return the boundary reached : the navigation resolved already
+ eCell.leadVolume = nextVolume;
+ return ExtrapolationCode::SuccessBoundaryReached;
+ }
+ // remember the last boundary surface for loop protection
+ eCell.lastBoundarySurface = &bSurface;
+ eCell.lastBoundaryParameters = eCell.leadParameters;
+ // set next volume and reset lead layer
+ eCell.leadVolume = nextVolume;
+ eCell.leadLayer = 0;
+ // we have bParameters -> break the loop over boundaryIntersections
+ return ExtrapolationCode::InProgress;
+ }
+ // you need to keep on trying
+ return ExtrapolationCode::Unset;
+}
/** handle the failure - as configured */
-template <class T> Acts::ExtrapolationCode Acts::StaticNavigationEngine::resolvePositionT(Acts::ExtrapolationCell<T>& eCell,
- Acts::PropDirection pDir,
- bool /*noLoop*/ ) const
-{
- EX_MSG_DEBUG(++eCell.navigationStep, "navigation", "", "resolve position '"<< eCell.leadParameters->position()
- << (int(pDir) > 0 ? "' along momentum." : "' opposite momentum.") );
+template <class T>
+Acts::ExtrapolationCode
+Acts::StaticNavigationEngine::resolvePositionT(
+ Acts::ExtrapolationCell<T>& eCell,
+ Acts::PropDirection pDir,
+ bool /*noLoop*/) const
+{
+ EX_MSG_DEBUG(++eCell.navigationStep,
+ "navigation",
+ "",
+ "resolve position '"
+ << eCell.leadParameters->position()
+ << (int(pDir) > 0 ? "' along momentum."
+ : "' opposite momentum."));
- // noLoop= True is used when we have exit from leadVolume
+ // noLoop= True is used when we have exit from leadVolume
- if (!eCell.leadVolume) eCell.leadVolume = m_config.trackingGeometry->lowestStaticTrackingVolume(eCell.leadParameters->position());
- if (!eCell.leadVolume) return ExtrapolationCode::FailureNavigation;
- const TrackingVolume* nextVol=0;
- if ( m_config.trackingGeometry->atVolumeBoundary(eCell.leadParameters->position(),
- eCell.leadParameters->momentum(),
- eCell.leadVolume,
- nextVol, pDir, 0.01) ) { //!< @TODO set tolerance globally
-
- //if (noLoop && nextVol==eCell.leadVolume) return ExtrapolationCode::FailureLoop;
- if (nextVol) {
- eCell.leadVolume = nextVol;
- return ExtrapolationCode::InProgress;
- } else return ExtrapolationCode::FailureNavigation;
- }
+ if (!eCell.leadVolume)
+ eCell.leadVolume = m_config.trackingGeometry->lowestStaticTrackingVolume(
+ eCell.leadParameters->position());
+ if (!eCell.leadVolume) return ExtrapolationCode::FailureNavigation;
+ const TrackingVolume* nextVol = 0;
+ if (m_config.trackingGeometry->atVolumeBoundary(
+ eCell.leadParameters->position(),
+ eCell.leadParameters->momentum(),
+ eCell.leadVolume,
+ nextVol,
+ pDir,
+ 0.01)) { //!< @TODO set tolerance globally
- return ExtrapolationCode::InProgress;
+ // if (noLoop && nextVol==eCell.leadVolume) return
+ // ExtrapolationCode::FailureLoop;
+ if (nextVol) {
+ eCell.leadVolume = nextVol;
+ return ExtrapolationCode::InProgress;
+ } else
+ return ExtrapolationCode::FailureNavigation;
+ }
+
+ return ExtrapolationCode::InProgress;
}
diff --git a/Core/include/ACTS/Layers/ConeLayer.hpp b/Core/include/ACTS/Layers/ConeLayer.hpp
index f642e0961..69bf23971 100644
--- a/Core/include/ACTS/Layers/ConeLayer.hpp
+++ b/Core/include/ACTS/Layers/ConeLayer.hpp
@@ -24,69 +24,80 @@ class MsgStream;
#include <algorithm>
namespace Acts {
-
- class ConeBounds;
- class OverlapDescriptor;
-
- /**
- @class ConeLayer
-
- Class to describe a cylindrical detector layer for tracking, it inhertis from both,
- Layer base class and ConeSurface class
-
- */
-
- class ConeLayer : virtual public ConeSurface, public Layer {
-
- public:
- /** Factory for shared layer */
- static LayerPtr create(std::shared_ptr<Transform3D> transform,
- std::shared_ptr<const ConeBounds> cbounds,
- std::unique_ptr<SurfaceArray> surfaceArray,
- double thickness = 0.,
- OverlapDescriptor* od = 0,
- int laytyp=int(Acts::active))
- { return LayerPtr(new ConeLayer(transform,cbounds,std::move(surfaceArray), thickness, od, laytyp));}
-
- /** Factory for shared layer with shift */
- static LayerPtr create(const ConeLayer& cla, const Transform3D& shift)
- { return LayerPtr(new ConeLayer(cla, shift)); }
-
- /** Clone with a shift - only cloning that is allowed */
- LayerPtr cloneWithShift(const Transform3D& shift) const override
- { return ConeLayer::create(*this,shift); }
-
- /** Copy constructor of ConeLayer - forbidden */
- ConeLayer(const ConeLayer& cla) = delete;
-
- /** Assignment operator for ConeLayers - forbidden */
- ConeLayer& operator=(const ConeLayer&) = delete;
-
- /** Destructor*/
- virtual ~ConeLayer(){}
-
- /** Transforms the layer into a Surface representation for extrapolation */
- const ConeSurface& surfaceRepresentation() const override;
-
- protected:
- /** Default Constructor*/
- ConeLayer(){}
-
- /** Constructor with ConeSurface components,
- MaterialProperties and pointer SurfaceArray (passing ownership)
- @TODO implement ApproachDescriptor */
- ConeLayer(std::shared_ptr<Transform3D> transform,
- std::shared_ptr<const ConeBounds> cbounds,
- std::unique_ptr<SurfaceArray> surfaceArray,
- double thickness = 0.,
- OverlapDescriptor* od = 0,
- int laytyp=int(Acts::active));
-
- /** Copy constructor with shift*/
- ConeLayer(const ConeLayer& cla, const Transform3D& tr);
-
- };
-
-} // end of namespace
-
-#endif // TRKGEOMETY_CONELAYER_H
+
+class ConeBounds;
+class OverlapDescriptor;
+
+/**
+ @class ConeLayer
+
+ Class to describe a cylindrical detector layer for tracking, it inhertis from
+ both,
+ Layer base class and ConeSurface class
+
+*/
+
+class ConeLayer : virtual public ConeSurface, public Layer
+{
+public:
+ /** Factory for shared layer */
+ static LayerPtr
+ create(std::shared_ptr<Transform3D> transform,
+ std::shared_ptr<const ConeBounds> cbounds,
+ std::unique_ptr<SurfaceArray> surfaceArray,
+ double thickness = 0.,
+ OverlapDescriptor* od = 0,
+ int laytyp = int(Acts::active))
+ {
+ return LayerPtr(new ConeLayer(
+ transform, cbounds, std::move(surfaceArray), thickness, od, laytyp));
+ }
+
+ /** Factory for shared layer with shift */
+ static LayerPtr
+ create(const ConeLayer& cla, const Transform3D& shift)
+ {
+ return LayerPtr(new ConeLayer(cla, shift));
+ }
+
+ /** Clone with a shift - only cloning that is allowed */
+ LayerPtr
+ cloneWithShift(const Transform3D& shift) const override
+ {
+ return ConeLayer::create(*this, shift);
+ }
+
+ /** Copy constructor of ConeLayer - forbidden */
+ ConeLayer(const ConeLayer& cla) = delete;
+
+ /** Assignment operator for ConeLayers - forbidden */
+ ConeLayer&
+ operator=(const ConeLayer&)
+ = delete;
+
+ /** Destructor*/
+ virtual ~ConeLayer() {}
+ /** Transforms the layer into a Surface representation for extrapolation */
+ const ConeSurface&
+ surfaceRepresentation() const override;
+
+protected:
+ /** Default Constructor*/
+ ConeLayer() {}
+ /** Constructor with ConeSurface components,
+ MaterialProperties and pointer SurfaceArray (passing ownership)
+ @TODO implement ApproachDescriptor */
+ ConeLayer(std::shared_ptr<Transform3D> transform,
+ std::shared_ptr<const ConeBounds> cbounds,
+ std::unique_ptr<SurfaceArray> surfaceArray,
+ double thickness = 0.,
+ OverlapDescriptor* od = 0,
+ int laytyp = int(Acts::active));
+
+ /** Copy constructor with shift*/
+ ConeLayer(const ConeLayer& cla, const Transform3D& tr);
+};
+
+} // end of namespace
+
+#endif // TRKGEOMETY_CONELAYER_H
diff --git a/Core/include/ACTS/Layers/CylinderLayer.hpp b/Core/include/ACTS/Layers/CylinderLayer.hpp
index 4128268e5..841f5c253 100644
--- a/Core/include/ACTS/Layers/CylinderLayer.hpp
+++ b/Core/include/ACTS/Layers/CylinderLayer.hpp
@@ -29,70 +29,89 @@ class SurfaceMaterial;
class OverlapDescriptor;
class ApproachDescriptor;
- /**
- @class CylinderLayer
-
- Class to describe a cylindrical detector layer for tracking, it inhertis from both,
- Layer base class and CylinderSurface class
-
- */
-
- class CylinderLayer : public CylinderSurface, public Layer {
-
- public:
- /**create a shared, fully deployed CylinderLayer */
- static LayerPtr create(std::shared_ptr<Transform3D> transform,
- std::shared_ptr<const CylinderBounds> cbounds,
- std::unique_ptr<SurfaceArray> surfaceArray = nullptr,
- double thickness = 0.,
- OverlapDescriptor* od = nullptr,
- ApproachDescriptor* ad = nullptr,
- int laytyp=int(Acts::passive))
- { return LayerPtr(new CylinderLayer(transform, cbounds, std::move(surfaceArray), thickness, od, ad, laytyp));}
-
- /** Copy constructor with shift - will not copy anything of the static next/previous environment*/
- static LayerPtr create(const CylinderLayer& cla, const Transform3D& shift)
- { return LayerPtr(new CylinderLayer(cla, shift)); }
-
- /** Clone with a shift - only cloning that is allowed */
- LayerPtr cloneWithShift(const Transform3D& shift) const override
- { return CylinderLayer::create(*this,shift); }
-
- /** Copy constructor - forbidden, create a new one if you need */
- CylinderLayer(const CylinderLayer& cla) = delete;
-
- /** Assignment operator for CylinderLayers - forbidden, create a new one */
- CylinderLayer& operator=(const CylinderLayer&) = delete;
-
- /** Destructor*/
- virtual ~CylinderLayer(){}
-
- /** Transforms the layer into a Surface representation for global positioning & navigation */
- const CylinderSurface& surfaceRepresentation() const override;
-
- private:
- /** build approach surfaces */
- void buildApproachDescriptor() const;
-
- protected:
-
- /** Default Constructor*/
- CylinderLayer(){}
-
- /** Fully deployed CylinderLayer constructor */
- CylinderLayer(std::shared_ptr<Transform3D> transform,
- std::shared_ptr<const CylinderBounds> cbounds,
- std::unique_ptr<SurfaceArray> surfaceArray = nullptr,
- double thickness = 0.,
- OverlapDescriptor* od = nullptr,
- ApproachDescriptor* ad = nullptr,
- int laytyp=int(Acts::passive));
-
- /** Copy constructor with shift - will not copy anything of the static next/previous environment*/
- CylinderLayer(const CylinderLayer& cla, const Transform3D& tr);
-
- };
-
-} // end of namespace
-
-#endif // TRKGEOMETY_CYLINDERLAYER_H
+/**
+ @class CylinderLayer
+
+ Class to describe a cylindrical detector layer for tracking, it inhertis from
+ both,
+ Layer base class and CylinderSurface class
+
+*/
+
+class CylinderLayer : public CylinderSurface, public Layer
+{
+public:
+ /**create a shared, fully deployed CylinderLayer */
+ static LayerPtr
+ create(std::shared_ptr<Transform3D> transform,
+ std::shared_ptr<const CylinderBounds> cbounds,
+ std::unique_ptr<SurfaceArray> surfaceArray = nullptr,
+ double thickness = 0.,
+ OverlapDescriptor* od = nullptr,
+ ApproachDescriptor* ad = nullptr,
+ int laytyp = int(Acts::passive))
+ {
+ return LayerPtr(new CylinderLayer(transform,
+ cbounds,
+ std::move(surfaceArray),
+ thickness,
+ od,
+ ad,
+ laytyp));
+ }
+
+ /** Copy constructor with shift - will not copy anything of the static
+ * next/previous environment*/
+ static LayerPtr
+ create(const CylinderLayer& cla, const Transform3D& shift)
+ {
+ return LayerPtr(new CylinderLayer(cla, shift));
+ }
+
+ /** Clone with a shift - only cloning that is allowed */
+ LayerPtr
+ cloneWithShift(const Transform3D& shift) const override
+ {
+ return CylinderLayer::create(*this, shift);
+ }
+
+ /** Copy constructor - forbidden, create a new one if you need */
+ CylinderLayer(const CylinderLayer& cla) = delete;
+
+ /** Assignment operator for CylinderLayers - forbidden, create a new one */
+ CylinderLayer&
+ operator=(const CylinderLayer&)
+ = delete;
+
+ /** Destructor*/
+ virtual ~CylinderLayer() {}
+ /** Transforms the layer into a Surface representation for global positioning
+ * & navigation */
+ const CylinderSurface&
+ surfaceRepresentation() const override;
+
+private:
+ /** build approach surfaces */
+ void
+ buildApproachDescriptor() const;
+
+protected:
+ /** Default Constructor*/
+ CylinderLayer() {}
+ /** Fully deployed CylinderLayer constructor */
+ CylinderLayer(std::shared_ptr<Transform3D> transform,
+ std::shared_ptr<const CylinderBounds> cbounds,
+ std::unique_ptr<SurfaceArray> surfaceArray = nullptr,
+ double thickness = 0.,
+ OverlapDescriptor* od = nullptr,
+ ApproachDescriptor* ad = nullptr,
+ int laytyp = int(Acts::passive));
+
+ /** Copy constructor with shift - will not copy anything of the static
+ * next/previous environment*/
+ CylinderLayer(const CylinderLayer& cla, const Transform3D& tr);
+};
+
+} // end of namespace
+
+#endif // TRKGEOMETY_CYLINDERLAYER_H
diff --git a/Core/include/ACTS/Layers/DiscLayer.hpp b/Core/include/ACTS/Layers/DiscLayer.hpp
index 57fdaaca4..bf920edac 100644
--- a/Core/include/ACTS/Layers/DiscLayer.hpp
+++ b/Core/include/ACTS/Layers/DiscLayer.hpp
@@ -23,76 +23,95 @@ class MsgStream;
namespace Acts {
- class DiscBounds;
- class SurfaceMaterial;
- class OverlapDescriptor;
- class ApproachDescriptor;
-
- /**
- @class DiscLayer
-
- Class to describe a disc-like detector layer for tracking,
- it inhertis from both, Layer base class
- and DiscSurface class
-
- */
-
- class DiscLayer : virtual public DiscSurface, public Layer {
-
- friend class TrackingVolume;
-
- public:
- /** Factory constructor with DiscSurface components and pointer to SurfaceArray (passing ownership) */
- static LayerPtr create(std::shared_ptr<Transform3D> transform,
- std::shared_ptr<const DiscBounds> dbounds,
- std::unique_ptr<SurfaceArray> surfaceArray = nullptr,
- double thickness = 0.,
- OverlapDescriptor* od = nullptr,
- ApproachDescriptor* ad = nullptr,
- int laytyp=int(Acts::passive))
- { return LayerPtr(new DiscLayer(transform,dbounds,std::move(surfaceArray),thickness,od,ad,laytyp)); }
-
- /** Factory constructor as copy with shift */
- static LayerPtr create(const DiscLayer& cla, const Transform3D& shift)
- { return LayerPtr(new DiscLayer(cla,shift)); }
-
- /** Clone with a shift - only cloning that is allowed */
- LayerPtr cloneWithShift(const Transform3D& shift) const override
- { return DiscLayer::create(*this,shift); }
-
- /** Copy constructor of DiscLayer - forbidden */
- DiscLayer(const DiscLayer& cla) = delete;
-
- /* *Assignment operator for DiscLayers - forbidden */
- DiscLayer& operator=(const DiscLayer&) = delete;
-
- /** Destructor*/
- virtual ~DiscLayer(){}
-
- /** Transforms the layer into a Surface representation for extrapolation */
- const DiscSurface& surfaceRepresentation() const override;
-
- private:
- /** build approach surfaces */
- void buildApproachDescriptor() const;
-
- protected:
- /** Default Constructor*/
- DiscLayer(){}
-
- /** Constructor with DiscSurface components and pointer to SurfaceArray (passing ownership) */
- DiscLayer(std::shared_ptr<Transform3D> transform,
- std::shared_ptr<const DiscBounds> dbounds,
- std::unique_ptr<SurfaceArray> surfaceArray = nullptr,
- double thickness = 0.,
- OverlapDescriptor* od = nullptr,
- ApproachDescriptor* ad = nullptr,
- int laytyp=int(Acts::active));
-
- /** Copy constructor with shift*/
- DiscLayer(const DiscLayer& cla, const Transform3D& tr);
- };
-
-} // end of namespace
-
-#endif // TRKGEOMETY_DISCLAYER_H
+class DiscBounds;
+class SurfaceMaterial;
+class OverlapDescriptor;
+class ApproachDescriptor;
+
+/**
+ @class DiscLayer
+
+ Class to describe a disc-like detector layer for tracking,
+ it inhertis from both, Layer base class
+ and DiscSurface class
+
+ */
+
+class DiscLayer : virtual public DiscSurface, public Layer
+{
+ friend class TrackingVolume;
+
+public:
+ /** Factory constructor with DiscSurface components and pointer to
+ * SurfaceArray (passing ownership) */
+ static LayerPtr
+ create(std::shared_ptr<Transform3D> transform,
+ std::shared_ptr<const DiscBounds> dbounds,
+ std::unique_ptr<SurfaceArray> surfaceArray = nullptr,
+ double thickness = 0.,
+ OverlapDescriptor* od = nullptr,
+ ApproachDescriptor* ad = nullptr,
+ int laytyp = int(Acts::passive))
+ {
+ return LayerPtr(new DiscLayer(transform,
+ dbounds,
+ std::move(surfaceArray),
+ thickness,
+ od,
+ ad,
+ laytyp));
+ }
+
+ /** Factory constructor as copy with shift */
+ static LayerPtr
+ create(const DiscLayer& cla, const Transform3D& shift)
+ {
+ return LayerPtr(new DiscLayer(cla, shift));
+ }
+
+ /** Clone with a shift - only cloning that is allowed */
+ LayerPtr
+ cloneWithShift(const Transform3D& shift) const override
+ {
+ return DiscLayer::create(*this, shift);
+ }
+
+ /** Copy constructor of DiscLayer - forbidden */
+ DiscLayer(const DiscLayer& cla) = delete;
+
+ /* *Assignment operator for DiscLayers - forbidden */
+ DiscLayer&
+ operator=(const DiscLayer&)
+ = delete;
+
+ /** Destructor*/
+ virtual ~DiscLayer() {}
+ /** Transforms the layer into a Surface representation for extrapolation */
+ const DiscSurface&
+ surfaceRepresentation() const override;
+
+private:
+ /** build approach surfaces */
+ void
+ buildApproachDescriptor() const;
+
+protected:
+ /** Default Constructor*/
+ DiscLayer() {}
+ /** Constructor with DiscSurface components and pointer to SurfaceArray
+ * (passing ownership) */
+ DiscLayer(std::shared_ptr<Transform3D> transform,
+ std::shared_ptr<const DiscBounds> dbounds,
+ std::unique_ptr<SurfaceArray> surfaceArray = nullptr,
+ double thickness = 0.,
+ OverlapDescriptor* od = nullptr,
+ ApproachDescriptor* ad = nullptr,
+ int laytyp = int(Acts::active));
+
+ /** Copy constructor with shift*/
+ DiscLayer(const DiscLayer& cla, const Transform3D& tr);
+};
+
+} // end of namespace
+
+#endif // TRKGEOMETY_DISCLAYER_H
diff --git a/Core/include/ACTS/Layers/Layer.hpp b/Core/include/ACTS/Layers/Layer.hpp
index 810328f8b..ad91b31e3 100644
--- a/Core/include/ACTS/Layers/Layer.hpp
+++ b/Core/include/ACTS/Layers/Layer.hpp
@@ -14,303 +14,377 @@
#define ACTS_DETECTOR_LAYER_H 1
// Core module
-#include "ACTS/Utilities/Definitions.hpp"
-#include "ACTS/Utilities/GeometryObject.hpp"
+#include "ACTS/EventData/NeutralParameters.hpp"
+#include "ACTS/EventData/TrackParameters.hpp"
#include "ACTS/Utilities/ApproachDescriptor.hpp"
-#include "ACTS/Utilities/OverlapDescriptor.hpp"
#include "ACTS/Utilities/BinnedArray.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Utilities/GeometryObject.hpp"
#include "ACTS/Utilities/Intersection.hpp"
+#include "ACTS/Utilities/OverlapDescriptor.hpp"
#include "ACTS/Volumes/AbstractVolume.hpp"
-#include "ACTS/EventData/TrackParameters.hpp"
-#include "ACTS/EventData/NeutralParameters.hpp"
namespace Acts {
-
- class Surface;
- class SurfaceMaterial;
- class MaterialProperties;
- class BinUtility;
- class Volume;
- class VolumeBounds;
- class TrackingVolume;
- class DetachedTrackingVolume;
- class ApproachDescriptor;
- class ICompatibilityEstimator;
-
- typedef ObjectIntersection<Surface> SurfaceIntersection;
-
- // master typedef
- class Layer;
- typedef std::shared_ptr<const Layer> LayerPtr;
- typedef std::pair<const Layer*, const Layer*> NextLayers;
-
-
- /**
- @enum LayerType
-
- For readability
- */
- enum LayerType { passive = 0,
- active = 1 };
-
- /**
- @class Layer
-
- Base Class for a Detector Layer in the Tracking realm.
- An actual implemented Detector Layer inheriting from this base
- class has to inherit from a specific type of Surface as well.
- In addition, a Layer can carry:
-
- - a SurfaceArray of Surfaces holding the actual detector elements or subSurfaces.
- - SurfaceMaterial for Surface-based materialUpdates
- - an OverlapDescriptor (mainly used for blind extrapolation)
- - a pointer to the TrackingVolume (can only be set by such)
- - an active/passive code :
- 0 - activ
- 1 - passive
- [....] - other
-
- The search type for compatible surfaces on a layer is [ the higher the number, the faster ]:
- --------- Layer internal ------------------------------------------------
- -1 - untested: provide all layer surfaces to the extrapolation engine
- - does not work with endSurface, will be increased to 0 if endSurface is given
- - debug mode only !
- 0 - test all on intersection and provide to the extrapolation engine
- --------- Overlap descriptor --------------------------------------------
- 1 - provide bin surface and registered neighbours and bin mates
- - does not work with endSurface, will be increased to 2 if endSurface is given
- 2 - as 1 but with intersection test @TODO compatibility test
- 3 - provide bin surface and next bin surfaces (if differ)
- - does not work with endSurface, will be increased to 4 if endSurface is given
- 4 - as 3 but with intersection test @TODO compatibility test
- 5 - whatever the overlap descriptor returns with this
+class Surface;
+class SurfaceMaterial;
+class MaterialProperties;
+class BinUtility;
+class Volume;
+class VolumeBounds;
+class TrackingVolume;
+class DetachedTrackingVolume;
+class ApproachDescriptor;
+class ICompatibilityEstimator;
+
+typedef ObjectIntersection<Surface> SurfaceIntersection;
+
+// master typedef
+class Layer;
+typedef std::shared_ptr<const Layer> LayerPtr;
+typedef std::pair<const Layer*, const Layer*> NextLayers;
+
+/**
+ @enum LayerType
+
+ For readability
+*/
+enum LayerType { passive = 0, active = 1 };
+
+/**
+ @class Layer
+
+ Base Class for a Detector Layer in the Tracking realm.
+ An actual implemented Detector Layer inheriting from this base
+ class has to inherit from a specific type of Surface as well.
+ In addition, a Layer can carry:
+
+ - a SurfaceArray of Surfaces holding the actual detector elements or
+ subSurfaces.
+ - SurfaceMaterial for Surface-based materialUpdates
+ - an OverlapDescriptor (mainly used for blind extrapolation)
+ - a pointer to the TrackingVolume (can only be set by such)
+ - an active/passive code :
+ 0 - activ
+ 1 - passive
+ [....] - other
+
+ The search type for compatible surfaces on a layer is [ the higher the
+ number, the faster ]:
+ --------- Layer internal ------------------------------------------------
+ -1 - untested: provide all layer surfaces to the extrapolation engine
+ - does not work with endSurface, will be increased to 0 if
+ endSurface is given
+ - debug mode only !
+ 0 - test all on intersection and provide to the extrapolation engine
+ --------- Overlap descriptor --------------------------------------------
+ 1 - provide bin surface and registered neighbours and bin mates
+ - does not work with endSurface, will be increased to 2 if
+ endSurface is given
+ 2 - as 1 but with intersection test @TODO compatibility test
+ 3 - provide bin surface and next bin surfaces (if differ)
+ - does not work with endSurface, will be increased to 4 if
+ endSurface is given
+ 4 - as 3 but with intersection test @TODO compatibility test
+ 5 - whatever the overlap descriptor returns with this
+
+*/
+
+class Layer : public virtual GeometryObject
+{
+ /** Declare the TrackingVolume as a friend, to be able to register previous,
+ next and set the enclosing TrackingVolume*/
+ friend class TrackingVolume;
+
+ /** Declare the DetachedTrackingVolume as a friend to be able to register it
+ */
+ friend class DetachedTrackingVolume;
+
+public:
+ /** Clone at a with a shift - this is the only clone allowed */
+ virtual LayerPtr
+ cloneWithShift(const Transform3D& shift) const = 0;
+
+ /** Destructor*/
+ virtual ~Layer();
+
+ /** Assignment operator - forbidden, layer assignment can be ambiguous */
+ Layer&
+ operator=(const Layer& lay)
+ = delete;
+
+ /** Return the entire SurfaceArray, returns a nullptr if no SurfaceArray */
+ const SurfaceArray*
+ surfaceArray() const;
+
+ /** Transforms the layer into a Surface representation for extrapolation */
+ virtual const Surface&
+ surfaceRepresentation() const = 0;
+
+ /** Return the Thickness of the Layer */
+ double
+ thickness() const;
+
+ /** templated onLayer() method */
+ template <class T>
+ bool
+ onLayer(const T& parameters,
+ const BoundaryCheck& bcheck = BoundaryCheck(true)) const;
+
+ /** isOnLayer() method, using isOnSurface() with Layer specific tolerance */
+ virtual bool
+ isOnLayer(const Vector3D& gp,
+ const BoundaryCheck& bcheck = BoundaryCheck(true)) const;
+
+ /** getting the overlap descriptor */
+ const OverlapDescriptor*
+ overlapDescriptor() const;
+
+ /** getting the approach descriptor */
+ const ApproachDescriptor*
+ approachDescriptor() const;
+
+ /** Surface seen on approach - if not defined differently, it is the
+ * surfaceRepresentation() */
+ virtual const SurfaceIntersection
+ surfaceOnApproach(const Vector3D& pos,
+ const Vector3D& dir,
+ PropDirection pdir,
+ const BoundaryCheck& bcheck,
+ bool resolveSubSurfaces = false,
+ const ICompatibilityEstimator* ice = nullptr) const;
+
+ /** get compatible surfaces starting from charged parameters
+ returns back the compatible surfaces either with straight line estimation,
+ or (@TODO later) with a compatiblityEstimator.
+ - if start/end surface are given, surfaces are provided in between (start
+ & end excluded)
+ - the boolean indicates if the surfaces are direction ordered
+ */
+ virtual bool
+ compatibleSurfaces(std::vector<SurfaceIntersection>& cSurfaces,
+ const TrackParameters& pars,
+ PropDirection pdir,
+ const BoundaryCheck& bcheck,
+ bool collectSensitive,
+ bool collectPassive,
+ int searchType,
+ const Surface* startSurface = nullptr,
+ const Surface* endSurface = nullptr,
+ const ICompatibilityEstimator* ice = nullptr) const;
+
+ /** get compatible surfaces starting from charged parameters
+ returns back the compatible surfaces either with straight line estimation,
+ or (@TODO later) with a compatiblityEstimator.
+ - if start/end surface are given, surfaces are provided in between (start
+ & end excluded)
+ - the boolean indicates if the surfaces are direction ordered
+ */
+ virtual bool
+ compatibleSurfaces(std::vector<SurfaceIntersection>& cSurfaces,
+ const NeutralParameters& pars,
+ PropDirection pdir,
+ const BoundaryCheck& bcheck,
+ bool collectSensitive,
+ bool collectPassive,
+ int searchType,
+ const Surface* startSurface = nullptr,
+ const Surface* endSurface = nullptr,
+ const ICompatibilityEstimator* ice = nullptr) const;
+
+ /** Has sub-structure method:
+ - sub-structure depending on :
+ (a) only when required to resolve sub surfaces for sensitive hits
+ (b) also material is ordered with sub structure */
+ virtual bool
+ hasSubStructure(bool resolveSensitive = false) const;
+
+ /** Boolean check method if layer has material:
+ - checks if any of the layer surfaces has material:
+ - can be approach surfaces or layer surface */
+ virtual bool
+ hasMaterial() const;
+
+ /** Boolean check method if layer has sensitive surfaces */
+ virtual bool
+ hasSensitive() const;
+
+ const Layer*
+ nextLayer(const Vector3D& pos, const Vector3D& dir) const;
+
+ /** get the confining TrackingVolume */
+ const TrackingVolume*
+ enclosingTrackingVolume() const;
+
+ /** get the confining DetachedTrackingVolume */
+ const DetachedTrackingVolume*
+ enclosingDetachedTrackingVolume() const;
+
+ /** register Volume associated to the layer - if you want to do that by hand*/
+ void
+ registerRepresentingVolume(const AbstractVolume* theVol) const;
+
+ /** get the Volume associated to the layer */
+ const AbstractVolume*
+ representingVolume() const;
+
+protected:
+ /** Default Constructor*/
+ Layer();
+
+ /** Copy Constructor */
+ Layer(const Layer& lay);
+
+ /** Constructor with pointer to SurfaceArray (passing ownership) */
+ Layer(std::unique_ptr<SurfaceArray> surfaceArray,
+ double thickness = 0.,
+ OverlapDescriptor* od = nullptr,
+ ApproachDescriptor* ad = nullptr,
+ int ltype = int(passive));
+
+ /** get compatible surfaces starting from charged parameters - forward call
+ * from explicit methods */
+ template <class T>
+ bool
+ getCompatibleSurfaces(std::vector<SurfaceIntersection>& cSurfaces,
+ const T& pars,
+ PropDirection pdir,
+ const BoundaryCheck& bcheck,
+ bool collectSensitive,
+ bool collectPassive,
+ int searchType,
+ const Surface* startSurface = nullptr,
+ const Surface* endSurface = nullptr,
+ const ICompatibilityEstimator* ice = nullptr) const;
+
+ /** test compatible surface - checking directly for intersection & collection
+ */
+ void
+ testCompatibleSurface(std::vector<SurfaceIntersection>& cSurfaces,
+ const Surface& surface,
+ const Vector3D& pos,
+ const Vector3D& dir,
+ PropDirection pdir,
+ const BoundaryCheck& bcheck,
+ double maxPathLength,
+ bool collectSensitive,
+ bool collectPassive,
+ bool intersectionTest,
+ const Surface* startSurface = nullptr,
+ const Surface* endSurface = nullptr,
+ const ICompatibilityEstimator* ice = nullptr) const;
+
+ /** private method to set enclosing TrackingVolume, called by friend class
+ only
+ optionally, the layer can be resized to the dimensions of the
+ TrackingVolume
+ - Bounds of the Surface are resized
+ - MaterialProperties dimensions are resized
+ - SubSurface array boundaries are NOT resized
*/
-
- class Layer : public virtual GeometryObject {
-
- /** Declare the TrackingVolume as a friend, to be able to register previous,
- next and set the enclosing TrackingVolume*/
- friend class TrackingVolume;
-
- /** Declare the DetachedTrackingVolume as a friend to be able to register it */
- friend class DetachedTrackingVolume;
-
- public:
-
- /** Clone at a with a shift - this is the only clone allowed */
- virtual LayerPtr cloneWithShift(const Transform3D& shift) const = 0;
-
- /** Destructor*/
- virtual ~Layer();
-
- /** Assignment operator - forbidden, layer assignment can be ambiguous */
- Layer& operator=(const Layer& lay) = delete;
-
- /** Return the entire SurfaceArray, returns a nullptr if no SurfaceArray */
- const SurfaceArray* surfaceArray() const;
-
- /** Transforms the layer into a Surface representation for extrapolation */
- virtual const Surface& surfaceRepresentation() const = 0;
-
- /** Return the Thickness of the Layer */
- double thickness() const;
-
- /** templated onLayer() method */
- template <class T> bool onLayer(const T& parameters, const BoundaryCheck& bcheck = BoundaryCheck(true)) const;
-
- /** isOnLayer() method, using isOnSurface() with Layer specific tolerance */
- virtual bool isOnLayer(const Vector3D& gp, const BoundaryCheck& bcheck = BoundaryCheck(true)) const;
-
- /** getting the overlap descriptor */
- const OverlapDescriptor* overlapDescriptor() const;
-
- /** getting the approach descriptor */
- const ApproachDescriptor* approachDescriptor() const;
-
- /** Surface seen on approach - if not defined differently, it is the surfaceRepresentation() */
- virtual const SurfaceIntersection surfaceOnApproach(const Vector3D& pos,
- const Vector3D& dir,
- PropDirection pdir,
- const BoundaryCheck& bcheck,
- bool resolveSubSurfaces = false,
- const ICompatibilityEstimator* ice = nullptr) const;
-
- /** get compatible surfaces starting from charged parameters
- returns back the compatible surfaces either with straight line estimation,
- or (@TODO later) with a compatiblityEstimator.
- - if start/end surface are given, surfaces are provided in between (start & end excluded)
- - the boolean indicates if the surfaces are direction ordered
- */
- virtual bool compatibleSurfaces(std::vector<SurfaceIntersection>& cSurfaces,
- const TrackParameters& pars,
- PropDirection pdir,
- const BoundaryCheck& bcheck,
- bool collectSensitive,
- bool collectPassive,
- int searchType,
- const Surface* startSurface = nullptr,
- const Surface* endSurface = nullptr,
- const ICompatibilityEstimator* ice = nullptr) const;
-
- /** get compatible surfaces starting from charged parameters
- returns back the compatible surfaces either with straight line estimation,
- or (@TODO later) with a compatiblityEstimator.
- - if start/end surface are given, surfaces are provided in between (start & end excluded)
- - the boolean indicates if the surfaces are direction ordered
- */
- virtual bool compatibleSurfaces(std::vector<SurfaceIntersection>& cSurfaces,
- const NeutralParameters& pars,
- PropDirection pdir,
- const BoundaryCheck& bcheck,
- bool collectSensitive,
- bool collectPassive,
- int searchType,
- const Surface* startSurface = nullptr,
- const Surface* endSurface = nullptr,
- const ICompatibilityEstimator* ice = nullptr) const;
-
-
- /** Has sub-structure method:
- - sub-structure depending on :
- (a) only when required to resolve sub surfaces for sensitive hits
- (b) also material is ordered with sub structure */
- virtual bool hasSubStructure(bool resolveSensitive=false) const;
-
- /** Boolean check method if layer has material:
- - checks if any of the layer surfaces has material:
- - can be approach surfaces or layer surface */
- virtual bool hasMaterial() const;
-
- /** Boolean check method if layer has sensitive surfaces */
- virtual bool hasSensitive() const;
-
- const Layer* nextLayer(const Vector3D& pos, const Vector3D& dir) const;
-
- /** get the confining TrackingVolume */
- const TrackingVolume* enclosingTrackingVolume() const;
-
- /** get the confining DetachedTrackingVolume */
- const DetachedTrackingVolume* enclosingDetachedTrackingVolume() const;
-
- /** register Volume associated to the layer - if you want to do that by hand*/
- void registerRepresentingVolume(const AbstractVolume *theVol) const;
-
- /** get the Volume associated to the layer */
- const AbstractVolume* representingVolume() const;
-
- protected:
- /** Default Constructor*/
- Layer();
-
- /** Copy Constructor */
- Layer(const Layer& lay);
-
- /** Constructor with pointer to SurfaceArray (passing ownership) */
- Layer(std::unique_ptr<SurfaceArray> surfaceArray,
- double thickness = 0.,
- OverlapDescriptor* od = nullptr,
- ApproachDescriptor* ad = nullptr,
- int ltype=int(passive));
-
- /** get compatible surfaces starting from charged parameters - forward call from explicit methods */
- template <class T> bool getCompatibleSurfaces(std::vector<SurfaceIntersection>& cSurfaces,
- const T& pars,
- PropDirection pdir,
- const BoundaryCheck& bcheck,
- bool collectSensitive,
- bool collectPassive,
- int searchType,
- const Surface* startSurface = nullptr,
- const Surface* endSurface = nullptr,
- const ICompatibilityEstimator* ice = nullptr) const;
-
- /** test compatible surface - checking directly for intersection & collection */
- void testCompatibleSurface(std::vector<SurfaceIntersection>& cSurfaces,
- const Surface& surface,
- const Vector3D& pos,
- const Vector3D& dir,
- PropDirection pdir,
- const BoundaryCheck& bcheck,
- double maxPathLength,
- bool collectSensitive,
- bool collectPassive,
- bool intersectionTest,
- const Surface* startSurface = nullptr,
- const Surface* endSurface = nullptr,
- const ICompatibilityEstimator* ice = nullptr) const;
-
-
-
- /** private method to set enclosing TrackingVolume, called by friend class only
- optionally, the layer can be resized to the dimensions of the TrackingVolume
- - Bounds of the Surface are resized
- - MaterialProperties dimensions are resized
- - SubSurface array boundaries are NOT resized
- */
- void encloseTrackingVolume(const TrackingVolume& tvol) const;
-
- /** private method to set the enclosed detached TV,
- called by friend class only */
- void encloseDetachedTrackingVolume(const DetachedTrackingVolume& tvol) const;
-
-
- mutable NextLayers m_nextLayers; //!< the previous Layer according to BinGenUtils
- mutable const BinUtility* m_nextLayerUtility; //!< the bin utility to find the next layer
-
- std::unique_ptr<SurfaceArray> m_surfaceArray; //!< SurfaceArray on this layer Surface
- double m_layerThickness; //!< thickness of the Layer
-
- OverlapDescriptor* m_overlapDescriptor; //!< descriptor for overlap/next surface
- mutable ApproachDescriptor* m_approachDescriptor; //!< surface for approaching
- mutable const TrackingVolume* m_enclosingTrackingVolume; //!< Enclosing TrackingVolume
- mutable const DetachedTrackingVolume* m_enclosingDetachedTrackingVolume; //!< Enclosing DetachedTrackingVolume
-
- mutable const AbstractVolume* m_representingVolume; //!< Representing Volume - the surfaces of that can be used as
-
- int m_layerType; //!< make a passive/active division
-
- };
-
- inline const SurfaceArray* Layer::surfaceArray() const
- { return m_surfaceArray.get(); }
-
- inline double Layer::thickness() const
- { return m_layerThickness; }
-
- inline const OverlapDescriptor* Layer::overlapDescriptor() const
- { return m_overlapDescriptor; }
-
- inline const TrackingVolume* Layer::enclosingTrackingVolume() const
- { return m_enclosingTrackingVolume; }
-
- inline void Layer::encloseTrackingVolume(const TrackingVolume& tvol) const
- { m_enclosingTrackingVolume = &(tvol); }
-
- inline const DetachedTrackingVolume* Layer::enclosingDetachedTrackingVolume() const
- { return m_enclosingDetachedTrackingVolume; }
-
- inline void Layer::encloseDetachedTrackingVolume(const DetachedTrackingVolume& tvol) const
- { m_enclosingDetachedTrackingVolume = &(tvol); }
-
- inline const AbstractVolume* Layer::representingVolume() const
- { return m_representingVolume; }
-
- inline const Layer* Layer::nextLayer(const Vector3D& gp, const Vector3D& mom) const {
- // no binutility -> no chance to find out the direction
- if (!m_nextLayerUtility) return nullptr;
- return (m_nextLayerUtility->nextDirection(gp, mom) < 0) ? m_nextLayers.first : m_nextLayers.second;
- }
-
- inline void Layer::registerRepresentingVolume(const AbstractVolume *theVol) const
- { delete m_representingVolume; m_representingVolume = theVol; }
-
- #include "ACTS/Layers/detail/Layer.ipp"
-
- /** Layers are constructedd with shared_ptr factories, hence the layer array is describes as: */
- typedef BinnedArray< LayerPtr > LayerArray;
-
-} // end of namespace
-
-#endif // ACTS_DETECTOR_LAYER_H
-
+ void
+ encloseTrackingVolume(const TrackingVolume& tvol) const;
+
+ /** private method to set the enclosed detached TV,
+ called by friend class only */
+ void
+ encloseDetachedTrackingVolume(const DetachedTrackingVolume& tvol) const;
+
+ mutable NextLayers
+ m_nextLayers; //!< the previous Layer according to BinGenUtils
+ mutable const BinUtility*
+ m_nextLayerUtility; //!< the bin utility to find the next layer
+
+ std::unique_ptr<SurfaceArray>
+ m_surfaceArray; //!< SurfaceArray on this layer Surface
+ double m_layerThickness; //!< thickness of the Layer
+
+ OverlapDescriptor*
+ m_overlapDescriptor; //!< descriptor for overlap/next surface
+ mutable ApproachDescriptor*
+ m_approachDescriptor; //!< surface for approaching
+ mutable const TrackingVolume*
+ m_enclosingTrackingVolume; //!< Enclosing TrackingVolume
+ mutable const DetachedTrackingVolume*
+ m_enclosingDetachedTrackingVolume; //!< Enclosing DetachedTrackingVolume
+
+ mutable const AbstractVolume* m_representingVolume; //!< Representing Volume
+ //!- the surfaces of that
+ //!can be used as
+
+ int m_layerType; //!< make a passive/active division
+};
+
+inline const SurfaceArray*
+Layer::surfaceArray() const
+{
+ return m_surfaceArray.get();
+}
+
+inline double
+Layer::thickness() const
+{
+ return m_layerThickness;
+}
+
+inline const OverlapDescriptor*
+Layer::overlapDescriptor() const
+{
+ return m_overlapDescriptor;
+}
+
+inline const TrackingVolume*
+Layer::enclosingTrackingVolume() const
+{
+ return m_enclosingTrackingVolume;
+}
+
+inline void
+Layer::encloseTrackingVolume(const TrackingVolume& tvol) const
+{
+ m_enclosingTrackingVolume = &(tvol);
+}
+
+inline const DetachedTrackingVolume*
+Layer::enclosingDetachedTrackingVolume() const
+{
+ return m_enclosingDetachedTrackingVolume;
+}
+
+inline void
+Layer::encloseDetachedTrackingVolume(const DetachedTrackingVolume& tvol) const
+{
+ m_enclosingDetachedTrackingVolume = &(tvol);
+}
+
+inline const AbstractVolume*
+Layer::representingVolume() const
+{
+ return m_representingVolume;
+}
+
+inline const Layer*
+Layer::nextLayer(const Vector3D& gp, const Vector3D& mom) const
+{
+ // no binutility -> no chance to find out the direction
+ if (!m_nextLayerUtility) return nullptr;
+ return (m_nextLayerUtility->nextDirection(gp, mom) < 0) ? m_nextLayers.first
+ : m_nextLayers.second;
+}
+
+inline void
+Layer::registerRepresentingVolume(const AbstractVolume* theVol) const
+{
+ delete m_representingVolume;
+ m_representingVolume = theVol;
+}
+
+#include "ACTS/Layers/detail/Layer.ipp"
+
+/** Layers are constructedd with shared_ptr factories, hence the layer array is
+ * describes as: */
+typedef BinnedArray<LayerPtr> LayerArray;
+
+} // end of namespace
+
+#endif // ACTS_DETECTOR_LAYER_H
diff --git a/Core/include/ACTS/Layers/NavigationLayer.hpp b/Core/include/ACTS/Layers/NavigationLayer.hpp
index 619803028..5d7a23005 100644
--- a/Core/include/ACTS/Layers/NavigationLayer.hpp
+++ b/Core/include/ACTS/Layers/NavigationLayer.hpp
@@ -21,90 +21,107 @@ class MsgStream;
#include "ACTS/Utilities/Definitions.hpp"
namespace Acts {
-
- class Surface;
- class BinUtility;
-
- /**
- @class NavigationLayer
-
- Class to be used for gaps in Volumes as a navigational link.
- Navigation Layers have a surface representation, but should usually never be
- propagated to.
-
-
- */
-
- class NavigationLayer : public Layer {
-
- public:
- /** Factory Constructor - the surface representation is given by pointer (ownership passed)
- - spacer layer if needed */
- static LayerPtr create(Surface* sRepresentation, double thickness=0.)
- { return LayerPtr(new NavigationLayer(sRepresentation, thickness)); }
-
- /** Clone with a shift - only cloning that is allowed */
- LayerPtr cloneWithShift(const Transform3D& shift) const override;
-
- /** Destructor*/
- virtual ~NavigationLayer();
-
- /** The binning position method - as default the center is given, but may be overloaded */
- virtual Vector3D binningPosition(BinningValue bValue) const override;
-
- /** Copy Constructor - fobidden */
- NavigationLayer(const NavigationLayer&) = delete;
-
- /** Assignment operator - forbidden */
- NavigationLayer& operator=(const NavigationLayer&) = delete;
-
- /** Transforms the layer into a Surface representation for extrapolation */
- const Surface& surfaceRepresentation() const override;
-
- /** isOnLayer() method, using isOnSurface() with Layer specific tolerance */
- bool isOnLayer(const Vector3D& gp, const BoundaryCheck& bcheck = BoundaryCheck(true)) const override;
-
- /** Boolean check method if layer has material:
- - checks if any of the layer surfaces has material:
- - can be approach surfaces or layer surface */
- bool hasMaterial() const override;
-
- /** Boolean check method if layer has sensitive surfaces */
- bool hasSensitive() const override;
-
- protected:
- /** Default Constructor*/
- NavigationLayer(){}
-
- /** Constructor - the surface representation is given by pointer (ownership passed)
- - spacer layer if needed */
- NavigationLayer(Surface* surfaceRepresentation,
- double thickness);
-
- Surface* m_surfaceRepresentation; //!< for the navigation Volume the surface is a private member */
-
- };
-
- inline const Surface& NavigationLayer::surfaceRepresentation() const
- {
- return (*m_surfaceRepresentation);
- }
-
- inline Vector3D NavigationLayer::binningPosition(BinningValue bValue) const
- {
- return m_surfaceRepresentation->binningPosition(bValue);
- }
-
- inline bool NavigationLayer::hasMaterial() const
- {
- return false;
- }
- inline bool NavigationLayer::hasSensitive() const
+class Surface;
+class BinUtility;
+
+/**
+ @class NavigationLayer
+
+ Class to be used for gaps in Volumes as a navigational link.
+ Navigation Layers have a surface representation, but should usually never be
+ propagated to.
+
+
+ */
+
+class NavigationLayer : public Layer
+{
+public:
+ /** Factory Constructor - the surface representation is given by pointer
+ (ownership passed)
+ - spacer layer if needed */
+ static LayerPtr
+ create(Surface* sRepresentation, double thickness = 0.)
{
- return false;
+ return LayerPtr(new NavigationLayer(sRepresentation, thickness));
}
-
-} // end of namespace
-#endif // ACTS_DETECTOR_NAVIGATIONLAYER_H
+ /** Clone with a shift - only cloning that is allowed */
+ LayerPtr
+ cloneWithShift(const Transform3D& shift) const override;
+
+ /** Destructor*/
+ virtual ~NavigationLayer();
+
+ /** The binning position method - as default the center is given, but may be
+ * overloaded */
+ virtual Vector3D
+ binningPosition(BinningValue bValue) const override;
+
+ /** Copy Constructor - fobidden */
+ NavigationLayer(const NavigationLayer&) = delete;
+
+ /** Assignment operator - forbidden */
+ NavigationLayer&
+ operator=(const NavigationLayer&)
+ = delete;
+
+ /** Transforms the layer into a Surface representation for extrapolation */
+ const Surface&
+ surfaceRepresentation() const override;
+
+ /** isOnLayer() method, using isOnSurface() with Layer specific tolerance */
+ bool
+ isOnLayer(const Vector3D& gp,
+ const BoundaryCheck& bcheck = BoundaryCheck(true)) const override;
+
+ /** Boolean check method if layer has material:
+ - checks if any of the layer surfaces has material:
+ - can be approach surfaces or layer surface */
+ bool
+ hasMaterial() const override;
+
+ /** Boolean check method if layer has sensitive surfaces */
+ bool
+ hasSensitive() const override;
+
+protected:
+ /** Default Constructor*/
+ NavigationLayer() {}
+ /** Constructor - the surface representation is given by pointer (ownership
+ passed)
+ - spacer layer if needed */
+ NavigationLayer(Surface* surfaceRepresentation, double thickness);
+
+ Surface* m_surfaceRepresentation; //!< for the navigation Volume the surface
+ //!is a private member */
+};
+
+inline const Surface&
+NavigationLayer::surfaceRepresentation() const
+{
+ return (*m_surfaceRepresentation);
+}
+
+inline Vector3D
+NavigationLayer::binningPosition(BinningValue bValue) const
+{
+ return m_surfaceRepresentation->binningPosition(bValue);
+}
+
+inline bool
+NavigationLayer::hasMaterial() const
+{
+ return false;
+}
+
+inline bool
+NavigationLayer::hasSensitive() const
+{
+ return false;
+}
+
+} // end of namespace
+
+#endif // ACTS_DETECTOR_NAVIGATIONLAYER_H
diff --git a/Core/include/ACTS/Layers/PlaneLayer.hpp b/Core/include/ACTS/Layers/PlaneLayer.hpp
index 015ad2c26..3b9c612aa 100644
--- a/Core/include/ACTS/Layers/PlaneLayer.hpp
+++ b/Core/include/ACTS/Layers/PlaneLayer.hpp
@@ -25,74 +25,84 @@ class MsgStream;
namespace Acts {
- class OverlapDescriptor;
- class ApproachDescriptor;
-
- /**
- @class PlaneLayer
-
- Class to describe a planar detector layer for tracking,
- it inhertis from both, Layer base class and PlaneSurface class
-
- */
-
- class PlaneLayer : virtual public PlaneSurface, public Layer {
-
- public:
- /** Factory for a shared plane layer */
- static LayerPtr create(std::shared_ptr<Transform3D> transform,
- std::shared_ptr<const PlanarBounds> pbounds,
- std::unique_ptr<SurfaceArray> surfaces = nullptr,
- double thickness = 0.,
- OverlapDescriptor* od = nullptr,
- ApproachDescriptor* ad = nullptr,
- int laytyp=int(Acts::active))
- { return LayerPtr(new PlaneLayer(transform, pbounds, std::move(surfaces), thickness, od, ad, laytyp)); }
-
- /** Factory for a shared plane layer */
- static LayerPtr create(const PlaneLayer& pla, const Transform3D& tr)
- { return LayerPtr(new PlaneLayer(pla,tr)); }
-
- /** Clone with a shift - only cloning that is allowed */
- LayerPtr cloneWithShift(const Transform3D& shift) const
- { return PlaneLayer::create(*this,shift); }
-
- /** Copy constructor of PlaneLayer - forbidden */
- PlaneLayer(const PlaneLayer& pla) = delete;
-
- /** Assignment operator for PlaneLayers - forbidden */
- PlaneLayer& operator=(const PlaneLayer&) = delete;
-
- /** Destructor*/
- virtual ~PlaneLayer(){}
-
- /** Transforms the layer into a Surface representation for extrapolation */
- const PlaneSurface& surfaceRepresentation() const;
-
- private:
-
- /** build approach surfaces */
- void buildApproachDescriptor() const;
-
- protected:
- /** Default Constructor*/
- PlaneLayer(){}
-
- /** Constructor with PlaneSurface components
- - shared bounds */
- PlaneLayer(std::shared_ptr<Transform3D> transform,
- std::shared_ptr<const PlanarBounds>& pbounds,
- std::unique_ptr<SurfaceArray> surfaceArray = nullptr,
- double thickness = 0.,
- OverlapDescriptor* od = nullptr,
- ApproachDescriptor* ad = nullptr,
- int laytyp=int(Acts::active));
-
- /** Copy constructor with shift*/
- PlaneLayer(const PlaneLayer& pla, const Transform3D& tr);
-
- };
-
-} // end of namespace
-
-#endif // TRKGEOMETY_PLANELAYER_H
+class OverlapDescriptor;
+class ApproachDescriptor;
+
+/**
+ @class PlaneLayer
+
+ Class to describe a planar detector layer for tracking,
+ it inhertis from both, Layer base class and PlaneSurface class
+
+ */
+
+class PlaneLayer : virtual public PlaneSurface, public Layer
+{
+public:
+ /** Factory for a shared plane layer */
+ static LayerPtr
+ create(std::shared_ptr<Transform3D> transform,
+ std::shared_ptr<const PlanarBounds> pbounds,
+ std::unique_ptr<SurfaceArray> surfaces = nullptr,
+ double thickness = 0.,
+ OverlapDescriptor* od = nullptr,
+ ApproachDescriptor* ad = nullptr,
+ int laytyp = int(Acts::active))
+ {
+ return LayerPtr(new PlaneLayer(
+ transform, pbounds, std::move(surfaces), thickness, od, ad, laytyp));
+ }
+
+ /** Factory for a shared plane layer */
+ static LayerPtr
+ create(const PlaneLayer& pla, const Transform3D& tr)
+ {
+ return LayerPtr(new PlaneLayer(pla, tr));
+ }
+
+ /** Clone with a shift - only cloning that is allowed */
+ LayerPtr
+ cloneWithShift(const Transform3D& shift) const
+ {
+ return PlaneLayer::create(*this, shift);
+ }
+
+ /** Copy constructor of PlaneLayer - forbidden */
+ PlaneLayer(const PlaneLayer& pla) = delete;
+
+ /** Assignment operator for PlaneLayers - forbidden */
+ PlaneLayer&
+ operator=(const PlaneLayer&)
+ = delete;
+
+ /** Destructor*/
+ virtual ~PlaneLayer() {}
+ /** Transforms the layer into a Surface representation for extrapolation */
+ const PlaneSurface&
+ surfaceRepresentation() const;
+
+private:
+ /** build approach surfaces */
+ void
+ buildApproachDescriptor() const;
+
+protected:
+ /** Default Constructor*/
+ PlaneLayer() {}
+ /** Constructor with PlaneSurface components
+ - shared bounds */
+ PlaneLayer(std::shared_ptr<Transform3D> transform,
+ std::shared_ptr<const PlanarBounds>& pbounds,
+ std::unique_ptr<SurfaceArray> surfaceArray = nullptr,
+ double thickness = 0.,
+ OverlapDescriptor* od = nullptr,
+ ApproachDescriptor* ad = nullptr,
+ int laytyp = int(Acts::active));
+
+ /** Copy constructor with shift*/
+ PlaneLayer(const PlaneLayer& pla, const Transform3D& tr);
+};
+
+} // end of namespace
+
+#endif // TRKGEOMETY_PLANELAYER_H
diff --git a/Core/include/ACTS/Layers/SubtractedCylinderLayer.hpp b/Core/include/ACTS/Layers/SubtractedCylinderLayer.hpp
index 64917a298..0024b8384 100644
--- a/Core/include/ACTS/Layers/SubtractedCylinderLayer.hpp
+++ b/Core/include/ACTS/Layers/SubtractedCylinderLayer.hpp
@@ -14,69 +14,79 @@
#define ACTS_DETECTOR_SUBTRACTEDCYLINDERLAYER_H
// Trk
-#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Layers/Layer.hpp"
#include "ACTS/Surfaces/SubtractedCylinderSurface.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
// Amg
namespace Acts {
- /**
- @class SubtractedCylinderLayer
-
- Class to describe a cylindrical detector layer for tracking, with subtraction; it inhertis from both,
- Layer base class and SubtractedCylinderSurface class
-
- */
-
- class SubtractedCylinderLayer : virtual public SubtractedCylinderSurface, public Layer {
-
- public:
- /** Factory constructor with arguments */
- static LayerPtr create(const SubtractedCylinderSurface* subCyl,
- double thickness = 0.,
- int laytyp=int(Acts::active))
- { return LayerPtr(new SubtractedCylinderLayer(subCyl,thickness, laytyp));}
-
- /** Factory copy constructor with shift */
- static LayerPtr create(const SubtractedCylinderLayer& cla, const Transform3D& tr)
- { return LayerPtr(new SubtractedCylinderLayer(cla,tr));}
-
- /** Clone with shift - the only allowed way to clone */
- LayerPtr cloneWithShift(const Transform3D& shift) const override
- { return SubtractedCylinderLayer::create(*this,shift); }
-
- /** Copy constructor - forbidden */
- SubtractedCylinderLayer(const SubtractedCylinderLayer&) = delete;
-
- /** Assignment operator - forbidden */
- SubtractedCylinderLayer& operator=(const SubtractedCylinderLayer&) = delete;
-
- /** Destructor*/
- virtual ~SubtractedCylinderLayer(){}
-
- /** Transforms the layer into a Surface representation for extrapolation */
- const SubtractedCylinderSurface& surfaceRepresentation() const override;
-
- /** use the base class insideBounds (Vector2d, BoundaryCheck) */
- using CylinderSurface::insideBounds;
-
-
- private:
- /** Default Constructor*/
- SubtractedCylinderLayer(){}
-
- /** Constructor with SubtractedCylinderSurface components */
- SubtractedCylinderLayer(const SubtractedCylinderSurface* subCyl,
- double thickness = 0.,
- int laytyp=int(Acts::active));
-
- /** Copy constructor with shift*/
- SubtractedCylinderLayer(const SubtractedCylinderLayer& cla, const Transform3D& tr);
-
- };
-
-} // end of namespace
-
-#endif // ACTS_DETECTOR_SUBTRACTEDCYLINDERLAYER_H
+/**
+ @class SubtractedCylinderLayer
+
+ Class to describe a cylindrical detector layer for tracking, with subtraction;
+ it inhertis from both,
+ Layer base class and SubtractedCylinderSurface class
+
+*/
+
+class SubtractedCylinderLayer : virtual public SubtractedCylinderSurface,
+ public Layer
+{
+public:
+ /** Factory constructor with arguments */
+ static LayerPtr
+ create(const SubtractedCylinderSurface* subCyl,
+ double thickness = 0.,
+ int laytyp = int(Acts::active))
+ {
+ return LayerPtr(new SubtractedCylinderLayer(subCyl, thickness, laytyp));
+ }
+
+ /** Factory copy constructor with shift */
+ static LayerPtr
+ create(const SubtractedCylinderLayer& cla, const Transform3D& tr)
+ {
+ return LayerPtr(new SubtractedCylinderLayer(cla, tr));
+ }
+
+ /** Clone with shift - the only allowed way to clone */
+ LayerPtr
+ cloneWithShift(const Transform3D& shift) const override
+ {
+ return SubtractedCylinderLayer::create(*this, shift);
+ }
+
+ /** Copy constructor - forbidden */
+ SubtractedCylinderLayer(const SubtractedCylinderLayer&) = delete;
+
+ /** Assignment operator - forbidden */
+ SubtractedCylinderLayer&
+ operator=(const SubtractedCylinderLayer&)
+ = delete;
+
+ /** Destructor*/
+ virtual ~SubtractedCylinderLayer() {}
+ /** Transforms the layer into a Surface representation for extrapolation */
+ const SubtractedCylinderSurface&
+ surfaceRepresentation() const override;
+
+ /** use the base class insideBounds (Vector2d, BoundaryCheck) */
+ using CylinderSurface::insideBounds;
+
+private:
+ /** Default Constructor*/
+ SubtractedCylinderLayer() {}
+ /** Constructor with SubtractedCylinderSurface components */
+ SubtractedCylinderLayer(const SubtractedCylinderSurface* subCyl,
+ double thickness = 0.,
+ int laytyp = int(Acts::active));
+
+ /** Copy constructor with shift*/
+ SubtractedCylinderLayer(const SubtractedCylinderLayer& cla,
+ const Transform3D& tr);
+};
+
+} // end of namespace
+#endif // ACTS_DETECTOR_SUBTRACTEDCYLINDERLAYER_H
diff --git a/Core/include/ACTS/Layers/SubtractedPlaneLayer.hpp b/Core/include/ACTS/Layers/SubtractedPlaneLayer.hpp
index d17c34b9f..4bd934117 100644
--- a/Core/include/ACTS/Layers/SubtractedPlaneLayer.hpp
+++ b/Core/include/ACTS/Layers/SubtractedPlaneLayer.hpp
@@ -14,68 +14,77 @@
#define ACTS_DETECTOR_SUBTRACTEDPLANELAYER_H
// Geometry module
-#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Layers/PlaneLayer.hpp"
#include "ACTS/Surfaces/SubtractedPlaneSurface.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
// Core module
namespace Acts {
- class OverlapDescriptor;
-
- /**
- @class SubtractedPlaneLayer
-
- Class to describe a planar detector layer for tracking, with subtraction
-
- */
-
- class SubtractedPlaneLayer : virtual public SubtractedPlaneSurface, public Layer {
-
- public:
- /** Factory Constructor with SubtractedPlaneSurface */
- static LayerPtr create(const SubtractedPlaneSurface* subtrPlaneSurf,
- double thickness = 0.,
- OverlapDescriptor* od = 0,
- int laytyp=int(Acts::active))
- { return LayerPtr(new SubtractedPlaneLayer(subtrPlaneSurf,thickness, od, laytyp)); }
-
- /** Factory Constructor as a copy with shift */
- static LayerPtr create(const SubtractedPlaneLayer& pla, const Transform3D& tr)
- { return LayerPtr(new SubtractedPlaneLayer(pla,tr)); }
-
- /** Clone with shift - the only allowed way to clone */
- LayerPtr cloneWithShift(const Transform3D& shift) const override
- { return SubtractedPlaneLayer::create(*this,shift); }
-
- /** Copy constructor of SubtractedPlaneLayer - is forbidden */
- SubtractedPlaneLayer(const SubtractedPlaneLayer& pla) = delete;
-
- /** Assignment operator for PlaneLayers */
- SubtractedPlaneLayer& operator=(const SubtractedPlaneLayer&) = delete;
-
- /** Destructor*/
- virtual ~SubtractedPlaneLayer(){}
-
- /** Transforms the layer into a Surface representation for extrapolation */
- const SubtractedPlaneSurface& surfaceRepresentation() const override;
-
- protected:
- /** Default Constructor*/
- SubtractedPlaneLayer(){}
-
- /** Constructor with SubtractedPlaneSurface and Material */
- SubtractedPlaneLayer(const SubtractedPlaneSurface* subtrPlaneSurf,
- double thickness = 0.,
- OverlapDescriptor* od = 0,
- int laytyp=int(Acts::active));
-
- /** Copy constructor with shift*/
- SubtractedPlaneLayer(const SubtractedPlaneLayer& pla, const Transform3D& tr);
-
- };
-
-} // end of namespace
-
-#endif // TRKGEOMETY_SUBTRACTEDPLANELAYER_H
+class OverlapDescriptor;
+
+/**
+ @class SubtractedPlaneLayer
+
+ Class to describe a planar detector layer for tracking, with subtraction
+
+ */
+
+class SubtractedPlaneLayer : virtual public SubtractedPlaneSurface, public Layer
+{
+public:
+ /** Factory Constructor with SubtractedPlaneSurface */
+ static LayerPtr
+ create(const SubtractedPlaneSurface* subtrPlaneSurf,
+ double thickness = 0.,
+ OverlapDescriptor* od = 0,
+ int laytyp = int(Acts::active))
+ {
+ return LayerPtr(
+ new SubtractedPlaneLayer(subtrPlaneSurf, thickness, od, laytyp));
+ }
+
+ /** Factory Constructor as a copy with shift */
+ static LayerPtr
+ create(const SubtractedPlaneLayer& pla, const Transform3D& tr)
+ {
+ return LayerPtr(new SubtractedPlaneLayer(pla, tr));
+ }
+
+ /** Clone with shift - the only allowed way to clone */
+ LayerPtr
+ cloneWithShift(const Transform3D& shift) const override
+ {
+ return SubtractedPlaneLayer::create(*this, shift);
+ }
+
+ /** Copy constructor of SubtractedPlaneLayer - is forbidden */
+ SubtractedPlaneLayer(const SubtractedPlaneLayer& pla) = delete;
+
+ /** Assignment operator for PlaneLayers */
+ SubtractedPlaneLayer&
+ operator=(const SubtractedPlaneLayer&)
+ = delete;
+
+ /** Destructor*/
+ virtual ~SubtractedPlaneLayer() {}
+ /** Transforms the layer into a Surface representation for extrapolation */
+ const SubtractedPlaneSurface&
+ surfaceRepresentation() const override;
+
+protected:
+ /** Default Constructor*/
+ SubtractedPlaneLayer() {}
+ /** Constructor with SubtractedPlaneSurface and Material */
+ SubtractedPlaneLayer(const SubtractedPlaneSurface* subtrPlaneSurf,
+ double thickness = 0.,
+ OverlapDescriptor* od = 0,
+ int laytyp = int(Acts::active));
+
+ /** Copy constructor with shift*/
+ SubtractedPlaneLayer(const SubtractedPlaneLayer& pla, const Transform3D& tr);
+};
+
+} // end of namespace
+#endif // TRKGEOMETY_SUBTRACTEDPLANELAYER_H
diff --git a/Core/include/ACTS/Layers/detail/Layer.ipp b/Core/include/ACTS/Layers/detail/Layer.ipp
index 8bbead963..4e5c23e60 100644
--- a/Core/include/ACTS/Layers/detail/Layer.ipp
+++ b/Core/include/ACTS/Layers/detail/Layer.ipp
@@ -1,151 +1,198 @@
-template <class T> bool Layer::onLayer(const T& pars, const BoundaryCheck& bcheck) const
+template <class T>
+bool
+Layer::onLayer(const T& pars, const BoundaryCheck& bcheck) const
{
- return isOnLayer(pars.position(),bcheck);
+ return isOnLayer(pars.position(), bcheck);
}
/** returns all Compatible surfaces with given BoundaryCheck */
-template <class T> bool Layer::getCompatibleSurfaces(std::vector<SurfaceIntersection>& cSurfaces,
- const T& pars,
- PropDirection pDir,
- const BoundaryCheck& bcheck,
- bool collectSensitive,
- bool collectPassive,
- int searchType,
- const Surface* startSurface,
- const Surface* endSurface,
- const ICompatibilityEstimator* ice) const
+template <class T>
+bool
+Layer::getCompatibleSurfaces(std::vector<SurfaceIntersection>& cSurfaces,
+ const T& pars,
+ PropDirection pDir,
+ const BoundaryCheck& bcheck,
+ bool collectSensitive,
+ bool collectPassive,
+ int searchType,
+ const Surface* startSurface,
+ const Surface* endSurface,
+ const ICompatibilityEstimator* ice) const
{
- // @TODO check if the approach surface should be provided, would be a waste since it's already propagated for
-
- // intersectionTest with searchType
- bool intersectionTest = !(searchType%2);
-
- // fast exit - nothing to do
- if (!m_surfaceArray || !m_overlapDescriptor || !m_approachDescriptor) return false;
+ // @TODO check if the approach surface should be provided, would be a waste
+ // since it's already propagated for
- // position and momentum/dir
- const Vector3D& pos = pars.position();
- const Vector3D dir = (pDir == oppositeMomentum) ? Vector3D(-1.*pars.momentum().unit()) : pars.momentum().unit() ;
+ // intersectionTest with searchType
+ bool intersectionTest = !(searchType % 2);
- // check if you have to stop at the endSurface
- double maxPathLength = 10e10;
- if (endSurface){
- // intersect the end surface
- Intersection endInter = endSurface->intersectionEstimate(pos,dir,pDir,bcheck);
- // non-valid intersection with the end surface provided at this layer indicates wrong direction or faulty setup
- // -> do not return compatible surfaces since they may lead you on a wrong navigation path
- if (endInter.valid && endInter.pathLength > 0.)
- maxPathLength = endInter.pathLength;
- else return cSurfaces.size();
- // search Type will be increased automatically when endSurface is given and no test done
- if (searchType%2) ++searchType;
- }
-
- // we have a contained surface array
- // - resolve the different search modes
- if (m_surfaceArray){
- // constructed test surfaces
- std::vector<const Surface*> compatibleTestSurfaces;
- //
- if (searchType <=0){
- // that take all the test surfaces & their bin mates
- auto allTestSurfaces = m_surfaceArray->arrayObjects();
- // reserve twice the amount
- compatibleTestSurfaces.reserve(allTestSurfaces.size());
- for (auto& atSurface : allTestSurfaces){
- // get the bin mates if they exist
- if (atSurface && atSurface->associatedDetectorElement()){
- // get the bin mates
- auto bmElements = atSurface->associatedDetectorElement()->binmembers();
- for (auto& bmElement: bmElements)
- compatibleTestSurfaces.push_back(&(bmElement->surface()));
- }
- compatibleTestSurfaces.push_back(atSurface);
- }
- } else if (m_overlapDescriptor && searchType <= 5) {
- // get the first target surface for search types > 2
- const Surface* ftSurface = m_surfaceArray->object(pos);
- // outsource to the OverlapDescriptor - if you have a first target surface
- if (ftSurface)
- m_overlapDescriptor->reachableSurfaces(compatibleTestSurfaces,
- *ftSurface,
- pos,
- dir,
- searchType);
+ // fast exit - nothing to do
+ if (!m_surfaceArray || !m_overlapDescriptor || !m_approachDescriptor)
+ return false;
+
+ // position and momentum/dir
+ const Vector3D& pos = pars.position();
+ const Vector3D dir = (pDir == oppositeMomentum)
+ ? Vector3D(-1. * pars.momentum().unit())
+ : pars.momentum().unit();
+
+ // check if you have to stop at the endSurface
+ double maxPathLength = 10e10;
+ if (endSurface) {
+ // intersect the end surface
+ Intersection endInter
+ = endSurface->intersectionEstimate(pos, dir, pDir, bcheck);
+ // non-valid intersection with the end surface provided at this layer
+ // indicates wrong direction or faulty setup
+ // -> do not return compatible surfaces since they may lead you on a wrong
+ // navigation path
+ if (endInter.valid && endInter.pathLength > 0.)
+ maxPathLength = endInter.pathLength;
+ else
+ return cSurfaces.size();
+ // search Type will be increased automatically when endSurface is given and
+ // no test done
+ if (searchType % 2) ++searchType;
+ }
+
+ // we have a contained surface array
+ // - resolve the different search modes
+ if (m_surfaceArray) {
+ // constructed test surfaces
+ std::vector<const Surface*> compatibleTestSurfaces;
+ //
+ if (searchType <= 0) {
+ // that take all the test surfaces & their bin mates
+ auto allTestSurfaces = m_surfaceArray->arrayObjects();
+ // reserve twice the amount
+ compatibleTestSurfaces.reserve(allTestSurfaces.size());
+ for (auto& atSurface : allTestSurfaces) {
+ // get the bin mates if they exist
+ if (atSurface && atSurface->associatedDetectorElement()) {
+ // get the bin mates
+ auto bmElements
+ = atSurface->associatedDetectorElement()->binmembers();
+ for (auto& bmElement : bmElements)
+ compatibleTestSurfaces.push_back(&(bmElement->surface()));
}
- // loop over all the possible surfaces and test them
- for (auto& ctSurface : compatibleTestSurfaces)
- testCompatibleSurface(cSurfaces,
- *ctSurface,
- pos,dir,pDir,
- bcheck,maxPathLength,
- collectSensitive,
- collectPassive,
- intersectionTest,
- startSurface,
- endSurface,
- ice);
-
- }
-
- // the layer surface itself is a testSurface
- const Surface* layerSurface = &surfaceRepresentation();
- testCompatibleSurface(cSurfaces,*layerSurface,pos,dir,pDir,bcheck,maxPathLength,collectSensitive,collectPassive,intersectionTest,startSurface,endSurface,ice);
-
- // the approach surfaces are testSurfaces
- if (m_approachDescriptor){
- // the approach surfaces
- const std::vector< const Surface* >& approachSurfaces = m_approachDescriptor->containedSurfaces();
- for (auto& aSurface : approachSurfaces)
- testCompatibleSurface(cSurfaces,*aSurface,pos,dir,pDir,bcheck,maxPathLength,collectSensitive,collectPassive,intersectionTest,startSurface,endSurface,ice);
+ compatibleTestSurfaces.push_back(atSurface);
+ }
+ } else if (m_overlapDescriptor && searchType <= 5) {
+ // get the first target surface for search types > 2
+ const Surface* ftSurface = m_surfaceArray->object(pos);
+ // outsource to the OverlapDescriptor - if you have a first target surface
+ if (ftSurface)
+ m_overlapDescriptor->reachableSurfaces(
+ compatibleTestSurfaces, *ftSurface, pos, dir, searchType);
}
+ // loop over all the possible surfaces and test them
+ for (auto& ctSurface : compatibleTestSurfaces)
+ testCompatibleSurface(cSurfaces,
+ *ctSurface,
+ pos,
+ dir,
+ pDir,
+ bcheck,
+ maxPathLength,
+ collectSensitive,
+ collectPassive,
+ intersectionTest,
+ startSurface,
+ endSurface,
+ ice);
+ }
+
+ // the layer surface itself is a testSurface
+ const Surface* layerSurface = &surfaceRepresentation();
+ testCompatibleSurface(cSurfaces,
+ *layerSurface,
+ pos,
+ dir,
+ pDir,
+ bcheck,
+ maxPathLength,
+ collectSensitive,
+ collectPassive,
+ intersectionTest,
+ startSurface,
+ endSurface,
+ ice);
+
+ // the approach surfaces are testSurfaces
+ if (m_approachDescriptor) {
+ // the approach surfaces
+ const std::vector<const Surface*>& approachSurfaces
+ = m_approachDescriptor->containedSurfaces();
+ for (auto& aSurface : approachSurfaces)
+ testCompatibleSurface(cSurfaces,
+ *aSurface,
+ pos,
+ dir,
+ pDir,
+ bcheck,
+ maxPathLength,
+ collectSensitive,
+ collectPassive,
+ intersectionTest,
+ startSurface,
+ endSurface,
+ ice);
+ }
+
+ // only sort it if the intersection was done
+ if (intersectionTest) std::sort(cSurfaces.begin(), cSurfaces.end());
- // only sort it if the intersection was done
- if (intersectionTest)
- std::sort(cSurfaces.begin(),cSurfaces.end());
-
- // return
- return intersectionTest;
+ // return
+ return intersectionTest;
}
-inline void Layer::testCompatibleSurface(std::vector<SurfaceIntersection>& cSurfaces,
- const Surface& surface,
- const Vector3D& pos,
- const Vector3D& dir,
- PropDirection pDir,
- const BoundaryCheck& bcheck,
- double maxPathLength,
- bool collectSensitive,
- bool collectPassive,
- bool intersectionTest,
- const Surface* startSurface,
- const Surface* endSurface,
- const ICompatibilityEstimator*) const
+inline void
+Layer::testCompatibleSurface(std::vector<SurfaceIntersection>& cSurfaces,
+ const Surface& surface,
+ const Vector3D& pos,
+ const Vector3D& dir,
+ PropDirection pDir,
+ const BoundaryCheck& bcheck,
+ double maxPathLength,
+ bool collectSensitive,
+ bool collectPassive,
+ bool intersectionTest,
+ const Surface* startSurface,
+ const Surface* endSurface,
+ const ICompatibilityEstimator*) const
{
- // fast exists
+ // fast exists
// (1) skip the start and end surface
if (&surface == endSurface || &surface == startSurface) return;
// (2) no material, no passive collection, not active
- if (!surface.isActive() && !collectPassive && surface.surfaceMaterial() == nullptr ) return;
+ if (!surface.isActive() && !collectPassive
+ && surface.surfaceMaterial() == nullptr)
+ return;
// (3) is active, not configured for collect active
- if (surface.isActive() && !collectSensitive && surface.surfaceMaterial() == nullptr ) return;
+ if (surface.isActive() && !collectSensitive
+ && surface.surfaceMaterial() == nullptr)
+ return;
// then take it if you don't have to do an intersection
- if (!intersectionTest){
- // return the surface
- cSurfaces.push_back(SurfaceIntersection(Intersection(pos, 0., true), &surface, pDir));
- // job done
- return;
+ if (!intersectionTest) {
+ // return the surface
+ cSurfaces.push_back(
+ SurfaceIntersection(Intersection(pos, 0., true), &surface, pDir));
+ // job done
+ return;
}
// check if you need to force the momentum direction
- bool fDirection = ( pDir == anyDirection ? false : true );
- // the intersection
- Intersection sfIntersection = surface.intersectionEstimate(pos, dir, fDirection, bcheck);
- // check if the intersection is valid and the maxPathLength has not been exceeded
- if (sfIntersection.valid && sfIntersection.pathLength < maxPathLength ){
- // resulting propDirection
- PropDirection rDir = ( sfIntersection.pathLength > 0 ? alongMomentum : oppositeMomentum );
- // and the surfaces & direction to push back - take all
- if (collectPassive || (collectSensitive && surface.isActive()) || surface.surfaceMaterial() )
- cSurfaces.push_back(SurfaceIntersection(sfIntersection,&surface,rDir));
- }
+ bool fDirection = (pDir == anyDirection ? false : true);
+ // the intersection
+ Intersection sfIntersection
+ = surface.intersectionEstimate(pos, dir, fDirection, bcheck);
+ // check if the intersection is valid and the maxPathLength has not been
+ // exceeded
+ if (sfIntersection.valid && sfIntersection.pathLength < maxPathLength) {
+ // resulting propDirection
+ PropDirection rDir
+ = (sfIntersection.pathLength > 0 ? alongMomentum : oppositeMomentum);
+ // and the surfaces & direction to push back - take all
+ if (collectPassive || (collectSensitive && surface.isActive())
+ || surface.surfaceMaterial())
+ cSurfaces.push_back(SurfaceIntersection(sfIntersection, &surface, rDir));
+ }
}
\ No newline at end of file
diff --git a/Core/include/ACTS/MagneticField/IMagneticFieldSvc.hpp b/Core/include/ACTS/MagneticField/IMagneticFieldSvc.hpp
index accd96f98..a01116759 100644
--- a/Core/include/ACTS/MagneticField/IMagneticFieldSvc.hpp
+++ b/Core/include/ACTS/MagneticField/IMagneticFieldSvc.hpp
@@ -15,36 +15,39 @@
#ifdef ACTS_MAGNETICFIELDINTERFACE_PLUGIN
#include ACTS_MAGNETICFIELDINTERFACE_PLUGIN
-#else
+#else
namespace Acts {
/** @ class IMagneticFieldSvc
-
- This is a highly repetitive call, hence the interface is extremely simplistic
- */
- class IMagneticFieldSvc {
-
- ///////////////////////////////////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
- public:
-
- /** get B field value at given position */
- /** xyz[3] is in mm, bxyz[3] is in kT */
- /** if deriv[9] is given, field derivatives are returned in kT/mm */
- virtual void getField(const double *xyz, double *bxyz, double *deriv = nullptr) const = 0;
+ This is a highly repetitive call, hence the interface is extremely
+ simplistic
- /** get B field value on the z-r plane at given position */
- /** works only inside the solenoid; otherwise calls getField() above */
- /** xyz[3] is in mm, bxyz[3] is in kT */
- /** if deriv[9] is given, field derivatives are returned in kT/mm */
- virtual void getFieldZR(const double *xyz, double *bxyz, double *deriv = nullptr) const = 0;
-
- };
+ */
+class IMagneticFieldSvc
+{
+ ///////////////////////////////////////////////////////////////////
+ // Public methods:
+ ///////////////////////////////////////////////////////////////////
+public:
+ /** get B field value at given position */
+ /** xyz[3] is in mm, bxyz[3] is in kT */
+ /** if deriv[9] is given, field derivatives are returned in kT/mm */
+ virtual void
+ getField(const double* xyz, double* bxyz, double* deriv = nullptr) const = 0;
+
+ /** get B field value on the z-r plane at given position */
+ /** works only inside the solenoid; otherwise calls getField() above */
+ /** xyz[3] is in mm, bxyz[3] is in kT */
+ /** if deriv[9] is given, field derivatives are returned in kT/mm */
+ virtual void
+ getFieldZR(const double* xyz,
+ double* bxyz,
+ double* deriv = nullptr) const = 0;
+};
}
-#endif // ACTS_MAGNETICFIELDINTERFACE_PLUGIN
+#endif // ACTS_MAGNETICFIELDINTERFACE_PLUGIN
-#endif //> ! ACTS_MAGNETICFIELDINTERFACES_IMAGFIELDSVC_H
+#endif //> ! ACTS_MAGNETICFIELDINTERFACES_IMAGFIELDSVC_H
diff --git a/Core/include/ACTS/Material/BinnedSurfaceMaterial.hpp b/Core/include/ACTS/Material/BinnedSurfaceMaterial.hpp
index ccccda46a..2f3c5a8c6 100644
--- a/Core/include/ACTS/Material/BinnedSurfaceMaterial.hpp
+++ b/Core/include/ACTS/Material/BinnedSurfaceMaterial.hpp
@@ -14,126 +14,144 @@
#define ACTS_MATERIAL_BINNEDSURFACEMATERIAL_H 1
// Geometry module
-#include "ACTS/Utilities/Definitions.hpp"
-#include "ACTS/Material/SurfaceMaterial.hpp"
#include "ACTS/Material/MaterialProperties.hpp"
+#include "ACTS/Material/SurfaceMaterial.hpp"
#include "ACTS/Utilities/BinUtility.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
// Core module
namespace Acts {
+/**
+ @class BinnedSurfaceMaterial
+
+ It extends the SurfaceMaterial base class and is just an array of it
- /**
- @class BinnedSurfaceMaterial
+ */
- It extends the SurfaceMaterial base class and is just an array of it
+class BinnedSurfaceMaterial : public SurfaceMaterial
+{
+public:
+ /** Default Constructor - needed by POOL*/
+ BinnedSurfaceMaterial();
+ /** Default Constructor for emptly material */
+ BinnedSurfaceMaterial(BinUtility& binutility);
+
+ /**Explizit constructor with only full MaterialProperties,
+ and split factors:
+ - 1. : oppositePre
+ - 0. : alongPre
+ ===> 1 Dimensional array
+
+ ATTENTION: Ownership of MaterialProperties objects is given!
*/
+ BinnedSurfaceMaterial(const Acts::BinUtility& binutility,
+ const MaterialPropertiesVector& fullProperties,
+ double splitFactor = 0.);
- class BinnedSurfaceMaterial : public SurfaceMaterial {
-
- public:
- /** Default Constructor - needed by POOL*/
- BinnedSurfaceMaterial();
-
- /** Default Constructor for emptly material */
- BinnedSurfaceMaterial(BinUtility& binutility);
-
- /**Explizit constructor with only full MaterialProperties,
- and split factors:
- - 1. : oppositePre
- - 0. : alongPre
- ===> 1 Dimensional array
-
- ATTENTION: Ownership of MaterialProperties objects is given!
- */
- BinnedSurfaceMaterial(const Acts::BinUtility& binutility,
- const MaterialPropertiesVector& fullProperties,
- double splitFactor=0.);
-
- /**Explizit constructor with only full MaterialProperties,
- and split factors:
- - 1. : oppositePre
- - 0. : alongPre
- ===> 2 Dimensional array
-
- ATTENTION: Ownership of MaterialProperties objects is given!
- */
- BinnedSurfaceMaterial(const Acts::BinUtility& binutility,
- const MaterialPropertiesMatrix& fullProperties,
- double splitFactor=0.);
-
- /**Copy Constructor */
- BinnedSurfaceMaterial(const BinnedSurfaceMaterial& mprop);
-
- /**Destructor*/
- virtual ~BinnedSurfaceMaterial();
-
- /**Pseudo-Constructor clone()*/
- BinnedSurfaceMaterial* clone() const override;
-
- /** Assignment operator */
- BinnedSurfaceMaterial& operator=(const BinnedSurfaceMaterial& lmp);
-
- /** Scale operator */
- BinnedSurfaceMaterial& operator*=(double scale) override;
-
- /** Return the BinUtility */
- const BinUtility* binUtility() const override;
-
- /** Update the BinUtility if necessary - passing ownership of the utility class*/
- void updateBinning(BinUtility* bu) const override;
-
- /**Return method for full material description of the Layer - for all bins*/
- const MaterialPropertiesMatrix& fullMaterial() const;
-
- /**Return method for full material description of the Layer - local coordinates */
- const MaterialProperties* material(const Vector2D& lp) const override;
-
- /**Return method for full material description of the Layer - global coordinates */
- const MaterialProperties* material(const Vector3D& gp) const override;
-
- /** Access the single bin */
- const MaterialProperties* material(size_t bin0, size_t bin1 ) const override;
-
- /** Output Method for std::ostream, to be overloaded by child classes */
- std::ostream& dump(std::ostream& sl) const override;
-
- private:
-
- mutable BinUtility* m_binUtility; //!< the helper for the bin finding
-
- /** The five different MaterialProperties */
- MaterialPropertiesMatrix m_fullMaterial;
-
- /** helper method - to clear the material*/
- void clearMaterial();
-
- /** helper method - to refill the material */
- void fillMaterial(const MaterialPropertiesMatrix& matMatrix);
-
- };
-
-
-inline const BinUtility* BinnedSurfaceMaterial::binUtility() const
- { return m_binUtility; }
-
- inline const MaterialPropertiesMatrix& BinnedSurfaceMaterial::fullMaterial() const
- { return m_fullMaterial; }
-
- inline const MaterialProperties* BinnedSurfaceMaterial::material(size_t bin0, size_t bin1 ) const
- {
- return m_fullMaterial.at(bin1).at(bin0);
- }
-
- inline void BinnedSurfaceMaterial::updateBinning(BinUtility* bu) const {
- if (bu){
- delete m_binUtility;
- m_binUtility = bu;
- }
- }
+ /**Explizit constructor with only full MaterialProperties,
+ and split factors:
+ - 1. : oppositePre
+ - 0. : alongPre
+ ===> 2 Dimensional array
+ ATTENTION: Ownership of MaterialProperties objects is given!
+ */
+ BinnedSurfaceMaterial(const Acts::BinUtility& binutility,
+ const MaterialPropertiesMatrix& fullProperties,
+ double splitFactor = 0.);
+
+ /**Copy Constructor */
+ BinnedSurfaceMaterial(const BinnedSurfaceMaterial& mprop);
+
+ /**Destructor*/
+ virtual ~BinnedSurfaceMaterial();
+
+ /**Pseudo-Constructor clone()*/
+ BinnedSurfaceMaterial*
+ clone() const override;
+
+ /** Assignment operator */
+ BinnedSurfaceMaterial&
+ operator=(const BinnedSurfaceMaterial& lmp);
+
+ /** Scale operator */
+ BinnedSurfaceMaterial&
+ operator*=(double scale) override;
+
+ /** Return the BinUtility */
+ const BinUtility*
+ binUtility() const override;
+
+ /** Update the BinUtility if necessary - passing ownership of the utility
+ * class*/
+ void
+ updateBinning(BinUtility* bu) const override;
+
+ /**Return method for full material description of the Layer - for all bins*/
+ const MaterialPropertiesMatrix&
+ fullMaterial() const;
+
+ /**Return method for full material description of the Layer - local
+ * coordinates */
+ const MaterialProperties*
+ material(const Vector2D& lp) const override;
+
+ /**Return method for full material description of the Layer - global
+ * coordinates */
+ const MaterialProperties*
+ material(const Vector3D& gp) const override;
+
+ /** Access the single bin */
+ const MaterialProperties*
+ material(size_t bin0, size_t bin1) const override;
+
+ /** Output Method for std::ostream, to be overloaded by child classes */
+ std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ mutable BinUtility* m_binUtility; //!< the helper for the bin finding
+
+ /** The five different MaterialProperties */
+ MaterialPropertiesMatrix m_fullMaterial;
+
+ /** helper method - to clear the material*/
+ void
+ clearMaterial();
+
+ /** helper method - to refill the material */
+ void
+ fillMaterial(const MaterialPropertiesMatrix& matMatrix);
+};
+
+inline const BinUtility*
+BinnedSurfaceMaterial::binUtility() const
+{
+ return m_binUtility;
+}
+
+inline const MaterialPropertiesMatrix&
+BinnedSurfaceMaterial::fullMaterial() const
+{
+ return m_fullMaterial;
+}
+inline const MaterialProperties*
+BinnedSurfaceMaterial::material(size_t bin0, size_t bin1) const
+{
+ return m_fullMaterial.at(bin1).at(bin0);
+}
+
+inline void
+BinnedSurfaceMaterial::updateBinning(BinUtility* bu) const
+{
+ if (bu) {
+ delete m_binUtility;
+ m_binUtility = bu;
+ }
+}
}
#endif
diff --git a/Core/include/ACTS/Material/HomogeneousSurfaceMaterial.hpp b/Core/include/ACTS/Material/HomogeneousSurfaceMaterial.hpp
index 7c186a52d..448c29f78 100644
--- a/Core/include/ACTS/Material/HomogeneousSurfaceMaterial.hpp
+++ b/Core/include/ACTS/Material/HomogeneousSurfaceMaterial.hpp
@@ -14,86 +14,114 @@
#define ACTS_MATERIAL_HOMOGENOUSLAYERMATERIAL_H
// Core module
-#include "ACTS/Material/SurfaceMaterial.hpp"
#include "ACTS/Material/MaterialProperties.hpp"
+#include "ACTS/Material/SurfaceMaterial.hpp"
// STD/STL
#include <vector>
#include "ACTS/Utilities/Definitions.hpp"
namespace Acts {
-
- class BinUtility;
- /**
- @class HomogeneousSurfaceMaterial
-
- It extends the SurfaceMaterial base class and describes a simple homogeneus material
- descriptions
-
- */
-
- class HomogeneousSurfaceMaterial : public SurfaceMaterial {
-
- public:
- /** Default Constructor - creates empty HomogeneousSurfaceMaterial */
- HomogeneousSurfaceMaterial();
-
- /**Explizit constructor with only full MaterialProperties, and a split factor*/
- HomogeneousSurfaceMaterial(const MaterialProperties& full, double splitFactor=1.);
-
- /**Copy Constructor */
- HomogeneousSurfaceMaterial(const HomogeneousSurfaceMaterial& mprop);
-
- /**Destructor*/
- virtual ~HomogeneousSurfaceMaterial();
-
- /**Pseudo-Constructor clone()*/
- HomogeneousSurfaceMaterial* clone() const override;
-
- /** Assignment operator */
- HomogeneousSurfaceMaterial& operator=(const HomogeneousSurfaceMaterial& lmp);
-
- /** Scale operator */
- HomogeneousSurfaceMaterial& operator*=(double scale) override;
-
- /**Return method for full material description of the Layer - local coordinates*/
- virtual const MaterialProperties* material(const Vector2D& lp) const override;
-
- /**Return method for full material description of the Layer - global coordinates*/
- virtual const MaterialProperties* material(const Vector3D& gp) const override;
-
- /**Direct access via bins to the MaterialProperties */
- virtual const MaterialProperties* material(size_t ib0, size_t ib1) const override;
-
- /** Return the BinUtility */
- const BinUtility* binUtility() const override { return nullptr; }
-
- /** Update the BinUtility if necessary - passing ownership of the utility class*/
- void updateBinning(BinUtility*) const override { }
-
- /** Output Method for std::ostream, to be overloaded by child classes */
- std::ostream& dump(std::ostream& sl) const override;
-
- private:
- /** The five different MaterialProperties */
- MaterialProperties* m_fullMaterial;
-
- };
-
-inline HomogeneousSurfaceMaterial* HomogeneousSurfaceMaterial::clone() const
- { return new HomogeneousSurfaceMaterial(*this); }
-
-inline const MaterialProperties* HomogeneousSurfaceMaterial::material(const Vector2D&) const
- { return m_fullMaterial; }
-
-inline const MaterialProperties* HomogeneousSurfaceMaterial::material(const Vector3D&) const
- { return m_fullMaterial; }
-
-inline const MaterialProperties* HomogeneousSurfaceMaterial::material(size_t, size_t) const
- { return m_fullMaterial; }
-
-} // end of namespace
-
-#endif
-
-
+class BinUtility;
+/**
+ @class HomogeneousSurfaceMaterial
+
+ It extends the SurfaceMaterial base class and describes a simple homogeneus
+ material
+ descriptions
+
+ */
+
+class HomogeneousSurfaceMaterial : public SurfaceMaterial
+{
+public:
+ /** Default Constructor - creates empty HomogeneousSurfaceMaterial */
+ HomogeneousSurfaceMaterial();
+
+ /**Explizit constructor with only full MaterialProperties, and a split
+ * factor*/
+ HomogeneousSurfaceMaterial(const MaterialProperties& full,
+ double splitFactor = 1.);
+
+ /**Copy Constructor */
+ HomogeneousSurfaceMaterial(const HomogeneousSurfaceMaterial& mprop);
+
+ /**Destructor*/
+ virtual ~HomogeneousSurfaceMaterial();
+
+ /**Pseudo-Constructor clone()*/
+ HomogeneousSurfaceMaterial*
+ clone() const override;
+
+ /** Assignment operator */
+ HomogeneousSurfaceMaterial&
+ operator=(const HomogeneousSurfaceMaterial& lmp);
+
+ /** Scale operator */
+ HomogeneousSurfaceMaterial&
+ operator*=(double scale) override;
+
+ /**Return method for full material description of the Layer - local
+ * coordinates*/
+ virtual const MaterialProperties*
+ material(const Vector2D& lp) const override;
+
+ /**Return method for full material description of the Layer - global
+ * coordinates*/
+ virtual const MaterialProperties*
+ material(const Vector3D& gp) const override;
+
+ /**Direct access via bins to the MaterialProperties */
+ virtual const MaterialProperties*
+ material(size_t ib0, size_t ib1) const override;
+
+ /** Return the BinUtility */
+ const BinUtility*
+ binUtility() const override
+ {
+ return nullptr;
+ }
+
+ /** Update the BinUtility if necessary - passing ownership of the utility
+ * class*/
+ void
+ updateBinning(BinUtility*) const override
+ {
+ }
+
+ /** Output Method for std::ostream, to be overloaded by child classes */
+ std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ /** The five different MaterialProperties */
+ MaterialProperties* m_fullMaterial;
+};
+
+inline HomogeneousSurfaceMaterial*
+HomogeneousSurfaceMaterial::clone() const
+{
+ return new HomogeneousSurfaceMaterial(*this);
+}
+
+inline const MaterialProperties*
+HomogeneousSurfaceMaterial::material(const Vector2D&) const
+{
+ return m_fullMaterial;
+}
+
+inline const MaterialProperties*
+HomogeneousSurfaceMaterial::material(const Vector3D&) const
+{
+ return m_fullMaterial;
+}
+
+inline const MaterialProperties*
+ HomogeneousSurfaceMaterial::material(size_t, size_t) const
+{
+ return m_fullMaterial;
+}
+
+} // end of namespace
+
+#endif
diff --git a/Core/include/ACTS/Material/Material.hpp b/Core/include/ACTS/Material/Material.hpp
index a21feecb1..cb4091d3e 100644
--- a/Core/include/ACTS/Material/Material.hpp
+++ b/Core/include/ACTS/Material/Material.hpp
@@ -13,207 +13,238 @@
#ifndef ACTS_MATERIAL_MATERIAL_H
#define ACTS_MATERIAL_MATERIAL_H
-#include <utility>
-#include <vector>
-#include <sstream>
-#include <iostream>
+#include <climits>
#include <iomanip>
+#include <iostream>
+#include <sstream>
#include <string>
-#include <climits>
+#include <utility>
+#include <vector>
namespace Acts {
- static double s_oneOverUcharMax = 1./double(UCHAR_MAX);
-
- /** @class ElementFraction */
- class ElementFraction : public std::pair<unsigned char, unsigned char> {
- public:
- /** Default Constructor */
- ElementFraction() :
- std::pair <unsigned char, unsigned char>(0,0)
- {}
-
- /** Copy Constructor from base class */
- ElementFraction(const std::pair<unsigned char, unsigned char>& ef ) :
- std::pair <unsigned char, unsigned char>(ef){}
-
- /**Constructor from arguments */
- ElementFraction(unsigned char iz, unsigned char ifrac) :
- std::pair <unsigned char, unsigned char>(iz,ifrac){}
-
- /** assignment operator from base class */
- ElementFraction& operator=(const std::pair<unsigned char, unsigned char>& ef )
- {
- if (this != &ef){
- std::pair<unsigned char, unsigned char>::operator=(ef);
- }
- return (*this);
- }
-
- /** Return in a nice format */
- unsigned int element() const { return static_cast<unsigned int>((*this).first); }
-
- /** Return in a nice format */
- double fraction() const { return (static_cast<unsigned int>((*this).second))*s_oneOverUcharMax; }
-
- };
-
- /** @struct MaterialComposition */
- class MaterialComposition : public std::vector< ElementFraction > {
- public:
- /** default constructor*/
- MaterialComposition() :
- std::vector< ElementFraction > ()
- {}
-
- ~MaterialComposition(){}
-
- /** constructor for persistency (1), size optimized */
- MaterialComposition(const std::vector<unsigned char>& iel, const std::vector<unsigned char>& ifrac)
- {
- reserve(iel.size());
- for (std::size_t elvc =0; elvc < iel.size() && ifrac.size(); ++elvc )
- push_back( ElementFraction(iel.at(elvc),ifrac.at(elvc)) );
- }
-
- /** constructor for persistency (2), size optimized */
- MaterialComposition(const std::vector< std::pair< unsigned char, unsigned char > >& efracs )
- {
- reserve(efracs.size());
- for (auto& efracIt : efracs )
- push_back( efracIt );
+static double s_oneOverUcharMax = 1. / double(UCHAR_MAX);
+
+/** @class ElementFraction */
+class ElementFraction : public std::pair<unsigned char, unsigned char>
+{
+public:
+ /** Default Constructor */
+ ElementFraction() : std::pair<unsigned char, unsigned char>(0, 0) {}
+ /** Copy Constructor from base class */
+ ElementFraction(const std::pair<unsigned char, unsigned char>& ef)
+ : std::pair<unsigned char, unsigned char>(ef)
+ {
+ }
+
+ /**Constructor from arguments */
+ ElementFraction(unsigned char iz, unsigned char ifrac)
+ : std::pair<unsigned char, unsigned char>(iz, ifrac)
+ {
+ }
+
+ /** assignment operator from base class */
+ ElementFraction&
+ operator=(const std::pair<unsigned char, unsigned char>& ef)
+ {
+ if (this != &ef) {
+ std::pair<unsigned char, unsigned char>::operator=(ef);
+ }
+ return (*this);
+ }
+
+ /** Return in a nice format */
+ unsigned int
+ element() const
+ {
+ return static_cast<unsigned int>((*this).first);
+ }
+
+ /** Return in a nice format */
+ double
+ fraction() const
+ {
+ return (static_cast<unsigned int>((*this).second)) * s_oneOverUcharMax;
+ }
+};
+
+/** @struct MaterialComposition */
+class MaterialComposition : public std::vector<ElementFraction>
+{
+public:
+ /** default constructor*/
+ MaterialComposition() : std::vector<ElementFraction>() {}
+ ~MaterialComposition() {}
+ /** constructor for persistency (1), size optimized */
+ MaterialComposition(const std::vector<unsigned char>& iel,
+ const std::vector<unsigned char>& ifrac)
+ {
+ reserve(iel.size());
+ for (std::size_t elvc = 0; elvc < iel.size() && ifrac.size(); ++elvc)
+ push_back(ElementFraction(iel.at(elvc), ifrac.at(elvc)));
+ }
+
+ /** constructor for persistency (2), size optimized */
+ MaterialComposition(
+ const std::vector<std::pair<unsigned char, unsigned char>>& efracs)
+ {
+ reserve(efracs.size());
+ for (auto& efracIt : efracs) push_back(efracIt);
+ }
+
+ /** Copy constructor from base class */
+ MaterialComposition(const std::vector<ElementFraction>& mc)
+ : std::vector<ElementFraction>(mc)
+ {
+ }
+
+ /** assignment operator from base class */
+ MaterialComposition&
+ operator=(const std::vector<ElementFraction>& mc)
+ {
+ if (this != &mc) {
+ std::vector<ElementFraction>::operator=(mc);
+ }
+ return (*this);
+ }
+
+ /** assignment operator for persistency (2) */
+ MaterialComposition&
+ operator=(const std::vector<std::pair<unsigned char, unsigned char>>& efracs)
+ {
+ clear();
+ reserve(efracs.size());
+ for (auto& efracIt : efracs) push_back(efracIt);
+ return (*this);
+ }
+};
+
+/** @class Material
+
+ A common object to be contained by
+ - MaterialStep ( for mapping)
+ - MaterialProperties ( for reconstruction )
+ - it is optimized for T/P split
+
+*/
+class Material
+{
+public:
+ // standard x0, l0, A, Z, rho description
+ mutable float X0;
+ mutable float L0;
+ mutable float A;
+ mutable float Z;
+ mutable float rho;
+ mutable float dEdX;
+ mutable float zOaTr;
+ mutable MaterialComposition* composition;
+
+ /** Default Constructor needed for POOL */
+ Material()
+ : X0(10.e10)
+ , L0(10.e10)
+ , A(0.)
+ , Z(0.)
+ , rho(0.)
+ , dEdX(0.)
+ , zOaTr(0.)
+ , composition(0)
+ {
+ }
+
+ /** Constructor with arguments */
+ Material(float iX0,
+ float iL0,
+ float iA,
+ float iZ,
+ float iRho,
+ float idEdX = 0.,
+ MaterialComposition* mc = 0)
+ : X0(iX0)
+ , L0(iL0)
+ , A(iA)
+ , Z(iZ)
+ , rho(iRho)
+ , dEdX(idEdX)
+ , zOaTr(iA > 0 ? iZ / iA * iRho : 0.)
+ , composition(mc)
+ {
+ }
+
+ /** Copy Constructor */
+ Material(const Material& amc)
+ : X0(amc.X0)
+ , L0(amc.L0)
+ , A(amc.A)
+ , Z(amc.Z)
+ , rho(amc.rho)
+ , dEdX(amc.dEdX)
+ , zOaTr(amc.zOaTr)
+ , composition(amc.composition ? new MaterialComposition(*amc.composition)
+ : 0)
+ {
+ }
+
+ /** Desctructor - delete the composition if there */
+ ~Material() { delete composition; }
+ /** Assignment operator */
+ Material&
+ operator=(const Material& amc)
+ {
+ if (this != &amc) {
+ X0 = amc.X0;
+ L0 = amc.L0;
+ A = amc.A;
+ Z = amc.Z;
+ rho = amc.rho;
+ dEdX = amc.dEdX;
+ zOaTr = amc.zOaTr;
+ delete composition;
+ composition
+ = amc.composition ? new MaterialComposition(*amc.composition) : 0;
}
-
- /** Copy constructor from base class */
- MaterialComposition(const std::vector< ElementFraction >& mc) :
- std::vector< ElementFraction > (mc) {}
-
- /** assignment operator from base class */
- MaterialComposition& operator=(const std::vector< ElementFraction >& mc )
- {
- if (this != &mc){
- std::vector< ElementFraction >::operator=(mc);
- }
- return (*this);
- }
-
- /** assignment operator for persistency (2) */
- MaterialComposition& operator=(const std::vector< std::pair< unsigned char, unsigned char > >& efracs )
- {
- clear();
- reserve(efracs.size());
- for (auto& efracIt : efracs )
- push_back( efracIt );
- return (*this);
- }
-
- };
-
-
- /** @class Material
-
- A common object to be contained by
- - MaterialStep ( for mapping)
- - MaterialProperties ( for reconstruction )
- - it is optimized for T/P split
-
- */
- class Material {
- public :
- // standard x0, l0, A, Z, rho description
- mutable float X0;
- mutable float L0;
- mutable float A;
- mutable float Z;
- mutable float rho;
- mutable float dEdX;
- mutable float zOaTr;
- mutable MaterialComposition* composition;
-
- /** Default Constructor needed for POOL */
- Material() :
- X0(10.e10),
- L0(10.e10),
- A(0.),
- Z(0.),
- rho(0.),
- dEdX(0.),
- zOaTr(0.),
- composition(0)
- {}
-
- /** Constructor with arguments */
- Material(float iX0,
- float iL0,
- float iA,
- float iZ,
- float iRho,
- float idEdX = 0.,
- MaterialComposition* mc = 0) :
- X0(iX0),
- L0(iL0),
- A(iA),
- Z(iZ),
- rho(iRho),
- dEdX(idEdX),
- zOaTr( iA>0? iZ/iA*iRho : 0.),
- composition(mc)
- {}
-
-
- /** Copy Constructor */
- Material(const Material& amc) :
- X0(amc.X0),
- L0(amc.L0),
- A(amc.A),
- Z(amc.Z),
- rho(amc.rho),
- dEdX(amc.dEdX),
- zOaTr(amc.zOaTr),
- composition( amc.composition ? new MaterialComposition(*amc.composition) : 0 )
- {}
-
- /** Desctructor - delete the composition if there */
- ~Material() { delete composition; }
-
- /** Assignment operator */
- Material& operator=(const Material& amc) {
- if (this != &amc){
- X0 = amc.X0;
- L0 = amc.L0;
- A = amc.A;
- Z = amc.Z;
- rho = amc.rho;
- dEdX = amc.dEdX;
- zOaTr = amc.zOaTr;
- delete composition;
- composition = amc.composition ? new MaterialComposition(*amc.composition) : 0;
- }
- return (*this);
- }
-
- /** scaling method */
- Material* scale( float sf) const;
-
- /** access to members */
- float zOverAtimesRho() const { return (*this).zOaTr; }
- float x0() const { return (*this).X0; }
- float averageZ() const { return (*this).Z; }
-
- /** spit out as a string */
- std::string toString() const {
- std::ostringstream sout;
- sout << std::setiosflags(std::ios::fixed) << std::setprecision(4);
- sout << "(" << X0 << " | " << L0 << " | " << A << " | " << Z << " | " << rho <<")";
- return sout.str();
- }
-
- };
-
- inline Material* Material::scale( float sf) const {
- return new Material( X0/sf, L0/sf, sf*A, sf*Z, sf*rho);
+ return (*this);
}
+ /** scaling method */
+ Material*
+ scale(float sf) const;
+
+ /** access to members */
+ float
+ zOverAtimesRho() const
+ {
+ return (*this).zOaTr;
+ }
+ float
+ x0() const
+ {
+ return (*this).X0;
+ }
+ float
+ averageZ() const
+ {
+ return (*this).Z;
+ }
+
+ /** spit out as a string */
+ std::string
+ toString() const
+ {
+ std::ostringstream sout;
+ sout << std::setiosflags(std::ios::fixed) << std::setprecision(4);
+ sout << "(" << X0 << " | " << L0 << " | " << A << " | " << Z << " | " << rho
+ << ")";
+ return sout.str();
+ }
+};
+
+inline Material*
+Material::scale(float sf) const
+{
+ return new Material(X0 / sf, L0 / sf, sf * A, sf * Z, sf * rho);
+}
}
#endif
diff --git a/Core/include/ACTS/Material/MaterialProperties.hpp b/Core/include/ACTS/Material/MaterialProperties.hpp
index 69b7c1591..ff6f64296 100644
--- a/Core/include/ACTS/Material/MaterialProperties.hpp
+++ b/Core/include/ACTS/Material/MaterialProperties.hpp
@@ -20,166 +20,221 @@
namespace Acts {
- /**
- @class MaterialProperties
-
- Material with information associated to a thickness of material
-
- the units are :
- - thickness [mm] ( only used for layer description)
- - X0 [mm]
- - L0 [mm]
- - A [g/mole]
- - Z
- - rho [g/mm3]
-
- */
-
- class MaterialProperties {
-
- public:
-
- /** Default Constructor */
- MaterialProperties();
-
- /** Constructor - for averaged material */
- MaterialProperties(float path,
- float Xo,
- float Lo,
- float averageA,
- float averageZ,
- float averageRho,
- float dEdX=0.);
-
- /** Constructor - for full Material class */
- MaterialProperties(const Material& material, float path);
-
- /** Copy Constructor */
- MaterialProperties(const MaterialProperties& mprop);
-
- /** Destructor */
- virtual ~MaterialProperties(){}
-
- /** Pseudo-Constructor clone() */
- virtual MaterialProperties* clone() const;
-
- /** Assignment Operator */
- MaterialProperties& operator =( const MaterialProperties& mprop);
-
- /** Scale operator - scales the material thickness */
- MaterialProperties& operator *= ( float scale);
-
- /** Return the stored Material */
- const Material& material() const;
-
- /** Return the radiation length */
- float x0() const;
-
- /** Return the nuclear interaction length */
- float l0() const;
-
- /** Return the thickness in mm */
- float thickness() const;
-
- /** Return the radiationlength fraction */
- float thicknessInX0() const;
-
- /** Return the nuclear interaction length fraction */
- float thicknessInL0() const;
-
- /** Returns the average Z of the material */
- float averageZ() const;
-
- /** Return the average A of the material [gram/mole] */
- float averageA() const;
-
- /** Return the average density of the material
- - in [g/mm^3]
- */
- float averageRho() const;
-
- /** Return the @f$ Z/A * rho @f$ */
- float zOverAtimesRho() const;
-
- /** Return the @f$ d* Z/A * rho @f$ */
- float zOverAtimesRhoTimesD() const;
-
- /** Return method for @f$ dE/dX @f$*/
- float dEdX() const;
-
- /** Material averaging */
- void addMaterial(const Material& mp, float dInX0) const;
-
- /** Set Material */
- void setMaterial(const Material& mp, float thickness=1.) const;
-
- protected:
- /** Set dEdX - important for material calibarion */
- virtual void setDeDx(float dEdX) const;
-
- mutable Material m_material;
-
- mutable float m_dInX0; //!< thickness in units of radiation length
- mutable float m_dInL0; //!< thickness in units of nuclear interaction length
- mutable float m_zOaTrTd; //!< @f$ \frac{Z}{A}\cdot\rho\cdot d @f$ - in ATLAS units
-
- };
-
- /** Return method for the full material */
- inline const Material& MaterialProperties::material() const
- { return m_material; }
-
- /** Return method for thicknes in units of radiation length - dimensionless */
- inline float MaterialProperties::thicknessInX0() const { return m_dInX0; }
-
- /** Return method for thickness in units of nuclear interaction length - dimensionless */
- inline float MaterialProperties::thicknessInL0() const { return m_dInL0; }
-
- /** Return method for thickness in mm */
- inline float MaterialProperties::thickness() const { return m_dInX0*m_material.X0; }
-
- /** Return method for radiation length - in [mm] */
- inline float MaterialProperties::x0() const
- { return m_material.X0; }
-
- /** Return method for nuclear interaction length - in [mm] */
- inline float MaterialProperties::l0() const
- { return m_material.L0; }
-
- /** Return method for @f$ \frac{A}{Z}\cdot\rho @f$ */
- inline float MaterialProperties::zOverAtimesRho() const
- { return m_material.zOaTr; }
-
- /** Return method for @f$ \frac{A}{Z}\cdot\rho\cdot d @f$ */
- inline float MaterialProperties::zOverAtimesRhoTimesD() const
- { return m_zOaTrTd; }
-
- /** Return method for @f$ A @f$ */
- inline float MaterialProperties::averageA() const
- { return m_material.A; }
-
- /** Return method for @f$ Z @f$ */
- inline float MaterialProperties::averageZ() const
- { return m_material.Z; }
-
- /** Return method for @f$ Z @f$ */
- inline float MaterialProperties::averageRho() const
- { return m_material.rho; }
-
- /** Return method for @f$ dE/dX @f$ */
- inline float MaterialProperties::dEdX() const
- { return m_material.dEdX; }
-
- /**Overload of << operator for std::ostream for debug output*/
- std::ostream& operator<<( std::ostream& sl, const MaterialProperties& mprop);
-
- /** Useful typedefs */
-
- typedef std::vector< const MaterialProperties*> MaterialPropertiesVector;
- typedef std::vector<MaterialPropertiesVector> MaterialPropertiesMatrix;
-
-
-} // end of namespace
-
-#endif // ACTS_DETECTOR_MATERIALPROPERTIES_H
-
+/**
+ @class MaterialProperties
+
+ Material with information associated to a thickness of material
+
+ the units are :
+ - thickness [mm] ( only used for layer description)
+ - X0 [mm]
+ - L0 [mm]
+ - A [g/mole]
+ - Z
+ - rho [g/mm3]
+
+ */
+
+class MaterialProperties
+{
+public:
+ /** Default Constructor */
+ MaterialProperties();
+
+ /** Constructor - for averaged material */
+ MaterialProperties(float path,
+ float Xo,
+ float Lo,
+ float averageA,
+ float averageZ,
+ float averageRho,
+ float dEdX = 0.);
+
+ /** Constructor - for full Material class */
+ MaterialProperties(const Material& material, float path);
+
+ /** Copy Constructor */
+ MaterialProperties(const MaterialProperties& mprop);
+
+ /** Destructor */
+ virtual ~MaterialProperties() {}
+ /** Pseudo-Constructor clone() */
+ virtual MaterialProperties*
+ clone() const;
+
+ /** Assignment Operator */
+ MaterialProperties&
+ operator=(const MaterialProperties& mprop);
+
+ /** Scale operator - scales the material thickness */
+ MaterialProperties&
+ operator*=(float scale);
+
+ /** Return the stored Material */
+ const Material&
+ material() const;
+
+ /** Return the radiation length */
+ float
+ x0() const;
+
+ /** Return the nuclear interaction length */
+ float
+ l0() const;
+
+ /** Return the thickness in mm */
+ float
+ thickness() const;
+
+ /** Return the radiationlength fraction */
+ float
+ thicknessInX0() const;
+
+ /** Return the nuclear interaction length fraction */
+ float
+ thicknessInL0() const;
+
+ /** Returns the average Z of the material */
+ float
+ averageZ() const;
+
+ /** Return the average A of the material [gram/mole] */
+ float
+ averageA() const;
+
+ /** Return the average density of the material
+ - in [g/mm^3]
+ */
+ float
+ averageRho() const;
+
+ /** Return the @f$ Z/A * rho @f$ */
+ float
+ zOverAtimesRho() const;
+
+ /** Return the @f$ d* Z/A * rho @f$ */
+ float
+ zOverAtimesRhoTimesD() const;
+
+ /** Return method for @f$ dE/dX @f$*/
+ float
+ dEdX() const;
+
+ /** Material averaging */
+ void
+ addMaterial(const Material& mp, float dInX0) const;
+
+ /** Set Material */
+ void
+ setMaterial(const Material& mp, float thickness = 1.) const;
+
+protected:
+ /** Set dEdX - important for material calibarion */
+ virtual void
+ setDeDx(float dEdX) const;
+
+ mutable Material m_material;
+
+ mutable float m_dInX0; //!< thickness in units of radiation length
+ mutable float m_dInL0; //!< thickness in units of nuclear interaction length
+ mutable float
+ m_zOaTrTd; //!< @f$ \frac{Z}{A}\cdot\rho\cdot d @f$ - in ATLAS units
+};
+
+/** Return method for the full material */
+inline const Material&
+MaterialProperties::material() const
+{
+ return m_material;
+}
+
+/** Return method for thicknes in units of radiation length - dimensionless */
+inline float
+MaterialProperties::thicknessInX0() const
+{
+ return m_dInX0;
+}
+
+/** Return method for thickness in units of nuclear interaction length -
+ * dimensionless */
+inline float
+MaterialProperties::thicknessInL0() const
+{
+ return m_dInL0;
+}
+
+/** Return method for thickness in mm */
+inline float
+MaterialProperties::thickness() const
+{
+ return m_dInX0 * m_material.X0;
+}
+
+/** Return method for radiation length - in [mm] */
+inline float
+MaterialProperties::x0() const
+{
+ return m_material.X0;
+}
+
+/** Return method for nuclear interaction length - in [mm] */
+inline float
+MaterialProperties::l0() const
+{
+ return m_material.L0;
+}
+
+/** Return method for @f$ \frac{A}{Z}\cdot\rho @f$ */
+inline float
+MaterialProperties::zOverAtimesRho() const
+{
+ return m_material.zOaTr;
+}
+
+/** Return method for @f$ \frac{A}{Z}\cdot\rho\cdot d @f$ */
+inline float
+MaterialProperties::zOverAtimesRhoTimesD() const
+{
+ return m_zOaTrTd;
+}
+
+/** Return method for @f$ A @f$ */
+inline float
+MaterialProperties::averageA() const
+{
+ return m_material.A;
+}
+
+/** Return method for @f$ Z @f$ */
+inline float
+MaterialProperties::averageZ() const
+{
+ return m_material.Z;
+}
+
+/** Return method for @f$ Z @f$ */
+inline float
+MaterialProperties::averageRho() const
+{
+ return m_material.rho;
+}
+
+/** Return method for @f$ dE/dX @f$ */
+inline float
+MaterialProperties::dEdX() const
+{
+ return m_material.dEdX;
+}
+
+/**Overload of << operator for std::ostream for debug output*/
+std::ostream&
+operator<<(std::ostream& sl, const MaterialProperties& mprop);
+
+/** Useful typedefs */
+
+typedef std::vector<const MaterialProperties*> MaterialPropertiesVector;
+typedef std::vector<MaterialPropertiesVector> MaterialPropertiesMatrix;
+
+} // end of namespace
+
+#endif // ACTS_DETECTOR_MATERIALPROPERTIES_H
diff --git a/Core/include/ACTS/Material/SurfaceMaterial.hpp b/Core/include/ACTS/Material/SurfaceMaterial.hpp
index c803548ae..01c46cfc4 100644
--- a/Core/include/ACTS/Material/SurfaceMaterial.hpp
+++ b/Core/include/ACTS/Material/SurfaceMaterial.hpp
@@ -18,101 +18,115 @@
// EventData module
#include "ACTS/Utilities/Definitions.hpp"
// STD/STL
-#include <vector>
#include <memory>
+#include <vector>
namespace Acts {
- class BinUtility;
- class ElementTable;
-
- /**
- @enum MaterialConcentration
-
- Simple enum to identify when a material update on a non-structured layer should be done,
- options are alongPre and oppositePre.
-
- */
-
- enum MaterialConcentration { alongPre = 1, split = 0, oppositePre = -1 };
-
- /**
- @class SurfaceMaterial
-
- MaterialProperties that are associated to a surface,
- extended by certain special representations
-
- The SurfaceMaterial class inherits from GeometryID,
- in order to allow storing the material in a file and assigning it uniquely.
-
- */
-
- class SurfaceMaterial {
-
- public:
-
- /**Constructor*/
- SurfaceMaterial() :
- m_splitFactor(1.)
- {}
-
- /**Constructor*/
- SurfaceMaterial(double splitFactor) :
- m_splitFactor(splitFactor)
- {}
-
- /**Destructor*/
- virtual ~SurfaceMaterial(){}
-
- /**Pseudo-Constructor clone()*/
- virtual SurfaceMaterial* clone() const = 0;
-
- /** Scale operator */
- virtual SurfaceMaterial& operator*=(double scale) = 0;
-
- /** Return method for full material description of the Surface - from local coordinates */
- virtual const MaterialProperties* material(const Vector2D& lp) const = 0;
-
- /** Return method for full material description of the Surface - from the global coordinates */
- virtual const MaterialProperties* material(const Vector3D& gp) const = 0;
-
- /**Direct access via bins to the MaterialProperties */
- virtual const MaterialProperties* material(size_t ib0, size_t ib1) const = 0;
-
- /** Update the ElementTable */
- void updateElementTable(std::shared_ptr<const ElementTable> ) const { return; }
-
- /** Get the ElementTable */
- const ElementTable* elementTable() const { return nullptr; }
-
- /** Update pre factor */
- double factor(PropDirection pDir, MaterialUpdateStage mStage) const;
-
- /** Return the BinUtility */
- virtual const BinUtility* binUtility() const = 0;
-
- /** Update the BinUtility if necessary - passing ownership of the utility class*/
- virtual void updateBinning(BinUtility* bu) const = 0;
-
- /** Output Method for std::ostream, to be overloaded by child classes */
- virtual std::ostream& dump(std::ostream& sl) const = 0;
-
- protected :
- double m_splitFactor; //!< the split factor in favour of oppositePre
-
- };
-
-/** inline return methods for the pre/post factors */
-inline double SurfaceMaterial::factor(PropDirection pDir, MaterialUpdateStage mStage ) const
-{
- if (mStage == Acts::fullUpdate) return 1.;
- return ( pDir*mStage > 0 ? m_splitFactor : 1.-m_splitFactor );
-}
+class BinUtility;
+class ElementTable;
+
+/**
+ @enum MaterialConcentration
+
+ Simple enum to identify when a material update on a non-structured layer
+ should be done,
+ options are alongPre and oppositePre.
+
+ */
+
+enum MaterialConcentration { alongPre = 1, split = 0, oppositePre = -1 };
+
+/**
+ @class SurfaceMaterial
+
+ MaterialProperties that are associated to a surface,
+ extended by certain special representations
+
+ The SurfaceMaterial class inherits from GeometryID,
+ in order to allow storing the material in a file and assigning it uniquely.
+
+ */
+
+class SurfaceMaterial
+{
+public:
+ /**Constructor*/
+ SurfaceMaterial() : m_splitFactor(1.) {}
+ /**Constructor*/
+ SurfaceMaterial(double splitFactor) : m_splitFactor(splitFactor) {}
+ /**Destructor*/
+ virtual ~SurfaceMaterial() {}
+ /**Pseudo-Constructor clone()*/
+ virtual SurfaceMaterial*
+ clone() const = 0;
+
+ /** Scale operator */
+ virtual SurfaceMaterial&
+ operator*=(double scale)
+ = 0;
+
+ /** Return method for full material description of the Surface - from local
+ * coordinates */
+ virtual const MaterialProperties*
+ material(const Vector2D& lp) const = 0;
+
+ /** Return method for full material description of the Surface - from the
+ * global coordinates */
+ virtual const MaterialProperties*
+ material(const Vector3D& gp) const = 0;
+
+ /**Direct access via bins to the MaterialProperties */
+ virtual const MaterialProperties*
+ material(size_t ib0, size_t ib1) const = 0;
+
+ /** Update the ElementTable */
+ void
+ updateElementTable(std::shared_ptr<const ElementTable>) const
+ {
+ return;
+ }
+
+ /** Get the ElementTable */
+ const ElementTable*
+ elementTable() const
+ {
+ return nullptr;
+ }
+
+ /** Update pre factor */
+ double
+ factor(PropDirection pDir, MaterialUpdateStage mStage) const;
+
+ /** Return the BinUtility */
+ virtual const BinUtility*
+ binUtility() const = 0;
+
+ /** Update the BinUtility if necessary - passing ownership of the utility
+ * class*/
+ virtual void
+ updateBinning(BinUtility* bu) const = 0;
+
+ /** Output Method for std::ostream, to be overloaded by child classes */
+ virtual std::ostream&
+ dump(std::ostream& sl) const = 0;
+
+protected:
+ double m_splitFactor; //!< the split factor in favour of oppositePre
+};
+
+/** inline return methods for the pre/post factors */
+inline double
+SurfaceMaterial::factor(PropDirection pDir, MaterialUpdateStage mStage) const
+{
+ if (mStage == Acts::fullUpdate) return 1.;
+ return (pDir * mStage > 0 ? m_splitFactor : 1. - m_splitFactor);
+}
//**Overload of << operator for std::ostream for debug output*/
-std::ostream& operator<<( std::ostream& sl, const SurfaceMaterial& sm);
-
-} // end of namespace
+std::ostream&
+operator<<(std::ostream& sl, const SurfaceMaterial& sm);
-#endif // ACTS_MATERIAL_SURFACEMATERIAL_H
+} // end of namespace
+#endif // ACTS_MATERIAL_SURFACEMATERIAL_H
diff --git a/Core/include/ACTS/Surfaces/BoundaryCheck.hpp b/Core/include/ACTS/Surfaces/BoundaryCheck.hpp
index 3c427e9ea..51a1f2f43 100644
--- a/Core/include/ACTS/Surfaces/BoundaryCheck.hpp
+++ b/Core/include/ACTS/Surfaces/BoundaryCheck.hpp
@@ -21,270 +21,302 @@
namespace Acts {
- /**
- @class BoundaryCheck
-
- The BoundaryCheck class allows to steer the way surface
- boundaries are used for inside/outside checks of
- parameters.
-
- These checks are performed in the local 2D frame of the
- surface and can either be:
- - inside/outside with and without tolerance
- - inside/outside according to a given chi2 value
-
- It also provides all the necessary tools for the individual implementations in the different SurfaceBounds classes.
-
- */
-
- // maint struct for comparing the extent of arbitrary convex polygons relative to prefixed axes
- struct KDOP {
- float min;
- // Minimum distance (from origin) along axes
- float max;
- // Maximum distance (from origin) along axes
- };
-
- // struct needed for FastSinCos method (see below)
- struct sincosCache {
- double sinC;
- double cosC;
- };
-
- class BoundaryCheck {
- // saves us a lot of function calls in the EllipseToPoly method
- static constexpr double s_cos22 = 0.923879532511286756128183189396788286822416625863642486115097;
- static constexpr double s_cos45 = 0.707106781186547524400844362104849039284835937688474036588339;
- static constexpr double s_cos67 = 0.382683432365089771728459984030398866761344562485627041433800;
-
- public:
- enum BoundaryCheckType {
- absolute = 0, //!< absolute check including tolerances
- chi2corr = 1 //!< relative (chi2 based) with full correlations
- };
-
- bool checkLoc1; //!< check local 1 coordinate
- bool checkLoc2; //!< check local 2 coordinate
-
- double toleranceLoc1; //!< absolute tolerance in local 1 coordinate
- double toleranceLoc2; //!< absolute tolerance in local 2 coordinate
-
- int nSigmas; //!< allowed sigmas for chi2 boundary check
- ActsSymMatrixD<2> lCovariance; //!< local covariance matrix
-
- BoundaryCheckType bcType;
-
- /** Constructor for single boolean behavious */
- BoundaryCheck(bool sCheck) :
- checkLoc1(sCheck),
- checkLoc2(sCheck),
- toleranceLoc1(0.),
- toleranceLoc2(0.),
- nSigmas(-1),
- lCovariance(ActsSymMatrixD<2>::Identity()),
- bcType(absolute)
- {}
-
- /** Constructor for tolerance based check */
- BoundaryCheck(bool chkL1, bool chkL2, double tloc1=0., double tloc2=0.) :
- checkLoc1(chkL1),
- checkLoc2(chkL2),
- toleranceLoc1(tloc1),
- toleranceLoc2(tloc2),
- nSigmas(-1),
- lCovariance(ActsSymMatrixD<2>::Identity()),
- bcType(absolute)
- {}
-
- /** Constructor for chi2 based check */
- BoundaryCheck(const ActsSymMatrixD<2>& lCov,
- int nsig=1,
- bool chkL1=true,
- bool chkL2=true) :
- checkLoc1(chkL1),
- checkLoc2(chkL2),
- toleranceLoc1(0.),
- toleranceLoc2(0.),
- nSigmas(nsig),
- lCovariance(lCov),
- bcType(chi2corr)
- {}
-
- /** Conversion operator to bool */
- operator bool() const { return (checkLoc1 || checkLoc2); }
-
-
- /** Each Bounds has a method inside, which checks if a LocalPosition is inside the bounds.
- Inside can be called without/with boundary check */
- void ComputeKDOP(std::vector<Vector2D> v, std::vector<Vector2D> KDOPAxes, std::vector<KDOP> &kdop) const;
-
- std::vector<Vector2D> EllipseToPoly(int resolution = 3) const;
-
- bool TestKDOPKDOP(std::vector<KDOP> &a, std::vector<KDOP> &b) const;
-
- double FastArcTan(double x) const;
-
- sincosCache FastSinCos(double x) const;
- };
-
- // should have maximum (average) error of 0.0015 (0.00089) radians or 0.0859 (0.0509) degrees, fine for us and much faster (>4 times)
- inline double BoundaryCheck::FastArcTan(double x) const
- {
- double y;
- bool complement = false; // true if arg was >1
- bool sign = false; // true if arg was < 0
- if (x<0.){
- x = -x;
- sign = true; // arctan(-x)=-arctan(x)
- }
- if (x>1.){
- x = 1./x; // keep arg between 0 and 1
- complement = true;
- }
- y = M_PI_4*x - x*(fabs(x) - 1)*(0.2447 + 0.0663*fabs(x));
- if (complement) y = M_PI_2 - y; // correct for 1/x if we did that
- if (sign) y = -y; // correct for negative arg
- return y;
- }
-
- // should have maximum (average) error of 0.001 (0.0005) radians or 0.0573 (0.029) degrees, fine for us and much faster (>8 times)
- inline sincosCache BoundaryCheck::FastSinCos(double x) const
- {
- sincosCache tmp;
- //always wrap input angle to -PI..PI
- if (x < -M_PI)
- x += 2.*M_PI;
- else
- if (x > M_PI)
- x -= 2.*M_PI;
-
- //compute sine
- if (x < 0.)
- {
- tmp.sinC = 1.27323954 * x + .405284735 * x * x;
-
- if (tmp.sinC < 0.)
- tmp.sinC = .225 * (tmp.sinC *-tmp.sinC - tmp.sinC) + tmp.sinC;
- else
- tmp.sinC = .225 * (tmp.sinC * tmp.sinC - tmp.sinC) + tmp.sinC;
- }
- else
- {
- tmp.sinC = 1.27323954 * x - 0.405284735 * x * x;
-
- if (tmp.sinC < 0.)
- tmp.sinC = .225 * (tmp.sinC *-tmp.sinC - tmp.sinC) + tmp.sinC;
- else
- tmp.sinC = .225 * (tmp.sinC * tmp.sinC - tmp.sinC) + tmp.sinC;
- }
-
- //compute cosine: sin(x + PI/2) = cos(x)
- x += M_PI_2;
- if (x > M_PI)
- x -= 2.*M_PI;
-
- if (x < 0.)
- {
- tmp.cosC = 1.27323954 * x + 0.405284735 * x * x;
-
- if (tmp.cosC < 0.)
- tmp.cosC = .225 * (tmp.cosC *-tmp.cosC - tmp.cosC) + tmp.cosC;
- else
- tmp.cosC = .225 * (tmp.cosC * tmp.cosC - tmp.cosC) + tmp.cosC;
- }
- else
- {
- tmp.cosC = 1.27323954 * x - 0.405284735 * x * x;
-
- if (tmp.cosC < 0.)
- tmp.cosC = .225 * (tmp.cosC *-tmp.cosC - tmp.cosC) + tmp.cosC;
- else
- tmp.cosC = .225 * (tmp.cosC * tmp.cosC - tmp.cosC) + tmp.cosC;
- }
- return tmp;
- }
-
- // does the conversion of an ellipse of height h and width w to an polygon with 4 + 4*resolution points
- inline std::vector<Vector2D> BoundaryCheck::EllipseToPoly(int resolution) const
- {
- const double h = nSigmas*sqrt(lCovariance(1,1));
- const double w = nSigmas*sqrt(lCovariance(0,0));
-
- // first add the four vertices
- std::vector<Vector2D> v((1+resolution)*4);
- Vector2D p;
- p << w, 0; v.at(0) = p;
- p << -w,0; v.at(1) = p;
- p << 0, h; v.at(2) = p;
- p << 0,-h; v.at(3) = p;
-
- // now add a number, equal to the resolution, of equidistant points in each quadrant
- // resolution == 3 seems to be a solid working point, but possibility open to change to any number in the future
- Vector2D t(1,1);
- ActsSymMatrixD<2> t1; t1 << 1,0,0,-1;
- ActsSymMatrixD<2> t2; t2 << -1,0,0,-1;
- ActsSymMatrixD<2> t3; t3 << -1,0,0,1;
- if(resolution != 3){
- sincosCache scResult;
- for(int i=1; i<=resolution; i++) {
- scResult = FastSinCos(M_PI_2*i/(resolution+1));
- t << w*scResult.sinC,h*scResult.cosC;
- v.at(i*4+0) = t;
- v.at(i*4+1) = t1*t;
- v.at(i*4+2) = t2*t;
- v.at(i*4+3) = t3*t;
- }
- }
- else{
- t << w*s_cos22,h*s_cos67;
- v.at(4) = t;
- v.at(5) = t1*t;
- v.at(6) = t2*t;
- v.at(7) = t3*t;
- t << w*s_cos45,h*s_cos45;
- v.at(8) = t;
- v.at(9) = t1*t;
- v.at(10) = t2*t;
- v.at(11) = t3*t;
- t << w*s_cos67,h*s_cos22;
- v.at(12) = t;
- v.at(13) = t1*t;
- v.at(14) = t2*t;
- v.at(15) = t3*t;
- }
- return v;
- }
-
- // calculates KDOP object from given polygon and set of axes
- inline void BoundaryCheck::ComputeKDOP(std::vector<Vector2D> v, std::vector<Vector2D> KDOPAxes, std::vector<KDOP> &kdop) const
- {
- // initialize KDOP to first point
- unsigned int k = KDOPAxes.size();
- for(unsigned int i=0; i<k; i++) {
- kdop.at(i).max = KDOPAxes.at(i)(0,0)*v.at(0)(0,0)+KDOPAxes.at(i)(1,0)*v.at(0)(1,0);
- kdop.at(i).min = KDOPAxes.at(i)(0,0)*v.at(0)(0,0)+KDOPAxes.at(i)(1,0)*v.at(0)(1,0);
- }
- // now for each additional point, update KDOP bounds if necessary
- float value;
- for(unsigned int i=1; i<v.size(); i++) {
- for(unsigned int j=0; j<k; j++) {
- value = KDOPAxes.at(j)(0,0)*v.at(i)(0,0)+KDOPAxes.at(j)(1,0)*v.at(i)(1,0);
- if (value < kdop.at(j).min) kdop.at(j).min = value;
- else if (value > kdop.at(j).max) kdop.at(j).max = value;
- }
- }
- }
-
- // this is the method to actually check if two KDOPs overlap
- inline bool BoundaryCheck::TestKDOPKDOP(std::vector<KDOP> &a, std::vector<KDOP> &b) const
- {
- int k = a.size();
- // check if any intervals are non-overlapping, return if so
- for(int i=0;i<k;i++) if(a.at(i).min > b.at(i).max || a.at(i).max < b.at(i).min) return false;
- // all intervals are overlapping, so KDOPs must intersect
- return true;
- }
+/**
+ @class BoundaryCheck
+
+ The BoundaryCheck class allows to steer the way surface
+ boundaries are used for inside/outside checks of
+ parameters.
+
+ These checks are performed in the local 2D frame of the
+ surface and can either be:
+ - inside/outside with and without tolerance
+ - inside/outside according to a given chi2 value
+
+It also provides all the necessary tools for the individual implementations in
+the different SurfaceBounds classes.
+
+ */
+
+// maint struct for comparing the extent of arbitrary convex polygons relative
+// to prefixed axes
+struct KDOP
+{
+ float min;
+ // Minimum distance (from origin) along axes
+ float max;
+ // Maximum distance (from origin) along axes
+};
+
+// struct needed for FastSinCos method (see below)
+struct sincosCache
+{
+ double sinC;
+ double cosC;
+};
+
+class BoundaryCheck
+{
+ // saves us a lot of function calls in the EllipseToPoly method
+ static constexpr double s_cos22
+ = 0.923879532511286756128183189396788286822416625863642486115097;
+ static constexpr double s_cos45
+ = 0.707106781186547524400844362104849039284835937688474036588339;
+ static constexpr double s_cos67
+ = 0.382683432365089771728459984030398866761344562485627041433800;
+
+public:
+ enum BoundaryCheckType {
+ absolute = 0, //!< absolute check including tolerances
+ chi2corr = 1 //!< relative (chi2 based) with full correlations
+ };
+
+ bool checkLoc1; //!< check local 1 coordinate
+ bool checkLoc2; //!< check local 2 coordinate
+
+ double toleranceLoc1; //!< absolute tolerance in local 1 coordinate
+ double toleranceLoc2; //!< absolute tolerance in local 2 coordinate
+
+ int nSigmas; //!< allowed sigmas for chi2 boundary check
+ ActsSymMatrixD<2> lCovariance; //!< local covariance matrix
+
+ BoundaryCheckType bcType;
+
+ /** Constructor for single boolean behavious */
+ BoundaryCheck(bool sCheck)
+ : checkLoc1(sCheck)
+ , checkLoc2(sCheck)
+ , toleranceLoc1(0.)
+ , toleranceLoc2(0.)
+ , nSigmas(-1)
+ , lCovariance(ActsSymMatrixD<2>::Identity())
+ , bcType(absolute)
+ {
+ }
+
+ /** Constructor for tolerance based check */
+ BoundaryCheck(bool chkL1, bool chkL2, double tloc1 = 0., double tloc2 = 0.)
+ : checkLoc1(chkL1)
+ , checkLoc2(chkL2)
+ , toleranceLoc1(tloc1)
+ , toleranceLoc2(tloc2)
+ , nSigmas(-1)
+ , lCovariance(ActsSymMatrixD<2>::Identity())
+ , bcType(absolute)
+ {
+ }
+
+ /** Constructor for chi2 based check */
+ BoundaryCheck(const ActsSymMatrixD<2>& lCov,
+ int nsig = 1,
+ bool chkL1 = true,
+ bool chkL2 = true)
+ : checkLoc1(chkL1)
+ , checkLoc2(chkL2)
+ , toleranceLoc1(0.)
+ , toleranceLoc2(0.)
+ , nSigmas(nsig)
+ , lCovariance(lCov)
+ , bcType(chi2corr)
+ {
+ }
+
+ /** Conversion operator to bool */
+ operator bool() const { return (checkLoc1 || checkLoc2); }
+ /** Each Bounds has a method inside, which checks if a LocalPosition is inside
+ the bounds.
+ Inside can be called without/with boundary check */
+ void
+ ComputeKDOP(std::vector<Vector2D> v,
+ std::vector<Vector2D> KDOPAxes,
+ std::vector<KDOP>& kdop) const;
+
+ std::vector<Vector2D>
+ EllipseToPoly(int resolution = 3) const;
+
+ bool
+ TestKDOPKDOP(std::vector<KDOP>& a, std::vector<KDOP>& b) const;
+
+ double
+ FastArcTan(double x) const;
+
+ sincosCache
+ FastSinCos(double x) const;
+};
+
+// should have maximum (average) error of 0.0015 (0.00089) radians or 0.0859
+// (0.0509) degrees, fine for us and much faster (>4 times)
+inline double
+BoundaryCheck::FastArcTan(double x) const
+{
+ double y;
+ bool complement = false; // true if arg was >1
+ bool sign = false; // true if arg was < 0
+ if (x < 0.) {
+ x = -x;
+ sign = true; // arctan(-x)=-arctan(x)
+ }
+ if (x > 1.) {
+ x = 1. / x; // keep arg between 0 and 1
+ complement = true;
+ }
+ y = M_PI_4 * x - x * (fabs(x) - 1) * (0.2447 + 0.0663 * fabs(x));
+ if (complement) y = M_PI_2 - y; // correct for 1/x if we did that
+ if (sign) y = -y; // correct for negative arg
+ return y;
+}
+
+// should have maximum (average) error of 0.001 (0.0005) radians or 0.0573
+// (0.029) degrees, fine for us and much faster (>8 times)
+inline sincosCache
+BoundaryCheck::FastSinCos(double x) const
+{
+ sincosCache tmp;
+ // always wrap input angle to -PI..PI
+ if (x < -M_PI)
+ x += 2. * M_PI;
+ else if (x > M_PI)
+ x -= 2. * M_PI;
+
+ // compute sine
+ if (x < 0.) {
+ tmp.sinC = 1.27323954 * x + .405284735 * x * x;
+
+ if (tmp.sinC < 0.)
+ tmp.sinC = .225 * (tmp.sinC * -tmp.sinC - tmp.sinC) + tmp.sinC;
+ else
+ tmp.sinC = .225 * (tmp.sinC * tmp.sinC - tmp.sinC) + tmp.sinC;
+ } else {
+ tmp.sinC = 1.27323954 * x - 0.405284735 * x * x;
+
+ if (tmp.sinC < 0.)
+ tmp.sinC = .225 * (tmp.sinC * -tmp.sinC - tmp.sinC) + tmp.sinC;
+ else
+ tmp.sinC = .225 * (tmp.sinC * tmp.sinC - tmp.sinC) + tmp.sinC;
+ }
+
+ // compute cosine: sin(x + PI/2) = cos(x)
+ x += M_PI_2;
+ if (x > M_PI) x -= 2. * M_PI;
+
+ if (x < 0.) {
+ tmp.cosC = 1.27323954 * x + 0.405284735 * x * x;
+
+ if (tmp.cosC < 0.)
+ tmp.cosC = .225 * (tmp.cosC * -tmp.cosC - tmp.cosC) + tmp.cosC;
+ else
+ tmp.cosC = .225 * (tmp.cosC * tmp.cosC - tmp.cosC) + tmp.cosC;
+ } else {
+ tmp.cosC = 1.27323954 * x - 0.405284735 * x * x;
+
+ if (tmp.cosC < 0.)
+ tmp.cosC = .225 * (tmp.cosC * -tmp.cosC - tmp.cosC) + tmp.cosC;
+ else
+ tmp.cosC = .225 * (tmp.cosC * tmp.cosC - tmp.cosC) + tmp.cosC;
+ }
+ return tmp;
+}
+
+// does the conversion of an ellipse of height h and width w to an polygon with
+// 4 + 4*resolution points
+inline std::vector<Vector2D>
+BoundaryCheck::EllipseToPoly(int resolution) const
+{
+ const double h = nSigmas * sqrt(lCovariance(1, 1));
+ const double w = nSigmas * sqrt(lCovariance(0, 0));
+
+ // first add the four vertices
+ std::vector<Vector2D> v((1 + resolution) * 4);
+ Vector2D p;
+ p << w, 0;
+ v.at(0) = p;
+ p << -w, 0;
+ v.at(1) = p;
+ p << 0, h;
+ v.at(2) = p;
+ p << 0, -h;
+ v.at(3) = p;
+
+ // now add a number, equal to the resolution, of equidistant points in each
+ // quadrant
+ // resolution == 3 seems to be a solid working point, but possibility open to
+ // change to any number in the future
+ Vector2D t(1, 1);
+ ActsSymMatrixD<2> t1;
+ t1 << 1, 0, 0, -1;
+ ActsSymMatrixD<2> t2;
+ t2 << -1, 0, 0, -1;
+ ActsSymMatrixD<2> t3;
+ t3 << -1, 0, 0, 1;
+ if (resolution != 3) {
+ sincosCache scResult;
+ for (int i = 1; i <= resolution; i++) {
+ scResult = FastSinCos(M_PI_2 * i / (resolution + 1));
+ t << w * scResult.sinC, h * scResult.cosC;
+ v.at(i * 4 + 0) = t;
+ v.at(i * 4 + 1) = t1 * t;
+ v.at(i * 4 + 2) = t2 * t;
+ v.at(i * 4 + 3) = t3 * t;
+ }
+ } else {
+ t << w * s_cos22, h * s_cos67;
+ v.at(4) = t;
+ v.at(5) = t1 * t;
+ v.at(6) = t2 * t;
+ v.at(7) = t3 * t;
+ t << w * s_cos45, h * s_cos45;
+ v.at(8) = t;
+ v.at(9) = t1 * t;
+ v.at(10) = t2 * t;
+ v.at(11) = t3 * t;
+ t << w * s_cos67, h * s_cos22;
+ v.at(12) = t;
+ v.at(13) = t1 * t;
+ v.at(14) = t2 * t;
+ v.at(15) = t3 * t;
+ }
+ return v;
+}
+
+// calculates KDOP object from given polygon and set of axes
+inline void
+BoundaryCheck::ComputeKDOP(std::vector<Vector2D> v,
+ std::vector<Vector2D> KDOPAxes,
+ std::vector<KDOP>& kdop) const
+{
+ // initialize KDOP to first point
+ unsigned int k = KDOPAxes.size();
+ for (unsigned int i = 0; i < k; i++) {
+ kdop.at(i).max = KDOPAxes.at(i)(0, 0) * v.at(0)(0, 0)
+ + KDOPAxes.at(i)(1, 0) * v.at(0)(1, 0);
+ kdop.at(i).min = KDOPAxes.at(i)(0, 0) * v.at(0)(0, 0)
+ + KDOPAxes.at(i)(1, 0) * v.at(0)(1, 0);
+ }
+ // now for each additional point, update KDOP bounds if necessary
+ float value;
+ for (unsigned int i = 1; i < v.size(); i++) {
+ for (unsigned int j = 0; j < k; j++) {
+ value = KDOPAxes.at(j)(0, 0) * v.at(i)(0, 0)
+ + KDOPAxes.at(j)(1, 0) * v.at(i)(1, 0);
+ if (value < kdop.at(j).min)
+ kdop.at(j).min = value;
+ else if (value > kdop.at(j).max)
+ kdop.at(j).max = value;
+ }
+ }
+}
+// this is the method to actually check if two KDOPs overlap
+inline bool
+BoundaryCheck::TestKDOPKDOP(std::vector<KDOP>& a, std::vector<KDOP>& b) const
+{
+ int k = a.size();
+ // check if any intervals are non-overlapping, return if so
+ for (int i = 0; i < k; i++)
+ if (a.at(i).min > b.at(i).max || a.at(i).max < b.at(i).min) return false;
+ // all intervals are overlapping, so KDOPs must intersect
+ return true;
+}
}
-#endif // ACTS_SURFACES_BOUNDARYCHECK_H
+#endif // ACTS_SURFACES_BOUNDARYCHECK_H
diff --git a/Core/include/ACTS/Surfaces/ConeBounds.hpp b/Core/include/ACTS/Surfaces/ConeBounds.hpp
index 4852ede5a..0ac5d78f3 100644
--- a/Core/include/ACTS/Surfaces/ConeBounds.hpp
+++ b/Core/include/ACTS/Surfaces/ConeBounds.hpp
@@ -13,222 +13,314 @@
#ifndef ACTS_SURFACESCONEBOUNDS_H
#define ACTS_SURFACESCONEBOUNDS_H
-#include<cfloat>
+#include <cfloat>
#include "ACTS/Surfaces/SurfaceBounds.hpp"
#include "ACTS/Utilities/Definitions.hpp"
namespace Acts {
- /**
- @class ConeBounds
-
- Bounds for a conical Surface,
- the opening angle is stored in \f$ \tan(\alpha) \f$ and always positively defined.
- The cone can open to both sides, steered by \f$ z_min \f$ and \f$ z_max \f$.
-
- @image html ConeBounds.gif
-
- */
-
- class ConeBounds : public SurfaceBounds {
- public:
- /** BoundValues for readablility */
- enum BoundValues {
- bv_alpha = 0,
- bv_minZ = 1,
- bv_maxZ = 2,
- bv_averagePhi = 3,
- bv_halfPhiSector = 4,
- bv_length = 5
- };
-
- /** Default Constructor*/
- ConeBounds();
-
- /** Constructor - open cone with alpha, by default a full cone
- but optionally can make a conical section */
- ConeBounds(double alpha, bool symm, double halfphi=M_PI, double avphi=0.);
+/**
+ @class ConeBounds
+
+ Bounds for a conical Surface,
+ the opening angle is stored in \f$ \tan(\alpha) \f$ and always positively
+ defined.
+ The cone can open to both sides, steered by \f$ z_min \f$ and \f$ z_max \f$.
+
+ @image html ConeBounds.gif
+
+*/
+
+class ConeBounds : public SurfaceBounds
+{
+public:
+ /** BoundValues for readablility */
+ enum BoundValues {
+ bv_alpha = 0,
+ bv_minZ = 1,
+ bv_maxZ = 2,
+ bv_averagePhi = 3,
+ bv_halfPhiSector = 4,
+ bv_length = 5
+ };
+
+ /** Default Constructor*/
+ ConeBounds();
+
+ /** Constructor - open cone with alpha, by default a full cone
+ but optionally can make a conical section */
+ ConeBounds(double alpha, bool symm, double halfphi = M_PI, double avphi = 0.);
+
+ /** Constructor - open cone with alpha, minz and maxz, by
+ default a full cone but can optionally make it a conical section */
+ ConeBounds(double alpha,
+ double zmin,
+ double zmax,
+ double halfphi = M_PI,
+ double avphi = 0.);
+
+ /** Copy Constructor */
+ ConeBounds(const ConeBounds& cylbo);
+
+ /** Destructor */
+ virtual ~ConeBounds();
+
+ /** Assignment operator*/
+ ConeBounds&
+ operator=(const ConeBounds& cylbo);
+
+ /** Equality operator*/
+ virtual bool
+ operator==(const SurfaceBounds& sbo) const override;
+
+ /** Virtual constructor */
+ virtual ConeBounds*
+ clone() const override;
+
+ /** Return the bounds type */
+ virtual BoundsType
+ type() const override
+ {
+ return SurfaceBounds::Cone;
+ }
- /** Constructor - open cone with alpha, minz and maxz, by
- default a full cone but can optionally make it a conical section */
- ConeBounds(double alpha, double zmin, double zmax, double halfphi=M_PI, double avphi=0.);
-
- /** Copy Constructor */
- ConeBounds(const ConeBounds& cylbo);
-
- /** Destructor */
- virtual ~ConeBounds();
-
- /** Assignment operator*/
- ConeBounds& operator=(const ConeBounds& cylbo);
-
- /** Equality operator*/
- virtual bool operator==(const SurfaceBounds& sbo) const override;
-
- /** Virtual constructor */
- virtual ConeBounds* clone() const override;
-
- /** Return the bounds type */
- virtual BoundsType type() const override { return SurfaceBounds::Cone; }
-
- /** This method checks if a LocalPosition is inside z bounds and rphi value- interface method */
- virtual bool inside(const Vector2D& locpo, double tol1, double tol2) const override;
- virtual bool inside(const Vector2D& locpo, const BoundaryCheck& bchk=true) const override;
-
- /** This method checks if a GlobalPosition is inside the Cylinder - not an interface method,
- assumes that GlobalPosition is in the right frame*/
- virtual bool inside(const Vector3D& gp, double tol1=0., double tol2=0.) const;
- virtual bool inside(const Vector3D& locpo, const BoundaryCheck& bchk) const;
-
- /** This method checks inside bounds in loc1
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc1(const Vector2D& locpo, double tol1=0.) const override;
-
- /** This method checks inside bounds in loc1
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc2(const Vector2D& locpo, double tol2=0.) const override;
-
- /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
- virtual double minDistance(const Vector2D& pos) const override;
-
- /** This method returns the maximal radius - for an unbound cone it returns MAXBOUNDVALUE*/
- virtual double r() const override;
-
- /** Return the radius at a specific z values */
- double r(double z) const;
-
- /** This method returns the average phi*/
- double tanAlpha() const;
- double sinAlpha() const;
- double cosAlpha() const;
- double alpha() const;
-
- /** This method returns the minimum z value in the local framee
- - for an unbound symmetric cone, it returns -MAXBOUNDVALUE*/
- double minZ() const;
-
- /** This method returns the maximum z value in the local framee
- - for an unbound cone, it returns MAXBOUNDVALUE*/
- double maxZ() const;
-
- /** This method returns the average phi value (i.e. the "middle"
- phi value for the conical sector we are describing) */
-
- double averagePhi() const;
- /** This method returns the half-phi width of the sector (so that
- averagePhi +/- halfPhiSector gives the phi bounds of the
- cone) */
- double halfPhiSector() const;
-
- /** Output Method for std::ostream */
- virtual std::ostream& dump(std::ostream& sl) const override;
-
- private:
- /** internal storage of the geometry parameters */
- std::vector<TDD_real_t> m_boundValues;
- TDD_real_t m_tanAlpha;
- TDD_real_t m_sinAlpha;
- TDD_real_t m_cosAlpha;
-
- /** Helper function for angle parameter initialization */
- virtual void initCache() override;
-
- /** Helpers for inside() functions */
- inline double minPhi() const {return m_boundValues.at(ConeBounds::bv_averagePhi)-m_boundValues.at(ConeBounds::bv_halfPhiSector);}
- inline double maxPhi() const {return m_boundValues.at(ConeBounds::bv_averagePhi)+m_boundValues.at(ConeBounds::bv_halfPhiSector);}
- };
-
- inline ConeBounds* ConeBounds::clone() const
- { return new ConeBounds(*this); }
-
- inline bool ConeBounds::inside(const Vector2D &locpo, double tol1, double tol2) const
- {
- double z = locpo[Acts::eLOC_Z];
- bool insideZ = z > (m_boundValues.at(ConeBounds::bv_minZ)-tol2) && z < (m_boundValues.at(ConeBounds::bv_maxZ)+tol2);
- if (!insideZ) return false;
- // TODO: Do we need some sort of "R" tolerance also here (take
- // it off the z tol2 in that case?) or does the rphi tol1 cover
- // this? (Could argue either way)
- double coneR = z*m_tanAlpha;
- double minRPhi = coneR*minPhi() - tol1, maxRPhi = coneR*maxPhi() + tol1;
- return minRPhi < locpo[Acts::eLOC_RPHI] && locpo[Acts::eLOC_RPHI] < maxRPhi;
- }
-
- inline bool ConeBounds::inside(const Vector3D &glopo, double tol1, double tol2) const
- {
- // coords are (rphi,z)
- return inside(Vector2D(glopo.perp()*glopo.phi(),glopo.z()) ,tol1,tol2);
- }
-
- inline bool ConeBounds::inside(const Vector3D &glopo, const BoundaryCheck& bchk) const
- {
- // coords are (rphi,z)
- return inside(Vector2D(glopo.perp()*glopo.phi(),glopo.z()) ,bchk.toleranceLoc1,bchk.toleranceLoc2);
- }
-
- inline bool ConeBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
+ /** This method checks if a LocalPosition is inside z bounds and rphi value-
+ * interface method */
+ virtual bool
+ inside(const Vector2D& locpo, double tol1, double tol2) const override;
+ virtual bool
+ inside(const Vector2D& locpo,
+ const BoundaryCheck& bchk = true) const override;
+
+ /** This method checks if a GlobalPosition is inside the Cylinder - not an
+ interface method,
+ assumes that GlobalPosition is in the right frame*/
+ virtual bool
+ inside(const Vector3D& gp, double tol1 = 0., double tol2 = 0.) const;
+ virtual bool
+ inside(const Vector3D& locpo, const BoundaryCheck& bchk) const;
+
+ /** This method checks inside bounds in loc1
+- loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc1(const Vector2D& locpo, double tol1 = 0.) const override;
+
+ /** This method checks inside bounds in loc1
+- loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc2(const Vector2D& locpo, double tol2 = 0.) const override;
+
+ /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
+ virtual double
+ minDistance(const Vector2D& pos) const override;
+
+ /** This method returns the maximal radius - for an unbound cone it returns
+ * MAXBOUNDVALUE*/
+ virtual double
+ r() const override;
+
+ /** Return the radius at a specific z values */
+ double
+ r(double z) const;
+
+ /** This method returns the average phi*/
+ double
+ tanAlpha() const;
+ double
+ sinAlpha() const;
+ double
+ cosAlpha() const;
+ double
+ alpha() const;
+
+ /** This method returns the minimum z value in the local framee
+- for an unbound symmetric cone, it returns -MAXBOUNDVALUE*/
+ double
+ minZ() const;
+
+ /** This method returns the maximum z value in the local framee
+- for an unbound cone, it returns MAXBOUNDVALUE*/
+ double
+ maxZ() const;
+
+ /** This method returns the average phi value (i.e. the "middle"
+phi value for the conical sector we are describing) */
+
+ double
+ averagePhi() const;
+ /** This method returns the half-phi width of the sector (so that
+averagePhi +/- halfPhiSector gives the phi bounds of the
+cone) */
+ double
+ halfPhiSector() const;
+
+ /** Output Method for std::ostream */
+ virtual std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ /** internal storage of the geometry parameters */
+ std::vector<TDD_real_t> m_boundValues;
+ TDD_real_t m_tanAlpha;
+ TDD_real_t m_sinAlpha;
+ TDD_real_t m_cosAlpha;
+
+ /** Helper function for angle parameter initialization */
+ virtual void
+ initCache() override;
+
+ /** Helpers for inside() functions */
+ inline double
+ minPhi() const
{
- return ConeBounds::inside(locpo,bchk.toleranceLoc1,bchk.toleranceLoc2);
+ return m_boundValues.at(ConeBounds::bv_averagePhi)
+ - m_boundValues.at(ConeBounds::bv_halfPhiSector);
}
+ inline double
+ maxPhi() const
+ {
+ return m_boundValues.at(ConeBounds::bv_averagePhi)
+ + m_boundValues.at(ConeBounds::bv_halfPhiSector);
+ }
+};
+
+inline ConeBounds*
+ConeBounds::clone() const
+{
+ return new ConeBounds(*this);
+}
- inline bool ConeBounds::insideLoc1(const Vector2D &locpo, double tol1) const
- {
- double z = locpo[Acts::eLOC_Z];
- double coneR = z*m_tanAlpha;
- double minRPhi = coneR*minPhi() - tol1, maxRPhi = coneR*maxPhi() + tol1;
- return minRPhi < locpo[Acts::eLOC_RPHI] && locpo[Acts::eLOC_RPHI] < maxRPhi;
- }
+inline bool
+ConeBounds::inside(const Vector2D& locpo, double tol1, double tol2) const
+{
+ double z = locpo[Acts::eLOC_Z];
+ bool insideZ = z > (m_boundValues.at(ConeBounds::bv_minZ) - tol2)
+ && z < (m_boundValues.at(ConeBounds::bv_maxZ) + tol2);
+ if (!insideZ) return false;
+ // TODO: Do we need some sort of "R" tolerance also here (take
+ // it off the z tol2 in that case?) or does the rphi tol1 cover
+ // this? (Could argue either way)
+ double coneR = z * m_tanAlpha;
+ double minRPhi = coneR * minPhi() - tol1, maxRPhi = coneR * maxPhi() + tol1;
+ return minRPhi < locpo[Acts::eLOC_RPHI] && locpo[Acts::eLOC_RPHI] < maxRPhi;
+}
+
+inline bool
+ConeBounds::inside(const Vector3D& glopo, double tol1, double tol2) const
+{
+ // coords are (rphi,z)
+ return inside(Vector2D(glopo.perp() * glopo.phi(), glopo.z()), tol1, tol2);
+}
- inline bool ConeBounds::insideLoc2(const Vector2D &locpo, double tol2) const
- {
- double z = locpo[Acts::eLOC_Z];
- return (z > (m_boundValues.at(ConeBounds::bv_minZ) - tol2) && z < (m_boundValues.at(ConeBounds::bv_maxZ) + tol2));
- }
+inline bool
+ConeBounds::inside(const Vector3D& glopo, const BoundaryCheck& bchk) const
+{
+ // coords are (rphi,z)
+ return inside(Vector2D(glopo.perp() * glopo.phi(), glopo.z()),
+ bchk.toleranceLoc1,
+ bchk.toleranceLoc2);
+}
- inline double ConeBounds::r() const
- {
- double z = fabs(m_boundValues.at(ConeBounds::bv_maxZ)), mz = fabs(m_boundValues.at(ConeBounds::bv_minZ));
- if(mz > z)
- z = mz;
- return fabs(z*m_tanAlpha);
- }
+inline bool
+ConeBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
+{
+ return ConeBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
+}
- inline double ConeBounds::r(double z) const
- {
- return fabs(z*m_tanAlpha);
- }
+inline bool
+ConeBounds::insideLoc1(const Vector2D& locpo, double tol1) const
+{
+ double z = locpo[Acts::eLOC_Z];
+ double coneR = z * m_tanAlpha;
+ double minRPhi = coneR * minPhi() - tol1, maxRPhi = coneR * maxPhi() + tol1;
+ return minRPhi < locpo[Acts::eLOC_RPHI] && locpo[Acts::eLOC_RPHI] < maxRPhi;
+}
+inline bool
+ConeBounds::insideLoc2(const Vector2D& locpo, double tol2) const
+{
+ double z = locpo[Acts::eLOC_Z];
+ return (z > (m_boundValues.at(ConeBounds::bv_minZ) - tol2)
+ && z < (m_boundValues.at(ConeBounds::bv_maxZ) + tol2));
+}
- inline double ConeBounds::tanAlpha() const { return m_tanAlpha; }
+inline double
+ConeBounds::r() const
+{
+ double z = fabs(m_boundValues.at(ConeBounds::bv_maxZ)),
+ mz = fabs(m_boundValues.at(ConeBounds::bv_minZ));
+ if (mz > z) z = mz;
+ return fabs(z * m_tanAlpha);
+}
- inline double ConeBounds::sinAlpha() const { return m_sinAlpha; }
+inline double
+ConeBounds::r(double z) const
+{
+ return fabs(z * m_tanAlpha);
+}
- inline double ConeBounds::cosAlpha() const { return m_cosAlpha; }
+inline double
+ConeBounds::tanAlpha() const
+{
+ return m_tanAlpha;
+}
- inline double ConeBounds::alpha() const { return m_boundValues.at(ConeBounds::bv_alpha); }
+inline double
+ConeBounds::sinAlpha() const
+{
+ return m_sinAlpha;
+}
- inline double ConeBounds::minZ() const { return m_boundValues.at(ConeBounds::bv_minZ); }
+inline double
+ConeBounds::cosAlpha() const
+{
+ return m_cosAlpha;
+}
- inline double ConeBounds::maxZ() const { return m_boundValues.at(ConeBounds::bv_maxZ); }
+inline double
+ConeBounds::alpha() const
+{
+ return m_boundValues.at(ConeBounds::bv_alpha);
+}
- inline double ConeBounds::averagePhi() const { return m_boundValues.at(ConeBounds::bv_averagePhi); }
+inline double
+ConeBounds::minZ() const
+{
+ return m_boundValues.at(ConeBounds::bv_minZ);
+}
- inline double ConeBounds::halfPhiSector() const { return m_boundValues.at(ConeBounds::bv_halfPhiSector); }
+inline double
+ConeBounds::maxZ() const
+{
+ return m_boundValues.at(ConeBounds::bv_maxZ);
+}
- inline void ConeBounds::initCache()
- {
- m_tanAlpha = tan(m_boundValues.at(ConeBounds::bv_alpha));
- m_sinAlpha = sin(m_boundValues.at(ConeBounds::bv_alpha));
- m_cosAlpha = cos(m_boundValues.at(ConeBounds::bv_alpha));
- // validate the halfphi
- if(m_boundValues.at(ConeBounds::bv_halfPhiSector) < 0.)
- m_boundValues.at(ConeBounds::bv_halfPhiSector) = -m_boundValues.at(ConeBounds::bv_halfPhiSector);
- if(m_boundValues.at(ConeBounds::bv_halfPhiSector) > M_PI)
- m_boundValues.at(ConeBounds::bv_halfPhiSector) = M_PI;
- }
+inline double
+ConeBounds::averagePhi() const
+{
+ return m_boundValues.at(ConeBounds::bv_averagePhi);
}
-#endif // ACTS_SURFACESCONEBOUNDS_H
+inline double
+ConeBounds::halfPhiSector() const
+{
+ return m_boundValues.at(ConeBounds::bv_halfPhiSector);
+}
+inline void
+ConeBounds::initCache()
+{
+ m_tanAlpha = tan(m_boundValues.at(ConeBounds::bv_alpha));
+ m_sinAlpha = sin(m_boundValues.at(ConeBounds::bv_alpha));
+ m_cosAlpha = cos(m_boundValues.at(ConeBounds::bv_alpha));
+ // validate the halfphi
+ if (m_boundValues.at(ConeBounds::bv_halfPhiSector) < 0.)
+ m_boundValues.at(ConeBounds::bv_halfPhiSector)
+ = -m_boundValues.at(ConeBounds::bv_halfPhiSector);
+ if (m_boundValues.at(ConeBounds::bv_halfPhiSector) > M_PI)
+ m_boundValues.at(ConeBounds::bv_halfPhiSector) = M_PI;
+}
+}
+#endif // ACTS_SURFACESCONEBOUNDS_H
diff --git a/Core/include/ACTS/Surfaces/ConeSurface.hpp b/Core/include/ACTS/Surfaces/ConeSurface.hpp
index 57616d64a..97690e683 100644
--- a/Core/include/ACTS/Surfaces/ConeSurface.hpp
+++ b/Core/include/ACTS/Surfaces/ConeSurface.hpp
@@ -13,176 +13,227 @@
#ifndef ACTS_SURFACES_CONESURFACE_H
#define ACTS_SURFACES_CONESURFACE_H 1
-#include "ACTS/Surfaces/Surface.hpp"
#include "ACTS/Surfaces/ConeBounds.hpp"
+#include "ACTS/Surfaces/Surface.hpp"
#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Utilities/ParameterDefinitions.hpp"
namespace Acts {
- /**
- @class ConeSurface
-
- Class for a conical surface in the Tracking geometry.
- It inherits from Surface.
-
- The ConeSurface is special since no corresponding
- TrackParameters exist since they're numerical instable
- at the tip of the cone.
- Propagations to a cone surface will be returned in
- curvilinear coordinates.
-
- */
-
- class ConeSurface : public Surface {
-
- public:
- /** Default Constructor*/
- ConeSurface();
-
- /** Constructor form HepTransform and an opening angle */
- ConeSurface(std::shared_ptr<Transform3D> htrans, double alpha, bool symmetric=false);
-
- /** Constructor form HepTransform, radius halfphi, and halflenght*/
- ConeSurface(std::shared_ptr<Transform3D> htrans, double alpha, double locZmin, double locZmax, double halfPhi=M_PI);
-
- /** Constructor from HepTransform and CylinderBounds
- - ownership of the bounds is passed */
- ConeSurface(std::shared_ptr<Transform3D> htrans, std::shared_ptr<const ConeBounds> cbounds);
-
- /** Constructor from HepTransform by unique_ptr.
- - bounds is not set. */
- ConeSurface(std::unique_ptr<Transform3D> htrans);
-
- /** Copy constructor */
- ConeSurface(const ConeSurface& csf);
-
- /** Copy constructor with shift */
- ConeSurface(const ConeSurface& csf, const Transform3D& transf);
+/**
+ @class ConeSurface
- /** Destructor*/
- virtual ~ConeSurface();
+ Class for a conical surface in the Tracking geometry.
+ It inherits from Surface.
- /** Assignment operator*/
- ConeSurface& operator=(const ConeSurface& csf);
+ The ConeSurface is special since no corresponding
+ TrackParameters exist since they're numerical instable
+ at the tip of the cone.
+ Propagations to a cone surface will be returned in
+ curvilinear coordinates.
- /** Equality operator*/
- virtual bool operator==(const Surface& sf) const override;
+ */
- /** Implicit Constructor*/
- virtual ConeSurface* clone(const Transform3D* shift = nullptr) const override;
+class ConeSurface : public Surface
+{
+public:
+ /** Default Constructor*/
+ ConeSurface();
- /** The binning position method - is overloaded for r-type binning */
- virtual Vector3D binningPosition(BinningValue bValue) const override;
+ /** Constructor form HepTransform and an opening angle */
+ ConeSurface(std::shared_ptr<Transform3D> htrans,
+ double alpha,
+ bool symmetric = false);
- /** Return the surface type */
- virtual SurfaceType type() const override { return Surface::Cone; }
+ /** Constructor form HepTransform, radius halfphi, and halflenght*/
+ ConeSurface(std::shared_ptr<Transform3D> htrans,
+ double alpha,
+ double locZmin,
+ double locZmax,
+ double halfPhi = M_PI);
- /** Return the measurement frame - this is needed for alignment, in particular for StraightLine and Perigee Surface
- - the default implementation is the the RotationMatrix3D of the transform */
- virtual const RotationMatrix3D measurementFrame(const Vector3D& glopos, const Vector3D& glomom) const override;
+ /** Constructor from HepTransform and CylinderBounds
+ - ownership of the bounds is passed */
+ ConeSurface(std::shared_ptr<Transform3D> htrans,
+ std::shared_ptr<const ConeBounds> cbounds);
- /**Return method for surface normal information
- at a given local point, overwrites the normal() from base class.*/
- virtual const Vector3D& normal() const override;
+ /** Constructor from HepTransform by unique_ptr.
+ - bounds is not set. */
+ ConeSurface(std::unique_ptr<Transform3D> htrans);
- /**Return method for surface normal information
- at a given local point, overwrites the normal() from base class.*/
- virtual const Vector3D normal(const Vector2D& locpo) const override;
+ /** Copy constructor */
+ ConeSurface(const ConeSurface& csf);
- /**Return method for surface normal information
- at a given local point, overwrites the normal() from base class.*/
- virtual const Vector3D normal(const Vector3D& global) const override;
+ /** Copy constructor with shift */
+ ConeSurface(const ConeSurface& csf, const Transform3D& transf);
- /**Return method for the rotational symmetry axis - the z-Axis of the HepTransform */
- virtual const Vector3D& rotSymmetryAxis() const;
+ /** Destructor*/
+ virtual ~ConeSurface();
- /**This method returns the ConeBounds by reference
- (NoBounds is not possible for cone)*/
- virtual const ConeBounds& bounds() const override;
+ /** Assignment operator*/
+ ConeSurface&
+ operator=(const ConeSurface& csf);
- /** Specialized for ConeSurface : LocalToGlobal method without dynamic memory allocation */
- virtual void localToGlobal(const Vector2D& locp, const Vector3D& mom, Vector3D& glob) const override;
+ /** Equality operator*/
+ virtual bool
+ operator==(const Surface& sf) const override;
- /** Specialized for ConeSurface : GlobalToLocal method without dynamic memory allocation - boolean checks if on surface */
- virtual bool globalToLocal(const Vector3D& glob, const Vector3D& mom, Vector2D& loc) const override;
+ /** Implicit Constructor*/
+ virtual ConeSurface*
+ clone(const Transform3D* shift = nullptr) const override;
- /** fast straight line intersection schema - provides closest intersection and (signed) path length
+ /** The binning position method - is overloaded for r-type binning */
+ virtual Vector3D
+ binningPosition(BinningValue bValue) const override;
- <b>mathematical motivation:</b>
-
- The calculation will be done in the 3-dim frame of the cone,
- i.e. the symmetry axis of the cone is the z-axis, x- and y-axis are perpenticular
- to the the z-axis. In this frame the cone is centered around the origin.
- Therefore the two points describing the line have to be first recalculated into the new frame.
- Suppose, this is done, the points of intersection can be
- obtained as follows:<br>
-
- The cone is described by the implicit equation
- @f$x^2 + y^2 = z^2 \tan \alpha@f$
- where @f$\alpha@f$ is opening half-angle of the cone the and
- the line by the parameter equation (with @f$t@f$ the
- parameter and @f$x_1@f$ and @f$x_2@f$ are points on the line)
- @f$(x,y,z) = \vec x_1 + (\vec x_2 - \vec x_2) t @f$.
- The intersection is the given to the value of @f$t@f$ where
- the @f$(x,y,z)@f$ coordinates of the line satisfy the implicit
- equation of the cone. Inserting the expression for the points
- on the line into the equation of the cone and rearranging to
- the form of a gives (letting @f$ \vec x_d = \frac{\vec x_2 - \vec
- x_1}{\abs{\vec x_2 - \vec x_1}} @f$):
- @f$t^2 (x_d^2 + y_d^2 - z_d^2 \tan^2 \alpha) + 2 t (x_1 x_d +
- y_1 y_d - z_1 z_d \tan^2 \alpha) + (x_1^2 + y_1^2 - z_1^2
- \tan^2 \alpha) = 0 @f$
- Solving the above for @f$t@f$ and putting the values into the
- equation of the line gives the points of intersection. @f$t@f$
- is also the length of the path, since we normalized @f$x_d@f$
- to be unit length.
- */
- virtual Intersection intersectionEstimate(const Vector3D& pos,const Vector3D& dir, bool forceDir=false, const BoundaryCheck& bchk = false) const override;
-
- /** the pathCorrection for derived classes with thickness */
- virtual double pathCorrection(const Vector3D&, const Vector3D&) const override;
-
- /** Return properly formatted class name for screen output */
- virtual std::string name() const override { return "Acts::ConeSurface"; }
-
- protected: //!< data members
- std::shared_ptr<const ConeBounds> m_bounds; //!< bounds (shared)
- mutable Vector3D* m_rotSymmetryAxis; //!< The rotational symmetry axis
- };
-
- inline ConeSurface* ConeSurface::clone(const Transform3D* shift) const
+ /** Return the surface type */
+ virtual SurfaceType
+ type() const override
{
- if (shift) new ConeSurface(*this,*shift);
- return new ConeSurface(*this);
+ return Surface::Cone;
}
- inline const Vector3D& ConeSurface::normal() const
- { return Surface::normal(); }
-
- inline const Vector3D ConeSurface::normal(const Vector2D& lp) const
+ /** Return the measurement frame - this is needed for alignment, in particular
+ for StraightLine and Perigee Surface
+ - the default implementation is the the RotationMatrix3D of the transform */
+ virtual const RotationMatrix3D
+ measurementFrame(const Vector3D& glopos,
+ const Vector3D& glomom) const override;
+
+ /**Return method for surface normal information
+ at a given local point, overwrites the normal() from base class.*/
+ virtual const Vector3D&
+ normal() const override;
+
+ /**Return method for surface normal information
+ at a given local point, overwrites the normal() from base class.*/
+ virtual const Vector3D
+ normal(const Vector2D& locpo) const override;
+
+ /**Return method for surface normal information
+ at a given local point, overwrites the normal() from base class.*/
+ virtual const Vector3D
+ normal(const Vector3D& global) const override;
+
+ /**Return method for the rotational symmetry axis - the z-Axis of the
+ * HepTransform */
+ virtual const Vector3D&
+ rotSymmetryAxis() const;
+
+ /**This method returns the ConeBounds by reference
+ (NoBounds is not possible for cone)*/
+ virtual const ConeBounds&
+ bounds() const override;
+
+ /** Specialized for ConeSurface : LocalToGlobal method without dynamic memory
+ * allocation */
+ virtual void
+ localToGlobal(const Vector2D& locp,
+ const Vector3D& mom,
+ Vector3D& glob) const override;
+
+ /** Specialized for ConeSurface : GlobalToLocal method without dynamic memory
+ * allocation - boolean checks if on surface */
+ virtual bool
+ globalToLocal(const Vector3D& glob,
+ const Vector3D& mom,
+ Vector2D& loc) const override;
+
+ /** fast straight line intersection schema - provides closest intersection and
+ (signed) path length
+
+ <b>mathematical motivation:</b>
+
+ The calculation will be done in the 3-dim frame of the cone,
+ i.e. the symmetry axis of the cone is the z-axis, x- and y-axis are
+ perpenticular
+ to the the z-axis. In this frame the cone is centered around the origin.
+ Therefore the two points describing the line have to be first recalculated
+ into the new frame.
+ Suppose, this is done, the points of intersection can be
+ obtained as follows:<br>
+
+ The cone is described by the implicit equation
+ @f$x^2 + y^2 = z^2 \tan \alpha@f$
+ where @f$\alpha@f$ is opening half-angle of the cone the and
+ the line by the parameter equation (with @f$t@f$ the
+ parameter and @f$x_1@f$ and @f$x_2@f$ are points on the line)
+ @f$(x,y,z) = \vec x_1 + (\vec x_2 - \vec x_2) t @f$.
+ The intersection is the given to the value of @f$t@f$ where
+ the @f$(x,y,z)@f$ coordinates of the line satisfy the implicit
+ equation of the cone. Inserting the expression for the points
+ on the line into the equation of the cone and rearranging to
+ the form of a gives (letting @f$ \vec x_d = \frac{\vec x_2 - \vec
+ x_1}{\abs{\vec x_2 - \vec x_1}} @f$):
+ @f$t^2 (x_d^2 + y_d^2 - z_d^2 \tan^2 \alpha) + 2 t (x_1 x_d +
+ y_1 y_d - z_1 z_d \tan^2 \alpha) + (x_1^2 + y_1^2 - z_1^2
+ \tan^2 \alpha) = 0 @f$
+ Solving the above for @f$t@f$ and putting the values into the
+ equation of the line gives the points of intersection. @f$t@f$
+ is also the length of the path, since we normalized @f$x_d@f$
+ to be unit length.
+ */
+ virtual Intersection
+ intersectionEstimate(const Vector3D& pos,
+ const Vector3D& dir,
+ bool forceDir = false,
+ const BoundaryCheck& bchk = false) const override;
+
+ /** the pathCorrection for derived classes with thickness */
+ virtual double
+ pathCorrection(const Vector3D&, const Vector3D&) const override;
+
+ /** Return properly formatted class name for screen output */
+ virtual std::string
+ name() const override
{
- // (cos phi cos alpha, sin phi cos alpha, sgn z sin alpha)
- double phi = lp[Acts::eLOC_RPHI]/(bounds().r(lp[Acts::eLOC_Z])),
- sgn = lp[Acts::eLOC_Z] > 0 ? -1. : +1.;
- Vector3D localNormal(cos(phi) * bounds().cosAlpha(),
- sin(phi) * bounds().cosAlpha(),
- sgn*bounds().sinAlpha());
- return Vector3D(transform().rotation()*localNormal);
+ return "Acts::ConeSurface";
}
- inline const Vector3D ConeSurface::normal(const Vector3D& gp) const {
- Vector2D local(0.,0.);
- globalToLocal(gp,Vector3D::UnitX(),local);
- return normal(local);
- }
-
- inline const ConeBounds& ConeSurface::bounds() const {
- return (*m_bounds.get());
- }
-
-} // end of namespace
-
-#endif // ACTS_SURFACESCONESURFACE_H
-
-
+protected: //!< data members
+ std::shared_ptr<const ConeBounds> m_bounds; //!< bounds (shared)
+ mutable Vector3D* m_rotSymmetryAxis; //!< The rotational symmetry axis
+};
+
+inline ConeSurface*
+ConeSurface::clone(const Transform3D* shift) const
+{
+ if (shift) new ConeSurface(*this, *shift);
+ return new ConeSurface(*this);
+}
+
+inline const Vector3D&
+ConeSurface::normal() const
+{
+ return Surface::normal();
+}
+
+inline const Vector3D
+ConeSurface::normal(const Vector2D& lp) const
+{
+ // (cos phi cos alpha, sin phi cos alpha, sgn z sin alpha)
+ double phi = lp[Acts::eLOC_RPHI] / (bounds().r(lp[Acts::eLOC_Z])),
+ sgn = lp[Acts::eLOC_Z] > 0 ? -1. : +1.;
+ Vector3D localNormal(cos(phi) * bounds().cosAlpha(),
+ sin(phi) * bounds().cosAlpha(),
+ sgn * bounds().sinAlpha());
+ return Vector3D(transform().rotation() * localNormal);
+}
+
+inline const Vector3D
+ConeSurface::normal(const Vector3D& gp) const
+{
+ Vector2D local(0., 0.);
+ globalToLocal(gp, Vector3D::UnitX(), local);
+ return normal(local);
+}
+
+inline const ConeBounds&
+ConeSurface::bounds() const
+{
+ return (*m_bounds.get());
+}
+
+} // end of namespace
+
+#endif // ACTS_SURFACESCONESURFACE_H
diff --git a/Core/include/ACTS/Surfaces/CylinderBounds.hpp b/Core/include/ACTS/Surfaces/CylinderBounds.hpp
index 8d15d1824..fda798413 100644
--- a/Core/include/ACTS/Surfaces/CylinderBounds.hpp
+++ b/Core/include/ACTS/Surfaces/CylinderBounds.hpp
@@ -19,201 +19,286 @@
namespace Acts {
- /**
- @class CylinderBounds
+/**
+ @class CylinderBounds
- Bounds for a cylindrical Surface.
+ Bounds for a cylindrical Surface.
- These bounds may be used for both, CylinderSurface and StraightLineSurface.
- In case of bounds for a StraightLineSurface the radius determines the radius within a localPosition
- is regarded as inside bounds.
+ These bounds may be used for both, CylinderSurface and StraightLineSurface.
+ In case of bounds for a StraightLineSurface the radius determines the radius
+ within a localPosition
+ is regarded as inside bounds.
- Acts::CylinderBounds also enhance the possibility of a cylinder segment with an opening angle @f$ 2\cdot\phi_{half}@f$
- around an average @f$ \phi @f$ angle @f$ \phi_{ave} @f$.
+ Acts::CylinderBounds also enhance the possibility of a cylinder segment with an
+ opening angle @f$ 2\cdot\phi_{half}@f$
+ around an average @f$ \phi @f$ angle @f$ \phi_{ave} @f$.
- @todo update the documentation picture for cylinder segments
+ @todo update the documentation picture for cylinder segments
- @image html CylinderBounds.gif
+ @image html CylinderBounds.gif
- */
+ */
- class CylinderBounds : public SurfaceBounds {
- public:
- /** BoundValues for readablility */
- enum BoundValues {
- bv_radius = 0,
- bv_averagePhi = 1,
- bv_halfPhiSector = 2,
- bv_halfZ = 3,
- bv_length = 4
- };
-
- /** Default Constructor*/
- CylinderBounds();
-
- /** Constructor - full cylinder */
- CylinderBounds(double radius, double halez);
-
- /** Constructor - cylinder segment */
- CylinderBounds(double radius, double halfphi, double halez);
-
- /** Constructor - cylinder segment with given averagePhi, not supposed for CylinderSurfaces*/
- CylinderBounds(double radius, double avphi, double halfphi, double halez);
-
- /** Copy Constructor */
- CylinderBounds(const CylinderBounds& cylbo);
-
- /** Destructor */
- virtual ~CylinderBounds();
-
- /** Assignment operator*/
- CylinderBounds& operator=(const CylinderBounds& cylbo);
-
- /** Move assignment operator*/
- CylinderBounds& operator=(CylinderBounds&& cylbo);
-
- /** Equality operator*/
- virtual bool operator==(const SurfaceBounds& sbo) const override;
-
- /** Virtual constructor */
- virtual CylinderBounds* clone() const override;
-
- /** Return the bounds type */
- virtual BoundsType type() const override { return SurfaceBounds::Cylinder; }
-
- /** This method checks if a LocalPosition is inside z bounds and rphi value- interface method */
- virtual bool inside(const Vector2D &locpo, double tol1, double tol2) const override;
- virtual bool inside(const Vector2D& locpo, const BoundaryCheck& bchk) const override;
-
- /** This method checks if a GlobalPosition is inside the Cylinder - not an interface method,
- assumes that GlobalPosition is in the right frame*/
- bool inside3D(const Vector3D& gp, const BoundaryCheck& bchk=true) const;
-
- /** This method checks inside bounds in loc1
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc1(const Vector2D& locpo, double tol1=0.) const override;
-
- /** This method checks inside bounds in loc1
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc2(const Vector2D& locpo, double tol2=0.) const override;
-
- /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
- virtual double minDistance(const Vector2D& pos) const override;
-
- /** This method checks if a LocalPosition is inside z bounds and inside the radius (for straws) */
- bool insideRadius(const Vector2D &locpo, double tol) const;
+class CylinderBounds : public SurfaceBounds
+{
+public:
+ /** BoundValues for readablility */
+ enum BoundValues {
+ bv_radius = 0,
+ bv_averagePhi = 1,
+ bv_halfPhiSector = 2,
+ bv_halfZ = 3,
+ bv_length = 4
+ };
- /** This method returns the radius*/
- virtual double r() const override;
+ /** Default Constructor*/
+ CylinderBounds();
- /** This method returns the average phi*/
- double averagePhi() const;
+ /** Constructor - full cylinder */
+ CylinderBounds(double radius, double halez);
- /** This method returns the halfPhiSector angle*/
- double halfPhiSector() const;
+ /** Constructor - cylinder segment */
+ CylinderBounds(double radius, double halfphi, double halez);
- /** This method returns the halflengthZ*/
- double halflengthZ() const;
+ /** Constructor - cylinder segment with given averagePhi, not supposed for
+ * CylinderSurfaces*/
+ CylinderBounds(double radius, double avphi, double halfphi, double halez);
- /** Output Method for std::ostream */
- virtual std::ostream& dump(std::ostream& sl) const override;
+ /** Copy Constructor */
+ CylinderBounds(const CylinderBounds& cylbo);
- private:
- /** helper methods for the inside check */
- bool inside(double r, double phi, double z, double tol1, double tol2) const;
- bool insideLocZ(double z, double tol2) const;
+ /** Destructor */
+ virtual ~CylinderBounds();
- /** internal storage of the geometry parameters */
- std::vector<TDD_real_t> m_boundValues;
- bool m_checkPhi;
+ /** Assignment operator*/
+ CylinderBounds&
+ operator=(const CylinderBounds& cylbo);
- };
+ /** Move assignment operator*/
+ CylinderBounds&
+ operator=(CylinderBounds&& cylbo);
- inline CylinderBounds* CylinderBounds::clone() const
- { return new CylinderBounds(*this); }
+ /** Equality operator*/
+ virtual bool
+ operator==(const SurfaceBounds& sbo) const override;
- inline bool CylinderBounds::inside(const Vector2D &locpo, double tol1, double tol2) const
- {
- double z = locpo[Acts::eLOC_Z];
- bool insideZ = insideLocZ(z,tol2);
- if (!insideZ) return false;
- // no check on Phi neccesary
- if (!m_checkPhi) return true;
- // now check insidePhi
- double localPhi = (locpo[Acts::eLOC_RPHI]/m_boundValues.at(CylinderBounds::bv_radius))-m_boundValues.at(CylinderBounds::bv_averagePhi);
- localPhi -= (localPhi > M_PI) ? 2.*M_PI : 0.;
- return ( localPhi*localPhi < (m_boundValues.at(CylinderBounds::bv_halfPhiSector)+tol1)*(m_boundValues.at(CylinderBounds::bv_halfPhiSector)+tol1) );
- }
+ /** Virtual constructor */
+ virtual CylinderBounds*
+ clone() const override;
- inline bool CylinderBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
+ /** Return the bounds type */
+ virtual BoundsType
+ type() const override
{
- if(bchk.bcType==0 || bchk.nSigmas==0 || m_boundValues.at(CylinderBounds::bv_halfPhiSector)!=M_PI) return CylinderBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
-
- float theta = (bchk.lCovariance(1,0) != 0 && (bchk.lCovariance(1,1)-bchk.lCovariance(0,0))!=0 ) ? .5*bchk.FastArcTan( 2*bchk.lCovariance(1,0)/(bchk.lCovariance(1,1)-bchk.lCovariance(0,0)) ) : 0.;
- sincosCache scResult = bchk.FastSinCos(theta);
- double dphi = scResult.sinC*scResult.sinC*bchk.lCovariance(0,0);
- double dz = scResult.cosC*scResult.cosC*bchk.lCovariance(0,1);
- double max_ell = dphi > dz ? dphi : dz;
- double limit = bchk.nSigmas*sqrt(max_ell);
- return insideLocZ(locpo[Acts::eLOC_Z],limit);
+ return SurfaceBounds::Cylinder;
}
- inline bool CylinderBounds::inside3D(const Vector3D& glopo, const BoundaryCheck& bchk) const
- {
- return inside(glopo.perp(),glopo.phi(),glopo.z(),bchk.toleranceLoc1,bchk.toleranceLoc1);
- }
+ /** This method checks if a LocalPosition is inside z bounds and rphi value-
+ * interface method */
+ virtual bool
+ inside(const Vector2D& locpo, double tol1, double tol2) const override;
+ virtual bool
+ inside(const Vector2D& locpo, const BoundaryCheck& bchk) const override;
+
+ /** This method checks if a GlobalPosition is inside the Cylinder - not an
+ interface method,
+ assumes that GlobalPosition is in the right frame*/
+ bool
+ inside3D(const Vector3D& gp, const BoundaryCheck& bchk = true) const;
+
+ /** This method checks inside bounds in loc1
+ - loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc1(const Vector2D& locpo, double tol1 = 0.) const override;
+
+ /** This method checks inside bounds in loc1
+ - loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc2(const Vector2D& locpo, double tol2 = 0.) const override;
+
+ /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
+ virtual double
+ minDistance(const Vector2D& pos) const override;
+
+ /** This method checks if a LocalPosition is inside z bounds and inside the
+ * radius (for straws) */
+ bool
+ insideRadius(const Vector2D& locpo, double tol) const;
+
+ /** This method returns the radius*/
+ virtual double
+ r() const override;
+
+ /** This method returns the average phi*/
+ double
+ averagePhi() const;
+
+ /** This method returns the halfPhiSector angle*/
+ double
+ halfPhiSector() const;
+
+ /** This method returns the halflengthZ*/
+ double
+ halflengthZ() const;
+
+ /** Output Method for std::ostream */
+ virtual std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ /** helper methods for the inside check */
+ bool
+ inside(double r, double phi, double z, double tol1, double tol2) const;
+ bool
+ insideLocZ(double z, double tol2) const;
+
+ /** internal storage of the geometry parameters */
+ std::vector<TDD_real_t> m_boundValues;
+ bool m_checkPhi;
+};
+
+inline CylinderBounds*
+CylinderBounds::clone() const
+{
+ return new CylinderBounds(*this);
+}
- //!< @TODO integrate tol1
- inline bool CylinderBounds::inside(double r, double phi, double z, double /*tol1*/, double tol2) const
- {
+inline bool
+CylinderBounds::inside(const Vector2D& locpo, double tol1, double tol2) const
+{
+ double z = locpo[Acts::eLOC_Z];
+ bool insideZ = insideLocZ(z, tol2);
+ if (!insideZ) return false;
+ // no check on Phi neccesary
+ if (!m_checkPhi) return true;
+ // now check insidePhi
+ double localPhi
+ = (locpo[Acts::eLOC_RPHI] / m_boundValues.at(CylinderBounds::bv_radius))
+ - m_boundValues.at(CylinderBounds::bv_averagePhi);
+ localPhi -= (localPhi > M_PI) ? 2. * M_PI : 0.;
+ return (localPhi * localPhi
+ < (m_boundValues.at(CylinderBounds::bv_halfPhiSector) + tol1)
+ * (m_boundValues.at(CylinderBounds::bv_halfPhiSector) + tol1));
+}
- bool insideZ = insideLocZ(z,tol2);
- if (!insideZ) return false;
- double diffR = (m_boundValues.at(CylinderBounds::bv_radius) - r );
- bool insideR = diffR*diffR < s_onSurfaceTolerance*s_onSurfaceTolerance;
- if (!insideR) return false;
- // now check insidePhi if needed
- if (!m_checkPhi) return true;
- // phi needs to be checked
- double localPhi = phi-m_boundValues.at(CylinderBounds::bv_averagePhi);
- localPhi -= (localPhi > M_PI) ? 2.*M_PI : 0.;
- return (localPhi*localPhi < m_boundValues.at(CylinderBounds::bv_halfPhiSector)*m_boundValues.at(CylinderBounds::bv_halfPhiSector));
- }
+inline bool
+CylinderBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
+{
+ if (bchk.bcType == 0 || bchk.nSigmas == 0
+ || m_boundValues.at(CylinderBounds::bv_halfPhiSector) != M_PI)
+ return CylinderBounds::inside(
+ locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
+
+ float theta = (bchk.lCovariance(1, 0) != 0
+ && (bchk.lCovariance(1, 1) - bchk.lCovariance(0, 0)) != 0)
+ ? .5
+ * bchk.FastArcTan(2 * bchk.lCovariance(1, 0)
+ / (bchk.lCovariance(1, 1) - bchk.lCovariance(0, 0)))
+ : 0.;
+ sincosCache scResult = bchk.FastSinCos(theta);
+ double dphi = scResult.sinC * scResult.sinC * bchk.lCovariance(0, 0);
+ double dz = scResult.cosC * scResult.cosC * bchk.lCovariance(0, 1);
+ double max_ell = dphi > dz ? dphi : dz;
+ double limit = bchk.nSigmas * sqrt(max_ell);
+ return insideLocZ(locpo[Acts::eLOC_Z], limit);
+}
- inline bool CylinderBounds::insideLocZ(double z, double tol2) const
- {
- return (m_boundValues.at(CylinderBounds::bv_halfZ)+tol2)-fabs(z) > 0.;
- }
+inline bool
+CylinderBounds::inside3D(const Vector3D& glopo, const BoundaryCheck& bchk) const
+{
+ return inside(glopo.perp(),
+ glopo.phi(),
+ glopo.z(),
+ bchk.toleranceLoc1,
+ bchk.toleranceLoc1);
+}
- inline bool CylinderBounds::insideLoc1(const Vector2D &locpo, double tol1) const
- {
- bool insideRphi = false;
- if (fabs(m_boundValues.at(CylinderBounds::bv_averagePhi))<10e-7)
- insideRphi = ( fabs(locpo[Acts::eLOC_RPHI]/m_boundValues.at(CylinderBounds::bv_radius)) < (m_boundValues.at(CylinderBounds::bv_halfPhiSector)+tol1) ) ;
- else {
- double localPhi = (locpo[Acts::eLOC_RPHI]/m_boundValues.at(CylinderBounds::bv_radius))-m_boundValues.at(CylinderBounds::bv_averagePhi);
- localPhi -= (localPhi > M_PI) ? 2.*M_PI : 0.;
- insideRphi = ( localPhi < (m_boundValues.at(CylinderBounds::bv_halfPhiSector)+tol1) ) ;
- }
- return (insideRphi);
- }
+//!< @TODO integrate tol1
+inline bool
+CylinderBounds::inside(double r,
+ double phi,
+ double z,
+ double /*tol1*/,
+ double tol2) const
+{
+ bool insideZ = insideLocZ(z, tol2);
+ if (!insideZ) return false;
+ double diffR = (m_boundValues.at(CylinderBounds::bv_radius) - r);
+ bool insideR = diffR * diffR < s_onSurfaceTolerance * s_onSurfaceTolerance;
+ if (!insideR) return false;
+ // now check insidePhi if needed
+ if (!m_checkPhi) return true;
+ // phi needs to be checked
+ double localPhi = phi - m_boundValues.at(CylinderBounds::bv_averagePhi);
+ localPhi -= (localPhi > M_PI) ? 2. * M_PI : 0.;
+ return (localPhi * localPhi
+ < m_boundValues.at(CylinderBounds::bv_halfPhiSector)
+ * m_boundValues.at(CylinderBounds::bv_halfPhiSector));
+}
- inline bool CylinderBounds::insideLoc2(const Vector2D &locpo, double tol2) const
- { return insideLocZ(locpo[Acts::eLOC_Z],tol2); }
+inline bool
+CylinderBounds::insideLocZ(double z, double tol2) const
+{
+ return (m_boundValues.at(CylinderBounds::bv_halfZ) + tol2) - fabs(z) > 0.;
+}
- inline bool CylinderBounds::insideRadius(const Vector2D& locpo, double tol) const
- {
- return ( this->inside(locpo,tol,0) && fabs(locpo[Acts::eLOC_R])< m_boundValues.at(CylinderBounds::bv_radius) + tol);
+inline bool
+CylinderBounds::insideLoc1(const Vector2D& locpo, double tol1) const
+{
+ bool insideRphi = false;
+ if (fabs(m_boundValues.at(CylinderBounds::bv_averagePhi)) < 10e-7)
+ insideRphi
+ = (fabs(locpo[Acts::eLOC_RPHI]
+ / m_boundValues.at(CylinderBounds::bv_radius))
+ < (m_boundValues.at(CylinderBounds::bv_halfPhiSector) + tol1));
+ else {
+ double localPhi
+ = (locpo[Acts::eLOC_RPHI] / m_boundValues.at(CylinderBounds::bv_radius))
+ - m_boundValues.at(CylinderBounds::bv_averagePhi);
+ localPhi -= (localPhi > M_PI) ? 2. * M_PI : 0.;
+ insideRphi = (localPhi < (m_boundValues.at(CylinderBounds::bv_halfPhiSector)
+ + tol1));
}
+ return (insideRphi);
+}
- inline double CylinderBounds::r() const { return m_boundValues.at(CylinderBounds::bv_radius); }
+inline bool
+CylinderBounds::insideLoc2(const Vector2D& locpo, double tol2) const
+{
+ return insideLocZ(locpo[Acts::eLOC_Z], tol2);
+}
- inline double CylinderBounds::averagePhi() const { return m_boundValues.at(CylinderBounds::bv_averagePhi); }
+inline bool
+CylinderBounds::insideRadius(const Vector2D& locpo, double tol) const
+{
+ return (this->inside(locpo, tol, 0)
+ && fabs(locpo[Acts::eLOC_R])
+ < m_boundValues.at(CylinderBounds::bv_radius) + tol);
+}
- inline double CylinderBounds::halfPhiSector() const { return m_boundValues.at(CylinderBounds::bv_halfPhiSector); }
+inline double
+CylinderBounds::r() const
+{
+ return m_boundValues.at(CylinderBounds::bv_radius);
+}
- inline double CylinderBounds::halflengthZ() const { return m_boundValues.at(CylinderBounds::bv_halfZ); }
+inline double
+CylinderBounds::averagePhi() const
+{
+ return m_boundValues.at(CylinderBounds::bv_averagePhi);
+}
+inline double
+CylinderBounds::halfPhiSector() const
+{
+ return m_boundValues.at(CylinderBounds::bv_halfPhiSector);
+}
+
+inline double
+CylinderBounds::halflengthZ() const
+{
+ return m_boundValues.at(CylinderBounds::bv_halfZ);
+}
}
-#endif // ACTS_SURFACES_CYLINDERBOUNDS_H
+#endif // ACTS_SURFACES_CYLINDERBOUNDS_H
diff --git a/Core/include/ACTS/Surfaces/CylinderSurface.hpp b/Core/include/ACTS/Surfaces/CylinderSurface.hpp
index 3f227e71b..dcd0f8f3c 100644
--- a/Core/include/ACTS/Surfaces/CylinderSurface.hpp
+++ b/Core/include/ACTS/Surfaces/CylinderSurface.hpp
@@ -13,184 +13,248 @@
#ifndef ACTS_SURFACES_CYLINDERSURFACE_H
#define ACTS_SURFACES_CYLINDERSURFACE_H 1
-#include "ACTS/Surfaces/Surface.hpp"
#include "ACTS/Surfaces/CylinderBounds.hpp"
+#include "ACTS/Surfaces/Surface.hpp"
#include "ACTS/Utilities/Definitions.hpp"
namespace Acts {
- /**
- @class CylinderSurface
-
- Class for a CylinderSurface in the TrackingGeometry.
- It inherits from Surface.
-
- The cylinder surface has a special role in the TrackingGeometry,
- since it builds the surfaces of all TrackingVolumes at container level
- for a cylindrical tracking geometry.
-
- @image html CylinderSurface.gif
-
- */
-
- class CylinderSurface : public Surface {
-
- public:
- /** Default Constructor*/
- CylinderSurface();
-
- /** Constructor from Transform3D, radius and halflenght*/
- CylinderSurface(std::shared_ptr<Transform3D> htrans, double radius, double hlength);
-
- /** Constructor from Transform3D, radius halfphi, and halflenght*/
- CylinderSurface(std::shared_ptr<Transform3D> htrans, double radius, double hphi, double hlength);
-
- /** Constructor from Transform3D and CylinderBounds
- - ownership of the bounds is passed */
- CylinderSurface(std::shared_ptr<Transform3D> htrans, const CylinderBounds* cbounds);
-
- /** Constructor from Transform3D and CylinderBounds
- - ownership of the bounds is passed */
- CylinderSurface(std::shared_ptr<Transform3D> htrans, std::shared_ptr<const CylinderBounds> cbounds);
-
- /** Constructor from Transform3D from unique_ptr.
- - bounds is not set */
- CylinderSurface(std::unique_ptr<Transform3D> htrans);
-
- /** Constructor from radius and halflenght - speed optimized for concentric volumes */
- CylinderSurface(double radius, double hlength);
-
- /** Constructor from radius halfphi, and halflenght - speed optimized fron concentric volumes */
- CylinderSurface(double radius, double hphi, double hlength);
+/**
+ @class CylinderSurface
- /** Copy constructor */
- CylinderSurface(const CylinderSurface& csf);
+ Class for a CylinderSurface in the TrackingGeometry.
+ It inherits from Surface.
- /** Copy constructor with shift */
- CylinderSurface(const CylinderSurface& csf, const Transform3D& transf);
+ The cylinder surface has a special role in the TrackingGeometry,
+ since it builds the surfaces of all TrackingVolumes at container level
+ for a cylindrical tracking geometry.
- /** Destructor*/
- virtual ~CylinderSurface();
+ @image html CylinderSurface.gif
- /** Assignment operator*/
- CylinderSurface& operator=(const CylinderSurface& csf);
+ */
- /** Equality operator*/
- virtual bool operator==(const Surface& sf) const override;
+class CylinderSurface : public Surface
+{
+public:
+ /** Default Constructor*/
+ CylinderSurface();
- /** Implicit Constructor - optionally with a shift */
- virtual CylinderSurface* clone(const Transform3D* shift = nullptr) const override;
+ /** Constructor from Transform3D, radius and halflenght*/
+ CylinderSurface(std::shared_ptr<Transform3D> htrans,
+ double radius,
+ double hlength);
- /** The binning position method - is overloaded for r-type binning */
- virtual Vector3D binningPosition(BinningValue bValue) const override;
+ /** Constructor from Transform3D, radius halfphi, and halflenght*/
+ CylinderSurface(std::shared_ptr<Transform3D> htrans,
+ double radius,
+ double hphi,
+ double hlength);
- /** Return the measurement frame - this is needed for alignment, in particular for StraightLine and Perigee Surface
- - the default implementation is the the RotationMatrix3D of the transform */
- virtual const RotationMatrix3D measurementFrame(const Vector3D& glopos, const Vector3D& glomom) const override;
+ /** Constructor from Transform3D and CylinderBounds
+ - ownership of the bounds is passed */
+ CylinderSurface(std::shared_ptr<Transform3D> htrans,
+ const CylinderBounds* cbounds);
- /** Return the surface type */
- virtual SurfaceType type() const override { return Surface::Cylinder; }
+ /** Constructor from Transform3D and CylinderBounds
+ - ownership of the bounds is passed */
+ CylinderSurface(std::shared_ptr<Transform3D> htrans,
+ std::shared_ptr<const CylinderBounds> cbounds);
- /** Return method for surface normal information
- at a given local point, overwrites the normal() from base class.*/
- virtual const Vector3D& normal() const override;
+ /** Constructor from Transform3D from unique_ptr.
+ - bounds is not set */
+ CylinderSurface(std::unique_ptr<Transform3D> htrans);
- /** Return method for surface normal information
- at a given local point, overwrites the normal() from base class.*/
- virtual const Vector3D normal(const Vector2D& locpo) const override;
+ /** Constructor from radius and halflenght - speed optimized for concentric
+ * volumes */
+ CylinderSurface(double radius, double hlength);
- /** Return method for surface normal information
- at a given global point, overwrites the normal() from base class.*/
- virtual const Vector3D normal(const Vector3D& global) const override;
+ /** Constructor from radius halfphi, and halflenght - speed optimized fron
+ * concentric volumes */
+ CylinderSurface(double radius, double hphi, double hlength);
- /** Return method for the rotational symmetry axis - the z-Axis of the HepTransform */
- virtual const Vector3D& rotSymmetryAxis() const;
+ /** Copy constructor */
+ CylinderSurface(const CylinderSurface& csf);
- /** This method returns the CylinderBounds by reference
- (NoBounds is not possible for cylinder)*/
- virtual const CylinderBounds& bounds() const override;
+ /** Copy constructor with shift */
+ CylinderSurface(const CylinderSurface& csf, const Transform3D& transf);
- /** Specialized for CylinderSurface : LocalToGlobal method without dynamic memory allocation */
- virtual void localToGlobal(const Vector2D& locp, const Vector3D& mom, Vector3D& glob) const override;
+ /** Destructor*/
+ virtual ~CylinderSurface();
- /** Specialized for CylinderSurface : GlobalToLocal method without dynamic memory allocation - boolean checks if on surface */
- virtual bool globalToLocal(const Vector3D& glob, const Vector3D& mom, Vector2D& loc) const override;
+ /** Assignment operator*/
+ CylinderSurface&
+ operator=(const CylinderSurface& csf);
- /** This method returns true if the GlobalPosition is on the Surface for both, within
- or without check of whether the local position is inside boundaries or not */
- virtual bool isOnSurface(const Vector3D& glopo, const BoundaryCheck& bchk=true) const override;
+ /** Equality operator*/
+ virtual bool
+ operator==(const Surface& sf) const override;
- /** fast straight line intersection schema - provides closest intersection and (signed) path length
+ /** Implicit Constructor - optionally with a shift */
+ virtual CylinderSurface*
+ clone(const Transform3D* shift = nullptr) const override;
- <b>mathematical motivation:</b>
+ /** The binning position method - is overloaded for r-type binning */
+ virtual Vector3D
+ binningPosition(BinningValue bValue) const override;
- The calculation will be done in the 3-dim frame of the cylinder,
- i.e. the symmetry axis of the cylinder is the z-axis, x- and y-axis are perpenticular
- to the the z-axis. In this frame the cylinder is centered around the origin.
- Therefore the two points describing the line have to be first recalculated into the new frame.
- Suppose, this is done, the intersection is straight forward:<br>
- may @f$p_{1}=(p_{1x}, p_{1y}, p_{1z}), p_{2}=(p_{2x}, p_{2y}, p_{2z}) @f$the two points describing the 3D-line,
- then the line in the \f$x-y@f$plane can be written as
- @f$y=kx+d\f$, where @f$k =\frac{p_{2y}-p_{1y}}{p_{2x}-p_{1x}}@f$such as @f$d=\frac{p_{2x}p_{1y}-p_{1x}p_{2y}}{p_{2x}-p_{1x}},\f$<br>
- and intersects with the corresponding circle @f$x^{2}+y^{2} = R^{2}. @f$<br>
- The solutions can then be found by a simple quadratic equation and reinsertion into the line equation.
- */
- virtual Intersection intersectionEstimate(const Vector3D& pos,
- const Vector3D& dir,
- bool forceDir = false,
- const BoundaryCheck& bchk = false) const override;
+ /** Return the measurement frame - this is needed for alignment, in particular
+ for StraightLine and Perigee Surface
+ - the default implementation is the the RotationMatrix3D of the transform
+ */
+ virtual const RotationMatrix3D
+ measurementFrame(const Vector3D& glopos,
+ const Vector3D& glomom) const override;
- /** the pathCorrection for derived classes with thickness */
- virtual double pathCorrection(const Vector3D& pos, const Vector3D& mom) const override;
-
- /** Return properly formatted class name for screen output */
- virtual std::string name() const override { return "Acts::CylinderSurface"; }
-
-
- protected: //!< data members
-
- mutable std::shared_ptr<const CylinderBounds> m_bounds; //!< bounds (shared)
- mutable Vector3D* m_rotSymmetryAxis; //!< The rotational symmetry axis
- };
-
- inline CylinderSurface* CylinderSurface::clone(const Transform3D* shift) const
+ /** Return the surface type */
+ virtual SurfaceType
+ type() const override
{
- if (shift) return new CylinderSurface(*this, *shift);
- return new CylinderSurface(*this);
+ return Surface::Cylinder;
}
- inline const Vector3D& CylinderSurface::normal() const
- { return Surface::normal(); }
-
- inline const Vector3D CylinderSurface::normal(const Vector2D& lp) const
+ /** Return method for surface normal information
+ at a given local point, overwrites the normal() from base class.*/
+ virtual const Vector3D&
+ normal() const override;
+
+ /** Return method for surface normal information
+ at a given local point, overwrites the normal() from base class.*/
+ virtual const Vector3D
+ normal(const Vector2D& locpo) const override;
+
+ /** Return method for surface normal information
+ at a given global point, overwrites the normal() from base class.*/
+ virtual const Vector3D
+ normal(const Vector3D& global) const override;
+
+ /** Return method for the rotational symmetry axis - the z-Axis of the
+ * HepTransform */
+ virtual const Vector3D&
+ rotSymmetryAxis() const;
+
+ /** This method returns the CylinderBounds by reference
+ (NoBounds is not possible for cylinder)*/
+ virtual const CylinderBounds&
+ bounds() const override;
+
+ /** Specialized for CylinderSurface : LocalToGlobal method without dynamic
+ * memory allocation */
+ virtual void
+ localToGlobal(const Vector2D& locp,
+ const Vector3D& mom,
+ Vector3D& glob) const override;
+
+ /** Specialized for CylinderSurface : GlobalToLocal method without dynamic
+ * memory allocation - boolean checks if on surface */
+ virtual bool
+ globalToLocal(const Vector3D& glob,
+ const Vector3D& mom,
+ Vector2D& loc) const override;
+
+ /** This method returns true if the GlobalPosition is on the Surface for both,
+ within
+ or without check of whether the local position is inside boundaries or not
+ */
+ virtual bool
+ isOnSurface(const Vector3D& glopo,
+ const BoundaryCheck& bchk = true) const override;
+
+ /** fast straight line intersection schema - provides closest intersection and
+ (signed) path length
+
+ <b>mathematical motivation:</b>
+
+ The calculation will be done in the 3-dim frame of the cylinder,
+ i.e. the symmetry axis of the cylinder is the z-axis, x- and y-axis are
+ perpenticular
+ to the the z-axis. In this frame the cylinder is centered around the
+ origin.
+ Therefore the two points describing the line have to be first recalculated
+ into the new frame.
+ Suppose, this is done, the intersection is straight forward:<br>
+ may @f$p_{1}=(p_{1x}, p_{1y}, p_{1z}), p_{2}=(p_{2x}, p_{2y}, p_{2z})
+ @f$the two points describing the 3D-line,
+ then the line in the \f$x-y@f$plane can be written as
+ @f$y=kx+d\f$, where @f$k =\frac{p_{2y}-p_{1y}}{p_{2x}-p_{1x}}@f$such as
+ @f$d=\frac{p_{2x}p_{1y}-p_{1x}p_{2y}}{p_{2x}-p_{1x}},\f$<br>
+ and intersects with the corresponding circle @f$x^{2}+y^{2} = R^{2}.
+ @f$<br>
+ The solutions can then be found by a simple quadratic equation and
+ reinsertion into the line equation.
+ */
+ virtual Intersection
+ intersectionEstimate(const Vector3D& pos,
+ const Vector3D& dir,
+ bool forceDir = false,
+ const BoundaryCheck& bchk = false) const override;
+
+ /** the pathCorrection for derived classes with thickness */
+ virtual double
+ pathCorrection(const Vector3D& pos, const Vector3D& mom) const override;
+
+ /** Return properly formatted class name for screen output */
+ virtual std::string
+ name() const override
{
- double phi = lp[Acts::eLOC_RPHI]/(bounds().r());
- Vector3D localNormal(cos(phi), sin(phi), 0.);
- return Vector3D(transform().rotation()*localNormal);
+ return "Acts::CylinderSurface";
}
- inline const Vector3D CylinderSurface::normal(const Vector3D& global) const
- {
- // transform the global position into the the cylinder frame
- const Vector3D& local3D = m_transform ? Vector3D(transform().inverse().linear()*global) : global;
- double phi = local3D.phi();
- Vector3D localNormal(cos(phi), sin(phi), 0.);
- return m_transform ? Vector3D(transform().rotation()*localNormal) : localNormal;
- }
-
- inline double CylinderSurface::pathCorrection(const Vector3D& pos, const Vector3D& mom) const
- {
- // the global normal vector is pos-center.unit() - at the z of the position @TODO make safe for tilt
- Vector3D pcT(pos.x()-center().x(),pos.y()-center().y(),0.) ;
- Vector3D normalT(pcT.unit()); // transverse normal
- double cosAlpha = normalT.dot(mom.unit());
- return fabs(1./cosAlpha);
- }
-
- inline const CylinderBounds& CylinderSurface::bounds() const
- { return (*m_bounds.get()); }
-
-
-} // end of namespace
-
-#endif // ACTS_SURFACES_CYLINDERSURFACE_H
+protected: //!< data members
+ mutable std::shared_ptr<const CylinderBounds> m_bounds; //!< bounds (shared)
+ mutable Vector3D* m_rotSymmetryAxis; //!< The rotational symmetry axis
+};
+
+inline CylinderSurface*
+CylinderSurface::clone(const Transform3D* shift) const
+{
+ if (shift) return new CylinderSurface(*this, *shift);
+ return new CylinderSurface(*this);
+}
+
+inline const Vector3D&
+CylinderSurface::normal() const
+{
+ return Surface::normal();
+}
+
+inline const Vector3D
+CylinderSurface::normal(const Vector2D& lp) const
+{
+ double phi = lp[Acts::eLOC_RPHI] / (bounds().r());
+ Vector3D localNormal(cos(phi), sin(phi), 0.);
+ return Vector3D(transform().rotation() * localNormal);
+}
+
+inline const Vector3D
+CylinderSurface::normal(const Vector3D& global) const
+{
+ // transform the global position into the the cylinder frame
+ const Vector3D& local3D = m_transform
+ ? Vector3D(transform().inverse().linear() * global)
+ : global;
+ double phi = local3D.phi();
+ Vector3D localNormal(cos(phi), sin(phi), 0.);
+ return m_transform ? Vector3D(transform().rotation() * localNormal)
+ : localNormal;
+}
+
+inline double
+CylinderSurface::pathCorrection(const Vector3D& pos, const Vector3D& mom) const
+{
+ // the global normal vector is pos-center.unit() - at the z of the position
+ // @TODO make safe for tilt
+ Vector3D pcT(pos.x() - center().x(), pos.y() - center().y(), 0.);
+ Vector3D normalT(pcT.unit()); // transverse normal
+ double cosAlpha = normalT.dot(mom.unit());
+ return fabs(1. / cosAlpha);
+}
+
+inline const CylinderBounds&
+CylinderSurface::bounds() const
+{
+ return (*m_bounds.get());
+}
+
+} // end of namespace
+
+#endif // ACTS_SURFACES_CYLINDERSURFACE_H
diff --git a/Core/include/ACTS/Surfaces/DiamondBounds.hpp b/Core/include/ACTS/Surfaces/DiamondBounds.hpp
index 142e2521a..736049419 100644
--- a/Core/include/ACTS/Surfaces/DiamondBounds.hpp
+++ b/Core/include/ACTS/Surfaces/DiamondBounds.hpp
@@ -14,216 +14,333 @@
#define ACTS_SURFACES_DIAMONDDBOUNDS_H 1
// Geometry module
+#include <math.h>
#include "ACTS/Surfaces/PlanarBounds.hpp"
-#include "ACTS/Utilities/ParameterDefinitions.hpp"
#include "ACTS/Utilities/Definitions.hpp"
-#include <math.h>
+#include "ACTS/Utilities/ParameterDefinitions.hpp"
namespace Acts {
- /**
- @class DiamondBounds
- Bounds for a double trapezoidal ("diamond"), planar Surface.
-
- */
-
- class DiamondBounds : public PlanarBounds {
-
- public:
- /** BoundValues for better readability */
- enum BoundValues {
- bv_minHalfX = 0,
- bv_medHalfX = 1,
- bv_maxHalfX = 2,
- bv_halfY1 = 3,
- bv_halfY2 = 4,
- bv_length = 5
- };
-
- /** Default Constructor, needed for persistency*/
- DiamondBounds();
-
- /** Constructor for symmetric Diamond*/
- DiamondBounds(double minhalex, double medhalex, double maxhalex, double haley1, double haley2);
-
- /** Copy constructor*/
- DiamondBounds(const DiamondBounds& diabo);
-
- /** Destructor*/
- virtual ~DiamondBounds();
-
- /** Virtual constructor*/
- DiamondBounds* clone() const override;
-
- /** Assignment operator*/
- DiamondBounds& operator=(const DiamondBounds& sbo);
-
- /** Equality operator*/
- virtual bool operator==(const SurfaceBounds& diabo) const override;
-
- /** Return the bounds type */
- virtual BoundsType type() const override { return SurfaceBounds::Diamond; }
-
- /** This method returns the halflength in X at minimal Y (first coordinate of local surface frame)*/
- double minHalflengthX() const;
-
- /** This method returns the (maximal) halflength in X (first coordinate of local surface frame)*/
- double medHalflengthX() const;
-
- /** This method returns the halflength in X at maximal Y (first coordinate of local surface frame)*/
- double maxHalflengthX() const;
-
- /** This method returns the halflength in Y of trapezoid at negative/positive Y (second coordinate)*/
- double halflengthY1() const;
- double halflengthY2() const;
-
- /** This method returns the maximal extension on the local plane*/
- virtual double r() const override;
-
- /** This method returns the opening angle alpha in point A */
- double alpha1() const;
-
- /** This method returns the opening angle alpha in point A' */
- double alpha2() const;
-
- /** The orientation of the Diamond is according to the figure */
- virtual bool inside(const Vector2D& locpo, double tol1 = 0., double tol2 = 0.) const override;
- virtual bool inside(const Vector2D& locpo, const BoundaryCheck& bchk) const override;
-
- /** This method checks inside bounds in loc1
- - loc1/loc2 correspond to the natural coordinates of the surface
- - As loc1/loc2 are correlated the single check doesn't make sense :
- -> check is done on enclosing Rectangle !
- */
- virtual bool insideLoc1(const Vector2D& locpo, double tol1=0.) const override;
-
- /** This method checks inside bounds in loc2
- - loc1/loc2 correspond to the natural coordinates of the surface
- - As loc1/loc2 are correlated the single check doesn't make sense :
- -> check is done on enclosing Rectangle !
- */
- virtual bool insideLoc2(const Vector2D& locpo, double tol2=0.) const override;
-
- /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
- virtual double minDistance(const Vector2D& pos) const override;
-
- /** Return the vertices - or, the points of the extremas */
- virtual const std::vector< Vector2D > vertices() const override;
-
- /** Output Method for std::ostream */
- virtual std::ostream& dump(std::ostream& sl) const override;
-
- private:
- /** inside() method for a full symmetric diamond */
- bool insideFull(const Vector2D& locpo, double tol1=0., double tol2=0.) const;
-
- /** initialize the alpha1/2 cache - needed also for object persistency */
- virtual void initCache() override;
-
- /** Internal parameters stored in the geometry */
- std::vector<TDD_real_t> m_boundValues;
- TDD_real_t m_alpha1;
- TDD_real_t m_alpha2;
-
+/**
+ @class DiamondBounds
+ Bounds for a double trapezoidal ("diamond"), planar Surface.
+
+ */
+
+class DiamondBounds : public PlanarBounds
+{
+public:
+ /** BoundValues for better readability */
+ enum BoundValues {
+ bv_minHalfX = 0,
+ bv_medHalfX = 1,
+ bv_maxHalfX = 2,
+ bv_halfY1 = 3,
+ bv_halfY2 = 4,
+ bv_length = 5
};
- inline DiamondBounds* DiamondBounds::clone() const { return new DiamondBounds(*this); }
+ /** Default Constructor, needed for persistency*/
+ DiamondBounds();
- inline double DiamondBounds::minHalflengthX() const { return m_boundValues.at(DiamondBounds::bv_minHalfX); }
+ /** Constructor for symmetric Diamond*/
+ DiamondBounds(double minhalex,
+ double medhalex,
+ double maxhalex,
+ double haley1,
+ double haley2);
- inline double DiamondBounds::medHalflengthX() const { return m_boundValues.at(DiamondBounds::bv_medHalfX); }
+ /** Copy constructor*/
+ DiamondBounds(const DiamondBounds& diabo);
- inline double DiamondBounds::maxHalflengthX() const { return m_boundValues.at(DiamondBounds::bv_maxHalfX); }
+ /** Destructor*/
+ virtual ~DiamondBounds();
- inline double DiamondBounds::halflengthY1() const { return m_boundValues.at(DiamondBounds::bv_halfY1); }
+ /** Virtual constructor*/
+ DiamondBounds*
+ clone() const override;
- inline double DiamondBounds::halflengthY2() const { return m_boundValues.at(DiamondBounds::bv_halfY2); }
+ /** Assignment operator*/
+ DiamondBounds&
+ operator=(const DiamondBounds& sbo);
- inline double DiamondBounds::r() const
- { return sqrt(m_boundValues.at(DiamondBounds::bv_medHalfX)*m_boundValues.at(DiamondBounds::bv_medHalfX)
- + m_boundValues.at(DiamondBounds::bv_halfY1)*m_boundValues.at(DiamondBounds::bv_halfY1)); }
+ /** Equality operator*/
+ virtual bool
+ operator==(const SurfaceBounds& diabo) const override;
- inline bool DiamondBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
+ /** Return the bounds type */
+ virtual BoundsType
+ type() const override
{
- if(bchk.bcType==0) return DiamondBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
-
- // a fast FALSE
- double max_ell = bchk.lCovariance(0,0) > bchk.lCovariance(1,1) ? bchk.lCovariance(0,0) :bchk.lCovariance(1,1);
- double limit = bchk.nSigmas*sqrt(max_ell);
- if ( locpo[Acts::eLOC_Y] < -2*m_boundValues.at(DiamondBounds::bv_halfY1) - limit) return false;
- if ( locpo[Acts::eLOC_Y] > 2*m_boundValues.at(DiamondBounds::bv_halfY2) + limit) return false;
- // a fast FALSE
- double fabsX = fabs(locpo[Acts::eLOC_X]);
- if (fabsX > (m_boundValues.at(DiamondBounds::bv_medHalfX) + limit)) return false;
- // a fast TRUE
- double min_ell = bchk.lCovariance(0,0) < bchk.lCovariance(1,1) ? bchk.lCovariance(0,0) : bchk.lCovariance(1,1);
- limit = bchk.nSigmas*sqrt(min_ell);
- if (fabsX < (fmin(m_boundValues.at(DiamondBounds::bv_minHalfX),m_boundValues.at(DiamondBounds::bv_maxHalfX)) - limit)) return true;
- // a fast TRUE
- if (fabs(locpo[Acts::eLOC_Y]) < (fmin(m_boundValues.at(DiamondBounds::bv_halfY1),m_boundValues.at(DiamondBounds::bv_halfY2)) - limit)) return true;
-
- // compute KDOP and axes for surface polygon
- std::vector<KDOP> elementKDOP(5);
- std::vector<Vector2D> elementP(6);
- float theta = (bchk.lCovariance(1,0) != 0 && (bchk.lCovariance(1,1)-bchk.lCovariance(0,0))!=0 ) ? .5*bchk.FastArcTan( 2*bchk.lCovariance(1,0)/(bchk.lCovariance(1,1)-bchk.lCovariance(0,0)) ) : 0.;
- sincosCache scResult = bchk.FastSinCos(theta);
- ActsMatrixD<2,2> rotMatrix ;
- rotMatrix << scResult.cosC, scResult.sinC,
- -scResult.sinC, scResult.cosC;
- ActsMatrixD<2,2> normal ;
- normal << 0, -1,
- 1, 0;
- // ellipse is always at (0,0), surface is moved to ellipse position and then rotated
- Vector2D p;
- p << -m_boundValues.at(DiamondBounds::bv_minHalfX),-2.*m_boundValues.at(DiamondBounds::bv_halfY1);
- elementP.at(0) =( rotMatrix * (p - locpo) );
- p << -m_boundValues.at(DiamondBounds::bv_medHalfX),0.;
- elementP.at(1) =( rotMatrix * (p - locpo) );
- p << -m_boundValues.at(DiamondBounds::bv_maxHalfX), 2.*m_boundValues.at(DiamondBounds::bv_halfY2);
- elementP.at(2) =( rotMatrix * (p - locpo) );
- p << m_boundValues.at(DiamondBounds::bv_maxHalfX), 2.*m_boundValues.at(DiamondBounds::bv_halfY2);
- elementP.at(3) =( rotMatrix * (p - locpo) );
- p << m_boundValues.at(DiamondBounds::bv_medHalfX), 0.;
- elementP.at(4) =( rotMatrix * (p - locpo) );
- p << m_boundValues.at(DiamondBounds::bv_minHalfX), -2.*m_boundValues.at(DiamondBounds::bv_halfY1);
- elementP.at(5) =( rotMatrix * (p - locpo) );
- std::vector<Vector2D> axis = {normal*(elementP.at(1)-elementP.at(0)), normal*(elementP.at(2)-elementP.at(1)), normal*(elementP.at(3)-elementP.at(2)), normal*(elementP.at(4)-elementP.at(3)), normal*(elementP.at(5)-elementP.at(4))};
- bchk.ComputeKDOP(elementP, axis, elementKDOP);
- // compute KDOP for error ellipse
- std::vector<KDOP> errelipseKDOP(5);
- bchk.ComputeKDOP(bchk.EllipseToPoly(3), axis, errelipseKDOP);
- // check if KDOPs overlap and return result
- return bchk.TestKDOPKDOP(elementKDOP, errelipseKDOP);
- }
-
- inline bool DiamondBounds::insideLoc1(const Vector2D &locpo, double tol1) const
- { return (fabs(locpo[Acts::eLOC_X]) < m_boundValues.at(DiamondBounds::bv_medHalfX) + tol1); }
-
- inline bool DiamondBounds::insideLoc2(const Vector2D &locpo, double tol2) const
- { return ((locpo[Acts::eLOC_Y] > -2.*m_boundValues.at(DiamondBounds::bv_halfY1) - tol2) && (locpo[Acts::eLOC_Y] < 2.*m_boundValues.at(DiamondBounds::bv_halfY2) + tol2) ); }
-
- inline void DiamondBounds::initCache() {
- m_alpha1 = atan2(m_boundValues.at(DiamondBounds::bv_medHalfX)-m_boundValues.at(DiamondBounds::bv_minHalfX), 2.*m_boundValues.at(DiamondBounds::bv_halfY1));
- m_alpha2 = atan2(m_boundValues.at(DiamondBounds::bv_medHalfX)-m_boundValues.at(DiamondBounds::bv_maxHalfX), 2.*m_boundValues.at(DiamondBounds::bv_halfY2));
- }
-
- inline const std::vector< Vector2D > DiamondBounds::vertices() const {
- // create the return vector
- std::vector< Vector2D > vertices;
- // fill the vertices
- vertices.reserve(6);
- vertices.push_back(Vector2D(m_boundValues.at(DiamondBounds::bv_minHalfX),-m_boundValues.at(DiamondBounds::bv_halfY1))); // [0]
- vertices.push_back(Vector2D(m_boundValues.at(DiamondBounds::bv_medHalfX),0.)); // [1]
- vertices.push_back(Vector2D(m_boundValues.at(DiamondBounds::bv_maxHalfX), m_boundValues.at(DiamondBounds::bv_halfY2))); // [2]
- vertices.push_back(Vector2D(-m_boundValues.at(DiamondBounds::bv_maxHalfX), m_boundValues.at(DiamondBounds::bv_halfY2))); // [3]
- vertices.push_back(Vector2D(-m_boundValues.at(DiamondBounds::bv_medHalfX),0.)); // [4]
- vertices.push_back(Vector2D(-m_boundValues.at(DiamondBounds::bv_minHalfX),-m_boundValues.at(DiamondBounds::bv_halfY1))); // [5]
- return vertices;
-
+ return SurfaceBounds::Diamond;
}
-
-
-} // end of namespace
-
-#endif // ACTS_SURFACES_DIAMONDBOUNDS_H
+ /** This method returns the halflength in X at minimal Y (first coordinate of
+ * local surface frame)*/
+ double
+ minHalflengthX() const;
+
+ /** This method returns the (maximal) halflength in X (first coordinate of
+ * local surface frame)*/
+ double
+ medHalflengthX() const;
+
+ /** This method returns the halflength in X at maximal Y (first coordinate of
+ * local surface frame)*/
+ double
+ maxHalflengthX() const;
+
+ /** This method returns the halflength in Y of trapezoid at negative/positive
+ * Y (second coordinate)*/
+ double
+ halflengthY1() const;
+ double
+ halflengthY2() const;
+
+ /** This method returns the maximal extension on the local plane*/
+ virtual double
+ r() const override;
+
+ /** This method returns the opening angle alpha in point A */
+ double
+ alpha1() const;
+
+ /** This method returns the opening angle alpha in point A' */
+ double
+ alpha2() const;
+
+ /** The orientation of the Diamond is according to the figure */
+ virtual bool
+ inside(const Vector2D& locpo,
+ double tol1 = 0.,
+ double tol2 = 0.) const override;
+ virtual bool
+ inside(const Vector2D& locpo, const BoundaryCheck& bchk) const override;
+
+ /** This method checks inside bounds in loc1
+ - loc1/loc2 correspond to the natural coordinates of the surface
+ - As loc1/loc2 are correlated the single check doesn't make sense :
+ -> check is done on enclosing Rectangle !
+ */
+ virtual bool
+ insideLoc1(const Vector2D& locpo, double tol1 = 0.) const override;
+
+ /** This method checks inside bounds in loc2
+ - loc1/loc2 correspond to the natural coordinates of the surface
+ - As loc1/loc2 are correlated the single check doesn't make sense :
+ -> check is done on enclosing Rectangle !
+ */
+ virtual bool
+ insideLoc2(const Vector2D& locpo, double tol2 = 0.) const override;
+
+ /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
+ virtual double
+ minDistance(const Vector2D& pos) const override;
+
+ /** Return the vertices - or, the points of the extremas */
+ virtual const std::vector<Vector2D>
+ vertices() const override;
+
+ /** Output Method for std::ostream */
+ virtual std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ /** inside() method for a full symmetric diamond */
+ bool
+ insideFull(const Vector2D& locpo, double tol1 = 0., double tol2 = 0.) const;
+
+ /** initialize the alpha1/2 cache - needed also for object persistency */
+ virtual void
+ initCache() override;
+
+ /** Internal parameters stored in the geometry */
+ std::vector<TDD_real_t> m_boundValues;
+ TDD_real_t m_alpha1;
+ TDD_real_t m_alpha2;
+};
+
+inline DiamondBounds*
+DiamondBounds::clone() const
+{
+ return new DiamondBounds(*this);
+}
+
+inline double
+DiamondBounds::minHalflengthX() const
+{
+ return m_boundValues.at(DiamondBounds::bv_minHalfX);
+}
+
+inline double
+DiamondBounds::medHalflengthX() const
+{
+ return m_boundValues.at(DiamondBounds::bv_medHalfX);
+}
+
+inline double
+DiamondBounds::maxHalflengthX() const
+{
+ return m_boundValues.at(DiamondBounds::bv_maxHalfX);
+}
+
+inline double
+DiamondBounds::halflengthY1() const
+{
+ return m_boundValues.at(DiamondBounds::bv_halfY1);
+}
+
+inline double
+DiamondBounds::halflengthY2() const
+{
+ return m_boundValues.at(DiamondBounds::bv_halfY2);
+}
+
+inline double
+DiamondBounds::r() const
+{
+ return sqrt(m_boundValues.at(DiamondBounds::bv_medHalfX)
+ * m_boundValues.at(DiamondBounds::bv_medHalfX)
+ + m_boundValues.at(DiamondBounds::bv_halfY1)
+ * m_boundValues.at(DiamondBounds::bv_halfY1));
+}
+
+inline bool
+DiamondBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
+{
+ if (bchk.bcType == 0)
+ return DiamondBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
+
+ // a fast FALSE
+ double max_ell = bchk.lCovariance(0, 0) > bchk.lCovariance(1, 1)
+ ? bchk.lCovariance(0, 0)
+ : bchk.lCovariance(1, 1);
+ double limit = bchk.nSigmas * sqrt(max_ell);
+ if (locpo[Acts::eLOC_Y]
+ < -2 * m_boundValues.at(DiamondBounds::bv_halfY1) - limit)
+ return false;
+ if (locpo[Acts::eLOC_Y]
+ > 2 * m_boundValues.at(DiamondBounds::bv_halfY2) + limit)
+ return false;
+ // a fast FALSE
+ double fabsX = fabs(locpo[Acts::eLOC_X]);
+ if (fabsX > (m_boundValues.at(DiamondBounds::bv_medHalfX) + limit))
+ return false;
+ // a fast TRUE
+ double min_ell = bchk.lCovariance(0, 0) < bchk.lCovariance(1, 1)
+ ? bchk.lCovariance(0, 0)
+ : bchk.lCovariance(1, 1);
+ limit = bchk.nSigmas * sqrt(min_ell);
+ if (fabsX < (fmin(m_boundValues.at(DiamondBounds::bv_minHalfX),
+ m_boundValues.at(DiamondBounds::bv_maxHalfX))
+ - limit))
+ return true;
+ // a fast TRUE
+ if (fabs(locpo[Acts::eLOC_Y])
+ < (fmin(m_boundValues.at(DiamondBounds::bv_halfY1),
+ m_boundValues.at(DiamondBounds::bv_halfY2))
+ - limit))
+ return true;
+
+ // compute KDOP and axes for surface polygon
+ std::vector<KDOP> elementKDOP(5);
+ std::vector<Vector2D> elementP(6);
+ float theta = (bchk.lCovariance(1, 0) != 0
+ && (bchk.lCovariance(1, 1) - bchk.lCovariance(0, 0)) != 0)
+ ? .5
+ * bchk.FastArcTan(2 * bchk.lCovariance(1, 0)
+ / (bchk.lCovariance(1, 1) - bchk.lCovariance(0, 0)))
+ : 0.;
+ sincosCache scResult = bchk.FastSinCos(theta);
+ ActsMatrixD<2, 2> rotMatrix;
+ rotMatrix << scResult.cosC, scResult.sinC, -scResult.sinC, scResult.cosC;
+ ActsMatrixD<2, 2> normal;
+ normal << 0, -1, 1, 0;
+ // ellipse is always at (0,0), surface is moved to ellipse position and then
+ // rotated
+ Vector2D p;
+ p << -m_boundValues.at(DiamondBounds::bv_minHalfX),
+ -2. * m_boundValues.at(DiamondBounds::bv_halfY1);
+ elementP.at(0) = (rotMatrix * (p - locpo));
+ p << -m_boundValues.at(DiamondBounds::bv_medHalfX), 0.;
+ elementP.at(1) = (rotMatrix * (p - locpo));
+ p << -m_boundValues.at(DiamondBounds::bv_maxHalfX),
+ 2. * m_boundValues.at(DiamondBounds::bv_halfY2);
+ elementP.at(2) = (rotMatrix * (p - locpo));
+ p << m_boundValues.at(DiamondBounds::bv_maxHalfX),
+ 2. * m_boundValues.at(DiamondBounds::bv_halfY2);
+ elementP.at(3) = (rotMatrix * (p - locpo));
+ p << m_boundValues.at(DiamondBounds::bv_medHalfX), 0.;
+ elementP.at(4) = (rotMatrix * (p - locpo));
+ p << m_boundValues.at(DiamondBounds::bv_minHalfX),
+ -2. * m_boundValues.at(DiamondBounds::bv_halfY1);
+ elementP.at(5) = (rotMatrix * (p - locpo));
+ std::vector<Vector2D> axis = {normal * (elementP.at(1) - elementP.at(0)),
+ normal * (elementP.at(2) - elementP.at(1)),
+ normal * (elementP.at(3) - elementP.at(2)),
+ normal * (elementP.at(4) - elementP.at(3)),
+ normal * (elementP.at(5) - elementP.at(4))};
+ bchk.ComputeKDOP(elementP, axis, elementKDOP);
+ // compute KDOP for error ellipse
+ std::vector<KDOP> errelipseKDOP(5);
+ bchk.ComputeKDOP(bchk.EllipseToPoly(3), axis, errelipseKDOP);
+ // check if KDOPs overlap and return result
+ return bchk.TestKDOPKDOP(elementKDOP, errelipseKDOP);
+}
+
+inline bool
+DiamondBounds::insideLoc1(const Vector2D& locpo, double tol1) const
+{
+ return (fabs(locpo[Acts::eLOC_X])
+ < m_boundValues.at(DiamondBounds::bv_medHalfX) + tol1);
+}
+
+inline bool
+DiamondBounds::insideLoc2(const Vector2D& locpo, double tol2) const
+{
+ return ((locpo[Acts::eLOC_Y]
+ > -2. * m_boundValues.at(DiamondBounds::bv_halfY1) - tol2)
+ && (locpo[Acts::eLOC_Y]
+ < 2. * m_boundValues.at(DiamondBounds::bv_halfY2) + tol2));
+}
+
+inline void
+DiamondBounds::initCache()
+{
+ m_alpha1 = atan2(m_boundValues.at(DiamondBounds::bv_medHalfX)
+ - m_boundValues.at(DiamondBounds::bv_minHalfX),
+ 2. * m_boundValues.at(DiamondBounds::bv_halfY1));
+ m_alpha2 = atan2(m_boundValues.at(DiamondBounds::bv_medHalfX)
+ - m_boundValues.at(DiamondBounds::bv_maxHalfX),
+ 2. * m_boundValues.at(DiamondBounds::bv_halfY2));
+}
+
+inline const std::vector<Vector2D>
+DiamondBounds::vertices() const
+{
+ // create the return vector
+ std::vector<Vector2D> vertices;
+ // fill the vertices
+ vertices.reserve(6);
+ vertices.push_back(
+ Vector2D(m_boundValues.at(DiamondBounds::bv_minHalfX),
+ -m_boundValues.at(DiamondBounds::bv_halfY1))); // [0]
+ vertices.push_back(
+ Vector2D(m_boundValues.at(DiamondBounds::bv_medHalfX), 0.)); // [1]
+ vertices.push_back(
+ Vector2D(m_boundValues.at(DiamondBounds::bv_maxHalfX),
+ m_boundValues.at(DiamondBounds::bv_halfY2))); // [2]
+ vertices.push_back(
+ Vector2D(-m_boundValues.at(DiamondBounds::bv_maxHalfX),
+ m_boundValues.at(DiamondBounds::bv_halfY2))); // [3]
+ vertices.push_back(
+ Vector2D(-m_boundValues.at(DiamondBounds::bv_medHalfX), 0.)); // [4]
+ vertices.push_back(
+ Vector2D(-m_boundValues.at(DiamondBounds::bv_minHalfX),
+ -m_boundValues.at(DiamondBounds::bv_halfY1))); // [5]
+ return vertices;
+}
+
+} // end of namespace
+
+#endif // ACTS_SURFACES_DIAMONDBOUNDS_H
diff --git a/Core/include/ACTS/Surfaces/DiscBounds.hpp b/Core/include/ACTS/Surfaces/DiscBounds.hpp
index ac29d0e65..04e83d96c 100644
--- a/Core/include/ACTS/Surfaces/DiscBounds.hpp
+++ b/Core/include/ACTS/Surfaces/DiscBounds.hpp
@@ -17,30 +17,26 @@
namespace Acts {
- /**
- @class DiscBounds
-
- common base class for all bounds that are in a r/phi frame
- - simply introduced to avoid wrong bound assigments to surfaces
-
- */
-
-
- class DiscBounds : public SurfaceBounds {
-
- public:
-
- /** Default Constructor */
- DiscBounds() : SurfaceBounds() {}
-
- /** Destructor */
- virtual ~DiscBounds(){}
-
- /** Virtual Constructor */
- virtual DiscBounds* clone() const = 0;
-
- };
-
-} // end of namespace
-
-#endif // ACTS_SURFACESDISCBOUNDS_H
+/**
+ @class DiscBounds
+
+ common base class for all bounds that are in a r/phi frame
+ - simply introduced to avoid wrong bound assigments to surfaces
+
+ */
+
+class DiscBounds : public SurfaceBounds
+{
+public:
+ /** Default Constructor */
+ DiscBounds() : SurfaceBounds() {}
+ /** Destructor */
+ virtual ~DiscBounds() {}
+ /** Virtual Constructor */
+ virtual DiscBounds*
+ clone() const = 0;
+};
+
+} // end of namespace
+
+#endif // ACTS_SURFACESDISCBOUNDS_H
diff --git a/Core/include/ACTS/Surfaces/DiscSurface.hpp b/Core/include/ACTS/Surfaces/DiscSurface.hpp
index 6899165a8..7f397f7e7 100644
--- a/Core/include/ACTS/Surfaces/DiscSurface.hpp
+++ b/Core/include/ACTS/Surfaces/DiscSurface.hpp
@@ -13,183 +13,247 @@
#ifndef ACTS_SURFACE_SDISCSURFACE_H
#define ACTS_SURFACE_SDISCSURFACE_H 1
-#include "ACTS/Surfaces/Surface.hpp"
#include "ACTS/Surfaces/DiscBounds.hpp"
#include "ACTS/Surfaces/NoBounds.hpp"
+#include "ACTS/Surfaces/Surface.hpp"
#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Utilities/Identifier.hpp"
namespace Acts {
- class RadialBounds;
- class DiscTrapezoidalBounds;
- class DetectorElementBase;
-
- /**
- @class DiscSurface
-
- Class for a DiscSurface in the TrackingGEometry.
- It inherits from Surface.
-
- */
-
- class DiscSurface : public Surface {
-
- public:
- /** Default Constructor*/
- DiscSurface();
-
- /** Constructor for Discs from Transform3D, \f$ r_{min}, r_{max} \f$ */
- DiscSurface(std::shared_ptr<Transform3D> htrans, double rmin, double rmax);
-
- /** Constructor for Discs from Transform3D, \f$ r_{min}, r_{max}, \phi_{hsec} \f$ */
- DiscSurface(std::shared_ptr<Transform3D> htrans, double rmin, double rmax, double hphisec);
-
- /** Constructor for Discs from Transform3D, \f$ r_{min}, r_{max}, hx_{min}, hx_{max} \f$
- In this case you have DiscTrapezoidalBounds*/
- DiscSurface(std::shared_ptr<Transform3D> htrans, double minhalfx, double maxhalfx, double maxR, double minR, double avephi, double stereo = 0.);
-
- /** Constructor for Discs from Transform3D and DiscBounds - ownership of bounds is passed */
- DiscSurface(std::shared_ptr<Transform3D> htrans, const RadialBounds* rbounds);
-
- /** Constructor for Discs from Transform3D and DiscTrapezoidalBounds - ownership of bounds is passed */
- DiscSurface(std::shared_ptr<Transform3D> htrans, const DiscTrapezoidalBounds* dtbounds);
-
- /** Constructor for Discs from Transform3D and shared DiscBounds */
- DiscSurface(std::shared_ptr<Transform3D> htrans, std::shared_ptr<const DiscBounds> dbounds);
-
- /** Constructor for Discs from Transform3D by unique_ptr
- - bounds is not set */
- DiscSurface(std::unique_ptr<Transform3D> htrans);
-
- /** Constructor from DetectorElementBase*/
- DiscSurface(const DetectorElementBase& detelement, const Identifier& identifier = Identifier());
-
- /** Copy Constructor*/
- DiscSurface(const DiscSurface& psf);
-
- /** Copy Constructor with shift*/
- DiscSurface(const DiscSurface& psf, const Transform3D& transf);
-
- /** Destructor*/
- virtual ~DiscSurface();
-
- /** Assignement operator*/
- DiscSurface& operator=(const DiscSurface&dsf);
-
- /** Equality operator*/
- virtual bool operator==(const Surface& sf) const override;
-
- /** Virtual constructor - shift can be given optionally */
- virtual DiscSurface* clone(const Transform3D* shift = nullptr) const override;
-
- /** Return the surface type */
- virtual SurfaceType type() const override { return Surface::Disc; }
-
- /**This method returns the bounds by reference*/
- const SurfaceBounds& bounds() const override;
-
- /** This method returns true if the GlobalPosition is on the Surface for both, within
- or without check of whether the local position is inside boundaries or not */
- virtual bool isOnSurface(const Vector3D& glopo, const BoundaryCheck& bchk=true) const override;
-
- /** Specialized for DiscSurface: LocalToGlobal method without dynamic memory allocation */
- virtual void localToGlobal(const Vector2D& locp, const Vector3D& mom, Vector3D& glob) const override;
-
- /** Specialized for DiscSurface: GlobalToLocal method without dynamic memory allocation - boolean checks if on surface */
- virtual bool globalToLocal(const Vector3D& glob, const Vector3D& mom, Vector2D& loc) const override;
-
- /** Special method for DiscSurface : local<->local transformations polar <-> cartesian */
- const Vector2D localPolarToCartesian(const Vector2D& locpol) const;
-
- /** Special method for Disc surface : local<->local transformations polar <-> cartesian */
- const Vector2D localCartesianToPolar(const Vector2D& loccart) const;
-
- /** Special method for DiscSurface : local<->local transformations polar <-> cartesian */
- const Vector2D localPolarToLocalCartesian(const Vector2D& locpol) const;
-
- /** Special method for DiscSurface : local<->global transformation when provided cartesian coordinates */
- const Vector3D localCartesianToGlobal(const Vector2D& locpos) const;
-
- /** Special method for DiscSurface : global<->local from cartesian coordinates */
- const Vector2D globalToLocalCartesian(const Vector3D& glopos, double tol=0.) const;
-
- /** fast straight line intersection schema - standard: provides closest intersection and (signed) path length
- forceDir is to provide the closest forward solution
-
- <b>mathematical motivation:</b>
-
- the equation of the plane is given by: <br>
- @f$ \vec n \cdot \vec x = \vec n \cdot \vec p,@f$ <br>
- where @f$ \vec n = (n_{x}, n_{y}, n_{z})@f$ denotes the normal vector of the plane,
- @f$ \vec p = (p_{x}, p_{y}, p_{z})@f$ one specific point on the plane and @f$ \vec x = (x,y,z) @f$ all possible points
- on the plane.<br>
- Given a line with:<br>
- @f$ \vec l(u) = \vec l_{1} + u \cdot \vec v @f$, <br>
- the solution for @f$ u @f$ can be written:
- @f$ u = \frac{\vec n (\vec p - \vec l_{1})}{\vec n \vec v}@f$ <br>
- If the denominator is 0 then the line lies:
- - either in the plane
- - perpenticular to the normal of the plane
- */
- virtual Intersection intersectionEstimate(const Vector3D& pos,
- const Vector3D& dir,
- bool forceDir = false,
- const BoundaryCheck& bchk = false) const override;
-
- /** Return properly formatted class name for screen output */
- virtual std::string name() const override { return "Acts::DiscSurface"; }
-
- protected: //!< data members
- mutable std::shared_ptr<const DiscBounds> m_bounds; //!< bounds (shared)
- mutable Vector3D* m_referencePoint; //!< a reference point on the Surface
- static NoBounds s_boundless; //!< static member for boundless approach
- };
-
- inline DiscSurface* DiscSurface::clone(const Transform3D* shift) const
+class RadialBounds;
+class DiscTrapezoidalBounds;
+class DetectorElementBase;
+
+/**
+ @class DiscSurface
+
+ Class for a DiscSurface in the TrackingGEometry.
+ It inherits from Surface.
+
+ */
+
+class DiscSurface : public Surface
+{
+public:
+ /** Default Constructor*/
+ DiscSurface();
+
+ /** Constructor for Discs from Transform3D, \f$ r_{min}, r_{max} \f$ */
+ DiscSurface(std::shared_ptr<Transform3D> htrans, double rmin, double rmax);
+
+ /** Constructor for Discs from Transform3D, \f$ r_{min}, r_{max}, \phi_{hsec}
+ * \f$ */
+ DiscSurface(std::shared_ptr<Transform3D> htrans,
+ double rmin,
+ double rmax,
+ double hphisec);
+
+ /** Constructor for Discs from Transform3D, \f$ r_{min}, r_{max}, hx_{min},
+ hx_{max} \f$
+ In this case you have DiscTrapezoidalBounds*/
+ DiscSurface(std::shared_ptr<Transform3D> htrans,
+ double minhalfx,
+ double maxhalfx,
+ double maxR,
+ double minR,
+ double avephi,
+ double stereo = 0.);
+
+ /** Constructor for Discs from Transform3D and DiscBounds - ownership of
+ * bounds is passed */
+ DiscSurface(std::shared_ptr<Transform3D> htrans, const RadialBounds* rbounds);
+
+ /** Constructor for Discs from Transform3D and DiscTrapezoidalBounds -
+ * ownership of bounds is passed */
+ DiscSurface(std::shared_ptr<Transform3D> htrans,
+ const DiscTrapezoidalBounds* dtbounds);
+
+ /** Constructor for Discs from Transform3D and shared DiscBounds */
+ DiscSurface(std::shared_ptr<Transform3D> htrans,
+ std::shared_ptr<const DiscBounds> dbounds);
+
+ /** Constructor for Discs from Transform3D by unique_ptr
+ - bounds is not set */
+ DiscSurface(std::unique_ptr<Transform3D> htrans);
+
+ /** Constructor from DetectorElementBase*/
+ DiscSurface(const DetectorElementBase& detelement,
+ const Identifier& identifier = Identifier());
+
+ /** Copy Constructor*/
+ DiscSurface(const DiscSurface& psf);
+
+ /** Copy Constructor with shift*/
+ DiscSurface(const DiscSurface& psf, const Transform3D& transf);
+
+ /** Destructor*/
+ virtual ~DiscSurface();
+
+ /** Assignement operator*/
+ DiscSurface&
+ operator=(const DiscSurface& dsf);
+
+ /** Equality operator*/
+ virtual bool
+ operator==(const Surface& sf) const override;
+
+ /** Virtual constructor - shift can be given optionally */
+ virtual DiscSurface*
+ clone(const Transform3D* shift = nullptr) const override;
+
+ /** Return the surface type */
+ virtual SurfaceType
+ type() const override
{
- if (shift) return new DiscSurface(*this,*shift);
- return new DiscSurface(*this);
+ return Surface::Disc;
}
- inline const SurfaceBounds& DiscSurface::bounds() const
+ /**This method returns the bounds by reference*/
+ const SurfaceBounds&
+ bounds() const override;
+
+ /** This method returns true if the GlobalPosition is on the Surface for both,
+ within
+ or without check of whether the local position is inside boundaries or not
+ */
+ virtual bool
+ isOnSurface(const Vector3D& glopo,
+ const BoundaryCheck& bchk = true) const override;
+
+ /** Specialized for DiscSurface: LocalToGlobal method without dynamic memory
+ * allocation */
+ virtual void
+ localToGlobal(const Vector2D& locp,
+ const Vector3D& mom,
+ Vector3D& glob) const override;
+
+ /** Specialized for DiscSurface: GlobalToLocal method without dynamic memory
+ * allocation - boolean checks if on surface */
+ virtual bool
+ globalToLocal(const Vector3D& glob,
+ const Vector3D& mom,
+ Vector2D& loc) const override;
+
+ /** Special method for DiscSurface : local<->local transformations polar <->
+ * cartesian */
+ const Vector2D
+ localPolarToCartesian(const Vector2D& locpol) const;
+
+ /** Special method for Disc surface : local<->local transformations polar <->
+ * cartesian */
+ const Vector2D
+ localCartesianToPolar(const Vector2D& loccart) const;
+
+ /** Special method for DiscSurface : local<->local transformations polar <->
+ * cartesian */
+ const Vector2D
+ localPolarToLocalCartesian(const Vector2D& locpol) const;
+
+ /** Special method for DiscSurface : local<->global transformation when
+ * provided cartesian coordinates */
+ const Vector3D
+ localCartesianToGlobal(const Vector2D& locpos) const;
+
+ /** Special method for DiscSurface : global<->local from cartesian coordinates
+ */
+ const Vector2D
+ globalToLocalCartesian(const Vector3D& glopos, double tol = 0.) const;
+
+ /** fast straight line intersection schema - standard: provides closest
+ intersection and (signed) path length
+ forceDir is to provide the closest forward solution
+
+ <b>mathematical motivation:</b>
+
+ the equation of the plane is given by: <br>
+ @f$ \vec n \cdot \vec x = \vec n \cdot \vec p,@f$ <br>
+ where @f$ \vec n = (n_{x}, n_{y}, n_{z})@f$ denotes the normal vector of
+ the plane,
+ @f$ \vec p = (p_{x}, p_{y}, p_{z})@f$ one specific point on the plane and
+ @f$ \vec x = (x,y,z) @f$ all possible points
+ on the plane.<br>
+ Given a line with:<br>
+ @f$ \vec l(u) = \vec l_{1} + u \cdot \vec v @f$, <br>
+ the solution for @f$ u @f$ can be written:
+ @f$ u = \frac{\vec n (\vec p - \vec l_{1})}{\vec n \vec v}@f$ <br>
+ If the denominator is 0 then the line lies:
+ - either in the plane
+ - perpenticular to the normal of the plane
+ */
+ virtual Intersection
+ intersectionEstimate(const Vector3D& pos,
+ const Vector3D& dir,
+ bool forceDir = false,
+ const BoundaryCheck& bchk = false) const override;
+
+ /** Return properly formatted class name for screen output */
+ virtual std::string
+ name() const override
{
- if (m_bounds) return (*(m_bounds.get()));
- if (Surface::m_associatedDetElement && Surface::m_associatedDetElementId.is_valid()){
- return m_associatedDetElement->bounds(Surface::m_associatedDetElementId);
- }
- if (Surface::m_associatedDetElement) return m_associatedDetElement->bounds();
- return s_boundless;
+ return "Acts::DiscSurface";
}
- inline const Vector2D DiscSurface::localPolarToCartesian(const Vector2D& locpol) const
- { return(Vector2D(locpol[Acts::eLOC_R]*cos(locpol[Acts::eLOC_PHI]),locpol[Acts::eLOC_R]*sin(locpol[Acts::eLOC_PHI]))); }
-
- inline const Vector2D DiscSurface::localCartesianToPolar(const Vector2D& loccart) const
- {
- return (Vector2D(sqrt(loccart[Acts::eLOC_X]*loccart[Acts::eLOC_X]+loccart[Acts::eLOC_Y]*loccart[Acts::eLOC_Y]),
- atan2(loccart[Acts::eLOC_Y], loccart[Acts::eLOC_X])));
+protected: //!< data members
+ mutable std::shared_ptr<const DiscBounds> m_bounds; //!< bounds (shared)
+ mutable Vector3D* m_referencePoint; //!< a reference point on the Surface
+ static NoBounds s_boundless; //!< static member for boundless approach
+};
+
+inline DiscSurface*
+DiscSurface::clone(const Transform3D* shift) const
+{
+ if (shift) return new DiscSurface(*this, *shift);
+ return new DiscSurface(*this);
+}
+
+inline const SurfaceBounds&
+DiscSurface::bounds() const
+{
+ if (m_bounds) return (*(m_bounds.get()));
+ if (Surface::m_associatedDetElement
+ && Surface::m_associatedDetElementId.is_valid()) {
+ return m_associatedDetElement->bounds(Surface::m_associatedDetElementId);
}
-
- inline Intersection DiscSurface::intersectionEstimate(const Vector3D& pos,
- const Vector3D& dir,
- bool forceDir,
- const BoundaryCheck& bchk) const
- {
- double denom = dir.dot(normal());
- if (denom){
- double u = (normal().dot((center()-pos)))/(denom);
- Vector3D intersectPoint(pos + u * dir);
- // evaluate the intersection in terms of direction
- bool isValid = forceDir ? ( u > 0.) : true;
- // evaluate (if necessary in terms of boundaries)
- isValid = bchk ? (isValid && isOnSurface(intersectPoint,bchk) ) : isValid;
- // return the result
- return Intersection(intersectPoint,u,isValid);
- }
- return Intersection(pos,0.,false);
+ if (Surface::m_associatedDetElement) return m_associatedDetElement->bounds();
+ return s_boundless;
+}
+
+inline const Vector2D
+DiscSurface::localPolarToCartesian(const Vector2D& locpol) const
+{
+ return (Vector2D(locpol[Acts::eLOC_R] * cos(locpol[Acts::eLOC_PHI]),
+ locpol[Acts::eLOC_R] * sin(locpol[Acts::eLOC_PHI])));
+}
+
+inline const Vector2D
+DiscSurface::localCartesianToPolar(const Vector2D& loccart) const
+{
+ return (Vector2D(sqrt(loccart[Acts::eLOC_X] * loccart[Acts::eLOC_X]
+ + loccart[Acts::eLOC_Y] * loccart[Acts::eLOC_Y]),
+ atan2(loccart[Acts::eLOC_Y], loccart[Acts::eLOC_X])));
+}
+
+inline Intersection
+DiscSurface::intersectionEstimate(const Vector3D& pos,
+ const Vector3D& dir,
+ bool forceDir,
+ const BoundaryCheck& bchk) const
+{
+ double denom = dir.dot(normal());
+ if (denom) {
+ double u = (normal().dot((center() - pos))) / (denom);
+ Vector3D intersectPoint(pos + u * dir);
+ // evaluate the intersection in terms of direction
+ bool isValid = forceDir ? (u > 0.) : true;
+ // evaluate (if necessary in terms of boundaries)
+ isValid = bchk ? (isValid && isOnSurface(intersectPoint, bchk)) : isValid;
+ // return the result
+ return Intersection(intersectPoint, u, isValid);
}
+ return Intersection(pos, 0., false);
+}
-} // end of namespace
+} // end of namespace
-#endif // ACTS_SURFACES_DISCSURFACE_H
+#endif // ACTS_SURFACES_DISCSURFACE_H
diff --git a/Core/include/ACTS/Surfaces/DiscTrapezoidalBounds.hpp b/Core/include/ACTS/Surfaces/DiscTrapezoidalBounds.hpp
index b7cea9edd..b1750918e 100644
--- a/Core/include/ACTS/Surfaces/DiscTrapezoidalBounds.hpp
+++ b/Core/include/ACTS/Surfaces/DiscTrapezoidalBounds.hpp
@@ -13,326 +13,497 @@
#ifndef ACTS_SURFACES_DISCTRAPEZOIDALBOUNDS_H
#define ACTS_SURFACES_DISCTRAPEZOIDALBOUNDS_H
+#include <cmath>
+#include <math.h>
#include "ACTS/Surfaces/DiscBounds.hpp"
-#include "ACTS/Utilities/ParameterDefinitions.hpp"
#include "ACTS/Utilities/Definitions.hpp"
-#include <math.h>
-#include <cmath>
+#include "ACTS/Utilities/ParameterDefinitions.hpp"
namespace Acts {
- /**
- @class DiscTrapezoidalBounds
-
- Class to describe the bounds for a planar DiscSurface.
- By providing an argument for hphisec, the bounds can
- be restricted to a phirange around the center position.
-
- */
-
- class DiscTrapezoidalBounds : public DiscBounds {
-
- public:
- /** enumeration for readability */
- enum BoundValues {
- bv_rMin = 0,
- bv_rMax = 1,
- bv_minHalfX = 2,
- bv_maxHalfX = 3,
- bv_halfY = 4,
- bv_halfPhiSector = 5,
- bv_averagePhi = 6,
- bv_rCenter = 7,
- bv_stereo = 8,
- bv_length = 9
- };
-
- /** Default Constructor*/
- DiscTrapezoidalBounds();
-
- /** Constructor for a symmetric Trapezoid giving min X lenght, max X lenght, Rmin and R max */
- DiscTrapezoidalBounds(double minhalfx, double maxhalfx, double rMin, double rMax, double avephi, double stereo = 0.);
-
- /** Copy constructor*/
- DiscTrapezoidalBounds(const DiscTrapezoidalBounds& disctrbo);
-
- /** Destructor*/
- virtual ~DiscTrapezoidalBounds();
-
- /** Assignment operator*/
- DiscTrapezoidalBounds& operator=(const DiscTrapezoidalBounds& disctrbo);
-
- /** Equality operator*/
- bool operator==(const SurfaceBounds& sbo) const override;
-
- /** Virtual constructor*/
- virtual DiscTrapezoidalBounds* clone() const override;
-
- /** Return the type - mainly for persistency */
- virtual SurfaceBounds::BoundsType type() const override { return SurfaceBounds::DiscTrapezoidal; }
-
- /** This method cheks if the radius given in the LocalPosition is inside [rMin,rMax]
- if only tol1 is given and additional in the phi sector is tol2 is given */
- virtual bool inside(const Vector2D &locpo, double tol1=0., double tol2=0.) const override;
- virtual bool inside(const Vector2D& locpo, const BoundaryCheck& bchk = true) const override;
-
- /** This method checks inside bounds in loc1
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc1(const Vector2D& locpo, double tol1=0.) const override;
-
- /** This method checks inside bounds in loc2
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc2(const Vector2D& locpo, double tol2=0.) const override;
-
- /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
- virtual double minDistance(const Vector2D& pos) const override;
-
- /** This method returns inner radius*/
- double rMin() const;
-
- /** This method returns outer radius*/
- double rMax() const;
-
- /** This method returns the maximum expansion on the plane (=rMax)*/
- virtual double r() const override;
-
- /** This method returns the average phi*/
- double averagePhi() const;
-
- /** This method returns the center radius*/
- double rCenter() const;
-
- /** This method returns the stereo angle*/
- double stereo() const;
-
- /** This method returns the halfPhiSector which is covered by the disc*/
- double halfPhiSector() const;
-
- /** This method returns the minimal halflength in X */
- double minHalflengthX() const;
-
- /** This method returns the maximal halflength in X */
- double maxHalflengthX() const;
-
- /** This method returns the halflength in Y (this is Rmax -Rmin)*/
- double halflengthY() const;
-
- /** Output Method for std::ostream */
- virtual std::ostream& dump(std::ostream& sl) const override;
-
- private:
- /** Internal members of the bounds (float/double)*/
- std::vector<TDD_real_t> m_boundValues;
-
+/**
+ @class DiscTrapezoidalBounds
+
+ Class to describe the bounds for a planar DiscSurface.
+ By providing an argument for hphisec, the bounds can
+ be restricted to a phirange around the center position.
+
+*/
+
+class DiscTrapezoidalBounds : public DiscBounds
+{
+public:
+ /** enumeration for readability */
+ enum BoundValues {
+ bv_rMin = 0,
+ bv_rMax = 1,
+ bv_minHalfX = 2,
+ bv_maxHalfX = 3,
+ bv_halfY = 4,
+ bv_halfPhiSector = 5,
+ bv_averagePhi = 6,
+ bv_rCenter = 7,
+ bv_stereo = 8,
+ bv_length = 9
};
- inline DiscTrapezoidalBounds* DiscTrapezoidalBounds::clone() const
- { return new DiscTrapezoidalBounds(*this); }
-
- inline bool DiscTrapezoidalBounds::inside(const Vector2D &locpo, double , double ) const
- {
- double rMedium = m_boundValues.at(DiscTrapezoidalBounds::bv_rCenter);
- double phi = m_boundValues.at(DiscTrapezoidalBounds::bv_averagePhi);
-
- Vector2D cartCenter(rMedium*cos(phi),
- rMedium*sin(phi));
-
- Vector2D cartPos(locpo[Acts::eLOC_R]*cos(locpo[Acts::eLOC_PHI]),
- locpo[Acts::eLOC_R]*sin(locpo[Acts::eLOC_PHI]));
-
- Vector2D Pos = cartPos - cartCenter;
-
- Vector2D DeltaPos(Pos[Acts::eLOC_X]*sin(phi) - Pos[Acts::eLOC_Y]*cos(phi),
- Pos[Acts::eLOC_Y]*sin(phi) + Pos[Acts::eLOC_X]*cos(phi));
+ /** Default Constructor*/
+ DiscTrapezoidalBounds();
- bool insideX = (fabs(DeltaPos[Acts::eLOC_X])<m_boundValues.at(DiscTrapezoidalBounds::bv_maxHalfX));
- bool insideY = (fabs(DeltaPos[Acts::eLOC_Y])<m_boundValues.at(DiscTrapezoidalBounds::bv_halfY));
+ /** Constructor for a symmetric Trapezoid giving min X lenght, max X lenght,
+ * Rmin and R max */
+ DiscTrapezoidalBounds(double minhalfx,
+ double maxhalfx,
+ double rMin,
+ double rMax,
+ double avephi,
+ double stereo = 0.);
- if (!insideX || !insideY) return false;
+ /** Copy constructor*/
+ DiscTrapezoidalBounds(const DiscTrapezoidalBounds& disctrbo);
- if (fabs(DeltaPos[Acts::eLOC_X]) < m_boundValues.at(DiscTrapezoidalBounds::bv_minHalfX)) return true;
+ /** Destructor*/
+ virtual ~DiscTrapezoidalBounds();
- double m = 2.*m_boundValues.at(DiscTrapezoidalBounds::bv_halfY)/(m_boundValues.at(DiscTrapezoidalBounds::bv_maxHalfX) - m_boundValues.at(DiscTrapezoidalBounds::bv_minHalfX));
+ /** Assignment operator*/
+ DiscTrapezoidalBounds&
+ operator=(const DiscTrapezoidalBounds& disctrbo);
- double q = m_boundValues.at(DiscTrapezoidalBounds::bv_halfY)*(m_boundValues.at(DiscTrapezoidalBounds::bv_maxHalfX) + m_boundValues.at(DiscTrapezoidalBounds::bv_minHalfX))/(m_boundValues.at(DiscTrapezoidalBounds::bv_minHalfX) - m_boundValues.at(DiscTrapezoidalBounds::bv_maxHalfX));
+ /** Equality operator*/
+ bool
+ operator==(const SurfaceBounds& sbo) const override;
- bool inside = (DeltaPos[Acts::eLOC_Y] > (m*fabs(DeltaPos[Acts::eLOC_X])+q));
-
- return inside;
+ /** Virtual constructor*/
+ virtual DiscTrapezoidalBounds*
+ clone() const override;
+ /** Return the type - mainly for persistency */
+ virtual SurfaceBounds::BoundsType
+ type() const override
+ {
+ return SurfaceBounds::DiscTrapezoidal;
}
- inline bool DiscTrapezoidalBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
+ /** This method cheks if the radius given in the LocalPosition is inside
+ [rMin,rMax]
+ if only tol1 is given and additional in the phi sector is tol2 is given */
+ virtual bool
+ inside(const Vector2D& locpo,
+ double tol1 = 0.,
+ double tol2 = 0.) const override;
+ virtual bool
+ inside(const Vector2D& locpo,
+ const BoundaryCheck& bchk = true) const override;
+
+ /** This method checks inside bounds in loc1
+- loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc1(const Vector2D& locpo, double tol1 = 0.) const override;
+
+ /** This method checks inside bounds in loc2
+- loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc2(const Vector2D& locpo, double tol2 = 0.) const override;
+
+ /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
+ virtual double
+ minDistance(const Vector2D& pos) const override;
+
+ /** This method returns inner radius*/
+ double
+ rMin() const;
+
+ /** This method returns outer radius*/
+ double
+ rMax() const;
+
+ /** This method returns the maximum expansion on the plane (=rMax)*/
+ virtual double
+ r() const override;
+
+ /** This method returns the average phi*/
+ double
+ averagePhi() const;
+
+ /** This method returns the center radius*/
+ double
+ rCenter() const;
+
+ /** This method returns the stereo angle*/
+ double
+ stereo() const;
+
+ /** This method returns the halfPhiSector which is covered by the disc*/
+ double
+ halfPhiSector() const;
+
+ /** This method returns the minimal halflength in X */
+ double
+ minHalflengthX() const;
+
+ /** This method returns the maximal halflength in X */
+ double
+ maxHalflengthX() const;
+
+ /** This method returns the halflength in Y (this is Rmax -Rmin)*/
+ double
+ halflengthY() const;
+
+ /** Output Method for std::ostream */
+ virtual std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ /** Internal members of the bounds (float/double)*/
+ std::vector<TDD_real_t> m_boundValues;
+};
+
+inline DiscTrapezoidalBounds*
+DiscTrapezoidalBounds::clone() const
+{
+ return new DiscTrapezoidalBounds(*this);
+}
+
+inline bool
+DiscTrapezoidalBounds::inside(const Vector2D& locpo, double, double) const
+{
+ double rMedium = m_boundValues.at(DiscTrapezoidalBounds::bv_rCenter);
+ double phi = m_boundValues.at(DiscTrapezoidalBounds::bv_averagePhi);
+
+ Vector2D cartCenter(rMedium * cos(phi), rMedium * sin(phi));
+
+ Vector2D cartPos(locpo[Acts::eLOC_R] * cos(locpo[Acts::eLOC_PHI]),
+ locpo[Acts::eLOC_R] * sin(locpo[Acts::eLOC_PHI]));
+
+ Vector2D Pos = cartPos - cartCenter;
+
+ Vector2D DeltaPos(Pos[Acts::eLOC_X] * sin(phi) - Pos[Acts::eLOC_Y] * cos(phi),
+ Pos[Acts::eLOC_Y] * sin(phi)
+ + Pos[Acts::eLOC_X] * cos(phi));
+
+ bool insideX = (fabs(DeltaPos[Acts::eLOC_X])
+ < m_boundValues.at(DiscTrapezoidalBounds::bv_maxHalfX));
+ bool insideY = (fabs(DeltaPos[Acts::eLOC_Y])
+ < m_boundValues.at(DiscTrapezoidalBounds::bv_halfY));
+
+ if (!insideX || !insideY) return false;
+
+ if (fabs(DeltaPos[Acts::eLOC_X])
+ < m_boundValues.at(DiscTrapezoidalBounds::bv_minHalfX))
+ return true;
+
+ double m = 2. * m_boundValues.at(DiscTrapezoidalBounds::bv_halfY)
+ / (m_boundValues.at(DiscTrapezoidalBounds::bv_maxHalfX)
+ - m_boundValues.at(DiscTrapezoidalBounds::bv_minHalfX));
+
+ double q = m_boundValues.at(DiscTrapezoidalBounds::bv_halfY)
+ * (m_boundValues.at(DiscTrapezoidalBounds::bv_maxHalfX)
+ + m_boundValues.at(DiscTrapezoidalBounds::bv_minHalfX))
+ / (m_boundValues.at(DiscTrapezoidalBounds::bv_minHalfX)
+ - m_boundValues.at(DiscTrapezoidalBounds::bv_maxHalfX));
+
+ bool inside
+ = (DeltaPos[Acts::eLOC_Y] > (m * fabs(DeltaPos[Acts::eLOC_X]) + q));
+
+ return inside;
+}
+
+inline bool
+DiscTrapezoidalBounds::inside(const Vector2D& locpo,
+ const BoundaryCheck& bchk) const
+{
+ if (bchk.bcType == 0 || bchk.nSigmas == 0
+ || m_boundValues.at(DiscTrapezoidalBounds::bv_rMin) != 0)
+ return DiscTrapezoidalBounds::inside(
+ locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
+ double alpha = fabs(locpo[Acts::eLOC_PHI]
+ - m_boundValues.at(DiscTrapezoidalBounds::bv_averagePhi));
+ if (alpha > M_PI) alpha = 2 * M_PI - alpha;
+ // a fast FALSE
+ sincosCache scResult = bchk.FastSinCos(locpo(1, 0));
+ double dx = bchk.nSigmas * sqrt(bchk.lCovariance(0, 0));
+ double dy = bchk.nSigmas
+ * sqrt(scResult.sinC * scResult.sinC * bchk.lCovariance(0, 0)
+ + locpo(0, 0) * locpo(0, 0) * scResult.cosC * scResult.cosC
+ * bchk.lCovariance(1, 1)
+ + 2 * scResult.cosC * scResult.sinC * locpo(0, 0)
+ * bchk.lCovariance(0, 1));
+ double max_ell = dx > dy ? dx : dy;
+ if (locpo(0, 0)
+ > (m_boundValues.at(DiscTrapezoidalBounds::bv_rMax)
+ * cos(m_boundValues.at(DiscTrapezoidalBounds::bv_halfPhiSector))
+ / cos(alpha)
+ + max_ell))
+ return false;
+ // a fast TRUE
+ double min_ell = dx < dy ? dx : dy;
+ if (locpo(0, 0)
+ < (m_boundValues.at(DiscTrapezoidalBounds::bv_rMax)
+ * cos(m_boundValues.at(DiscTrapezoidalBounds::bv_halfPhiSector))
+ / cos(alpha)
+ + min_ell))
+ return true;
+
+ // we are not using the KDOP approach here but rather a highly optimized one
+ class EllipseCollisionTest
+ {
+ private:
+ int m_maxIterations;
+ bool
+ iterate(double x,
+ double y,
+ double c0x,
+ double c0y,
+ double c2x,
+ double c2y,
+ double rr) const
{
- if(bchk.bcType==0 || bchk.nSigmas==0 || m_boundValues.at(DiscTrapezoidalBounds::bv_rMin)!=0) return DiscTrapezoidalBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
- double alpha = fabs(locpo[Acts::eLOC_PHI]-m_boundValues.at(DiscTrapezoidalBounds::bv_averagePhi));
- if ( alpha>M_PI) alpha = 2*M_PI - alpha;
- // a fast FALSE
- sincosCache scResult = bchk.FastSinCos(locpo(1,0));
- double dx = bchk.nSigmas*sqrt(bchk.lCovariance(0,0));
- double dy = bchk.nSigmas*sqrt(scResult.sinC*scResult.sinC*bchk.lCovariance(0,0) + locpo(0,0)*locpo(0,0)*scResult.cosC*scResult.cosC*bchk.lCovariance(1,1)+2*scResult.cosC*scResult.sinC*locpo(0,0)*bchk.lCovariance(0,1));
- double max_ell = dx > dy ? dx : dy;
- if (locpo(0,0) > ( m_boundValues.at(DiscTrapezoidalBounds::bv_rMax)*cos(m_boundValues.at(DiscTrapezoidalBounds::bv_halfPhiSector))/cos(alpha) + max_ell))
- return false;
- // a fast TRUE
- double min_ell = dx < dy ? dx : dy;
- if (locpo(0,0) < ( m_boundValues.at(DiscTrapezoidalBounds::bv_rMax)*cos(m_boundValues.at(DiscTrapezoidalBounds::bv_halfPhiSector))/cos(alpha) + min_ell))
- return true;
-
- // we are not using the KDOP approach here but rather a highly optimized one
- class EllipseCollisionTest {
- private:
- int m_maxIterations;
- bool iterate(double x, double y, double c0x, double c0y, double c2x, double c2y, double rr) const {
- std::vector<double> innerPolygonCoef(m_maxIterations+1);
- std::vector<double> outerPolygonCoef(m_maxIterations+1);
- /*
- t2______t4
- --_ \
- --_ \ /¨¨¨ ¨¨\
- t1 = (0, 0) ( t )
- | \ \__ _ /
- | \
- | t3
- | /
- | /
- t0
- */
- for (int t = 1; t <= m_maxIterations; t++) {
- int numNodes = 4 << t;
- innerPolygonCoef.at(t) = 0.5/cos(4*acos(0.0)/numNodes);
- double c1x = (c0x + c2x)*innerPolygonCoef.at(t);
- double c1y = (c0y + c2y)*innerPolygonCoef.at(t);
- double tx = x - c1x; // t indicates a translated coordinate
- double ty = y - c1y;
- if (tx*tx + ty*ty <= rr) {
- return true; // collision with t1
- }
- double t2x = c2x - c1x;
- double t2y = c2y - c1y;
- if (tx*t2x + ty*t2y >= 0 && tx*t2x + ty*t2y <= t2x*t2x + t2y*t2y &&
- (ty*t2x - tx*t2y >= 0 || rr*(t2x*t2x + t2y*t2y) >= (ty*t2x - tx*t2y)*(ty*t2x - tx*t2y))) {
- return true; // collision with t1---t2
- }
- double t0x = c0x - c1x;
- double t0y = c0y - c1y;
- if (tx*t0x + ty*t0y >= 0 && tx*t0x + ty*t0y <= t0x*t0x + t0y*t0y &&
- (ty*t0x - tx*t0y <= 0 || rr*(t0x*t0x + t0y*t0y) >= (ty*t0x - tx*t0y)*(ty*t0x - tx*t0y))) {
- return true; // collision with t1---t0
- }
- outerPolygonCoef.at(t) = 0.5/(cos(2*acos(0.0)/numNodes)*cos(2*acos(0.0)/numNodes));
- double c3x = (c0x + c1x)*outerPolygonCoef.at(t);
- double c3y = (c0y + c1y)*outerPolygonCoef.at(t);
- if ((c3x-x)*(c3x-x) + (c3y-y)*(c3y-y) < rr) {
- c2x = c1x;
- c2y = c1y;
- continue; // t3 is inside circle
- }
- double c4x = c1x - c3x + c1x;
- double c4y = c1y - c3y + c1y;
- if ((c4x-x)*(c4x-x) + (c4y-y)*(c4y-y) < rr) {
- c0x = c1x;
- c0y = c1y;
- continue; // t4 is inside circle
- }
- double t3x = c3x - c1x;
- double t3y = c3y - c1y;
- if (ty*t3x - tx*t3y <= 0 || rr*(t3x*t3x + t3y*t3y) > (ty*t3x - tx*t3y)*(ty*t3x - tx*t3y)) {
- if (tx*t3x + ty*t3y > 0) {
- if (std::abs(tx*t3x + ty*t3y) <= t3x*t3x + t3y*t3y || (x-c3x)*(c0x-c3x) + (y-c3y)*(c0y-c3y) >= 0) {
- c2x = c1x;
- c2y = c1y;
- continue; // circle center is inside t0---t1---t3
- }
- } else if (-(tx*t3x + ty*t3y) <= t3x*t3x + t3y*t3y || (x-c4x)*(c2x-c4x) + (y-c4y)*(c2y-c4y) >= 0) {
- c0x = c1x;
- c0y = c1y;
- continue; // circle center is inside t1---t2---t4
- }
- }
- return false; // no collision possible
- }
- return false; // out of iterations so it is unsure if there was a collision. But have to return something.
- }
- public:
- // test for collision between an ellipse of horizontal radius w and vertical radius h at (x0, y0) and a circle of radius r at (x1, y1)
- bool collide(double x0, double y0, double w, double h, double x1, double y1, double r) const {
- double x = fabs(x1 - x0);
- double y = fabs(y1 - y0);
- if (x*x + (h - y)*(h - y) <= r*r || (w - x)*(w - x) + y*y <= r*r || x*h + y*w <= w*h // collision with (0, h)
- || ((x*h + y*w - w*h)*(x*h + y*w - w*h) <= r*r*(w*w + h*h) && x*w - y*h >= -h*h && x*w - y*h <= w*w)) { // collision with (0, h)---(w, 0)
- return true;
- } else {
- if ((x-w)*(x-w) + (y-h)*(y-h) <= r*r || (x <= w && y - r <= h) || (y <= h && x - r <= w)) {
- return iterate(x, y, w, 0, 0, h, r*r); // collision within triangle (0, h) (w, h) (0, 0) is possible
- }
- return false;
- }
- }
- EllipseCollisionTest(int maxIterations) {
- this->m_maxIterations = maxIterations;
- }
- };
-
- EllipseCollisionTest test(4);
- // convert to cartesian coordinates
- ActsMatrixD<2,2> covRotMatrix ;
- covRotMatrix << scResult.cosC, -locpo(0,0)*scResult.sinC,
- scResult.sinC, locpo(0,0)*scResult.cosC;
- ActsMatrixD<2,2> lCovarianceCar = covRotMatrix*bchk.lCovariance*covRotMatrix.transpose();
- Vector2D locpoCar(covRotMatrix(1,1), -covRotMatrix(0,1));
-
- // ellipse is always at (0,0), surface is moved to ellipse position and then rotated
- double w = bchk.nSigmas*sqrt( lCovarianceCar(0,0));
- double h = bchk.nSigmas*sqrt( lCovarianceCar(1,1));
- double x0 = 0;
- double y0 = 0;
- float theta = (lCovarianceCar(1,0) != 0 && (lCovarianceCar(1,1)-lCovarianceCar(0,0))!=0 ) ? .5*bchk.FastArcTan( 2*lCovarianceCar(1,0)/(lCovarianceCar(1,1)-lCovarianceCar(0,0)) ) : 0.;
- scResult = bchk.FastSinCos(theta);
- ActsMatrixD<2,2> rotMatrix ;
- rotMatrix << scResult.cosC, scResult.sinC,
- -scResult.sinC, scResult.cosC;
- Vector2D tmp = rotMatrix * (- locpoCar) ;
- double x1 = tmp(0,0);
- double y1 = tmp(1,0);
- double r = m_boundValues.at(DiscTrapezoidalBounds::bv_rMax);
- // check if ellipse and circle overlap and return result
- return test.collide(x0, y0, w, h, x1, y1, r);
+ std::vector<double> innerPolygonCoef(m_maxIterations + 1);
+ std::vector<double> outerPolygonCoef(m_maxIterations + 1);
+ /*
+ t2______t4
+ --_ \
+ --_ \ /¨¨¨ ¨¨\
+ t1 = (0, 0) ( t )
+ | \ \__ _ /
+ | \
+ | t3
+ | /
+ | /
+ t0
+ */
+ for (int t = 1; t <= m_maxIterations; t++) {
+ int numNodes = 4 << t;
+ innerPolygonCoef.at(t) = 0.5 / cos(4 * acos(0.0) / numNodes);
+ double c1x = (c0x + c2x) * innerPolygonCoef.at(t);
+ double c1y = (c0y + c2y) * innerPolygonCoef.at(t);
+ double tx = x - c1x; // t indicates a translated coordinate
+ double ty = y - c1y;
+ if (tx * tx + ty * ty <= rr) {
+ return true; // collision with t1
+ }
+ double t2x = c2x - c1x;
+ double t2y = c2y - c1y;
+ if (tx * t2x + ty * t2y >= 0
+ && tx * t2x + ty * t2y <= t2x * t2x + t2y * t2y
+ && (ty * t2x - tx * t2y >= 0
+ || rr * (t2x * t2x + t2y * t2y)
+ >= (ty * t2x - tx * t2y) * (ty * t2x - tx * t2y))) {
+ return true; // collision with t1---t2
+ }
+ double t0x = c0x - c1x;
+ double t0y = c0y - c1y;
+ if (tx * t0x + ty * t0y >= 0
+ && tx * t0x + ty * t0y <= t0x * t0x + t0y * t0y
+ && (ty * t0x - tx * t0y <= 0
+ || rr * (t0x * t0x + t0y * t0y)
+ >= (ty * t0x - tx * t0y) * (ty * t0x - tx * t0y))) {
+ return true; // collision with t1---t0
+ }
+ outerPolygonCoef.at(t) = 0.5
+ / (cos(2 * acos(0.0) / numNodes) * cos(2 * acos(0.0) / numNodes));
+ double c3x = (c0x + c1x) * outerPolygonCoef.at(t);
+ double c3y = (c0y + c1y) * outerPolygonCoef.at(t);
+ if ((c3x - x) * (c3x - x) + (c3y - y) * (c3y - y) < rr) {
+ c2x = c1x;
+ c2y = c1y;
+ continue; // t3 is inside circle
+ }
+ double c4x = c1x - c3x + c1x;
+ double c4y = c1y - c3y + c1y;
+ if ((c4x - x) * (c4x - x) + (c4y - y) * (c4y - y) < rr) {
+ c0x = c1x;
+ c0y = c1y;
+ continue; // t4 is inside circle
+ }
+ double t3x = c3x - c1x;
+ double t3y = c3y - c1y;
+ if (ty * t3x - tx * t3y <= 0
+ || rr * (t3x * t3x + t3y * t3y)
+ > (ty * t3x - tx * t3y) * (ty * t3x - tx * t3y)) {
+ if (tx * t3x + ty * t3y > 0) {
+ if (std::abs(tx * t3x + ty * t3y) <= t3x * t3x + t3y * t3y
+ || (x - c3x) * (c0x - c3x) + (y - c3y) * (c0y - c3y) >= 0) {
+ c2x = c1x;
+ c2y = c1y;
+ continue; // circle center is inside t0---t1---t3
+ }
+ } else if (-(tx * t3x + ty * t3y) <= t3x * t3x + t3y * t3y
+ || (x - c4x) * (c2x - c4x) + (y - c4y) * (c2y - c4y)
+ >= 0) {
+ c0x = c1x;
+ c0y = c1y;
+ continue; // circle center is inside t1---t2---t4
+ }
+ }
+ return false; // no collision possible
+ }
+ return false; // out of iterations so it is unsure if there was a
+ // collision. But have to return something.
}
- inline bool DiscTrapezoidalBounds::insideLoc1(const Vector2D &locpo, double tol1) const {
- double alpha = fabs(locpo[Acts::eLOC_PHI]-m_boundValues.at(DiscTrapezoidalBounds::bv_averagePhi));
- if ( alpha>M_PI) alpha = 2*M_PI - alpha;
-
- return ( locpo[Acts::eLOC_R] > (m_boundValues.at(DiscTrapezoidalBounds::bv_rMin)*cos(m_boundValues.at(DiscTrapezoidalBounds::bv_halfPhiSector))/cos(alpha) - tol1) &&
- locpo[Acts::eLOC_R] < (m_boundValues.at(DiscTrapezoidalBounds::bv_rMax)*cos(m_boundValues.at(DiscTrapezoidalBounds::bv_halfPhiSector))/cos(alpha) + tol1)); }
-
- inline bool DiscTrapezoidalBounds::insideLoc2(const Vector2D &locpo, double tol2) const {
- double alpha = fabs(locpo[Acts::eLOC_PHI]-m_boundValues.at(DiscTrapezoidalBounds::bv_averagePhi));
- if ( alpha > M_PI ) alpha = 2.*M_PI-alpha;
- return (alpha <= (m_boundValues.at(DiscTrapezoidalBounds::bv_halfPhiSector) + tol2));
- }
-
- inline double DiscTrapezoidalBounds::rMin() const { return m_boundValues.at(DiscTrapezoidalBounds::bv_rMin); }
-
- inline double DiscTrapezoidalBounds::rMax() const { return m_boundValues.at(DiscTrapezoidalBounds::bv_rMax); }
-
- inline double DiscTrapezoidalBounds::r() const { return m_boundValues.at(DiscTrapezoidalBounds::bv_rMax); }
-
- inline double DiscTrapezoidalBounds::averagePhi() const { return m_boundValues.at(DiscTrapezoidalBounds::bv_averagePhi); }
-
- inline double DiscTrapezoidalBounds::rCenter() const { return m_boundValues.at(DiscTrapezoidalBounds::bv_rCenter); }
-
- inline double DiscTrapezoidalBounds::stereo() const { return m_boundValues.at(DiscTrapezoidalBounds::bv_stereo); }
-
- inline double DiscTrapezoidalBounds::halfPhiSector() const { return m_boundValues.at(DiscTrapezoidalBounds::bv_halfPhiSector); }
-
- inline double DiscTrapezoidalBounds::minHalflengthX() const { return m_boundValues.at(DiscTrapezoidalBounds::bv_minHalfX); }
-
- inline double DiscTrapezoidalBounds::maxHalflengthX() const { return m_boundValues.at(DiscTrapezoidalBounds::bv_maxHalfX); }
-
- inline double DiscTrapezoidalBounds::halflengthY() const {return m_boundValues.at(DiscTrapezoidalBounds::bv_halfY); }
-
-} // end of namespace
+ public:
+ // test for collision between an ellipse of horizontal radius w and vertical
+ // radius h at (x0, y0) and a circle of radius r at (x1, y1)
+ bool
+ collide(double x0,
+ double y0,
+ double w,
+ double h,
+ double x1,
+ double y1,
+ double r) const
+ {
+ double x = fabs(x1 - x0);
+ double y = fabs(y1 - y0);
+ if (x * x + (h - y) * (h - y) <= r * r
+ || (w - x) * (w - x) + y * y <= r * r
+ || x * h + y * w <= w * h // collision with (0, h)
+ || ((x * h + y * w - w * h) * (x * h + y * w - w * h)
+ <= r * r * (w * w + h * h)
+ && x * w - y * h >= -h * h
+ && x * w - y * h <= w * w)) { // collision with (0, h)---(w, 0)
+ return true;
+ } else {
+ if ((x - w) * (x - w) + (y - h) * (y - h) <= r * r
+ || (x <= w && y - r <= h)
+ || (y <= h && x - r <= w)) {
+ return iterate(x, y, w, 0, 0, h, r * r); // collision within triangle
+ // (0, h) (w, h) (0, 0) is
+ // possible
+ }
+ return false;
+ }
+ }
+ EllipseCollisionTest(int maxIterations)
+ {
+ this->m_maxIterations = maxIterations;
+ }
+ };
-#endif // ACTS_SURFACES_DISCTRAPEZOIDALBOUNDS_H
+ EllipseCollisionTest test(4);
+ // convert to cartesian coordinates
+ ActsMatrixD<2, 2> covRotMatrix;
+ covRotMatrix << scResult.cosC, -locpo(0, 0) * scResult.sinC, scResult.sinC,
+ locpo(0, 0) * scResult.cosC;
+ ActsMatrixD<2, 2> lCovarianceCar
+ = covRotMatrix * bchk.lCovariance * covRotMatrix.transpose();
+ Vector2D locpoCar(covRotMatrix(1, 1), -covRotMatrix(0, 1));
+
+ // ellipse is always at (0,0), surface is moved to ellipse position and then
+ // rotated
+ double w = bchk.nSigmas * sqrt(lCovarianceCar(0, 0));
+ double h = bchk.nSigmas * sqrt(lCovarianceCar(1, 1));
+ double x0 = 0;
+ double y0 = 0;
+ float theta = (lCovarianceCar(1, 0) != 0
+ && (lCovarianceCar(1, 1) - lCovarianceCar(0, 0)) != 0)
+ ? .5
+ * bchk.FastArcTan(2 * lCovarianceCar(1, 0)
+ / (lCovarianceCar(1, 1) - lCovarianceCar(0, 0)))
+ : 0.;
+ scResult = bchk.FastSinCos(theta);
+ ActsMatrixD<2, 2> rotMatrix;
+ rotMatrix << scResult.cosC, scResult.sinC, -scResult.sinC, scResult.cosC;
+ Vector2D tmp = rotMatrix * (-locpoCar);
+ double x1 = tmp(0, 0);
+ double y1 = tmp(1, 0);
+ double r = m_boundValues.at(DiscTrapezoidalBounds::bv_rMax);
+ // check if ellipse and circle overlap and return result
+ return test.collide(x0, y0, w, h, x1, y1, r);
+}
+
+inline bool
+DiscTrapezoidalBounds::insideLoc1(const Vector2D& locpo, double tol1) const
+{
+ double alpha = fabs(locpo[Acts::eLOC_PHI]
+ - m_boundValues.at(DiscTrapezoidalBounds::bv_averagePhi));
+ if (alpha > M_PI) alpha = 2 * M_PI - alpha;
+
+ return (locpo[Acts::eLOC_R]
+ > (m_boundValues.at(DiscTrapezoidalBounds::bv_rMin)
+ * cos(m_boundValues.at(
+ DiscTrapezoidalBounds::bv_halfPhiSector))
+ / cos(alpha)
+ - tol1)
+ && locpo[Acts::eLOC_R]
+ < (m_boundValues.at(DiscTrapezoidalBounds::bv_rMax)
+ * cos(m_boundValues.at(
+ DiscTrapezoidalBounds::bv_halfPhiSector))
+ / cos(alpha)
+ + tol1));
+}
+
+inline bool
+DiscTrapezoidalBounds::insideLoc2(const Vector2D& locpo, double tol2) const
+{
+ double alpha = fabs(locpo[Acts::eLOC_PHI]
+ - m_boundValues.at(DiscTrapezoidalBounds::bv_averagePhi));
+ if (alpha > M_PI) alpha = 2. * M_PI - alpha;
+ return (alpha <= (m_boundValues.at(DiscTrapezoidalBounds::bv_halfPhiSector)
+ + tol2));
+}
+
+inline double
+DiscTrapezoidalBounds::rMin() const
+{
+ return m_boundValues.at(DiscTrapezoidalBounds::bv_rMin);
+}
+
+inline double
+DiscTrapezoidalBounds::rMax() const
+{
+ return m_boundValues.at(DiscTrapezoidalBounds::bv_rMax);
+}
+
+inline double
+DiscTrapezoidalBounds::r() const
+{
+ return m_boundValues.at(DiscTrapezoidalBounds::bv_rMax);
+}
+
+inline double
+DiscTrapezoidalBounds::averagePhi() const
+{
+ return m_boundValues.at(DiscTrapezoidalBounds::bv_averagePhi);
+}
+
+inline double
+DiscTrapezoidalBounds::rCenter() const
+{
+ return m_boundValues.at(DiscTrapezoidalBounds::bv_rCenter);
+}
+
+inline double
+DiscTrapezoidalBounds::stereo() const
+{
+ return m_boundValues.at(DiscTrapezoidalBounds::bv_stereo);
+}
+
+inline double
+DiscTrapezoidalBounds::halfPhiSector() const
+{
+ return m_boundValues.at(DiscTrapezoidalBounds::bv_halfPhiSector);
+}
+
+inline double
+DiscTrapezoidalBounds::minHalflengthX() const
+{
+ return m_boundValues.at(DiscTrapezoidalBounds::bv_minHalfX);
+}
+
+inline double
+DiscTrapezoidalBounds::maxHalflengthX() const
+{
+ return m_boundValues.at(DiscTrapezoidalBounds::bv_maxHalfX);
+}
+
+inline double
+DiscTrapezoidalBounds::halflengthY() const
+{
+ return m_boundValues.at(DiscTrapezoidalBounds::bv_halfY);
+}
+
+} // end of namespace
+
+#endif // ACTS_SURFACES_DISCTRAPEZOIDALBOUNDS_H
diff --git a/Core/include/ACTS/Surfaces/EllipseBounds.hpp b/Core/include/ACTS/Surfaces/EllipseBounds.hpp
index 8ed12c3f3..2180dd759 100644
--- a/Core/include/ACTS/Surfaces/EllipseBounds.hpp
+++ b/Core/include/ACTS/Surfaces/EllipseBounds.hpp
@@ -13,169 +13,278 @@
#ifndef ACTS_SURFACES_ELLIPSEBOUNDS_H
#define ACTS_SURFACES_ELLIPSEBOUNDS_H 1
-#include "ACTS/Surfaces/PlanarBounds.hpp"
-#include "ACTS/Utilities/Definitions.hpp"
#include <math.h>
#include <stdlib.h>
+#include "ACTS/Surfaces/PlanarBounds.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
namespace Acts {
- /**
- @class EllipseBounds
-
- Class to describe the bounds for a planar EllipseSurface,
- i.e. the surface between two ellipses.
- By providing an argument for hphisec, the bounds can
- be restricted to a phirange around the center position.
-
- */
-
- class EllipseBounds : public PlanarBounds {
- public:
- /** @enum for readibility */
- enum BoundValues {
- bv_rMinX = 0,
- bv_rMinY = 1,
- bv_rMaxX = 2,
- bv_rMaxY = 3,
- bv_averagePhi = 4,
- bv_halfPhiSector = 5,
- bv_length = 6
- };
-
- /** Default Constructor*/
- EllipseBounds();
-
- /** Constructor for full of an ellipsoid disc around phi=0*/
- EllipseBounds(double minrad1, double minrad2, double maxrad1, double maxrad2, double hphisec=M_PI);
-
- /** Constructor for an ellipsoid disc around phi != 0*/
- EllipseBounds(double minrad1, double minrad2, double maxrad1, double maxrad2, double avephi, double hphisec);
-
- /** Copy constructor*/
- EllipseBounds(const EllipseBounds& discbo);
-
- /** Destructor*/
- virtual ~EllipseBounds();
-
- /** Assignment operator*/
- EllipseBounds& operator=(const EllipseBounds& discbo);
-
- /** Move assignment operator*/
- EllipseBounds& operator=(EllipseBounds&& discbo);
-
- /** Equality operator*/
- virtual bool operator==(const SurfaceBounds& sbo) const override;
-
- /** Virtual constructor*/
- virtual EllipseBounds* clone() const override;
-
- /** Return the type of the bounds for persistency */
- virtual BoundsType type() const override { return SurfaceBounds::Ellipse; }
-
- /** This method checks if the point given in the local coordinates is between two ellipsoids
- if only tol1 is given and additional in the phi sector is tol2 is given */
- virtual bool inside(const Vector2D &locpo, double tol1 = 0., double tol2 = 0.) const override;
- virtual bool inside(const Vector2D& locpo, const BoundaryCheck& bchk) const override;
-
- /** Check for inside first local coordinate */
- virtual bool insideLoc1(const Vector2D &locpo, double tol1 = 0.) const override;
-
- /** Check for inside second local coordinate */
- virtual bool insideLoc2(const Vector2D &locpo, double tol2 = 0.) const override;
-
- /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
- virtual double minDistance(const Vector2D& pos) const override;
-
- /** This method returns first inner radius*/
- double rMinX() const;
-
- /** This method returns second inner radius*/
- double rMinY() const;
-
- /** This method returns first outer radius*/
- double rMaxX() const;
-
- /** This method returns second outer radius*/
- double rMaxY() const;
-
- /** This method returns the maximum expansion on the plane (=max(rMaxX,rMaxY))*/
- virtual double r() const override;
-
- /** This method returns the average phi*/
- double averagePhi() const;
-
- /** Return the vertices - or, the points of the extremas */
- virtual const std::vector< Vector2D > vertices() const override;
-
- /** This method returns the halfPhiSector which is covered by the disc*/
- double halfPhiSector() const;
-
- /** Output Method for std::ostream */
- virtual std::ostream& dump(std::ostream& sl) const override;
+/**
+ @class EllipseBounds
+
+ Class to describe the bounds for a planar EllipseSurface,
+ i.e. the surface between two ellipses.
+ By providing an argument for hphisec, the bounds can
+ be restricted to a phirange around the center position.
+
+ */
+
+class EllipseBounds : public PlanarBounds
+{
+public:
+ /** @enum for readibility */
+ enum BoundValues {
+ bv_rMinX = 0,
+ bv_rMinY = 1,
+ bv_rMaxX = 2,
+ bv_rMaxY = 3,
+ bv_averagePhi = 4,
+ bv_halfPhiSector = 5,
+ bv_length = 6
+ };
+
+ /** Default Constructor*/
+ EllipseBounds();
+
+ /** Constructor for full of an ellipsoid disc around phi=0*/
+ EllipseBounds(double minrad1,
+ double minrad2,
+ double maxrad1,
+ double maxrad2,
+ double hphisec = M_PI);
+
+ /** Constructor for an ellipsoid disc around phi != 0*/
+ EllipseBounds(double minrad1,
+ double minrad2,
+ double maxrad1,
+ double maxrad2,
+ double avephi,
+ double hphisec);
+
+ /** Copy constructor*/
+ EllipseBounds(const EllipseBounds& discbo);
+
+ /** Destructor*/
+ virtual ~EllipseBounds();
+
+ /** Assignment operator*/
+ EllipseBounds&
+ operator=(const EllipseBounds& discbo);
+
+ /** Move assignment operator*/
+ EllipseBounds&
+ operator=(EllipseBounds&& discbo);
+
+ /** Equality operator*/
+ virtual bool
+ operator==(const SurfaceBounds& sbo) const override;
+
+ /** Virtual constructor*/
+ virtual EllipseBounds*
+ clone() const override;
+
+ /** Return the type of the bounds for persistency */
+ virtual BoundsType
+ type() const override
+ {
+ return SurfaceBounds::Ellipse;
+ }
- private:
- /** The internal storage of the bounds can be float/double*/
- std::vector<TDD_real_t> m_boundValues;
+ /** This method checks if the point given in the local coordinates is between
+ two ellipsoids
+ if only tol1 is given and additional in the phi sector is tol2 is given */
+ virtual bool
+ inside(const Vector2D& locpo,
+ double tol1 = 0.,
+ double tol2 = 0.) const override;
+ virtual bool
+ inside(const Vector2D& locpo, const BoundaryCheck& bchk) const override;
+
+ /** Check for inside first local coordinate */
+ virtual bool
+ insideLoc1(const Vector2D& locpo, double tol1 = 0.) const override;
+
+ /** Check for inside second local coordinate */
+ virtual bool
+ insideLoc2(const Vector2D& locpo, double tol2 = 0.) const override;
+
+ /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
+ virtual double
+ minDistance(const Vector2D& pos) const override;
+
+ /** This method returns first inner radius*/
+ double
+ rMinX() const;
+
+ /** This method returns second inner radius*/
+ double
+ rMinY() const;
+
+ /** This method returns first outer radius*/
+ double
+ rMaxX() const;
+
+ /** This method returns second outer radius*/
+ double
+ rMaxY() const;
+
+ /** This method returns the maximum expansion on the plane
+ * (=max(rMaxX,rMaxY))*/
+ virtual double
+ r() const override;
+
+ /** This method returns the average phi*/
+ double
+ averagePhi() const;
+
+ /** Return the vertices - or, the points of the extremas */
+ virtual const std::vector<Vector2D>
+ vertices() const override;
+
+ /** This method returns the halfPhiSector which is covered by the disc*/
+ double
+ halfPhiSector() const;
+
+ /** Output Method for std::ostream */
+ virtual std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ /** The internal storage of the bounds can be float/double*/
+ std::vector<TDD_real_t> m_boundValues;
+
+ /** helper function for squaring */
+ inline double
+ square(double x) const
+ {
+ return x * x;
+ };
+};
+
+inline EllipseBounds*
+EllipseBounds::clone() const
+{
+ return new EllipseBounds(*this);
+}
- /** helper function for squaring */
- inline double square(double x) const {return x*x;};
- };
+inline bool
+EllipseBounds::inside(const Vector2D& locpo, double tol1, double tol2) const
+{
+ double alpha = acos(cos(locpo[Acts::eLOC_PHI]
+ - m_boundValues.at(EllipseBounds::bv_averagePhi)));
+ bool insidePhi
+ = (m_boundValues.at(EllipseBounds::bv_halfPhiSector) + tol2 < M_PI)
+ ? (alpha <= (m_boundValues.at(EllipseBounds::bv_halfPhiSector) + tol2))
+ : 1;
+ bool insideInner = (m_boundValues.at(EllipseBounds::bv_rMinX) <= tol1)
+ || (m_boundValues.at(EllipseBounds::bv_rMinY) <= tol1)
+ || (square(locpo[Acts::eLOC_X]
+ / (m_boundValues.at(EllipseBounds::bv_rMinX) - tol1))
+ + square(locpo[Acts::eLOC_Y]
+ / (m_boundValues.at(EllipseBounds::bv_rMinY) - tol1))
+ > 1);
+ bool insideOuter
+ = (square(locpo[Acts::eLOC_X]
+ / (m_boundValues.at(EllipseBounds::bv_rMaxX) + tol1))
+ + square(locpo[Acts::eLOC_Y]
+ / (m_boundValues.at(EllipseBounds::bv_rMaxY) + tol1))
+ < 1);
+ return (insideInner && insideOuter && insidePhi);
+}
- inline EllipseBounds* EllipseBounds::clone() const
- { return new EllipseBounds(*this); }
+inline bool
+EllipseBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
+{
+ return EllipseBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
+}
- inline bool EllipseBounds::inside(const Vector2D &locpo, double tol1, double tol2) const
- { double alpha = acos(cos(locpo[Acts::eLOC_PHI]-m_boundValues.at(EllipseBounds::bv_averagePhi)));
- bool insidePhi = ( m_boundValues.at(EllipseBounds::bv_halfPhiSector)+tol2 < M_PI ) ? (alpha <= (m_boundValues.at(EllipseBounds::bv_halfPhiSector)+tol2)) : 1;
- bool insideInner =( m_boundValues.at(EllipseBounds::bv_rMinX)<=tol1 ) || ( m_boundValues.at(EllipseBounds::bv_rMinY) <= tol1 )
- || ( square(locpo[Acts::eLOC_X]/(m_boundValues.at(EllipseBounds::bv_rMinX)-tol1)) + square(locpo[Acts::eLOC_Y]/(m_boundValues.at(EllipseBounds::bv_rMinY)-tol1)) >1);
- bool insideOuter = ( square(locpo[Acts::eLOC_X]/(m_boundValues.at(EllipseBounds::bv_rMaxX)+tol1)) + square(locpo[Acts::eLOC_Y]/(m_boundValues.at(EllipseBounds::bv_rMaxY)+tol1)) <1);
- return ( insideInner && insideOuter && insidePhi );
+inline bool
+EllipseBounds::insideLoc1(const Vector2D& locpo, double tol1) const
+{
+ bool insideInner = (m_boundValues[EllipseBounds::bv_rMinX] <= tol1)
+ || (m_boundValues.at(EllipseBounds::bv_rMinY) <= tol1)
+ || (square(locpo[Acts::eLOC_X]
+ / (m_boundValues.at(EllipseBounds::bv_rMinX) - tol1))
+ + square(locpo[Acts::eLOC_Y]
+ / (m_boundValues.at(EllipseBounds::bv_rMinY) - tol1))
+ > 1);
+ bool insideOuter
+ = (square(locpo[Acts::eLOC_X]
+ / (m_boundValues.at(EllipseBounds::bv_rMaxX) + tol1))
+ + square(locpo[Acts::eLOC_Y]
+ / (m_boundValues.at(EllipseBounds::bv_rMaxY) + tol1))
+ < 1);
+ return (insideInner && insideOuter);
+}
- }
+inline bool
+EllipseBounds::insideLoc2(const Vector2D& locpo, double tol2) const
+{
+ double alpha = acos(cos(locpo[Acts::eLOC_PHI]
+ - m_boundValues.at(EllipseBounds::bv_averagePhi)));
+ bool insidePhi
+ = (m_boundValues.at(EllipseBounds::bv_halfPhiSector) + tol2 < M_PI)
+ ? (alpha <= (m_boundValues.at(EllipseBounds::bv_halfPhiSector) + tol2))
+ : 1;
+ return insidePhi;
+}
- inline bool EllipseBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
- {
- return EllipseBounds::inside(locpo,bchk.toleranceLoc1,bchk.toleranceLoc2);
- }
+inline double
+EllipseBounds::rMinX() const
+{
+ return m_boundValues.at(EllipseBounds::bv_rMinX);
+}
+inline double
+EllipseBounds::rMinY() const
+{
+ return m_boundValues.at(EllipseBounds::bv_rMinY);
+}
+inline double
+EllipseBounds::rMaxX() const
+{
+ return m_boundValues.at(EllipseBounds::bv_rMaxX);
+}
+inline double
+EllipseBounds::rMaxY() const
+{
+ return m_boundValues.at(EllipseBounds::bv_rMaxY);
+}
+inline double
+EllipseBounds::r() const
+{
+ return std::max(m_boundValues.at(EllipseBounds::bv_rMaxX),
+ m_boundValues.at(EllipseBounds::bv_rMaxY));
+}
+inline double
+EllipseBounds::averagePhi() const
+{
+ return m_boundValues.at(EllipseBounds::bv_averagePhi);
+}
+inline double
+EllipseBounds::halfPhiSector() const
+{
+ return m_boundValues.at(EllipseBounds::bv_halfPhiSector);
+}
- inline bool EllipseBounds::insideLoc1(const Vector2D &locpo, double tol1) const
- {
- bool insideInner =( m_boundValues[EllipseBounds::bv_rMinX]<=tol1 ) || ( m_boundValues.at(EllipseBounds::bv_rMinY) <= tol1 )
- || ( square(locpo[Acts::eLOC_X]/(m_boundValues.at(EllipseBounds::bv_rMinX)-tol1)) + square(locpo[Acts::eLOC_Y]/(m_boundValues.at(EllipseBounds::bv_rMinY)-tol1)) >1);
- bool insideOuter = ( square(locpo[Acts::eLOC_X]/(m_boundValues.at(EllipseBounds::bv_rMaxX)+tol1)) + square(locpo[Acts::eLOC_Y]/(m_boundValues.at(EllipseBounds::bv_rMaxY)+tol1)) <1);
- return ( insideInner && insideOuter );
+inline const std::vector<Vector2D>
+EllipseBounds::vertices() const
+{
+ // create the return vector
+ std::vector<Vector2D> vertices;
+ // fill the vertices
+ vertices.reserve(4);
+ vertices.push_back(
+ Vector2D(m_boundValues.at(EllipseBounds::bv_rMaxX), 0.)); // [0]
+ vertices.push_back(
+ Vector2D(0., m_boundValues.at(EllipseBounds::bv_rMaxY))); // [1]
+ vertices.push_back(
+ Vector2D(-m_boundValues.at(EllipseBounds::bv_rMaxX), 0.)); // [2]
+ vertices.push_back(
+ Vector2D(0., -m_boundValues.at(EllipseBounds::bv_rMaxY))); // [3]
+ return vertices;
}
- inline bool EllipseBounds::insideLoc2(const Vector2D &locpo, double tol2) const
- {
- double alpha = acos(cos(locpo[Acts::eLOC_PHI]-m_boundValues.at(EllipseBounds::bv_averagePhi)));
- bool insidePhi = ( m_boundValues.at(EllipseBounds::bv_halfPhiSector)+tol2 < M_PI ) ? (alpha <= (m_boundValues.at(EllipseBounds::bv_halfPhiSector)+tol2)) : 1;
- return insidePhi;
- }
-
- inline double EllipseBounds::rMinX() const { return m_boundValues.at(EllipseBounds::bv_rMinX); }
- inline double EllipseBounds::rMinY() const { return m_boundValues.at(EllipseBounds::bv_rMinY); }
- inline double EllipseBounds::rMaxX() const { return m_boundValues.at(EllipseBounds::bv_rMaxX); }
- inline double EllipseBounds::rMaxY() const { return m_boundValues.at(EllipseBounds::bv_rMaxY); }
- inline double EllipseBounds::r() const { return std::max(m_boundValues.at(EllipseBounds::bv_rMaxX),m_boundValues.at(EllipseBounds::bv_rMaxY)); }
- inline double EllipseBounds::averagePhi() const { return m_boundValues.at(EllipseBounds::bv_averagePhi); }
- inline double EllipseBounds::halfPhiSector() const { return m_boundValues.at(EllipseBounds::bv_halfPhiSector); }
-
- inline const std::vector< Vector2D > EllipseBounds::vertices() const {
- // create the return vector
- std::vector< Vector2D > vertices;
- // fill the vertices
- vertices.reserve(4);
- vertices.push_back(Vector2D(m_boundValues.at(EllipseBounds::bv_rMaxX),0.)); // [0]
- vertices.push_back(Vector2D(0., m_boundValues.at(EllipseBounds::bv_rMaxY))); // [1]
- vertices.push_back(Vector2D(-m_boundValues.at(EllipseBounds::bv_rMaxX),0.)); // [2]
- vertices.push_back(Vector2D(0., -m_boundValues.at(EllipseBounds::bv_rMaxY))); // [3]
- return vertices;
-
- }
-
-} // end of namespace
-
-#endif // ACTS_SURFACES_ELLIPSEBOUNDS_H
+} // end of namespace
+
+#endif // ACTS_SURFACES_ELLIPSEBOUNDS_H
diff --git a/Core/include/ACTS/Surfaces/InvalidBounds.hpp b/Core/include/ACTS/Surfaces/InvalidBounds.hpp
index 03b5fa4ed..3ca2b3419 100644
--- a/Core/include/ACTS/Surfaces/InvalidBounds.hpp
+++ b/Core/include/ACTS/Surfaces/InvalidBounds.hpp
@@ -14,70 +14,109 @@
#define ACTS_SURFACES_INVALIDBOUNDS_H
#include "ACTS/Surfaces/SurfaceBounds.hpp"
-#include "ACTS/Utilities/ParameterDefinitions.hpp"
#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Utilities/ParameterDefinitions.hpp"
namespace Acts {
- /**
- @class InvalidBounds
-
- Invalid Bounds object - catches problems in geometry building
-
- */
-
- class InvalidBounds : public SurfaceBounds {
- public:
- /** Default Constructor*/
- InvalidBounds(){}
-
- /** Destructor */
- ~InvalidBounds(){}
-
- /** Equality operator */
- virtual bool operator==(const SurfaceBounds& ) const override {return false;}
+/**
+ @class InvalidBounds
- /** Non-Equality operator*/
- virtual bool operator!=(const SurfaceBounds& ) const override {return true;}
+ Invalid Bounds object - catches problems in geometry building
- /** 'address of' will return nullptr **/
- InvalidBounds * operator &() {return nullptr;}
+ */
- /** Return SurfaceBounds for persistency */
- virtual SurfaceBounds::BoundsType type() const override { return SurfaceBounds::Other; }
-
- /** Method inside() returns false for any case */
- virtual bool inside(const Vector2D& , double =0., double =0.) const override {return false; }
- virtual bool inside(const Vector2D& , const BoundaryCheck& ) const override {return false; }
+class InvalidBounds : public SurfaceBounds
+{
+public:
+ /** Default Constructor*/
+ InvalidBounds() {}
+ /** Destructor */
+ ~InvalidBounds() {}
+ /** Equality operator */
+ virtual bool
+ operator==(const SurfaceBounds&) const override
+ {
+ return false;
+ }
- /** This method checks inside bounds in loc1
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc1(const Vector2D& , double =0.) const override {return false; }
+ /** Non-Equality operator*/
+ virtual bool
+ operator!=(const SurfaceBounds&) const override
+ {
+ return true;
+ }
- /** This method checks inside bounds in loc2
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc2(const Vector2D& , double =0.) const override {return false; }
+ /** 'address of' will return nullptr **/
+ InvalidBounds* operator&() { return nullptr; }
+ /** Return SurfaceBounds for persistency */
+ virtual SurfaceBounds::BoundsType
+ type() const override
+ {
+ return SurfaceBounds::Other;
+ }
- /** Minimal distance to boundary (=0 if inside) */
- virtual double minDistance(const Vector2D& ) const override {return std::nan("");}
+ /** Method inside() returns false for any case */
+ virtual bool
+ inside(const Vector2D&, double = 0., double = 0.) const override
+ {
+ return false;
+ }
+ virtual bool
+ inside(const Vector2D&, const BoundaryCheck&) const override
+ {
+ return false;
+ }
- /** Invalidate cloning of an invalid object */
- virtual InvalidBounds* clone() const override {return nullptr;}
+ /** This method checks inside bounds in loc1
+ - loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc1(const Vector2D&, double = 0.) const override
+ {
+ return false;
+ }
- /** r() method to complete inherited interface */
- virtual double r() const override {return std::nan(""); }
+ /** This method checks inside bounds in loc2
+ - loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc2(const Vector2D&, double = 0.) const override
+ {
+ return false;
+ }
- /** Output Method for std::ostream */
- virtual std::ostream& dump(std::ostream& sl) const override;
+ /** Minimal distance to boundary (=0 if inside) */
+ virtual double
+ minDistance(const Vector2D&) const override
+ {
+ return std::nan("");
+ }
- };
+ /** Invalidate cloning of an invalid object */
+ virtual InvalidBounds*
+ clone() const override
+ {
+ return nullptr;
+ }
- inline std::ostream& InvalidBounds::dump(std::ostream& sl) const
+ /** r() method to complete inherited interface */
+ virtual double
+ r() const override
{
- sl << "Acts::InvalidBounds ... invalid surface" << std::endl;
- return sl;
+ return std::nan("");
}
-} // end of namespace
+ /** Output Method for std::ostream */
+ virtual std::ostream&
+ dump(std::ostream& sl) const override;
+};
+
+inline std::ostream&
+InvalidBounds::dump(std::ostream& sl) const
+{
+ sl << "Acts::InvalidBounds ... invalid surface" << std::endl;
+ return sl;
+}
+
+} // end of namespace
-#endif // ACTS_SURFACES_INVALIDBOUNDS_H
+#endif // ACTS_SURFACES_INVALIDBOUNDS_H
diff --git a/Core/include/ACTS/Surfaces/NoBounds.hpp b/Core/include/ACTS/Surfaces/NoBounds.hpp
index 317f72750..de70848a9 100644
--- a/Core/include/ACTS/Surfaces/NoBounds.hpp
+++ b/Core/include/ACTS/Surfaces/NoBounds.hpp
@@ -13,87 +13,123 @@
#ifndef ACTS_SURFACESNOBOUNDS_H
#define ACTS_SURFACESNOBOUNDS_H
-#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Surfaces/SurfaceBounds.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
namespace Acts {
- /**
- @class NoBounds
-
- Bounds object for a boundless surface (...)
- */
-
- class NoBounds : public SurfaceBounds {
- public:
- /** Default Constructor*/
- NoBounds(){}
-
- /** Destructor */
- ~NoBounds(){}
-
- /** Equality operator */
- virtual bool operator==(const SurfaceBounds& sbo) const override;
-
- /** Return SurfaceBounds for persistency */
- virtual SurfaceBounds::BoundsType type() const final { return SurfaceBounds::Other; }
-
- /** Method inside() returns true for any case */
- virtual bool inside(const Vector2D& locpo, double tol1=0., double tol2=0.) const final;
- virtual bool inside(const Vector2D& locpo, const BoundaryCheck& bchk) const final;
-
- /** This method checks inside bounds in loc1
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc1(const Vector2D& locpo, double tol1=0.) const final;
-
- /** This method checks inside bounds in loc2
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc2(const Vector2D& locpo, double tol2=0.) const final;
-
- /** Minimal distance to boundary (=0 if inside) */
- virtual double minDistance(const Vector2D& pos) const final;
-
- /** Clone method to complete inherited interface */
- virtual NoBounds* clone() const final;
-
- /** r() method to complete inherited interface */
- virtual double r() const final;
-
- /** Output Method for std::ostream */
- virtual std::ostream& dump(std::ostream& sl) const final;
-
- };
-
- inline bool NoBounds::operator==(const SurfaceBounds&) const
- { return true; }
-
- inline bool NoBounds::inside(const Vector2D&, double, double) const
- { return true; }
-
- inline bool NoBounds::inside(const Vector2D&, const BoundaryCheck&) const
- { return true; }
-
- inline bool NoBounds::insideLoc1(const Vector2D&, double) const
- { return true; }
-
- inline bool NoBounds::insideLoc2(const Vector2D&, double) const
- { return true; }
-
- inline double NoBounds::minDistance(const Vector2D&) const
- { return 0.; }
-
- inline NoBounds* NoBounds::clone() const
- { return new NoBounds(); }
-
- inline double NoBounds::r() const
- { return 0.; }
-
- inline std::ostream& NoBounds::dump(std::ostream& sl) const
+/**
+ @class NoBounds
+
+ Bounds object for a boundless surface (...)
+*/
+
+class NoBounds : public SurfaceBounds
+{
+public:
+ /** Default Constructor*/
+ NoBounds() {}
+ /** Destructor */
+ ~NoBounds() {}
+ /** Equality operator */
+ virtual bool
+ operator==(const SurfaceBounds& sbo) const override;
+
+ /** Return SurfaceBounds for persistency */
+ virtual SurfaceBounds::BoundsType
+ type() const final
{
- sl << "Acts::NoBounds ... boundless surface" << std::endl;
- return sl;
+ return SurfaceBounds::Other;
}
-} // end of namespace
-
-#endif // ACTS_SURFACES_NOBOUNDS_H
+ /** Method inside() returns true for any case */
+ virtual bool
+ inside(const Vector2D& locpo, double tol1 = 0., double tol2 = 0.) const final;
+ virtual bool
+ inside(const Vector2D& locpo, const BoundaryCheck& bchk) const final;
+
+ /** This method checks inside bounds in loc1
+ - loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc1(const Vector2D& locpo, double tol1 = 0.) const final;
+
+ /** This method checks inside bounds in loc2
+ - loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc2(const Vector2D& locpo, double tol2 = 0.) const final;
+
+ /** Minimal distance to boundary (=0 if inside) */
+ virtual double
+ minDistance(const Vector2D& pos) const final;
+
+ /** Clone method to complete inherited interface */
+ virtual NoBounds*
+ clone() const final;
+
+ /** r() method to complete inherited interface */
+ virtual double
+ r() const final;
+
+ /** Output Method for std::ostream */
+ virtual std::ostream&
+ dump(std::ostream& sl) const final;
+};
+
+inline bool
+NoBounds::operator==(const SurfaceBounds&) const
+{
+ return true;
+}
+
+inline bool
+NoBounds::inside(const Vector2D&, double, double) const
+{
+ return true;
+}
+
+inline bool
+NoBounds::inside(const Vector2D&, const BoundaryCheck&) const
+{
+ return true;
+}
+
+inline bool
+NoBounds::insideLoc1(const Vector2D&, double) const
+{
+ return true;
+}
+
+inline bool
+NoBounds::insideLoc2(const Vector2D&, double) const
+{
+ return true;
+}
+
+inline double
+NoBounds::minDistance(const Vector2D&) const
+{
+ return 0.;
+}
+
+inline NoBounds*
+NoBounds::clone() const
+{
+ return new NoBounds();
+}
+
+inline double
+NoBounds::r() const
+{
+ return 0.;
+}
+
+inline std::ostream&
+NoBounds::dump(std::ostream& sl) const
+{
+ sl << "Acts::NoBounds ... boundless surface" << std::endl;
+ return sl;
+}
+
+} // end of namespace
+
+#endif // ACTS_SURFACES_NOBOUNDS_H
diff --git a/Core/include/ACTS/Surfaces/PerigeeSurface.hpp b/Core/include/ACTS/Surfaces/PerigeeSurface.hpp
index ad1abd4e0..35a66cbf8 100644
--- a/Core/include/ACTS/Surfaces/PerigeeSurface.hpp
+++ b/Core/include/ACTS/Surfaces/PerigeeSurface.hpp
@@ -13,193 +13,255 @@
#ifndef ACTS_SURFACES_PERIGEESURFACE_H
#define ACTS_SURFACES_PERIGEESURFACE_H 1
-#include "ACTS/Surfaces/Surface.hpp"
#include "ACTS/Surfaces/NoBounds.hpp"
+#include "ACTS/Surfaces/Surface.hpp"
#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Utilities/GeometryStatics.hpp"
namespace Acts {
- /**
- @class PerigeeSurface
-
- Class describing the Line to which the Perigee refers to.
- The Surface axis is fixed to be the z-axis of the Tracking frame.
- It inherits from Surface.
-
- */
-
- class PerigeeSurface : public Surface {
-
- public:
- /** Default Constructor - needed for persistency*/
- PerigeeSurface();
-
- /** Constructor from GlobalPosition*/
- PerigeeSurface(const Vector3D& gp);
-
- /** Constructor with a Transform - needed for tilt */
- PerigeeSurface(std::shared_ptr<Transform3D> tTransform);
-
- /** Constructor with a Transform by unique_ptr - needed for tilt */
- PerigeeSurface(std::unique_ptr<Transform3D> tTransform);
-
- /** Copy constructor*/
- PerigeeSurface(const PerigeeSurface& pesf);
-
- /** Copy constructor with shift*/
- PerigeeSurface(const PerigeeSurface& pesf, const Transform3D& transf);
-
- /** Destructor*/
- virtual ~PerigeeSurface();
-
- /** Virtual constructor*/
- virtual PerigeeSurface* clone(const Transform3D* shift = nullptr) const override;
-
- /** Assignment operator*/
- PerigeeSurface& operator=(const PerigeeSurface& slsf );
-
- /** Equality operator*/
- virtual bool operator==(const Surface& sf) const override;
+/**
+ @class PerigeeSurface
- /** Return the surface type */
- virtual SurfaceType type() const override { return Surface::Perigee; }
+ Class describing the Line to which the Perigee refers to.
+ The Surface axis is fixed to be the z-axis of the Tracking frame.
+ It inherits from Surface.
- /**Return method for transfromation, overwrites the transform() form base class*/
- virtual const Transform3D& transform() const override;
+ */
- /**Return method for surface center infromation, overwrites the center() form base class*/
- virtual const Vector3D& center() const override;
+class PerigeeSurface : public Surface
+{
+public:
+ /** Default Constructor - needed for persistency*/
+ PerigeeSurface();
- /** Return the measurement frame - this is needed for alignment, in particular for StraightLine and Perigee Surface
- - the default implementation is the the RotationMatrix3D of the transform */
- virtual const RotationMatrix3D measurementFrame(const Vector3D& glopos, const Vector3D& glomom) const override;
+ /** Constructor from GlobalPosition*/
+ PerigeeSurface(const Vector3D& gp);
- /** LocalToGlobal method without dynamic memory allocation */
- virtual void localToGlobal(const Vector2D& locp, const Vector3D& mom, Vector3D& glob) const override;
+ /** Constructor with a Transform - needed for tilt */
+ PerigeeSurface(std::shared_ptr<Transform3D> tTransform);
- /** GlobalToLocal method without dynamic memory allocation - boolean checks if on surface
- \image html SignOfDriftCircleD0.gif */
- virtual bool globalToLocal(const Vector3D& glob, const Vector3D& mom, Vector2D& loc) const override;
+ /** Constructor with a Transform by unique_ptr - needed for tilt */
+ PerigeeSurface(std::unique_ptr<Transform3D> tTransform);
- /** fast straight line intersection schema - standard: provides closest intersection and (signed) path length
- forceDir is to provide the closest forward solution
+ /** Copy constructor*/
+ PerigeeSurface(const PerigeeSurface& pesf);
- b>mathematical motivation:</b>
- Given two lines in parameteric form:<br>
- - @f$ \vec l_{a}(\lambda) = \vec m_a + \lambda \cdot \vec e_{a} @f$ <br>
- - @f$ \vec l_{b}(\mu) = \vec m_b + \mu \cdot \vec e_{b} @f$ <br>
- the vector between any two points on the two lines is given by:
- - @f$ \vec s(\lambda, \mu) = \vec l_{b} - l_{a} = \vec m_{ab} + \mu \cdot \vec e_{b} - \lambda \cdot \vec e_{a} @f$, <br>
- when @f$ \vec m_{ab} = \vec m_{b} - \vec m_{a} @f$.<br>
- @f$ \vec s(\lambda_0, \mu_0) @f$ denotes the vector between the two closest points <br>
- @f$ \vec l_{a,0} = l_{a}(\lambda_0) @f$ and @f$ \vec l_{b,0} = l_{b}(\mu_0) @f$ <br>
- and is perpenticular to both, @f$ \vec e_{a} @f$ and @f$ \vec e_{b} @f$.
+ /** Copy constructor with shift*/
+ PerigeeSurface(const PerigeeSurface& pesf, const Transform3D& transf);
- This results in a system of two linear equations:<br>
- - (i) @f$ 0 = \vec s(\lambda_0, \mu_0) \cdot \vec e_a = \vec m_ab \cdot \vec e_a + \mu_0 \vec e_a \cdot \vec e_b - \lambda_0 @f$ <br>
- - (ii) @f$ 0 = \vec s(\lambda_0, \mu_0) \cdot \vec e_b = \vec m_ab \cdot \vec e_b + \mu_0 - \lambda_0 \vec e_b \cdot \vec e_a @f$ <br>
+ /** Destructor*/
+ virtual ~PerigeeSurface();
- Solving (i), (ii) for @f$ \lambda_0 @f$ and @f$ \mu_0 @f$ yields:
- - @f$ \lambda_0 = \frac{(\vec m_ab \cdot \vec e_a)-(\vec m_ab \cdot \vec e_b)(\vec e_a \cdot \vec e_b)}{1-(\vec e_a \cdot \vec e_b)^2} @f$ <br>
- - @f$ \mu_0 = - \frac{(\vec m_ab \cdot \vec e_b)-(\vec m_ab \cdot \vec e_a)(\vec e_a \cdot \vec e_b)}{1-(\vec e_a \cdot \vec e_b)^2} @f$ <br>
- */
- virtual Intersection intersectionEstimate(const Vector3D& pos,
- const Vector3D& dir,
- bool forceDir = false,
- const BoundaryCheck& bchk = false) const override;
+ /** Virtual constructor*/
+ virtual PerigeeSurface*
+ clone(const Transform3D* shift = nullptr) const override;
+ /** Assignment operator*/
+ PerigeeSurface&
+ operator=(const PerigeeSurface& slsf);
- /** the pathCorrection for derived classes with thickness */
- virtual double pathCorrection(const Vector3D&, const Vector3D&) const override { return 1.; }
+ /** Equality operator*/
+ virtual bool
+ operator==(const Surface& sf) const override;
- /**This method checks if a globalPosition in on the Surface or not*/
- virtual bool isOnSurface(const Vector3D& glopo, const BoundaryCheck& bchk=true) const override;
-
- /**This surface calls the iside method of the bounds*/
- virtual bool insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk) const override;
-
- /** Special method for StraightLineSurface - provides the Line direction from cache: speedup */
- const Vector3D& lineDirection() const;
-
- /** Return bounds() method */
- virtual const NoBounds& bounds() const override;
-
- /** Return properly formatted class name for screen output */
- virtual std::string name() const override { return "Acts::PerigeeSurface"; }
-
- /** Output Method for std::ostream*/
- virtual std::ostream& dump(std::ostream& sl) const override;
-
- protected: //!< data members
-
- mutable Vector3D* m_lineDirection; //!< cache of the line direction (speeds up)
- static NoBounds s_perigeeBounds;
-
- };
-
-
- inline PerigeeSurface* PerigeeSurface::clone(const Transform3D* shift) const
+ /** Return the surface type */
+ virtual SurfaceType
+ type() const override
{
- if (shift) return new PerigeeSurface(*this,*shift);
- return new PerigeeSurface(*this);
+ return Surface::Perigee;
}
- inline const Transform3D& PerigeeSurface::transform() const
+ /**Return method for transfromation, overwrites the transform() form base
+ * class*/
+ virtual const Transform3D&
+ transform() const override;
+
+ /**Return method for surface center infromation, overwrites the center() form
+ * base class*/
+ virtual const Vector3D&
+ center() const override;
+
+ /** Return the measurement frame - this is needed for alignment, in particular
+ for StraightLine and Perigee Surface
+ - the default implementation is the the RotationMatrix3D of the transform
+ */
+ virtual const RotationMatrix3D
+ measurementFrame(const Vector3D& glopos,
+ const Vector3D& glomom) const override;
+
+ /** LocalToGlobal method without dynamic memory allocation */
+ virtual void
+ localToGlobal(const Vector2D& locp,
+ const Vector3D& mom,
+ Vector3D& glob) const override;
+
+ /** GlobalToLocal method without dynamic memory allocation - boolean checks if
+ on surface
+ \image html SignOfDriftCircleD0.gif */
+ virtual bool
+ globalToLocal(const Vector3D& glob,
+ const Vector3D& mom,
+ Vector2D& loc) const override;
+
+ /** fast straight line intersection schema - standard: provides closest
+ intersection and (signed) path length
+ forceDir is to provide the closest forward solution
+
+ b>mathematical motivation:</b>
+ Given two lines in parameteric form:<br>
+ - @f$ \vec l_{a}(\lambda) = \vec m_a + \lambda \cdot \vec e_{a} @f$ <br>
+ - @f$ \vec l_{b}(\mu) = \vec m_b + \mu \cdot \vec e_{b} @f$ <br>
+ the vector between any two points on the two lines is given by:
+ - @f$ \vec s(\lambda, \mu) = \vec l_{b} - l_{a} = \vec m_{ab} + \mu \cdot
+ \vec e_{b} - \lambda \cdot \vec e_{a} @f$, <br>
+ when @f$ \vec m_{ab} = \vec m_{b} - \vec m_{a} @f$.<br>
+ @f$ \vec s(\lambda_0, \mu_0) @f$ denotes the vector between the two
+ closest points <br>
+ @f$ \vec l_{a,0} = l_{a}(\lambda_0) @f$ and @f$ \vec l_{b,0} =
+ l_{b}(\mu_0) @f$ <br>
+ and is perpenticular to both, @f$ \vec e_{a} @f$ and @f$ \vec e_{b} @f$.
+
+ This results in a system of two linear equations:<br>
+ - (i) @f$ 0 = \vec s(\lambda_0, \mu_0) \cdot \vec e_a = \vec m_ab \cdot
+ \vec e_a + \mu_0 \vec e_a \cdot \vec e_b - \lambda_0 @f$ <br>
+ - (ii) @f$ 0 = \vec s(\lambda_0, \mu_0) \cdot \vec e_b = \vec m_ab \cdot
+ \vec e_b + \mu_0 - \lambda_0 \vec e_b \cdot \vec e_a @f$ <br>
+
+ Solving (i), (ii) for @f$ \lambda_0 @f$ and @f$ \mu_0 @f$ yields:
+ - @f$ \lambda_0 = \frac{(\vec m_ab \cdot \vec e_a)-(\vec m_ab \cdot \vec
+ e_b)(\vec e_a \cdot \vec e_b)}{1-(\vec e_a \cdot \vec e_b)^2} @f$ <br>
+ - @f$ \mu_0 = - \frac{(\vec m_ab \cdot \vec e_b)-(\vec m_ab \cdot \vec
+ e_a)(\vec e_a \cdot \vec e_b)}{1-(\vec e_a \cdot \vec e_b)^2} @f$ <br>
+ */
+ virtual Intersection
+ intersectionEstimate(const Vector3D& pos,
+ const Vector3D& dir,
+ bool forceDir = false,
+ const BoundaryCheck& bchk = false) const override;
+
+ /** the pathCorrection for derived classes with thickness */
+ virtual double
+ pathCorrection(const Vector3D&, const Vector3D&) const override
{
- if (!Surface::m_transform) return(s_idTransform);
- return(*Surface::m_transform);
+ return 1.;
}
- inline const Vector3D& PerigeeSurface::center() const
- {
- if (!Surface::m_center && !Surface::m_transform) return(s_origin);
- else if (!Surface::m_center) m_center = new Vector3D(m_transform->translation());
- return(*Surface::m_center);
- }
+ /**This method checks if a globalPosition in on the Surface or not*/
+ virtual bool
+ isOnSurface(const Vector3D& glopo,
+ const BoundaryCheck& bchk = true) const override;
- inline bool PerigeeSurface::insideBounds(const Vector2D&, const BoundaryCheck& ) const { return true;}
+ /**This surface calls the iside method of the bounds*/
+ virtual bool
+ insideBounds(const Vector2D& locpos,
+ const BoundaryCheck& bchk) const override;
- inline bool PerigeeSurface::isOnSurface(const Vector3D&, const BoundaryCheck&) const {return true;}
+ /** Special method for StraightLineSurface - provides the Line direction from
+ * cache: speedup */
+ const Vector3D&
+ lineDirection() const;
- inline const NoBounds& PerigeeSurface::bounds() const { return s_perigeeBounds; }
+ /** Return bounds() method */
+ virtual const NoBounds&
+ bounds() const override;
- inline Intersection PerigeeSurface::intersectionEstimate(const Vector3D& pos,
- const Vector3D& dir,
- bool forceDir,
- const BoundaryCheck&) const
+ /** Return properly formatted class name for screen output */
+ virtual std::string
+ name() const override
{
- // following nominclature found in header file and doxygen documentation
- // line one is the straight track
- const Vector3D ma = pos;
- const Vector3D& ea = dir;
- // line two is the line surface
- const Vector3D& mb = center();
- const Vector3D& eb = lineDirection();
- // now go ahead
- Vector3D mab(mb - ma);
- double eaTeb = ea.dot(eb);
- double denom = 1 - eaTeb*eaTeb;
- if (fabs(denom)>10e-7){
- double lambda0 = (mab.dot(ea) - mab.dot(eb)*eaTeb)/denom;
- // evaluate the direction, bounds are always true for Perigee
- bool isValid = forceDir ? (lambda0 > 0.) : true;
- return Intersection( (ma+lambda0*ea),lambda0, isValid );
- }
- return Intersection(pos,0.,false);
+ return "Acts::PerigeeSurface";
}
- inline const Vector3D& PerigeeSurface::lineDirection() const {
- if (m_lineDirection)
- return (*m_lineDirection);
- if (!m_lineDirection && Surface::m_transform) {
- m_lineDirection = new Vector3D(transform().rotation().col(2));
- return (*m_lineDirection);
- }
- return Acts::s_zAxis;
-
- }
+ /** Output Method for std::ostream*/
+ virtual std::ostream&
+ dump(std::ostream& sl) const override;
+
+protected: //!< data members
+ mutable Vector3D*
+ m_lineDirection; //!< cache of the line direction (speeds up)
+ static NoBounds s_perigeeBounds;
+};
+
+inline PerigeeSurface*
+PerigeeSurface::clone(const Transform3D* shift) const
+{
+ if (shift) return new PerigeeSurface(*this, *shift);
+ return new PerigeeSurface(*this);
+}
+
+inline const Transform3D&
+PerigeeSurface::transform() const
+{
+ if (!Surface::m_transform) return (s_idTransform);
+ return (*Surface::m_transform);
+}
+
+inline const Vector3D&
+PerigeeSurface::center() const
+{
+ if (!Surface::m_center && !Surface::m_transform)
+ return (s_origin);
+ else if (!Surface::m_center)
+ m_center = new Vector3D(m_transform->translation());
+ return (*Surface::m_center);
+}
+
+inline bool
+PerigeeSurface::insideBounds(const Vector2D&, const BoundaryCheck&) const
+{
+ return true;
+}
+
+inline bool
+PerigeeSurface::isOnSurface(const Vector3D&, const BoundaryCheck&) const
+{
+ return true;
+}
+
+inline const NoBounds&
+PerigeeSurface::bounds() const
+{
+ return s_perigeeBounds;
+}
+
+inline Intersection
+PerigeeSurface::intersectionEstimate(const Vector3D& pos,
+ const Vector3D& dir,
+ bool forceDir,
+ const BoundaryCheck&) const
+{
+ // following nominclature found in header file and doxygen documentation
+ // line one is the straight track
+ const Vector3D ma = pos;
+ const Vector3D& ea = dir;
+ // line two is the line surface
+ const Vector3D& mb = center();
+ const Vector3D& eb = lineDirection();
+ // now go ahead
+ Vector3D mab(mb - ma);
+ double eaTeb = ea.dot(eb);
+ double denom = 1 - eaTeb * eaTeb;
+ if (fabs(denom) > 10e-7) {
+ double lambda0 = (mab.dot(ea) - mab.dot(eb) * eaTeb) / denom;
+ // evaluate the direction, bounds are always true for Perigee
+ bool isValid = forceDir ? (lambda0 > 0.) : true;
+ return Intersection((ma + lambda0 * ea), lambda0, isValid);
+ }
+ return Intersection(pos, 0., false);
+}
+
+inline const Vector3D&
+PerigeeSurface::lineDirection() const
+{
+ if (m_lineDirection) return (*m_lineDirection);
+ if (!m_lineDirection && Surface::m_transform) {
+ m_lineDirection = new Vector3D(transform().rotation().col(2));
+ return (*m_lineDirection);
+ }
+ return Acts::s_zAxis;
+}
-} // end of namespace
+} // end of namespace
-#endif // ACTS_SURFACESPERIGEESURFACE_H
+#endif // ACTS_SURFACESPERIGEESURFACE_H
diff --git a/Core/include/ACTS/Surfaces/PlanarBounds.hpp b/Core/include/ACTS/Surfaces/PlanarBounds.hpp
index 6a593fdd2..fab810e64 100644
--- a/Core/include/ACTS/Surfaces/PlanarBounds.hpp
+++ b/Core/include/ACTS/Surfaces/PlanarBounds.hpp
@@ -17,32 +17,30 @@
namespace Acts {
- /**
- @class PlanarBounds
-
- common base class for all bounds that are in a local x/y cartesian frame
- - simply introduced to avoid wrong bound assigments to surfaces
-
- */
-
- class PlanarBounds : public SurfaceBounds {
-
- public:
-
- /** Default Constructor */
- PlanarBounds() : SurfaceBounds() {}
-
- /** Destructor */
- virtual ~PlanarBounds(){}
-
- /** Virtual Constructor */
- virtual PlanarBounds* clone() const = 0;
-
- /** Return the vertices - or, the points of the extremas */
- virtual const std::vector< Vector2D > vertices() const = 0;
-
- };
-
-} // end of namespace
-
-#endif // ACTS_SURFACES_PLANARBOUNDS_H
+/**
+ @class PlanarBounds
+
+ common base class for all bounds that are in a local x/y cartesian frame
+ - simply introduced to avoid wrong bound assigments to surfaces
+
+ */
+
+class PlanarBounds : public SurfaceBounds
+{
+public:
+ /** Default Constructor */
+ PlanarBounds() : SurfaceBounds() {}
+ /** Destructor */
+ virtual ~PlanarBounds() {}
+ /** Virtual Constructor */
+ virtual PlanarBounds*
+ clone() const = 0;
+
+ /** Return the vertices - or, the points of the extremas */
+ virtual const std::vector<Vector2D>
+ vertices() const = 0;
+};
+
+} // end of namespace
+
+#endif // ACTS_SURFACES_PLANARBOUNDS_H
diff --git a/Core/include/ACTS/Surfaces/PlaneSurface.hpp b/Core/include/ACTS/Surfaces/PlaneSurface.hpp
index 4a3073b40..faef1da10 100644
--- a/Core/include/ACTS/Surfaces/PlaneSurface.hpp
+++ b/Core/include/ACTS/Surfaces/PlaneSurface.hpp
@@ -13,168 +13,215 @@
#ifndef ACTS_SURFACES_PLANESURFACE_H
#define ACTS_SURFACES_PLANESURFACE_H 1
-#include "ACTS/Surfaces/Surface.hpp"
-#include "ACTS/Surfaces/PlanarBounds.hpp"
#include "ACTS/Surfaces/NoBounds.hpp"
+#include "ACTS/Surfaces/PlanarBounds.hpp"
+#include "ACTS/Surfaces/Surface.hpp"
#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Utilities/Identifier.hpp"
namespace Acts {
- class DetectorElementBase;
-
- /**
- @class PlaneSurface
- Class for a planaer rectangular or trapezoidal surface in the TrackingGeometry.
- It inherits from Surface.
-
- The Acts::PlaneSurface extends the Surface class with the possibility to convert
- in addition to local to global positions, also local to global direction (vice versa).
-
- @image html PlaneSurface.gif
-
- */
-
- class PlaneSurface : public Surface {
- public:
-
- /** Default Constructor - needed for persistency*/
- PlaneSurface();
-
- /** Copy Constructor*/
- PlaneSurface(const PlaneSurface& psf);
+class DetectorElementBase;
- /** Copy Constructor with shift*/
- PlaneSurface(const PlaneSurface& psf, const Transform3D& transf);
+/**
+ @class PlaneSurface
+ Class for a planaer rectangular or trapezoidal surface in the TrackingGeometry.
+ It inherits from Surface.
- /** Dedicated Constructor with normal vector */
- PlaneSurface(const Vector3D& position, const Vector3D& normal);
+ The Acts::PlaneSurface extends the Surface class with the possibility to
+ convert
+ in addition to local to global positions, also local to global direction (vice
+ versa).
- /** Constructor from DetectorElementBase - potentially with identifier */
- PlaneSurface(const DetectorElementBase& detelement, const Identifier& identifier = Identifier());
+ @image html PlaneSurface.gif
- /** Constructor for planar Surface without Bounds */
- PlaneSurface(std::shared_ptr<Transform3D> htrans);
+ */
- /** Constructor for planar Surface from unique_ptr without Bounds */
- PlaneSurface(std::unique_ptr<Transform3D> htrans);
+class PlaneSurface : public Surface
+{
+public:
+ /** Default Constructor - needed for persistency*/
+ PlaneSurface();
- /** Constructor for Rectangular Planes*/
- PlaneSurface(std::shared_ptr<Transform3D> htrans, double halephi, double haleta);
+ /** Copy Constructor*/
+ PlaneSurface(const PlaneSurface& psf);
- /** Constructor for Trapezoidal Planes*/
- PlaneSurface(std::shared_ptr<Transform3D> htrans, double minhalephi, double maxhalephi, double haleta);
+ /** Copy Constructor with shift*/
+ PlaneSurface(const PlaneSurface& psf, const Transform3D& transf);
- /** Constructor for Planes with a pointer - passing ownership */
- PlaneSurface(std::shared_ptr<Transform3D> htrans, const PlanarBounds* pbounds);
+ /** Dedicated Constructor with normal vector */
+ PlaneSurface(const Vector3D& position, const Vector3D& normal);
- /** Constructor for Planes with shared bounds object */
- PlaneSurface(std::shared_ptr<Transform3D> htrans, std::shared_ptr<const PlanarBounds> pbounds);
+ /** Constructor from DetectorElementBase - potentially with identifier */
+ PlaneSurface(const DetectorElementBase& detelement,
+ const Identifier& identifier = Identifier());
- /** Destructor*/
- virtual ~PlaneSurface();
+ /** Constructor for planar Surface without Bounds */
+ PlaneSurface(std::shared_ptr<Transform3D> htrans);
- /** Assignment operator*/
- PlaneSurface& operator=(const PlaneSurface& psf);
+ /** Constructor for planar Surface from unique_ptr without Bounds */
+ PlaneSurface(std::unique_ptr<Transform3D> htrans);
- /** Equality operator*/
- virtual bool operator==(const Surface& sf) const override;
+ /** Constructor for Rectangular Planes*/
+ PlaneSurface(std::shared_ptr<Transform3D> htrans,
+ double halephi,
+ double haleta);
- /** Virtual constructor - shift is optionally */
- virtual PlaneSurface* clone(const Transform3D* shift = nullptr) const override;
+ /** Constructor for Trapezoidal Planes*/
+ PlaneSurface(std::shared_ptr<Transform3D> htrans,
+ double minhalephi,
+ double maxhalephi,
+ double haleta);
- /** Return the surface type */
- virtual SurfaceType type() const override { return Surface::Plane; }
+ /** Constructor for Planes with a pointer - passing ownership */
+ PlaneSurface(std::shared_ptr<Transform3D> htrans,
+ const PlanarBounds* pbounds);
- /**This method returns the bounds by reference, static NoBounds in case of no boundaries*/
- virtual const SurfaceBounds& bounds() const override;
+ /** Constructor for Planes with shared bounds object */
+ PlaneSurface(std::shared_ptr<Transform3D> htrans,
+ std::shared_ptr<const PlanarBounds> pbounds);
- /**This method calls the inside() method of the Bounds*/
- virtual bool insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk) const override;
+ /** Destructor*/
+ virtual ~PlaneSurface();
- /** This method returns true if the GlobalPosition is on the Surface for both, within
- or without check of whether the local position is inside boundaries or not */
- virtual bool isOnSurface(const Vector3D& glopo, const BoundaryCheck& bchk=true) const override;
+ /** Assignment operator*/
+ PlaneSurface&
+ operator=(const PlaneSurface& psf);
- /** Specified for PlaneSurface: LocalToGlobal method without dynamic memory allocation */
- virtual void localToGlobal(const Vector2D& locp, const Vector3D& mom, Vector3D& glob) const override;
+ /** Equality operator*/
+ virtual bool
+ operator==(const Surface& sf) const override;
- /** Specified for PlaneSurface: GlobalToLocal method without dynamic memory allocation - boolean checks if on surface */
- virtual bool globalToLocal(const Vector3D& glob, const Vector3D& mom, Vector2D& loc) const override;
+ /** Virtual constructor - shift is optionally */
+ virtual PlaneSurface*
+ clone(const Transform3D* shift = nullptr) const override;
- /** fast straight line intersection schema - standard: provides closest intersection and (signed) path length
- forceDir is to provide the closest forward solution
-
- <b>mathematical motivation:</b>
-
- the equation of the plane is given by: <br>
- @f$ \vec n \cdot \vec x = \vec n \cdot \vec p,@f$ <br>
- where @f$ \vec n = (n_{x}, n_{y}, n_{z})@f$ denotes the normal vector of the plane,
- @f$ \vec p = (p_{x}, p_{y}, p_{z})@f$ one specific point on the plane and @f$ \vec x = (x,y,z) @f$ all possible points
- on the plane.<br>
- Given a line with:<br>
- @f$ \vec l(u) = \vec l_{1} + u \cdot \vec v @f$, <br>
- the solution for @f$ u @f$ can be written:
- @f$ u = \frac{\vec n (\vec p - \vec l_{1})}{\vec n \vec v}@f$ <br>
- If the denominator is 0 then the line lies:
- - either in the plane
- - perpenticular to the normal of the plane
-
- */
- virtual Intersection intersectionEstimate(const Vector3D& pos,
- const Vector3D& dir,
- bool forceDir,
- const BoundaryCheck& bchk = true) const override;
-
- /** Return properly formatted class name for screen output */
- virtual std::string name() const override { return "Acts::PlaneSurface"; }
-
- protected: //!< data members
- mutable std::shared_ptr<const PlanarBounds> m_bounds; //!< bounds (shared)
- static NoBounds s_boundless; //!< NoBounds as return object when no bounds are declared
-
- };
-
-
- inline PlaneSurface* PlaneSurface::clone(const Transform3D* shift) const
+ /** Return the surface type */
+ virtual SurfaceType
+ type() const override
{
- if (shift) new PlaneSurface(*this,*shift);
- return new PlaneSurface(*this);
+ return Surface::Plane;
}
- inline bool PlaneSurface::insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk) const
- { return (bounds().inside(locpos,bchk));}
+ /**This method returns the bounds by reference, static NoBounds in case of no
+ * boundaries*/
+ virtual const SurfaceBounds&
+ bounds() const override;
+
+ /**This method calls the inside() method of the Bounds*/
+ virtual bool
+ insideBounds(const Vector2D& locpos,
+ const BoundaryCheck& bchk) const override;
+
+ /** This method returns true if the GlobalPosition is on the Surface for both,
+ within
+ or without check of whether the local position is inside boundaries or not
+ */
+ virtual bool
+ isOnSurface(const Vector3D& glopo,
+ const BoundaryCheck& bchk = true) const override;
+
+ /** Specified for PlaneSurface: LocalToGlobal method without dynamic memory
+ * allocation */
+ virtual void
+ localToGlobal(const Vector2D& locp,
+ const Vector3D& mom,
+ Vector3D& glob) const override;
+
+ /** Specified for PlaneSurface: GlobalToLocal method without dynamic memory
+ * allocation - boolean checks if on surface */
+ virtual bool
+ globalToLocal(const Vector3D& glob,
+ const Vector3D& mom,
+ Vector2D& loc) const override;
+
+ /** fast straight line intersection schema - standard: provides closest
+ intersection and (signed) path length
+ forceDir is to provide the closest forward solution
+
+ <b>mathematical motivation:</b>
+
+ the equation of the plane is given by: <br>
+ @f$ \vec n \cdot \vec x = \vec n \cdot \vec p,@f$ <br>
+ where @f$ \vec n = (n_{x}, n_{y}, n_{z})@f$ denotes the normal vector of
+ the plane,
+ @f$ \vec p = (p_{x}, p_{y}, p_{z})@f$ one specific point on the plane and
+ @f$ \vec x = (x,y,z) @f$ all possible points
+ on the plane.<br>
+ Given a line with:<br>
+ @f$ \vec l(u) = \vec l_{1} + u \cdot \vec v @f$, <br>
+ the solution for @f$ u @f$ can be written:
+ @f$ u = \frac{\vec n (\vec p - \vec l_{1})}{\vec n \vec v}@f$ <br>
+ If the denominator is 0 then the line lies:
+ - either in the plane
+ - perpenticular to the normal of the plane
- inline const SurfaceBounds& PlaneSurface::bounds() const
+ */
+ virtual Intersection
+ intersectionEstimate(const Vector3D& pos,
+ const Vector3D& dir,
+ bool forceDir,
+ const BoundaryCheck& bchk = true) const override;
+
+ /** Return properly formatted class name for screen output */
+ virtual std::string
+ name() const override
{
- if (m_bounds.get()) return (*m_bounds.get());
- if (Surface::m_associatedDetElement && Surface::m_associatedDetElementId.is_valid()){
- return m_associatedDetElement->bounds(Surface::m_associatedDetElementId);
- }
- if (Surface::m_associatedDetElement) return m_associatedDetElement->bounds();
- return s_boundless;
+ return "Acts::PlaneSurface";
}
-
- inline Intersection PlaneSurface::intersectionEstimate(const Vector3D& pos,
- const Vector3D& dir,
- bool forceDir,
- const BoundaryCheck& bchk) const
- {
- double denom = dir.dot(normal());
- if (denom){
- double u = (normal().dot((center()-pos)))/(denom);
- Vector3D intersectPoint(pos + u * dir);
- // evaluate the intersection in terms of direction
- bool isValid = forceDir ? ( u > 0.) : true;
- // evaluate (if necessary in terms of boundaries)
- isValid = bchk ? (isValid && isOnSurface(intersectPoint,bchk) ) : isValid;
- // return the result
- return Intersection(intersectPoint,u,isValid);
- }
- return Intersection(pos,0.,false);
+protected: //!< data members
+ mutable std::shared_ptr<const PlanarBounds> m_bounds; //!< bounds (shared)
+ static NoBounds
+ s_boundless; //!< NoBounds as return object when no bounds are declared
+};
+
+inline PlaneSurface*
+PlaneSurface::clone(const Transform3D* shift) const
+{
+ if (shift) new PlaneSurface(*this, *shift);
+ return new PlaneSurface(*this);
+}
+
+inline bool
+PlaneSurface::insideBounds(const Vector2D& locpos,
+ const BoundaryCheck& bchk) const
+{
+ return (bounds().inside(locpos, bchk));
+}
+
+inline const SurfaceBounds&
+PlaneSurface::bounds() const
+{
+ if (m_bounds.get()) return (*m_bounds.get());
+ if (Surface::m_associatedDetElement
+ && Surface::m_associatedDetElementId.is_valid()) {
+ return m_associatedDetElement->bounds(Surface::m_associatedDetElementId);
+ }
+ if (Surface::m_associatedDetElement) return m_associatedDetElement->bounds();
+ return s_boundless;
+}
+
+inline Intersection
+PlaneSurface::intersectionEstimate(const Vector3D& pos,
+ const Vector3D& dir,
+ bool forceDir,
+ const BoundaryCheck& bchk) const
+{
+ double denom = dir.dot(normal());
+ if (denom) {
+ double u = (normal().dot((center() - pos))) / (denom);
+ Vector3D intersectPoint(pos + u * dir);
+ // evaluate the intersection in terms of direction
+ bool isValid = forceDir ? (u > 0.) : true;
+ // evaluate (if necessary in terms of boundaries)
+ isValid = bchk ? (isValid && isOnSurface(intersectPoint, bchk)) : isValid;
+ // return the result
+ return Intersection(intersectPoint, u, isValid);
}
+ return Intersection(pos, 0., false);
+}
-} // end of namespace
+} // end of namespace
-#endif // ACTS_SURFACES_PLANESURFACE_H
+#endif // ACTS_SURFACES_PLANESURFACE_H
diff --git a/Core/include/ACTS/Surfaces/RadialBounds.hpp b/Core/include/ACTS/Surfaces/RadialBounds.hpp
index 5e92e97ef..3d5f135c9 100644
--- a/Core/include/ACTS/Surfaces/RadialBounds.hpp
+++ b/Core/include/ACTS/Surfaces/RadialBounds.hpp
@@ -13,273 +13,388 @@
#ifndef ACTS_SURFACES_RADIALBOUNDS_H
#define ACTS_SURFACES_RADIALBOUNDS_H 1
+#include <cmath>
+#include <math.h>
#include "ACTS/Surfaces/DiscBounds.hpp"
-#include "ACTS/Utilities/ParameterDefinitions.hpp"
#include "ACTS/Utilities/Definitions.hpp"
-#include <math.h>
-#include <cmath>
+#include "ACTS/Utilities/ParameterDefinitions.hpp"
namespace Acts {
- /**
- @class RadialBounds
-
- Class to describe the bounds for a planar DiscSurface.
- By providing an argument for hphisec, the bounds can
- be restricted to a phirange around the center position.
-
- @image html RadialBounds.gif
-
- */
-
- class RadialBounds : public DiscBounds {
-
- public:
- /** enumeration for readability */
- enum BoundValues {
- bv_rMin = 0,
- bv_rMax = 1,
- bv_averagePhi = 2,
- bv_halfPhiSector = 3,
- bv_length = 4
- };
-
- /** Default Constructor*/
- RadialBounds();
-
- /** Constructor for full disc of symmetric disc around phi=0*/
- RadialBounds(double minrad, double maxrad, double hphisec=M_PI);
-
- /** Constructor for a symmetric disc around phi != 0*/
- RadialBounds(double minrad, double maxrad, double avephi, double hphisec);
-
- /** Copy constructor*/
- RadialBounds(const RadialBounds& discbo);
-
- /** Destructor*/
- virtual ~RadialBounds();
-
- /** Assignment operator*/
- RadialBounds& operator=(const RadialBounds& discbo);
-
- /** Equality operator*/
- virtual bool operator==(const SurfaceBounds& sbo) const override;
+/**
+ @class RadialBounds
- /** Virtual constructor*/
- virtual RadialBounds* clone() const override;
+ Class to describe the bounds for a planar DiscSurface.
+ By providing an argument for hphisec, the bounds can
+ be restricted to a phirange around the center position.
- /** Return the type - mainly for persistency */
- virtual SurfaceBounds::BoundsType type() const override { return SurfaceBounds::Disc; }
+ @image html RadialBounds.gif
- /** This method cheks if the radius given in the LocalPosition is inside [rMin,rMax]
- if only tol1 is given and additional in the phi sector is tol2 is given */
- virtual bool inside(const Vector2D &locpo, double tol1=0., double tol2=0.) const override;
- virtual bool inside(const Vector2D& locpo, const BoundaryCheck& bchk) const override;
+ */
- /** This method checks inside bounds in loc1
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc1(const Vector2D& locpo, double tol1=0.) const override;
-
- /** This method checks inside bounds in loc2
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc2(const Vector2D& locpo, double tol2=0.) const override;
-
- /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
- virtual double minDistance(const Vector2D& pos) const override;
-
- /** This method returns inner radius*/
- double rMin() const;
+class RadialBounds : public DiscBounds
+{
+public:
+ /** enumeration for readability */
+ enum BoundValues {
+ bv_rMin = 0,
+ bv_rMax = 1,
+ bv_averagePhi = 2,
+ bv_halfPhiSector = 3,
+ bv_length = 4
+ };
- /** This method returns outer radius*/
- double rMax() const;
+ /** Default Constructor*/
+ RadialBounds();
- /** This method returns the maximum expansion on the plane (=rMax)*/
- virtual double r() const override;
+ /** Constructor for full disc of symmetric disc around phi=0*/
+ RadialBounds(double minrad, double maxrad, double hphisec = M_PI);
- /** This method returns the average phi*/
- double averagePhi() const;
+ /** Constructor for a symmetric disc around phi != 0*/
+ RadialBounds(double minrad, double maxrad, double avephi, double hphisec);
- /** This method returns the halfPhiSector which is covered by the disc*/
- double halfPhiSector() const;
+ /** Copy constructor*/
+ RadialBounds(const RadialBounds& discbo);
- /** Output Method for std::ostream */
- virtual std::ostream& dump(std::ostream& sl) const override;
+ /** Destructor*/
+ virtual ~RadialBounds();
- private:
- /** Internal members of the bounds (float/double)*/
- std::vector<TDD_real_t> m_boundValues;
+ /** Assignment operator*/
+ RadialBounds&
+ operator=(const RadialBounds& discbo);
- };
+ /** Equality operator*/
+ virtual bool
+ operator==(const SurfaceBounds& sbo) const override;
- inline RadialBounds* RadialBounds::clone() const
- { return new RadialBounds(*this); }
+ /** Virtual constructor*/
+ virtual RadialBounds*
+ clone() const override;
- inline bool RadialBounds::inside(const Vector2D &locpo, double tol1, double tol2) const
+ /** Return the type - mainly for persistency */
+ virtual SurfaceBounds::BoundsType
+ type() const override
{
- double alpha = fabs(locpo[Acts::eLOC_PHI]-m_boundValues[RadialBounds::bv_averagePhi]);
- if ( alpha>M_PI) alpha = 2*M_PI - alpha;
- bool insidePhi = (alpha <= (m_boundValues[RadialBounds::bv_halfPhiSector]+tol2));
- return ( locpo[Acts::eLOC_R] > (m_boundValues[RadialBounds::bv_rMin] - tol1) && locpo[Acts::eLOC_R] < (m_boundValues[RadialBounds::bv_rMax] + tol1) && insidePhi );
+ return SurfaceBounds::Disc;
}
- inline bool RadialBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
- {
- if(bchk.bcType==0 || bchk.nSigmas==0 || m_boundValues[RadialBounds::bv_rMin]!=0 || m_boundValues[RadialBounds::bv_halfPhiSector]!=M_PI) return RadialBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
-
- // a fast FALSE
- sincosCache scResult = bchk.FastSinCos(locpo(1,0));
- double dx = bchk.nSigmas*sqrt(bchk.lCovariance(0,0));
- double dy = bchk.nSigmas*sqrt(scResult.sinC*scResult.sinC*bchk.lCovariance(0,0) + locpo(0,0)*locpo(0,0)*scResult.cosC*scResult.cosC*bchk.lCovariance(1,1)+2*scResult.cosC*scResult.sinC*locpo(0,0)*bchk.lCovariance(0,1));
- double max_ell = dx > dy ? dx : dy;
- if (locpo(0,0) > ( m_boundValues[RadialBounds::bv_rMax] + max_ell)) return false;
- // a fast TRUE
- double min_ell = dx < dy ? dx : dy;
- if (locpo(0,0) < ( m_boundValues[RadialBounds::bv_rMax] + min_ell)) return true;
-
- // we are not using the KDOP approach here but rather a highly optimized one
- class EllipseCollisionTest {
- private:
- int m_maxIterations;
- bool iterate(double x, double y, double c0x, double c0y, double c2x, double c2y, double rr) const {
- std::vector<double> innerPolygonCoef(m_maxIterations+1);
- std::vector<double> outerPolygonCoef(m_maxIterations+1);
- /*
- t2______t4
- --_ \
- --_ \ /¨¨¨ ¨¨\
- t1 = (0, 0) ( t )
- | \ \__ _ /
- | \
- | t3
- | /
- | /
- t0
- */
- for (int t = 1; t <= m_maxIterations; t++) {
- int numNodes = 4 << t;
- innerPolygonCoef[t] = 0.5/cos(4*acos(0.0)/numNodes);
- double c1x = (c0x + c2x)*innerPolygonCoef[t];
- double c1y = (c0y + c2y)*innerPolygonCoef[t];
- double tx = x - c1x; // t indicates a translated coordinate
- double ty = y - c1y;
- if (tx*tx + ty*ty <= rr) {
- return true; // collision with t1
- }
- double t2x = c2x - c1x;
- double t2y = c2y - c1y;
- if (tx*t2x + ty*t2y >= 0 && tx*t2x + ty*t2y <= t2x*t2x + t2y*t2y &&
- (ty*t2x - tx*t2y >= 0 || rr*(t2x*t2x + t2y*t2y) >= (ty*t2x - tx*t2y)*(ty*t2x - tx*t2y))) {
- return true; // collision with t1---t2
- }
- double t0x = c0x - c1x;
- double t0y = c0y - c1y;
- if (tx*t0x + ty*t0y >= 0 && tx*t0x + ty*t0y <= t0x*t0x + t0y*t0y &&
- (ty*t0x - tx*t0y <= 0 || rr*(t0x*t0x + t0y*t0y) >= (ty*t0x - tx*t0y)*(ty*t0x - tx*t0y))) {
- return true; // collision with t1---t0
- }
- outerPolygonCoef[t] = 0.5/(cos(2*acos(0.0)/numNodes)*cos(2*acos(0.0)/numNodes));
- double c3x = (c0x + c1x)*outerPolygonCoef[t];
- double c3y = (c0y + c1y)*outerPolygonCoef[t];
- if ((c3x-x)*(c3x-x) + (c3y-y)*(c3y-y) < rr) {
- c2x = c1x;
- c2y = c1y;
- continue; // t3 is inside circle
- }
- double c4x = c1x - c3x + c1x;
- double c4y = c1y - c3y + c1y;
- if ((c4x-x)*(c4x-x) + (c4y-y)*(c4y-y) < rr) {
- c0x = c1x;
- c0y = c1y;
- continue; // t4 is inside circle
- }
- double t3x = c3x - c1x;
- double t3y = c3y - c1y;
- if (ty*t3x - tx*t3y <= 0 || rr*(t3x*t3x + t3y*t3y) > (ty*t3x - tx*t3y)*(ty*t3x - tx*t3y)) {
- if (tx*t3x + ty*t3y > 0) {
- if (std::abs(tx*t3x + ty*t3y) <= t3x*t3x + t3y*t3y || (x-c3x)*(c0x-c3x) + (y-c3y)*(c0y-c3y) >= 0) {
- c2x = c1x;
- c2y = c1y;
- continue; // circle center is inside t0---t1---t3
- }
- } else if (-(tx*t3x + ty*t3y) <= t3x*t3x + t3y*t3y || (x-c4x)*(c2x-c4x) + (y-c4y)*(c2y-c4y) >= 0) {
- c0x = c1x;
- c0y = c1y;
- continue; // circle center is inside t1---t2---t4
- }
- }
- return false; // no collision possible
- }
- return false; // out of iterations so it is unsure if there was a collision. But have to return something.
- }
- public:
- // test for collision between an ellipse of horizontal radius w and vertical radius h at (x0, y0) and a circle of radius r at (x1, y1)
- bool collide(double x0, double y0, double w, double h, double x1, double y1, double r) const {
- double x = fabs(x1 - x0);
- double y = fabs(y1 - y0);
- if (x*x + (h - y)*(h - y) <= r*r || (w - x)*(w - x) + y*y <= r*r || x*h + y*w <= w*h // collision with (0, h)
- || ((x*h + y*w - w*h)*(x*h + y*w - w*h) <= r*r*(w*w + h*h) && x*w - y*h >= -h*h && x*w - y*h <= w*w)) { // collision with (0, h)---(w, 0)
- return true;
- } else {
- if ((x-w)*(x-w) + (y-h)*(y-h) <= r*r || (x <= w && y - r <= h) || (y <= h && x - r <= w)) {
- return iterate(x, y, w, 0, 0, h, r*r); // collision within triangle (0, h) (w, h) (0, 0) is possible
- }
- return false;
- }
- }
- EllipseCollisionTest(int maxIterations) {
- this->m_maxIterations = maxIterations;
- }
- };
-
- EllipseCollisionTest test(4);
- // convert to cartesian coordinates
- ActsMatrixD<2,2> covRotMatrix ;
- covRotMatrix << scResult.cosC, -locpo(0,0)*scResult.sinC,
- scResult.sinC, locpo(0,0)*scResult.cosC;
- ActsMatrixD<2,2> lCovarianceCar = covRotMatrix*bchk.lCovariance*covRotMatrix.transpose();
- Vector2D locpoCar(covRotMatrix(1,1), -covRotMatrix(0,1));
-
- // ellipse is always at (0,0), surface is moved to ellipse position and then rotated
- double w = bchk.nSigmas*sqrt( lCovarianceCar(0,0));
- double h = bchk.nSigmas*sqrt( lCovarianceCar(1,1));
- double x0 = 0;
- double y0 = 0;
- float theta = (lCovarianceCar(1,0) != 0 && (lCovarianceCar(1,1)-lCovarianceCar(0,0))!=0 ) ? .5*bchk.FastArcTan( 2*lCovarianceCar(1,0)/(lCovarianceCar(1,1)-lCovarianceCar(0,0)) ) : 0.;
- scResult = bchk.FastSinCos(theta);
- ActsMatrixD<2,2> rotMatrix ;
- rotMatrix << scResult.cosC, scResult.sinC,
- -scResult.sinC, scResult.cosC;
- Vector2D tmp = rotMatrix * (- locpoCar) ;
- double x1 = tmp(0,0);
- double y1 = tmp(1,0);
- double r = m_boundValues[RadialBounds::bv_rMax];
- // check if ellipse and circle overlap and return result
- return test.collide(x0, y0, w, h, x1, y1, r);
- }
-
- inline bool RadialBounds::insideLoc1(const Vector2D &locpo, double tol1) const
- { return (locpo[Acts::eLOC_R] > (m_boundValues[RadialBounds::bv_rMin] -tol1) && locpo[Acts::eLOC_R] < (m_boundValues[RadialBounds::bv_rMax] + tol1)); }
-
- inline bool RadialBounds::insideLoc2(const Vector2D &locpo, double tol2) const
+ /** This method cheks if the radius given in the LocalPosition is inside
+ [rMin,rMax]
+ if only tol1 is given and additional in the phi sector is tol2 is given */
+ virtual bool
+ inside(const Vector2D& locpo,
+ double tol1 = 0.,
+ double tol2 = 0.) const override;
+ virtual bool
+ inside(const Vector2D& locpo, const BoundaryCheck& bchk) const override;
+
+ /** This method checks inside bounds in loc1
+ - loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc1(const Vector2D& locpo, double tol1 = 0.) const override;
+
+ /** This method checks inside bounds in loc2
+ - loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc2(const Vector2D& locpo, double tol2 = 0.) const override;
+
+ /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
+ virtual double
+ minDistance(const Vector2D& pos) const override;
+
+ /** This method returns inner radius*/
+ double
+ rMin() const;
+
+ /** This method returns outer radius*/
+ double
+ rMax() const;
+
+ /** This method returns the maximum expansion on the plane (=rMax)*/
+ virtual double
+ r() const override;
+
+ /** This method returns the average phi*/
+ double
+ averagePhi() const;
+
+ /** This method returns the halfPhiSector which is covered by the disc*/
+ double
+ halfPhiSector() const;
+
+ /** Output Method for std::ostream */
+ virtual std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ /** Internal members of the bounds (float/double)*/
+ std::vector<TDD_real_t> m_boundValues;
+};
+
+inline RadialBounds*
+RadialBounds::clone() const
+{
+ return new RadialBounds(*this);
+}
+
+inline bool
+RadialBounds::inside(const Vector2D& locpo, double tol1, double tol2) const
+{
+ double alpha = fabs(locpo[Acts::eLOC_PHI]
+ - m_boundValues[RadialBounds::bv_averagePhi]);
+ if (alpha > M_PI) alpha = 2 * M_PI - alpha;
+ bool insidePhi
+ = (alpha <= (m_boundValues[RadialBounds::bv_halfPhiSector] + tol2));
+ return (locpo[Acts::eLOC_R] > (m_boundValues[RadialBounds::bv_rMin] - tol1)
+ && locpo[Acts::eLOC_R] < (m_boundValues[RadialBounds::bv_rMax] + tol1)
+ && insidePhi);
+}
+
+inline bool
+RadialBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
+{
+ if (bchk.bcType == 0 || bchk.nSigmas == 0
+ || m_boundValues[RadialBounds::bv_rMin] != 0
+ || m_boundValues[RadialBounds::bv_halfPhiSector] != M_PI)
+ return RadialBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
+
+ // a fast FALSE
+ sincosCache scResult = bchk.FastSinCos(locpo(1, 0));
+ double dx = bchk.nSigmas * sqrt(bchk.lCovariance(0, 0));
+ double dy = bchk.nSigmas
+ * sqrt(scResult.sinC * scResult.sinC * bchk.lCovariance(0, 0)
+ + locpo(0, 0) * locpo(0, 0) * scResult.cosC * scResult.cosC
+ * bchk.lCovariance(1, 1)
+ + 2 * scResult.cosC * scResult.sinC * locpo(0, 0)
+ * bchk.lCovariance(0, 1));
+ double max_ell = dx > dy ? dx : dy;
+ if (locpo(0, 0) > (m_boundValues[RadialBounds::bv_rMax] + max_ell))
+ return false;
+ // a fast TRUE
+ double min_ell = dx < dy ? dx : dy;
+ if (locpo(0, 0) < (m_boundValues[RadialBounds::bv_rMax] + min_ell))
+ return true;
+
+ // we are not using the KDOP approach here but rather a highly optimized one
+ class EllipseCollisionTest
{
- double alpha = fabs(locpo[Acts::eLOC_PHI]-m_boundValues[RadialBounds::bv_averagePhi]);
- if ( alpha > M_PI ) alpha = 2.*M_PI-alpha;
- //alpha -= alpha > M_PI ? 2.*M_PI : 0.;
- //alpha += alpha < -M_PI ? 2.*M_PI : 0.;
- bool insidePhi = (alpha <= (m_boundValues[RadialBounds::bv_halfPhiSector]+tol2));
- return insidePhi;
- }
-
- inline double RadialBounds::rMin() const { return m_boundValues[RadialBounds::bv_rMin]; }
-
- inline double RadialBounds::rMax() const { return m_boundValues[RadialBounds::bv_rMax]; }
-
- inline double RadialBounds::r() const { return m_boundValues[RadialBounds::bv_rMax]; }
-
- inline double RadialBounds::averagePhi() const { return m_boundValues[RadialBounds::bv_averagePhi]; }
-
- inline double RadialBounds::halfPhiSector() const { return m_boundValues[RadialBounds::bv_halfPhiSector]; }
-
-} // end of namespace
+ private:
+ int m_maxIterations;
+ bool
+ iterate(double x,
+ double y,
+ double c0x,
+ double c0y,
+ double c2x,
+ double c2y,
+ double rr) const
+ {
+ std::vector<double> innerPolygonCoef(m_maxIterations + 1);
+ std::vector<double> outerPolygonCoef(m_maxIterations + 1);
+ /*
+ t2______t4
+ --_ \
+ --_ \ /¨¨¨ ¨¨\
+ t1 = (0, 0) ( t )
+ | \ \__ _ /
+ | \
+ | t3
+ | /
+ | /
+ t0
+ */
+ for (int t = 1; t <= m_maxIterations; t++) {
+ int numNodes = 4 << t;
+ innerPolygonCoef[t] = 0.5 / cos(4 * acos(0.0) / numNodes);
+ double c1x = (c0x + c2x) * innerPolygonCoef[t];
+ double c1y = (c0y + c2y) * innerPolygonCoef[t];
+ double tx = x - c1x; // t indicates a translated coordinate
+ double ty = y - c1y;
+ if (tx * tx + ty * ty <= rr) {
+ return true; // collision with t1
+ }
+ double t2x = c2x - c1x;
+ double t2y = c2y - c1y;
+ if (tx * t2x + ty * t2y >= 0
+ && tx * t2x + ty * t2y <= t2x * t2x + t2y * t2y
+ && (ty * t2x - tx * t2y >= 0
+ || rr * (t2x * t2x + t2y * t2y)
+ >= (ty * t2x - tx * t2y) * (ty * t2x - tx * t2y))) {
+ return true; // collision with t1---t2
+ }
+ double t0x = c0x - c1x;
+ double t0y = c0y - c1y;
+ if (tx * t0x + ty * t0y >= 0
+ && tx * t0x + ty * t0y <= t0x * t0x + t0y * t0y
+ && (ty * t0x - tx * t0y <= 0
+ || rr * (t0x * t0x + t0y * t0y)
+ >= (ty * t0x - tx * t0y) * (ty * t0x - tx * t0y))) {
+ return true; // collision with t1---t0
+ }
+ outerPolygonCoef[t] = 0.5
+ / (cos(2 * acos(0.0) / numNodes) * cos(2 * acos(0.0) / numNodes));
+ double c3x = (c0x + c1x) * outerPolygonCoef[t];
+ double c3y = (c0y + c1y) * outerPolygonCoef[t];
+ if ((c3x - x) * (c3x - x) + (c3y - y) * (c3y - y) < rr) {
+ c2x = c1x;
+ c2y = c1y;
+ continue; // t3 is inside circle
+ }
+ double c4x = c1x - c3x + c1x;
+ double c4y = c1y - c3y + c1y;
+ if ((c4x - x) * (c4x - x) + (c4y - y) * (c4y - y) < rr) {
+ c0x = c1x;
+ c0y = c1y;
+ continue; // t4 is inside circle
+ }
+ double t3x = c3x - c1x;
+ double t3y = c3y - c1y;
+ if (ty * t3x - tx * t3y <= 0
+ || rr * (t3x * t3x + t3y * t3y)
+ > (ty * t3x - tx * t3y) * (ty * t3x - tx * t3y)) {
+ if (tx * t3x + ty * t3y > 0) {
+ if (std::abs(tx * t3x + ty * t3y) <= t3x * t3x + t3y * t3y
+ || (x - c3x) * (c0x - c3x) + (y - c3y) * (c0y - c3y) >= 0) {
+ c2x = c1x;
+ c2y = c1y;
+ continue; // circle center is inside t0---t1---t3
+ }
+ } else if (-(tx * t3x + ty * t3y) <= t3x * t3x + t3y * t3y
+ || (x - c4x) * (c2x - c4x) + (y - c4y) * (c2y - c4y)
+ >= 0) {
+ c0x = c1x;
+ c0y = c1y;
+ continue; // circle center is inside t1---t2---t4
+ }
+ }
+ return false; // no collision possible
+ }
+ return false; // out of iterations so it is unsure if there was a
+ // collision. But have to return something.
+ }
+
+ public:
+ // test for collision between an ellipse of horizontal radius w and vertical
+ // radius h at (x0, y0) and a circle of radius r at (x1, y1)
+ bool
+ collide(double x0,
+ double y0,
+ double w,
+ double h,
+ double x1,
+ double y1,
+ double r) const
+ {
+ double x = fabs(x1 - x0);
+ double y = fabs(y1 - y0);
+ if (x * x + (h - y) * (h - y) <= r * r
+ || (w - x) * (w - x) + y * y <= r * r
+ || x * h + y * w <= w * h // collision with (0, h)
+ || ((x * h + y * w - w * h) * (x * h + y * w - w * h)
+ <= r * r * (w * w + h * h)
+ && x * w - y * h >= -h * h
+ && x * w - y * h <= w * w)) { // collision with (0, h)---(w, 0)
+ return true;
+ } else {
+ if ((x - w) * (x - w) + (y - h) * (y - h) <= r * r
+ || (x <= w && y - r <= h)
+ || (y <= h && x - r <= w)) {
+ return iterate(x, y, w, 0, 0, h, r * r); // collision within triangle
+ // (0, h) (w, h) (0, 0) is
+ // possible
+ }
+ return false;
+ }
+ }
+ EllipseCollisionTest(int maxIterations)
+ {
+ this->m_maxIterations = maxIterations;
+ }
+ };
-#endif // ACTS_SURFACES_RADIALBOUNDS_H
+ EllipseCollisionTest test(4);
+ // convert to cartesian coordinates
+ ActsMatrixD<2, 2> covRotMatrix;
+ covRotMatrix << scResult.cosC, -locpo(0, 0) * scResult.sinC, scResult.sinC,
+ locpo(0, 0) * scResult.cosC;
+ ActsMatrixD<2, 2> lCovarianceCar
+ = covRotMatrix * bchk.lCovariance * covRotMatrix.transpose();
+ Vector2D locpoCar(covRotMatrix(1, 1), -covRotMatrix(0, 1));
+
+ // ellipse is always at (0,0), surface is moved to ellipse position and then
+ // rotated
+ double w = bchk.nSigmas * sqrt(lCovarianceCar(0, 0));
+ double h = bchk.nSigmas * sqrt(lCovarianceCar(1, 1));
+ double x0 = 0;
+ double y0 = 0;
+ float theta = (lCovarianceCar(1, 0) != 0
+ && (lCovarianceCar(1, 1) - lCovarianceCar(0, 0)) != 0)
+ ? .5
+ * bchk.FastArcTan(2 * lCovarianceCar(1, 0)
+ / (lCovarianceCar(1, 1) - lCovarianceCar(0, 0)))
+ : 0.;
+ scResult = bchk.FastSinCos(theta);
+ ActsMatrixD<2, 2> rotMatrix;
+ rotMatrix << scResult.cosC, scResult.sinC, -scResult.sinC, scResult.cosC;
+ Vector2D tmp = rotMatrix * (-locpoCar);
+ double x1 = tmp(0, 0);
+ double y1 = tmp(1, 0);
+ double r = m_boundValues[RadialBounds::bv_rMax];
+ // check if ellipse and circle overlap and return result
+ return test.collide(x0, y0, w, h, x1, y1, r);
+}
+
+inline bool
+RadialBounds::insideLoc1(const Vector2D& locpo, double tol1) const
+{
+ return (locpo[Acts::eLOC_R] > (m_boundValues[RadialBounds::bv_rMin] - tol1)
+ && locpo[Acts::eLOC_R]
+ < (m_boundValues[RadialBounds::bv_rMax] + tol1));
+}
+
+inline bool
+RadialBounds::insideLoc2(const Vector2D& locpo, double tol2) const
+{
+ double alpha = fabs(locpo[Acts::eLOC_PHI]
+ - m_boundValues[RadialBounds::bv_averagePhi]);
+ if (alpha > M_PI) alpha = 2. * M_PI - alpha;
+ // alpha -= alpha > M_PI ? 2.*M_PI : 0.;
+ // alpha += alpha < -M_PI ? 2.*M_PI : 0.;
+ bool insidePhi
+ = (alpha <= (m_boundValues[RadialBounds::bv_halfPhiSector] + tol2));
+ return insidePhi;
+}
+
+inline double
+RadialBounds::rMin() const
+{
+ return m_boundValues[RadialBounds::bv_rMin];
+}
+
+inline double
+RadialBounds::rMax() const
+{
+ return m_boundValues[RadialBounds::bv_rMax];
+}
+
+inline double
+RadialBounds::r() const
+{
+ return m_boundValues[RadialBounds::bv_rMax];
+}
+
+inline double
+RadialBounds::averagePhi() const
+{
+ return m_boundValues[RadialBounds::bv_averagePhi];
+}
+
+inline double
+RadialBounds::halfPhiSector() const
+{
+ return m_boundValues[RadialBounds::bv_halfPhiSector];
+}
+
+} // end of namespace
+
+#endif // ACTS_SURFACES_RADIALBOUNDS_H
diff --git a/Core/include/ACTS/Surfaces/RealQuadraticEquation.hpp b/Core/include/ACTS/Surfaces/RealQuadraticEquation.hpp
index 0b8f7df10..c9e1afb06 100644
--- a/Core/include/ACTS/Surfaces/RealQuadraticEquation.hpp
+++ b/Core/include/ACTS/Surfaces/RealQuadraticEquation.hpp
@@ -13,55 +13,64 @@
#ifndef ACTS_SURFACES_REALQUADRATICEQUATION_H
#define ACTS_SURFACES_REALQUADRATICEQUATION_H
-#include <utility>
#include <cmath>
+#include <utility>
namespace Acts {
- /** @enum RQESolutionType
- */
-
- enum RQESolutionType { none=0, one=1, two=2 };
-
- /** @struct RealQuadradicEquation
- Mathematic struct for solving real quadratic equations
-
- <b>Mathematical motivation</b>:<br>
- The equation is given by:<br>
- @f$ \alpha x^{2} + \beta x + \gamma = 0 @f$
- and has therefore the analytical solution:<br>
- @f$ x_{1, 2} = - \frac{\beta \pm \sqrt{\beta^{2}-4\alpha\gamma}}{2\alpha}@f$ <br>
- <br>
- - case @f$ \beta > 0 @f$:<br>
- @f$ x_{1} = - \frac{\beta + \sqrt{\beta^{2}-4\alpha\gamma}}{2\alpha} := \frac{q}{\alpha}@f$, <br>
- so that @f$ q= -\frac{1}{2}(\beta+sqrt{\beta^{2}-4\alpha\gamma})@f$.
- @f$ x_{2} @f$ can now be written as: @f$ x_{2} = \frac{\gamma}{q} = -\frac{2\gamma}{\beta+sqrt{\beta^{2}-4\alpha\gamma}}@f$, since: <br>
- @f$ -\frac{2\gamma}{\beta+sqrt{\beta^{2}-4\alpha\gamma}} = -\frac{2\gamma}{\beta}\frac{1}{1+\sqrt{1-4\alpha\gamma/\beta^{2}}}@f$, and <br>
- @f$ x_{2}\frac{1}{1-\sqrt{1-4\alpha\gamma/\beta^{2}}} = -\frac{2\gamma}{\beta}\frac{1}{1-1+4\alpha\gamma/\beta^{2}}=-\frac{\beta}{2\alpha}.@f$<br>
- Hence,@f$ -\frac{\beta(1-\sqrt{1-4\alpha\gamma/\beta^{2}}}{2\alpha} = - \frac{\beta - \sqrt{\beta^{2}-4\alpha\gamma}}{2\alpha} @f$.<br>
- - case @f$ \beta > 0 @f$ is similar.
-
- */
-
- struct RealQuadraticEquation {
+/** @enum RQESolutionType
+ */
- double first;
- double second;
- RQESolutionType solutions;
+enum RQESolutionType { none = 0, one = 1, two = 2 };
- RealQuadraticEquation(double alpha, double beta, double gamma) : first(0.), second(0.) {
- double discriminant = beta*beta - 4*alpha*gamma;
- if (discriminant<0) solutions = none;
- else {
- solutions = (discriminant==0) ? one : two;
- double q = -0.5*(beta + (beta>0 ? sqrt(discriminant) : -sqrt(discriminant)));
- first = q/alpha;
- second = gamma/q;
- }
- }
+/** @struct RealQuadradicEquation
+ Mathematic struct for solving real quadratic equations
- };
+ <b>Mathematical motivation</b>:<br>
+ The equation is given by:<br>
+ @f$ \alpha x^{2} + \beta x + \gamma = 0 @f$
+ and has therefore the analytical solution:<br>
+ @f$ x_{1, 2} = - \frac{\beta \pm \sqrt{\beta^{2}-4\alpha\gamma}}{2\alpha}@f$
+ <br>
+ <br>
+ - case @f$ \beta > 0 @f$:<br>
+ @f$ x_{1} = - \frac{\beta + \sqrt{\beta^{2}-4\alpha\gamma}}{2\alpha} :=
+ \frac{q}{\alpha}@f$, <br>
+ so that @f$ q= -\frac{1}{2}(\beta+sqrt{\beta^{2}-4\alpha\gamma})@f$.
+ @f$ x_{2} @f$ can now be written as: @f$ x_{2} = \frac{\gamma}{q} =
+ -\frac{2\gamma}{\beta+sqrt{\beta^{2}-4\alpha\gamma}}@f$, since: <br>
+ @f$ -\frac{2\gamma}{\beta+sqrt{\beta^{2}-4\alpha\gamma}} =
+ -\frac{2\gamma}{\beta}\frac{1}{1+\sqrt{1-4\alpha\gamma/\beta^{2}}}@f$, and
+ <br>
+ @f$ x_{2}\frac{1}{1-\sqrt{1-4\alpha\gamma/\beta^{2}}} =
+ -\frac{2\gamma}{\beta}\frac{1}{1-1+4\alpha\gamma/\beta^{2}}=-\frac{\beta}{2\alpha}.@f$<br>
+ Hence,@f$ -\frac{\beta(1-\sqrt{1-4\alpha\gamma/\beta^{2}}}{2\alpha} = -
+ \frac{\beta - \sqrt{\beta^{2}-4\alpha\gamma}}{2\alpha} @f$.<br>
+ - case @f$ \beta > 0 @f$ is similar.
-} // end of namespace
+ */
-#endif // ACTS_SURFACES_REALQUADRATICEQUATION_H
+struct RealQuadraticEquation
+{
+ double first;
+ double second;
+ RQESolutionType solutions;
+ RealQuadraticEquation(double alpha, double beta, double gamma)
+ : first(0.), second(0.)
+ {
+ double discriminant = beta * beta - 4 * alpha * gamma;
+ if (discriminant < 0)
+ solutions = none;
+ else {
+ solutions = (discriminant == 0) ? one : two;
+ double q = -0.5
+ * (beta + (beta > 0 ? sqrt(discriminant) : -sqrt(discriminant)));
+ first = q / alpha;
+ second = gamma / q;
+ }
+ }
+};
+
+} // end of namespace
+
+#endif // ACTS_SURFACES_REALQUADRATICEQUATION_H
diff --git a/Core/include/ACTS/Surfaces/RectangleBounds.hpp b/Core/include/ACTS/Surfaces/RectangleBounds.hpp
index e28db22e4..a83324842 100644
--- a/Core/include/ACTS/Surfaces/RectangleBounds.hpp
+++ b/Core/include/ACTS/Surfaces/RectangleBounds.hpp
@@ -18,176 +18,260 @@
namespace Acts {
- /**
- @class RectangleBounds
+/**
+ @class RectangleBounds
- Bounds for a rectangular, planar surface.
- The two local coordinates Acts::eLOC_X, Acts::eLOC_Y are for legacy reasons
- also called @f$ phi @f$ respectively @f$ eta @f$. The orientation
- with respect to the local surface framce can be seen in the attached
- illustration.
+ Bounds for a rectangular, planar surface.
+ The two local coordinates Acts::eLOC_X, Acts::eLOC_Y are for legacy reasons
+ also called @f$ phi @f$ respectively @f$ eta @f$. The orientation
+ with respect to the local surface framce can be seen in the attached
+ illustration.
- @image html RectangularBounds.gif
- */
+ @image html RectangularBounds.gif
+*/
+class RectangleBounds : public PlanarBounds
+{
+public:
+ /** @enum BoundValues for readability */
+ enum BoundValues { bv_halfX = 0, bv_halfY = 1, bv_length = 2 };
- class RectangleBounds : public PlanarBounds {
+ /** Default Constructor - needed for persistency*/
+ RectangleBounds();
- public:
+ /** Constructor with halflength in phi and halflength in eta*/
+ RectangleBounds(double halephi, double haleta);
- /** @enum BoundValues for readability */
- enum BoundValues {
- bv_halfX = 0,
- bv_halfY = 1,
- bv_length = 2
- };
+ /** Copy constructor*/
+ RectangleBounds(const RectangleBounds& recbo);
- /** Default Constructor - needed for persistency*/
- RectangleBounds();
+ /** Destructor*/
+ virtual ~RectangleBounds();
- /** Constructor with halflength in phi and halflength in eta*/
- RectangleBounds(double halephi, double haleta);
+ /** Assignment Operator*/
+ RectangleBounds&
+ operator=(const RectangleBounds& recbo);
- /** Copy constructor*/
- RectangleBounds(const RectangleBounds& recbo);
+ /** Equality operator*/
+ virtual bool
+ operator==(const SurfaceBounds& sbo) const override;
- /** Destructor*/
- virtual ~RectangleBounds();
+ /** Virtual constructor*/
+ virtual RectangleBounds*
+ clone() const override;
- /** Assignment Operator*/
- RectangleBounds& operator=(const RectangleBounds& recbo);
-
- /** Equality operator*/
- virtual bool operator==(const SurfaceBounds& sbo) const override;
-
- /** Virtual constructor*/
- virtual RectangleBounds* clone() const override;
-
- /** Return the type of the bounds for persistency */
- virtual BoundsType type() const override { return SurfaceBounds::Rectangle; }
-
- /** This method checks if the provided local coordinates are inside the surface bounds*/
- virtual bool inside(const Vector2D &locpo, double tol1=0., double tol2=0.) const override;
-
- /** This method checks if the provided local coordinates are inside the surface bounds*/
- virtual bool inside(const Vector2D& locpo, const BoundaryCheck& bchk) const override;
-
- /** This method checks inside bounds in loc1
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc1(const Vector2D& locpo, double tol1=0.) const override;
-
- /** This method checks inside bounds in loc2
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc2(const Vector2D& locpo, double tol2=0.) const override;
-
- /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
- virtual double minDistance(const Vector2D& pos) const override;
-
- /** This method returns the halflength in phi (first coordinate of local surface frame)*/
- double halflengthPhi() const;
-
- /** This method returns the halflength in Eta (second coordinate of local surface frame)*/
- double halflengthEta() const;
-
- /* *for consistant naming*/
- double halflengthX() const;
-
- /** for consitant naming*/
- double halflengthY() const;
-
- /** This method returns the maximal extension on the local plane, i.e. @f$s\sqrt{h_{\phi}^2 + h_{\eta}^2}\f$*/
- virtual double r() const override;
-
- /** Return the vertices - or, the points of the extremas */
- virtual const std::vector< Vector2D > vertices() const override;
-
- /** Output Method for std::ostream */
- virtual std::ostream& dump(std::ostream& sl) const override;
-
- private:
- /** The internal version of the bounds can be float/double*/
- std::vector<TDD_real_t> m_boundValues;
-
- };
-
- inline RectangleBounds* RectangleBounds::clone() const
- { return new RectangleBounds(*this); }
-
- inline bool RectangleBounds::inside(const Vector2D &locpo, double tol1, double tol2) const
- { return ((fabs(locpo[Acts::eLOC_X]) < m_boundValues.at(RectangleBounds::bv_halfX) + tol1) && (fabs(locpo[Acts::eLOC_Y]) < m_boundValues.at(RectangleBounds::bv_halfY) + tol2) ); }
-
- inline bool RectangleBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
+ /** Return the type of the bounds for persistency */
+ virtual BoundsType
+ type() const override
{
- if(bchk.bcType==0) return RectangleBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
-
- // a fast FALSE
- double max_ell = bchk.lCovariance(0,0) > bchk.lCovariance(1,1) ? bchk.lCovariance(0,0) : bchk.lCovariance(1,1);
- double limit = bchk.nSigmas*sqrt(max_ell);
- if (!RectangleBounds::inside(locpo, limit, limit)) return false;
- // a fast TRUE
- double min_ell = bchk.lCovariance(0,0) < bchk.lCovariance(1,1) ? bchk.lCovariance(0,0) : bchk.lCovariance(1,1);
- limit = bchk.nSigmas*sqrt(min_ell);
- if (RectangleBounds::inside(locpo, limit, limit)) return true;
-
- // compute KDOP and axes for surface polygon
- std::vector<KDOP> elementKDOP(4);
- std::vector<Vector2D> elementP(4);
- float theta = (bchk.lCovariance(1,0) != 0 && (bchk.lCovariance(1,1)-bchk.lCovariance(0,0))!=0 ) ? .5*bchk.FastArcTan( 2*bchk.lCovariance(1,0)/(bchk.lCovariance(1,1)-bchk.lCovariance(0,0)) ) : 0.;
- sincosCache scResult = bchk.FastSinCos(theta);
- ActsMatrixD<2,2> rotMatrix ;
- rotMatrix << scResult.cosC, scResult.sinC,
- -scResult.sinC, scResult.cosC;
- // ellipse is always at (0,0), surface is moved to ellipse position and then rotated
- Vector2D p;
- p << m_boundValues.at(RectangleBounds::bv_halfX),m_boundValues.at(RectangleBounds::bv_halfY);
- elementP.at(0) = ( rotMatrix * (p - locpo) );
- p << m_boundValues.at(RectangleBounds::bv_halfX),-m_boundValues.at(RectangleBounds::bv_halfY);
- elementP.at(1) =( rotMatrix * (p - locpo) );
- p << -m_boundValues.at(RectangleBounds::bv_halfX),m_boundValues.at(RectangleBounds::bv_halfY);
- elementP.at(2) =( rotMatrix * (p - locpo) );
- p << -m_boundValues.at(RectangleBounds::bv_halfX),-m_boundValues.at(RectangleBounds::bv_halfY);
- elementP.at(3) =( rotMatrix * (p - locpo) );
- std::vector<Vector2D> axis = {elementP.at(0)-elementP.at(1), elementP.at(0)-elementP.at(2), elementP.at(0)-elementP.at(3), elementP.at(1)-elementP.at(2)};
- bchk.ComputeKDOP(elementP, axis, elementKDOP);
- // compute KDOP for error ellipse
- std::vector<KDOP> errelipseKDOP(4);
- bchk.ComputeKDOP(bchk.EllipseToPoly(3), axis, errelipseKDOP);
- // check if KDOPs overlap and return result
- return bchk.TestKDOPKDOP(elementKDOP, errelipseKDOP);
+ return SurfaceBounds::Rectangle;
}
- inline bool RectangleBounds::insideLoc1(const Vector2D &locpo, double tol1) const
- { return (fabs(locpo[Acts::eLOC_X]) < m_boundValues.at(RectangleBounds::bv_halfX) + tol1); }
-
- inline bool RectangleBounds::insideLoc2(const Vector2D &locpo, double tol2) const
- { return (fabs(locpo[Acts::eLOC_Y]) < m_boundValues.at(RectangleBounds::bv_halfY) + tol2); }
-
- inline double RectangleBounds::halflengthPhi() const { return this->halflengthX(); }
-
- inline double RectangleBounds::halflengthEta() const { return this->halflengthY(); }
-
- inline double RectangleBounds::halflengthX() const { return m_boundValues.at(RectangleBounds::bv_halfX); }
-
- inline double RectangleBounds::halflengthY() const { return m_boundValues.at(RectangleBounds::bv_halfY); }
-
- inline double RectangleBounds::r() const {
- return sqrt(m_boundValues.at(RectangleBounds::bv_halfX)*m_boundValues.at(RectangleBounds::bv_halfX)
- + m_boundValues.at(RectangleBounds::bv_halfY)*m_boundValues.at(RectangleBounds::bv_halfY));
- }
-
- inline const std::vector< Vector2D > RectangleBounds::vertices() const {
- // create the return vector
- std::vector< Vector2D > vertices;
- // fill the vertices
- vertices.reserve(4);
- vertices.push_back(Vector2D(m_boundValues.at(RectangleBounds::bv_halfX),-m_boundValues.at(RectangleBounds::bv_halfY))); // [0]
- vertices.push_back(Vector2D(m_boundValues.at(RectangleBounds::bv_halfX), m_boundValues.at(RectangleBounds::bv_halfY))); // [1]
- vertices.push_back(Vector2D(-m_boundValues.at(RectangleBounds::bv_halfX),m_boundValues.at(RectangleBounds::bv_halfY))); // [1]
- vertices.push_back(Vector2D(-m_boundValues.at(RectangleBounds::bv_halfX),-m_boundValues.at(RectangleBounds::bv_halfY))); // [3]
- return vertices;
-
- }
-
-} // end of namespace
-
-#endif // ACTS_SURFACES_RECTANGLEBOUNDS_H
+ /** This method checks if the provided local coordinates are inside the
+ * surface bounds*/
+ virtual bool
+ inside(const Vector2D& locpo,
+ double tol1 = 0.,
+ double tol2 = 0.) const override;
+
+ /** This method checks if the provided local coordinates are inside the
+ * surface bounds*/
+ virtual bool
+ inside(const Vector2D& locpo, const BoundaryCheck& bchk) const override;
+
+ /** This method checks inside bounds in loc1
+ - loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc1(const Vector2D& locpo, double tol1 = 0.) const override;
+
+ /** This method checks inside bounds in loc2
+ - loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc2(const Vector2D& locpo, double tol2 = 0.) const override;
+
+ /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
+ virtual double
+ minDistance(const Vector2D& pos) const override;
+
+ /** This method returns the halflength in phi (first coordinate of local
+ * surface frame)*/
+ double
+ halflengthPhi() const;
+
+ /** This method returns the halflength in Eta (second coordinate of local
+ * surface frame)*/
+ double
+ halflengthEta() const;
+
+ /* *for consistant naming*/
+ double
+ halflengthX() const;
+
+ /** for consitant naming*/
+ double
+ halflengthY() const;
+
+ /** This method returns the maximal extension on the local plane, i.e.
+ * @f$s\sqrt{h_{\phi}^2 + h_{\eta}^2}\f$*/
+ virtual double
+ r() const override;
+
+ /** Return the vertices - or, the points of the extremas */
+ virtual const std::vector<Vector2D>
+ vertices() const override;
+
+ /** Output Method for std::ostream */
+ virtual std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ /** The internal version of the bounds can be float/double*/
+ std::vector<TDD_real_t> m_boundValues;
+};
+
+inline RectangleBounds*
+RectangleBounds::clone() const
+{
+ return new RectangleBounds(*this);
+}
+
+inline bool
+RectangleBounds::inside(const Vector2D& locpo, double tol1, double tol2) const
+{
+ return ((fabs(locpo[Acts::eLOC_X])
+ < m_boundValues.at(RectangleBounds::bv_halfX) + tol1)
+ && (fabs(locpo[Acts::eLOC_Y])
+ < m_boundValues.at(RectangleBounds::bv_halfY) + tol2));
+}
+
+inline bool
+RectangleBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
+{
+ if (bchk.bcType == 0)
+ return RectangleBounds::inside(
+ locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
+
+ // a fast FALSE
+ double max_ell = bchk.lCovariance(0, 0) > bchk.lCovariance(1, 1)
+ ? bchk.lCovariance(0, 0)
+ : bchk.lCovariance(1, 1);
+ double limit = bchk.nSigmas * sqrt(max_ell);
+ if (!RectangleBounds::inside(locpo, limit, limit)) return false;
+ // a fast TRUE
+ double min_ell = bchk.lCovariance(0, 0) < bchk.lCovariance(1, 1)
+ ? bchk.lCovariance(0, 0)
+ : bchk.lCovariance(1, 1);
+ limit = bchk.nSigmas * sqrt(min_ell);
+ if (RectangleBounds::inside(locpo, limit, limit)) return true;
+
+ // compute KDOP and axes for surface polygon
+ std::vector<KDOP> elementKDOP(4);
+ std::vector<Vector2D> elementP(4);
+ float theta = (bchk.lCovariance(1, 0) != 0
+ && (bchk.lCovariance(1, 1) - bchk.lCovariance(0, 0)) != 0)
+ ? .5
+ * bchk.FastArcTan(2 * bchk.lCovariance(1, 0)
+ / (bchk.lCovariance(1, 1) - bchk.lCovariance(0, 0)))
+ : 0.;
+ sincosCache scResult = bchk.FastSinCos(theta);
+ ActsMatrixD<2, 2> rotMatrix;
+ rotMatrix << scResult.cosC, scResult.sinC, -scResult.sinC, scResult.cosC;
+ // ellipse is always at (0,0), surface is moved to ellipse position and then
+ // rotated
+ Vector2D p;
+ p << m_boundValues.at(RectangleBounds::bv_halfX),
+ m_boundValues.at(RectangleBounds::bv_halfY);
+ elementP.at(0) = (rotMatrix * (p - locpo));
+ p << m_boundValues.at(RectangleBounds::bv_halfX),
+ -m_boundValues.at(RectangleBounds::bv_halfY);
+ elementP.at(1) = (rotMatrix * (p - locpo));
+ p << -m_boundValues.at(RectangleBounds::bv_halfX),
+ m_boundValues.at(RectangleBounds::bv_halfY);
+ elementP.at(2) = (rotMatrix * (p - locpo));
+ p << -m_boundValues.at(RectangleBounds::bv_halfX),
+ -m_boundValues.at(RectangleBounds::bv_halfY);
+ elementP.at(3) = (rotMatrix * (p - locpo));
+ std::vector<Vector2D> axis = {elementP.at(0) - elementP.at(1),
+ elementP.at(0) - elementP.at(2),
+ elementP.at(0) - elementP.at(3),
+ elementP.at(1) - elementP.at(2)};
+ bchk.ComputeKDOP(elementP, axis, elementKDOP);
+ // compute KDOP for error ellipse
+ std::vector<KDOP> errelipseKDOP(4);
+ bchk.ComputeKDOP(bchk.EllipseToPoly(3), axis, errelipseKDOP);
+ // check if KDOPs overlap and return result
+ return bchk.TestKDOPKDOP(elementKDOP, errelipseKDOP);
+}
+
+inline bool
+RectangleBounds::insideLoc1(const Vector2D& locpo, double tol1) const
+{
+ return (fabs(locpo[Acts::eLOC_X])
+ < m_boundValues.at(RectangleBounds::bv_halfX) + tol1);
+}
+
+inline bool
+RectangleBounds::insideLoc2(const Vector2D& locpo, double tol2) const
+{
+ return (fabs(locpo[Acts::eLOC_Y])
+ < m_boundValues.at(RectangleBounds::bv_halfY) + tol2);
+}
+
+inline double
+RectangleBounds::halflengthPhi() const
+{
+ return this->halflengthX();
+}
+
+inline double
+RectangleBounds::halflengthEta() const
+{
+ return this->halflengthY();
+}
+
+inline double
+RectangleBounds::halflengthX() const
+{
+ return m_boundValues.at(RectangleBounds::bv_halfX);
+}
+
+inline double
+RectangleBounds::halflengthY() const
+{
+ return m_boundValues.at(RectangleBounds::bv_halfY);
+}
+
+inline double
+RectangleBounds::r() const
+{
+ return sqrt(m_boundValues.at(RectangleBounds::bv_halfX)
+ * m_boundValues.at(RectangleBounds::bv_halfX)
+ + m_boundValues.at(RectangleBounds::bv_halfY)
+ * m_boundValues.at(RectangleBounds::bv_halfY));
+}
+
+inline const std::vector<Vector2D>
+RectangleBounds::vertices() const
+{
+ // create the return vector
+ std::vector<Vector2D> vertices;
+ // fill the vertices
+ vertices.reserve(4);
+ vertices.push_back(
+ Vector2D(m_boundValues.at(RectangleBounds::bv_halfX),
+ -m_boundValues.at(RectangleBounds::bv_halfY))); // [0]
+ vertices.push_back(
+ Vector2D(m_boundValues.at(RectangleBounds::bv_halfX),
+ m_boundValues.at(RectangleBounds::bv_halfY))); // [1]
+ vertices.push_back(
+ Vector2D(-m_boundValues.at(RectangleBounds::bv_halfX),
+ m_boundValues.at(RectangleBounds::bv_halfY))); // [1]
+ vertices.push_back(
+ Vector2D(-m_boundValues.at(RectangleBounds::bv_halfX),
+ -m_boundValues.at(RectangleBounds::bv_halfY))); // [3]
+ return vertices;
+}
+
+} // end of namespace
+
+#endif // ACTS_SURFACES_RECTANGLEBOUNDS_H
diff --git a/Core/include/ACTS/Surfaces/SlidingCylinderSurface.hpp b/Core/include/ACTS/Surfaces/SlidingCylinderSurface.hpp
index 239091841..b056d72cf 100644
--- a/Core/include/ACTS/Surfaces/SlidingCylinderSurface.hpp
+++ b/Core/include/ACTS/Surfaces/SlidingCylinderSurface.hpp
@@ -14,86 +14,112 @@
#define ACTS_SURFACES_SLIDINGCYLINDERSURFACE_H 1
#include "ACTS/Surfaces/CylinderSurface.hpp"
+#include "ACTS/Utilities/BinUtility.hpp"
#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Utilities/ParameterDefinitions.hpp"
-#include "ACTS/Utilities/BinUtility.hpp"
class Identifier;
namespace Acts {
- /**
- @class SlidingCylinderSurface
-
- Class for a Calo CylinderSurface with variable depth in the ATLAS detector.
- The variable depth is stored as a binned vector of radial corrections.
- Local eta bin is defined by base curvature and z position in base transform ( corrected for misalignement ).
- It inherits from CylinderSurface.
-
- */
-
- class SlidingCylinderSurface : public CylinderSurface {
- public:
- /** Default Constructor - needed for persistency*/
- SlidingCylinderSurface();
-
- /** Copy Constructor*/
- SlidingCylinderSurface(const SlidingCylinderSurface& psf);
-
- /** Copy Constructor with shift*/
- SlidingCylinderSurface(const SlidingCylinderSurface& psf, const Transform3D& transf);
-
- /** Constructor */
- SlidingCylinderSurface(const CylinderSurface& surf,
- BinUtility* bu = nullptr,
- const std::vector<float>* offset = nullptr,
- Transform3D* align = nullptr);
-
- /** Destructor*/
- virtual ~SlidingCylinderSurface();
-
- /** Virtual constructor - shift can be optionally applied */
- virtual SlidingCylinderSurface* clone(const Transform3D* shift = nullptr) const;
-
- /** Assignment operator*/
- SlidingCylinderSurface& operator=(const SlidingCylinderSurface& psf);
-
- /** Equality operator*/
- bool operator==(const Surface& sf) const;
-
- /** This method returns true if the GlobalPosition is on the Surface for both, within
- or without check of whether the local position is inside boundaries or not */
- bool isOnSurface(const Vector3D& glopo, const BoundaryCheck& bchk=true) const;
-
- /** Specialized for DiscSurface: LocalToGlobal method without dynamic memory allocation */
- void localToGlobal(const Vector2D& locp, const Vector3D& mom, Vector3D& glob) const;
-
- /** Specialized for DiscSurface: GlobalToLocal method without dynamic memory allocation - boolean checks if on surface */
- bool globalToLocal(const Vector3D& glob, const Vector3D& mom, Vector2D& loc) const;
-
- /**This method allows access to the bin utility*/
- const BinUtility* binUtility() const { return m_etaBin; }
-
- /**This method allows access to the radial offset values*/
- const std::vector<float>* offset() const { return m_depth; }
-
- /** Return properly formatted class name for screen output */
- std::string name() const { return "Acts::SlidingCylinderSurface"; }
-
- protected:
- const std::vector<float>* m_depth;
- BinUtility* m_etaBin;
- Transform3D* m_align;
- };
-
- inline SlidingCylinderSurface* SlidingCylinderSurface::clone(const Transform3D* shift) const
- {
- if (shift) new SlidingCylinderSurface(*this,*shift);
- return new SlidingCylinderSurface(*this);
- }
-
-} // end of namespace
-
-#endif // ACTS_SURFACES_SLIDINGCYLINDERSURFACE_H
-
-
+/**
+ @class SlidingCylinderSurface
+
+ Class for a Calo CylinderSurface with variable depth in the ATLAS detector.
+ The variable depth is stored as a binned vector of radial corrections.
+ Local eta bin is defined by base curvature and z position in base transform (
+ corrected for misalignement ).
+ It inherits from CylinderSurface.
+
+ */
+
+class SlidingCylinderSurface : public CylinderSurface
+{
+public:
+ /** Default Constructor - needed for persistency*/
+ SlidingCylinderSurface();
+
+ /** Copy Constructor*/
+ SlidingCylinderSurface(const SlidingCylinderSurface& psf);
+
+ /** Copy Constructor with shift*/
+ SlidingCylinderSurface(const SlidingCylinderSurface& psf,
+ const Transform3D& transf);
+
+ /** Constructor */
+ SlidingCylinderSurface(const CylinderSurface& surf,
+ BinUtility* bu = nullptr,
+ const std::vector<float>* offset = nullptr,
+ Transform3D* align = nullptr);
+
+ /** Destructor*/
+ virtual ~SlidingCylinderSurface();
+
+ /** Virtual constructor - shift can be optionally applied */
+ virtual SlidingCylinderSurface*
+ clone(const Transform3D* shift = nullptr) const;
+
+ /** Assignment operator*/
+ SlidingCylinderSurface&
+ operator=(const SlidingCylinderSurface& psf);
+
+ /** Equality operator*/
+ bool
+ operator==(const Surface& sf) const;
+
+ /** This method returns true if the GlobalPosition is on the Surface for both,
+ within
+ or without check of whether the local position is inside boundaries or not
+ */
+ bool
+ isOnSurface(const Vector3D& glopo, const BoundaryCheck& bchk = true) const;
+
+ /** Specialized for DiscSurface: LocalToGlobal method without dynamic memory
+ * allocation */
+ void
+ localToGlobal(const Vector2D& locp,
+ const Vector3D& mom,
+ Vector3D& glob) const;
+
+ /** Specialized for DiscSurface: GlobalToLocal method without dynamic memory
+ * allocation - boolean checks if on surface */
+ bool
+ globalToLocal(const Vector3D& glob, const Vector3D& mom, Vector2D& loc) const;
+
+ /**This method allows access to the bin utility*/
+ const BinUtility*
+ binUtility() const
+ {
+ return m_etaBin;
+ }
+
+ /**This method allows access to the radial offset values*/
+ const std::vector<float>*
+ offset() const
+ {
+ return m_depth;
+ }
+
+ /** Return properly formatted class name for screen output */
+ std::string
+ name() const
+ {
+ return "Acts::SlidingCylinderSurface";
+ }
+
+protected:
+ const std::vector<float>* m_depth;
+ BinUtility* m_etaBin;
+ Transform3D* m_align;
+};
+
+inline SlidingCylinderSurface*
+SlidingCylinderSurface::clone(const Transform3D* shift) const
+{
+ if (shift) new SlidingCylinderSurface(*this, *shift);
+ return new SlidingCylinderSurface(*this);
+}
+
+} // end of namespace
+
+#endif // ACTS_SURFACES_SLIDINGCYLINDERSURFACE_H
diff --git a/Core/include/ACTS/Surfaces/SlidingDiscSurface.hpp b/Core/include/ACTS/Surfaces/SlidingDiscSurface.hpp
index d28d6a4fe..94c17469f 100644
--- a/Core/include/ACTS/Surfaces/SlidingDiscSurface.hpp
+++ b/Core/include/ACTS/Surfaces/SlidingDiscSurface.hpp
@@ -14,92 +14,118 @@
#define ACTS_SURFACES_SLIDINGDISCSURFACE_H 1
// Geometry module
-#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Surfaces/DiscSurface.hpp"
-#include "ACTS/Surfaces/SurfaceBounds.hpp"
#include "ACTS/Surfaces/NoBounds.hpp"
+#include "ACTS/Surfaces/SurfaceBounds.hpp"
#include "ACTS/Utilities/BinUtility.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
namespace Acts {
- class DiscBounds;
- class DetectorElementBase;
-
- template<int DIM, class T, class S> class ParametersT;
-
- /**
- @class SlidingDiscSurface
-
- Class for a Calo DiscSurface with variable depth in the ATLAS detector.
- The variable depth is stored as a binned vector of shifts of the center along the normal.
- Local eta bin is defined by Acts::eLOC_R and z position for base transform ( corrected for misalignement ).
- Inherits from DiscSurface.
-
- */
-
- class SlidingDiscSurface : public DiscSurface {
-
- public:
- /** Default Constructor*/
- SlidingDiscSurface();
-
- /** Constructor */
- SlidingDiscSurface(const DiscSurface& surf,
- BinUtility* bu = nullptr,
- const std::vector<float>* offset = nullptr,
- Transform3D* align = nullptr);
-
- /** Copy Constructor*/
- SlidingDiscSurface(const SlidingDiscSurface& psf);
-
- /** Copy Constructor with shift*/
- SlidingDiscSurface(const SlidingDiscSurface& psf, const Transform3D& transf);
-
- /** Destructor*/
- virtual ~SlidingDiscSurface();
-
- /** Assignement operator*/
- SlidingDiscSurface& operator=(const SlidingDiscSurface&dsf);
-
- /** Equality operator*/
- bool operator==(const Surface& sf) const;
-
- /** Virtual constructor - shift can be optionally applied */
- virtual SlidingDiscSurface* clone(const Transform3D* shift = nullptr) const;
-
- /** This method returns true if the GlobalPosition is on the Surface for both, within
- or without check of whether the local position is inside boundaries or not */
- bool isOnSurface(const Vector3D& glopo, const BoundaryCheck& bchk=true) const;
-
- /** Specialized for DiscSurface: LocalToGlobal method without dynamic memory allocation */
- void localToGlobal(const Vector2D& locp, const Vector3D& mom, Vector3D& glob) const;
-
- /** Specialized for DiscSurface: GlobalToLocal method without dynamic memory allocation - boolean checks if on surface */
- bool globalToLocal(const Vector3D& glob, const Vector3D& mom, Vector2D& loc) const;
-
- /**This method allows access to the bin utility*/
- const BinUtility* binUtility() const { return m_etaBin; }
-
- /**This method allows access to the radial offset values*/
- const std::vector<float>* offset() const { return m_depth; }
-
- /** Return properly formatted class name for screen output */
- std::string name() const { return "Acts::SlidingDiscSurface"; }
+class DiscBounds;
+class DetectorElementBase;
+
+template <int DIM, class T, class S>
+class ParametersT;
+
+/**
+ @class SlidingDiscSurface
+
+ Class for a Calo DiscSurface with variable depth in the ATLAS detector.
+ The variable depth is stored as a binned vector of shifts of the center along
+ the normal.
+ Local eta bin is defined by Acts::eLOC_R and z position for base transform (
+ corrected for misalignement ).
+ Inherits from DiscSurface.
+
+ */
+
+class SlidingDiscSurface : public DiscSurface
+{
+public:
+ /** Default Constructor*/
+ SlidingDiscSurface();
+
+ /** Constructor */
+ SlidingDiscSurface(const DiscSurface& surf,
+ BinUtility* bu = nullptr,
+ const std::vector<float>* offset = nullptr,
+ Transform3D* align = nullptr);
+
+ /** Copy Constructor*/
+ SlidingDiscSurface(const SlidingDiscSurface& psf);
+
+ /** Copy Constructor with shift*/
+ SlidingDiscSurface(const SlidingDiscSurface& psf, const Transform3D& transf);
+
+ /** Destructor*/
+ virtual ~SlidingDiscSurface();
+
+ /** Assignement operator*/
+ SlidingDiscSurface&
+ operator=(const SlidingDiscSurface& dsf);
+
+ /** Equality operator*/
+ bool
+ operator==(const Surface& sf) const;
+
+ /** Virtual constructor - shift can be optionally applied */
+ virtual SlidingDiscSurface*
+ clone(const Transform3D* shift = nullptr) const;
+
+ /** This method returns true if the GlobalPosition is on the Surface for both,
+ within
+ or without check of whether the local position is inside boundaries or not
+ */
+ bool
+ isOnSurface(const Vector3D& glopo, const BoundaryCheck& bchk = true) const;
+
+ /** Specialized for DiscSurface: LocalToGlobal method without dynamic memory
+ * allocation */
+ void
+ localToGlobal(const Vector2D& locp,
+ const Vector3D& mom,
+ Vector3D& glob) const;
+
+ /** Specialized for DiscSurface: GlobalToLocal method without dynamic memory
+ * allocation - boolean checks if on surface */
+ bool
+ globalToLocal(const Vector3D& glob, const Vector3D& mom, Vector2D& loc) const;
+
+ /**This method allows access to the bin utility*/
+ const BinUtility*
+ binUtility() const
+ {
+ return m_etaBin;
+ }
- protected: //!< data members
- const std::vector<float>* m_depth;
- BinUtility* m_etaBin;
- Transform3D* m_align;
- };
+ /**This method allows access to the radial offset values*/
+ const std::vector<float>*
+ offset() const
+ {
+ return m_depth;
+ }
- inline SlidingDiscSurface* SlidingDiscSurface::clone(const Transform3D* shift) const
+ /** Return properly formatted class name for screen output */
+ std::string
+ name() const
{
- if (shift) new SlidingDiscSurface(*this,*shift);
- return new SlidingDiscSurface(*this);
+ return "Acts::SlidingDiscSurface";
}
-} // end of namespace
+protected: //!< data members
+ const std::vector<float>* m_depth;
+ BinUtility* m_etaBin;
+ Transform3D* m_align;
+};
-#endif // ACTS_SURFACES_SLIDINGDISCSURFACE_H
+inline SlidingDiscSurface*
+SlidingDiscSurface::clone(const Transform3D* shift) const
+{
+ if (shift) new SlidingDiscSurface(*this, *shift);
+ return new SlidingDiscSurface(*this);
+}
+} // end of namespace
+#endif // ACTS_SURFACES_SLIDINGDISCSURFACE_H
diff --git a/Core/include/ACTS/Surfaces/StraightLineSurface.hpp b/Core/include/ACTS/Surfaces/StraightLineSurface.hpp
index 0e3114009..2f562de02 100644
--- a/Core/include/ACTS/Surfaces/StraightLineSurface.hpp
+++ b/Core/include/ACTS/Surfaces/StraightLineSurface.hpp
@@ -13,173 +13,231 @@
#ifndef ACTS_SURFACESSTRAIGHTLINESURFACE_H
#define ACTS_SURFACESSTRAIGHTLINESURFACE_H
-#include "ACTS/Surfaces/Surface.hpp"
#include "ACTS/Surfaces/CylinderBounds.hpp"
#include "ACTS/Surfaces/NoBounds.hpp"
+#include "ACTS/Surfaces/Surface.hpp"
#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Utilities/Identifier.hpp"
namespace Acts {
- class DetectorElementBase;
-
- /**
- @class StraightLineSurface
-
- Class for a StraightLineSurface in the TrackingGeometry
- to describe dirft tube and straw like detectors.
- It inherits from Surface.
-
- */
-
- class StraightLineSurface : public Surface {
-
- public:
- /** Default Constructor - needed for persistency*/
- StraightLineSurface();
-
- /** Constructor from Transform3D (boundless surface)*/
- StraightLineSurface(std::shared_ptr<Transform3D> htrans);
-
- /** Constructor from Transform3D by unique_ptr (boundless surface)*/
- StraightLineSurface(std::unique_ptr<Transform3D> htrans);
-
- /** Constructor from Transform3D and bounds*/
- StraightLineSurface(std::shared_ptr<Transform3D> htrans, double radius, double halez);
-
- /** Constructor from Transform3D and bounds object - passing ownership */
- StraightLineSurface(std::shared_ptr<Transform3D> htrans, const CylinderBounds* cbounds);
-
- /** Constructor from Transform3D and a shared bounds object*/
- StraightLineSurface(std::shared_ptr<Transform3D> htrans, std::shared_ptr<const CylinderBounds> cbounds);
-
- /** Constructor from DetectorElementBase and Element identifier*/
- StraightLineSurface(const DetectorElementBase& detelement, const Identifier& identifier = Identifier());
-
- /** Copy constructor*/
- StraightLineSurface(const StraightLineSurface& slsf);
+class DetectorElementBase;
- /** Copy constructor with shift*/
- StraightLineSurface(const StraightLineSurface& slsf, const Transform3D& transf);
+/**
+ @class StraightLineSurface
- /** Destructor*/
- virtual ~StraightLineSurface();
+ Class for a StraightLineSurface in the TrackingGeometry
+ to describe dirft tube and straw like detectors.
+ It inherits from Surface.
- /** Assignment operator*/
- StraightLineSurface& operator=(const StraightLineSurface& slsf );
+ */
- /** Equality operator*/
- virtual bool operator==(const Surface& sf) const override;
+class StraightLineSurface : public Surface
+{
+public:
+ /** Default Constructor - needed for persistency*/
+ StraightLineSurface();
- /** Implicit constructor - shift can be provided */
- virtual StraightLineSurface* clone(const Transform3D* shift = nullptr) const override;
+ /** Constructor from Transform3D (boundless surface)*/
+ StraightLineSurface(std::shared_ptr<Transform3D> htrans);
- /** Return the measurement frame - this is needed for alignment, in particular for StraightLine and Perigee Surface
- - the default implementation is the the RotationMatrix3D of the transform */
- virtual const RotationMatrix3D measurementFrame(const Vector3D& glopos, const Vector3D& glomom) const override;
+ /** Constructor from Transform3D by unique_ptr (boundless surface)*/
+ StraightLineSurface(std::unique_ptr<Transform3D> htrans);
- /** Return the surface type */
- virtual SurfaceType type() const override { return Surface::Line; }
+ /** Constructor from Transform3D and bounds*/
+ StraightLineSurface(std::shared_ptr<Transform3D> htrans,
+ double radius,
+ double halez);
- /** Specified for StraightLineSurface: LocalToGlobal method without dynamic memory allocation */
- virtual void localToGlobal(const Vector2D& locp, const Vector3D& mom, Vector3D& glob) const override;
+ /** Constructor from Transform3D and bounds object - passing ownership */
+ StraightLineSurface(std::shared_ptr<Transform3D> htrans,
+ const CylinderBounds* cbounds);
- /** Specified for StraightLineSurface: GlobalToLocal method without dynamic memory allocation
- This method is the true global->local transformation.<br>
- makes use of globalToLocal and indicates the sign of the Acts::eLOC_R by the given momentum
+ /** Constructor from Transform3D and a shared bounds object*/
+ StraightLineSurface(std::shared_ptr<Transform3D> htrans,
+ std::shared_ptr<const CylinderBounds> cbounds);
- The calculation of the sign of the radius (or \f$ d_0 \f$) can be done as follows:<br>
- May \f$ \vec d = \vec m - \vec c \f$ denote the difference between the center of the line and
- the global position of the measurement/predicted state, then \f$ \vec d \f$ lies within the so
- called measurement plane.
- The measurement plane is determined by the two orthogonal vectors \f$ \vec{measY}= \vec{Acts::eLOC_Z} \f$
- and \f$ \vec{measX} = \vec{measY} \times \frac{\vec{p}}{|\vec{p}|} \f$.<br>
+ /** Constructor from DetectorElementBase and Element identifier*/
+ StraightLineSurface(const DetectorElementBase& detelement,
+ const Identifier& identifier = Identifier());
- The sign of the radius (\f$ d_{0} \f$ ) is then defined by the projection of \f$ \vec{d} \f$
- onto \f$ \vec{measX} \f$:<br>
- \f$ sign = -sign(\vec{d} \cdot \vec{measX}) \f$
+ /** Copy constructor*/
+ StraightLineSurface(const StraightLineSurface& slsf);
- \image html SignOfDriftCircleD0.gif
- */
- virtual bool globalToLocal(const Vector3D& glob, const Vector3D& mom, Vector2D& loc) const override;
+ /** Copy constructor with shift*/
+ StraightLineSurface(const StraightLineSurface& slsf,
+ const Transform3D& transf);
- /** Special method for StraightLineSurface - provides the Line direction from cache: speedup */
- const Vector3D& lineDirection() const;
+ /** Destructor*/
+ virtual ~StraightLineSurface();
- /** fast straight line intersection schema - standard: provides closest intersection and (signed) path length
- forceDir is to provide the closest forward solution
+ /** Assignment operator*/
+ StraightLineSurface&
+ operator=(const StraightLineSurface& slsf);
- b>mathematical motivation:</b>
- Given two lines in parameteric form:<br>
- - @f$ \vec l_{a}(\lambda) = \vec m_a + \lambda \cdot \vec e_{a} @f$ <br>
- - @f$ \vec l_{b}(\mu) = \vec m_b + \mu \cdot \vec e_{b} @f$ <br>
- the vector between any two points on the two lines is given by:
- - @f$ \vec s(\lambda, \mu) = \vec l_{b} - l_{a} = \vec m_{ab} + \mu \cdot \vec e_{b} - \lambda \cdot \vec e_{a} @f$, <br>
- when @f$ \vec m_{ab} = \vec m_{b} - \vec m_{a} @f$.<br>
- @f$ \vec s(\lambda_0, \mu_0) @f$ denotes the vector between the two closest points <br>
- @f$ \vec l_{a,0} = l_{a}(\lambda_0) @f$ and @f$ \vec l_{b,0} = l_{b}(\mu_0) @f$ <br>
- and is perpenticular to both, @f$ \vec e_{a} @f$ and @f$ \vec e_{b} @f$.
+ /** Equality operator*/
+ virtual bool
+ operator==(const Surface& sf) const override;
- This results in a system of two linear equations:<br>
- - (i) @f$ 0 = \vec s(\lambda_0, \mu_0) \cdot \vec e_a = \vec m_ab \cdot \vec e_a + \mu_0 \vec e_a \cdot \vec e_b - \lambda_0 @f$ <br>
- - (ii) @f$ 0 = \vec s(\lambda_0, \mu_0) \cdot \vec e_b = \vec m_ab \cdot \vec e_b + \mu_0 - \lambda_0 \vec e_b \cdot \vec e_a @f$ <br>
+ /** Implicit constructor - shift can be provided */
+ virtual StraightLineSurface*
+ clone(const Transform3D* shift = nullptr) const override;
- Solving (i), (ii) for @f$ \lambda_0 @f$ and @f$ \mu_0 @f$ yields:
- - @f$ \lambda_0 = \frac{(\vec m_ab \cdot \vec e_a)-(\vec m_ab \cdot \vec e_b)(\vec e_a \cdot \vec e_b)}{1-(\vec e_a \cdot \vec e_b)^2} @f$ <br>
- - @f$ \mu_0 = - \frac{(\vec m_ab \cdot \vec e_b)-(\vec m_ab \cdot \vec e_a)(\vec e_a \cdot \vec e_b)}{1-(\vec e_a \cdot \vec e_b)^2} @f$ <br>
- */
- virtual Intersection intersectionEstimate(const Vector3D& pos,
- const Vector3D& dir,
- bool forceDir,
- const BoundaryCheck& bchk=true) const override;
+ /** Return the measurement frame - this is needed for alignment, in particular
+ for StraightLine and Perigee Surface
+ - the default implementation is the the RotationMatrix3D of the transform
+ */
+ virtual const RotationMatrix3D
+ measurementFrame(const Vector3D& glopos,
+ const Vector3D& glomom) const override;
-
- /** the pathCorrection for derived classes with thickness */
- virtual double pathCorrection(const Vector3D&, const Vector3D&) const override { return 1.; }
-
- /** This method checks if the provided GlobalPosition is inside the assigned straw radius, but
- no check is done whether the GlobalPosition is inside bounds or not.
- It overwrites isOnSurface from Base Class as it saves the time of sign determination. */
- virtual bool isOnSurface(const Vector3D& glopo,
- const BoundaryCheck& bchk=true) const override;
-
- /**This method returns the bounds of the Surface by reference */
- virtual const SurfaceBounds& bounds() const override;
-
- /** Return properly formatted class name for screen output */
- virtual std::string name() const override { return "Acts::StraightLineSurface"; };
-
- protected: //!< data members
- mutable Vector3D* m_lineDirection; //!< cache of the line direction (speeds up)
- std::shared_ptr<const CylinderBounds> m_bounds; //!< bounds (shared)
- static NoBounds s_boundless; //!< NoBounds as return object when no bounds are declared
-
- };
-
- inline StraightLineSurface* StraightLineSurface::clone(const Transform3D* shift) const
+ /** Return the surface type */
+ virtual SurfaceType
+ type() const override
{
- if (shift) new StraightLineSurface(*this,*shift);
- return new StraightLineSurface(*this);
+ return Surface::Line;
}
- inline const SurfaceBounds& StraightLineSurface::bounds() const
+ /** Specified for StraightLineSurface: LocalToGlobal method without dynamic
+ * memory allocation */
+ virtual void
+ localToGlobal(const Vector2D& locp,
+ const Vector3D& mom,
+ Vector3D& glob) const override;
+
+ /** Specified for StraightLineSurface: GlobalToLocal method without dynamic
+ memory allocation
+ This method is the true global->local transformation.<br>
+ makes use of globalToLocal and indicates the sign of the Acts::eLOC_R by the
+ given momentum
+
+ The calculation of the sign of the radius (or \f$ d_0 \f$) can be done as
+ follows:<br>
+ May \f$ \vec d = \vec m - \vec c \f$ denote the difference between the
+ center of the line and
+ the global position of the measurement/predicted state, then \f$ \vec d \f$
+ lies within the so
+ called measurement plane.
+ The measurement plane is determined by the two orthogonal vectors \f$
+ \vec{measY}= \vec{Acts::eLOC_Z} \f$
+ and \f$ \vec{measX} = \vec{measY} \times \frac{\vec{p}}{|\vec{p}|} \f$.<br>
+
+ The sign of the radius (\f$ d_{0} \f$ ) is then defined by the projection of
+ \f$ \vec{d} \f$
+ onto \f$ \vec{measX} \f$:<br>
+ \f$ sign = -sign(\vec{d} \cdot \vec{measX}) \f$
+
+ \image html SignOfDriftCircleD0.gif
+ */
+ virtual bool
+ globalToLocal(const Vector3D& glob,
+ const Vector3D& mom,
+ Vector2D& loc) const override;
+
+ /** Special method for StraightLineSurface - provides the Line direction from
+ * cache: speedup */
+ const Vector3D&
+ lineDirection() const;
+
+ /** fast straight line intersection schema - standard: provides closest
+ intersection and (signed) path length
+ forceDir is to provide the closest forward solution
+
+ b>mathematical motivation:</b>
+ Given two lines in parameteric form:<br>
+ - @f$ \vec l_{a}(\lambda) = \vec m_a + \lambda \cdot \vec e_{a} @f$ <br>
+ - @f$ \vec l_{b}(\mu) = \vec m_b + \mu \cdot \vec e_{b} @f$ <br>
+ the vector between any two points on the two lines is given by:
+ - @f$ \vec s(\lambda, \mu) = \vec l_{b} - l_{a} = \vec m_{ab} + \mu \cdot
+ \vec e_{b} - \lambda \cdot \vec e_{a} @f$, <br>
+ when @f$ \vec m_{ab} = \vec m_{b} - \vec m_{a} @f$.<br>
+ @f$ \vec s(\lambda_0, \mu_0) @f$ denotes the vector between the two
+ closest points <br>
+ @f$ \vec l_{a,0} = l_{a}(\lambda_0) @f$ and @f$ \vec l_{b,0} =
+ l_{b}(\mu_0) @f$ <br>
+ and is perpenticular to both, @f$ \vec e_{a} @f$ and @f$ \vec e_{b} @f$.
+
+ This results in a system of two linear equations:<br>
+ - (i) @f$ 0 = \vec s(\lambda_0, \mu_0) \cdot \vec e_a = \vec m_ab \cdot
+ \vec e_a + \mu_0 \vec e_a \cdot \vec e_b - \lambda_0 @f$ <br>
+ - (ii) @f$ 0 = \vec s(\lambda_0, \mu_0) \cdot \vec e_b = \vec m_ab \cdot
+ \vec e_b + \mu_0 - \lambda_0 \vec e_b \cdot \vec e_a @f$ <br>
+
+ Solving (i), (ii) for @f$ \lambda_0 @f$ and @f$ \mu_0 @f$ yields:
+ - @f$ \lambda_0 = \frac{(\vec m_ab \cdot \vec e_a)-(\vec m_ab \cdot \vec
+ e_b)(\vec e_a \cdot \vec e_b)}{1-(\vec e_a \cdot \vec e_b)^2} @f$ <br>
+ - @f$ \mu_0 = - \frac{(\vec m_ab \cdot \vec e_b)-(\vec m_ab \cdot \vec
+ e_a)(\vec e_a \cdot \vec e_b)}{1-(\vec e_a \cdot \vec e_b)^2} @f$ <br>
+ */
+ virtual Intersection
+ intersectionEstimate(const Vector3D& pos,
+ const Vector3D& dir,
+ bool forceDir,
+ const BoundaryCheck& bchk = true) const override;
+
+ /** the pathCorrection for derived classes with thickness */
+ virtual double
+ pathCorrection(const Vector3D&, const Vector3D&) const override
{
- if (m_bounds.get()) return (*m_bounds.get());
- if (Surface::m_associatedDetElement && Surface::m_associatedDetElementId.is_valid()){
- return m_associatedDetElement->bounds(Surface::m_associatedDetElementId);
- }
- if (Surface::m_associatedDetElement) return m_associatedDetElement->bounds();
- return s_boundless;
+ return 1.;
}
- inline const Vector3D& StraightLineSurface::lineDirection() const {
- if (!m_lineDirection) {
- m_lineDirection = new Vector3D(transform().rotation().col(2));
- }
- return (*m_lineDirection);
- }
+ /** This method checks if the provided GlobalPosition is inside the assigned
+ straw radius, but
+ no check is done whether the GlobalPosition is inside bounds or not.
+ It overwrites isOnSurface from Base Class as it saves the time of sign
+ determination. */
+ virtual bool
+ isOnSurface(const Vector3D& glopo,
+ const BoundaryCheck& bchk = true) const override;
+
+ /**This method returns the bounds of the Surface by reference */
+ virtual const SurfaceBounds&
+ bounds() const override;
+
+ /** Return properly formatted class name for screen output */
+ virtual std::string
+ name() const override
+ {
+ return "Acts::StraightLineSurface";
+ };
-} // end of namespace
+protected: //!< data members
+ mutable Vector3D*
+ m_lineDirection; //!< cache of the line direction (speeds up)
+ std::shared_ptr<const CylinderBounds> m_bounds; //!< bounds (shared)
+ static NoBounds
+ s_boundless; //!< NoBounds as return object when no bounds are declared
+};
+
+inline StraightLineSurface*
+StraightLineSurface::clone(const Transform3D* shift) const
+{
+ if (shift) new StraightLineSurface(*this, *shift);
+ return new StraightLineSurface(*this);
+}
+
+inline const SurfaceBounds&
+StraightLineSurface::bounds() const
+{
+ if (m_bounds.get()) return (*m_bounds.get());
+ if (Surface::m_associatedDetElement
+ && Surface::m_associatedDetElementId.is_valid()) {
+ return m_associatedDetElement->bounds(Surface::m_associatedDetElementId);
+ }
+ if (Surface::m_associatedDetElement) return m_associatedDetElement->bounds();
+ return s_boundless;
+}
+
+inline const Vector3D&
+StraightLineSurface::lineDirection() const
+{
+ if (!m_lineDirection) {
+ m_lineDirection = new Vector3D(transform().rotation().col(2));
+ }
+ return (*m_lineDirection);
+}
-#endif // ACTS_SURFACESSTRAIGHTLINESURFACE_H
+} // end of namespace
+#endif // ACTS_SURFACESSTRAIGHTLINESURFACE_H
diff --git a/Core/include/ACTS/Surfaces/SubtractedCylinderSurface.hpp b/Core/include/ACTS/Surfaces/SubtractedCylinderSurface.hpp
index f7d8e38b8..37fbe70d9 100644
--- a/Core/include/ACTS/Surfaces/SubtractedCylinderSurface.hpp
+++ b/Core/include/ACTS/Surfaces/SubtractedCylinderSurface.hpp
@@ -14,86 +14,107 @@
#define ACTS_SURFACES_SUBTRACTEDCYLINDERSURFACE_H 1
#include "ACTS/Surfaces/CylinderSurface.hpp"
-#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Utilities/AreaExcluder.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Utilities/ParameterDefinitions.hpp"
class Identifier;
namespace Acts {
- /**
- @class SubtractedCylinderSurface
- Class for a cylinder subtracted/shared surface in the ATLAS detector.
- It owns its surface bounds and subtracted volume.
-
- */
+/**
+ @class SubtractedCylinderSurface
+ Class for a cylinder subtracted/shared surface in the ATLAS detector.
+ It owns its surface bounds and subtracted volume.
- class SubtractedCylinderSurface : public CylinderSurface {
- public:
- /** Default Constructor - needed for persistency*/
- SubtractedCylinderSurface();
+ */
- /** Copy Constructor*/
- SubtractedCylinderSurface(const SubtractedCylinderSurface& psf);
+class SubtractedCylinderSurface : public CylinderSurface
+{
+public:
+ /** Default Constructor - needed for persistency*/
+ SubtractedCylinderSurface();
- /** Copy Constructor with shift*/
- SubtractedCylinderSurface(const SubtractedCylinderSurface& psf, const Transform3D& transf);
+ /** Copy Constructor*/
+ SubtractedCylinderSurface(const SubtractedCylinderSurface& psf);
- /** Constructor */
- SubtractedCylinderSurface(const CylinderSurface& cs, AreaExcluder* vol, bool shared);
+ /** Copy Constructor with shift*/
+ SubtractedCylinderSurface(const SubtractedCylinderSurface& psf,
+ const Transform3D& transf);
- /**Destructor*/
- virtual ~SubtractedCylinderSurface();
+ /** Constructor */
+ SubtractedCylinderSurface(const CylinderSurface& cs,
+ AreaExcluder* vol,
+ bool shared);
- /**Assignment operator*/
- SubtractedCylinderSurface& operator=(const SubtractedCylinderSurface& psf);
+ /**Destructor*/
+ virtual ~SubtractedCylinderSurface();
- /**Equality operator*/
- bool operator==(const Surface& sf) const;
+ /**Assignment operator*/
+ SubtractedCylinderSurface&
+ operator=(const SubtractedCylinderSurface& psf);
- /** This method indicates the subtraction mode */
- bool shared() const;
+ /**Equality operator*/
+ bool
+ operator==(const Surface& sf) const;
- /**This method calls the inside() method of the Bounds*/
- bool insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk=true) const;
+ /** This method indicates the subtraction mode */
+ bool
+ shared() const;
- /**This method allows access to the subtracted part*/
- std::shared_ptr<AreaExcluder> subtractedVolume() const;
+ /**This method calls the inside() method of the Bounds*/
+ bool
+ insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk = true) const;
- /** Return properly formatted class name for screen output */
- std::string name() const { return "Acts::SubtractedCylinderSurface"; }
+ /**This method allows access to the subtracted part*/
+ std::shared_ptr<AreaExcluder>
+ subtractedVolume() const;
- protected:
- std::shared_ptr<AreaExcluder> m_subtrVol;
- bool m_shared;
- };
-
- inline bool SubtractedCylinderSurface::insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk) const
+ /** Return properly formatted class name for screen output */
+ std::string
+ name() const
{
- // no subtracted volume exists
- if (!m_subtrVol.get()) return (bounds().inside(locpos,bchk));
- // subtracted volume exists, needs to be checked
- double rCyl = bounds().r();
- double phiPos = locpos[Acts::eLOC_RPHI]/rCyl;
- const Vector3D gp(rCyl*cos(phiPos),rCyl*sin(phiPos),locpos[Acts::eLOC_Z]);
-
- bool inside_shared(this->bounds().inside(locpos,bchk) && m_subtrVol->inside(gp,0.) );
- bool inside(this->bounds().inside(locpos,bchk) && !m_subtrVol->inside(gp,0.) );
-
- if (m_shared) return inside_shared;
- return inside;
+ return "Acts::SubtractedCylinderSurface";
}
- inline bool SubtractedCylinderSurface::shared() const { return m_shared;}
-
- inline std::shared_ptr< AreaExcluder> SubtractedCylinderSurface::subtractedVolume() const
- {
- return m_subtrVol;
- }
-
-} // end of namespace
-
-#endif // ACTS_SURFACES_SUBTRACTEDCYLINDERSURFACE_H
-
-
+protected:
+ std::shared_ptr<AreaExcluder> m_subtrVol;
+ bool m_shared;
+};
+
+inline bool
+SubtractedCylinderSurface::insideBounds(const Vector2D& locpos,
+ const BoundaryCheck& bchk) const
+{
+ // no subtracted volume exists
+ if (!m_subtrVol.get()) return (bounds().inside(locpos, bchk));
+ // subtracted volume exists, needs to be checked
+ double rCyl = bounds().r();
+ double phiPos = locpos[Acts::eLOC_RPHI] / rCyl;
+ const Vector3D gp(
+ rCyl * cos(phiPos), rCyl * sin(phiPos), locpos[Acts::eLOC_Z]);
+
+ bool inside_shared(this->bounds().inside(locpos, bchk)
+ && m_subtrVol->inside(gp, 0.));
+ bool inside(this->bounds().inside(locpos, bchk)
+ && !m_subtrVol->inside(gp, 0.));
+
+ if (m_shared) return inside_shared;
+ return inside;
+}
+
+inline bool
+SubtractedCylinderSurface::shared() const
+{
+ return m_shared;
+}
+
+inline std::shared_ptr<AreaExcluder>
+SubtractedCylinderSurface::subtractedVolume() const
+{
+ return m_subtrVol;
+}
+
+} // end of namespace
+
+#endif // ACTS_SURFACES_SUBTRACTEDCYLINDERSURFACE_H
diff --git a/Core/include/ACTS/Surfaces/SubtractedDiscSurface.hpp b/Core/include/ACTS/Surfaces/SubtractedDiscSurface.hpp
index 50905c99a..0737412e4 100644
--- a/Core/include/ACTS/Surfaces/SubtractedDiscSurface.hpp
+++ b/Core/include/ACTS/Surfaces/SubtractedDiscSurface.hpp
@@ -13,79 +13,98 @@
#ifndef ACTS_SURFACES_SUBTRACTEDDISCSURFACE_H
#define ACTS_SURFACES_SUBTRACTEDDISCSURFACE_H 1
-#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Surfaces/DiscSurface.hpp"
#include "ACTS/Utilities/AreaExcluder.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
namespace Acts {
- /**
- @class SubtractedDiscSurface
- Class for a planar subtracted/shared surface in the ATLAS detector.
- It owns its surface bounds and subtracted volume.
-
- */
+/**
+ @class SubtractedDiscSurface
+ Class for a planar subtracted/shared surface in the ATLAS detector.
+ It owns its surface bounds and subtracted volume.
- class SubtractedDiscSurface : public DiscSurface {
- public:
- /** Default Constructor - needed for persistency*/
- SubtractedDiscSurface();
+ */
- /** Copy Constructor*/
- SubtractedDiscSurface(const SubtractedDiscSurface& psf);
+class SubtractedDiscSurface : public DiscSurface
+{
+public:
+ /** Default Constructor - needed for persistency*/
+ SubtractedDiscSurface();
- /** Copy Constructor*/
- SubtractedDiscSurface(const SubtractedDiscSurface& psf, const Transform3D& shift);
+ /** Copy Constructor*/
+ SubtractedDiscSurface(const SubtractedDiscSurface& psf);
- /** Constructor */
- SubtractedDiscSurface(const DiscSurface& ps , AreaExcluder* vol, bool shared);
+ /** Copy Constructor*/
+ SubtractedDiscSurface(const SubtractedDiscSurface& psf,
+ const Transform3D& shift);
- /**Destructor*/
- virtual ~SubtractedDiscSurface();
+ /** Constructor */
+ SubtractedDiscSurface(const DiscSurface& ps, AreaExcluder* vol, bool shared);
- /**Assignment operator*/
- SubtractedDiscSurface& operator=(const SubtractedDiscSurface& psf);
+ /**Destructor*/
+ virtual ~SubtractedDiscSurface();
- /**Equality operator*/
- bool operator==(const Surface& sf) const;
+ /**Assignment operator*/
+ SubtractedDiscSurface&
+ operator=(const SubtractedDiscSurface& psf);
- /** This method indicates the subtraction mode */
- bool shared() const;
+ /**Equality operator*/
+ bool
+ operator==(const Surface& sf) const;
- /**This method calls the inside() method of the Bounds*/
- bool insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk=true) const;
+ /** This method indicates the subtraction mode */
+ bool
+ shared() const;
- /**This method allows access to the subtracted part*/
- std::shared_ptr<AreaExcluder> subtractedVolume() const;
+ /**This method calls the inside() method of the Bounds*/
+ bool
+ insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk = true) const;
- /** Return properly formatted class name for screen output */
- std::string name() const { return "Acts::SubtractedDiscSurface"; }
+ /**This method allows access to the subtracted part*/
+ std::shared_ptr<AreaExcluder>
+ subtractedVolume() const;
- protected:
- std::shared_ptr<AreaExcluder> m_subtrVol;
- bool m_shared;
- };
-
- inline bool SubtractedDiscSurface::insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk) const
+ /** Return properly formatted class name for screen output */
+ std::string
+ name() const
{
- // no subtracted Volume exists
- if (!m_subtrVol.get()) return (this->bounds().inside(locpos,bchk));
- // subtracted Volume exists, needs to be checked
- double rPos = locpos[Acts::eLOC_R];
- double phiPos = locpos[Acts::eLOC_PHI];
- Vector3D gp(rPos*cos(phiPos),rPos*sin(phiPos),0.);
- if (m_shared) return (this->bounds().inside(locpos,bchk) && m_subtrVol->inside(gp,0.) );
- bool in(this->bounds().inside(locpos,bchk) && !m_subtrVol->inside(gp,0.)) ;
- return in;
+ return "Acts::SubtractedDiscSurface";
}
- inline bool SubtractedDiscSurface::shared() const { return m_shared;}
-
- inline std::shared_ptr<AreaExcluder> SubtractedDiscSurface::subtractedVolume() const
- {
- return m_subtrVol;
- }
-
-} // end of namespace
-
-#endif // ACTS_SURFACES_SUBTRACTEDDISCSURFACE_H
+protected:
+ std::shared_ptr<AreaExcluder> m_subtrVol;
+ bool m_shared;
+};
+
+inline bool
+SubtractedDiscSurface::insideBounds(const Vector2D& locpos,
+ const BoundaryCheck& bchk) const
+{
+ // no subtracted Volume exists
+ if (!m_subtrVol.get()) return (this->bounds().inside(locpos, bchk));
+ // subtracted Volume exists, needs to be checked
+ double rPos = locpos[Acts::eLOC_R];
+ double phiPos = locpos[Acts::eLOC_PHI];
+ Vector3D gp(rPos * cos(phiPos), rPos * sin(phiPos), 0.);
+ if (m_shared)
+ return (this->bounds().inside(locpos, bchk) && m_subtrVol->inside(gp, 0.));
+ bool in(this->bounds().inside(locpos, bchk) && !m_subtrVol->inside(gp, 0.));
+ return in;
+}
+
+inline bool
+SubtractedDiscSurface::shared() const
+{
+ return m_shared;
+}
+
+inline std::shared_ptr<AreaExcluder>
+SubtractedDiscSurface::subtractedVolume() const
+{
+ return m_subtrVol;
+}
+
+} // end of namespace
+
+#endif // ACTS_SURFACES_SUBTRACTEDDISCSURFACE_H
diff --git a/Core/include/ACTS/Surfaces/SubtractedPlaneSurface.hpp b/Core/include/ACTS/Surfaces/SubtractedPlaneSurface.hpp
index fccac8e8a..4557547aa 100644
--- a/Core/include/ACTS/Surfaces/SubtractedPlaneSurface.hpp
+++ b/Core/include/ACTS/Surfaces/SubtractedPlaneSurface.hpp
@@ -21,74 +21,93 @@ class Identifier;
namespace Acts {
- /**
- @class SubtractedPlaneSurface
+/**
+ @class SubtractedPlaneSurface
- Class for a planar subtracted/shared surface in the ATLAS detector.
- It owns its surface bounds and subtracted volume.
+ Class for a planar subtracted/shared surface in the ATLAS detector.
+ It owns its surface bounds and subtracted volume.
- */
+ */
- class SubtractedPlaneSurface : public PlaneSurface {
- public:
- /** Default Constructor - needed for persistency*/
- SubtractedPlaneSurface();
+class SubtractedPlaneSurface : public PlaneSurface
+{
+public:
+ /** Default Constructor - needed for persistency*/
+ SubtractedPlaneSurface();
- /** Copy Constructor*/
- SubtractedPlaneSurface(const SubtractedPlaneSurface& psf);
+ /** Copy Constructor*/
+ SubtractedPlaneSurface(const SubtractedPlaneSurface& psf);
- /** Copy Constructor with shift*/
- SubtractedPlaneSurface(const SubtractedPlaneSurface& psf, const Transform3D& transf);
+ /** Copy Constructor with shift*/
+ SubtractedPlaneSurface(const SubtractedPlaneSurface& psf,
+ const Transform3D& transf);
- /** Constructor */
- SubtractedPlaneSurface(const PlaneSurface& ps , AreaExcluder* vol, bool shared);
+ /** Constructor */
+ SubtractedPlaneSurface(const PlaneSurface& ps,
+ AreaExcluder* vol,
+ bool shared);
- /**Destructor*/
- virtual ~SubtractedPlaneSurface();
+ /**Destructor*/
+ virtual ~SubtractedPlaneSurface();
- /**Assignment operator*/
- SubtractedPlaneSurface& operator=(const SubtractedPlaneSurface& psf);
+ /**Assignment operator*/
+ SubtractedPlaneSurface&
+ operator=(const SubtractedPlaneSurface& psf);
- /**Equality operator*/
- bool operator==(const Surface& sf) const;
+ /**Equality operator*/
+ bool
+ operator==(const Surface& sf) const;
- /** This method indicates the subtraction mode */
- bool shared() const;
+ /** This method indicates the subtraction mode */
+ bool
+ shared() const;
- /**This method calls the inside() method of the Bounds*/
- bool insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk=true) const;
+ /**This method calls the inside() method of the Bounds*/
+ bool
+ insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk = true) const;
- /**This method allows access to the subtracted part*/
- std::shared_ptr<AreaExcluder> subtractedVolume() const;
+ /**This method allows access to the subtracted part*/
+ std::shared_ptr<AreaExcluder>
+ subtractedVolume() const;
- /** Return properly formatted class name for screen output */
- std::string name() const { return "Acts::SubtractedPlaneSurface"; }
-
- protected:
- std::shared_ptr<AreaExcluder> m_subtrVol;
- bool m_shared;
- };
-
- inline bool SubtractedPlaneSurface::insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk) const
+ /** Return properly formatted class name for screen output */
+ std::string
+ name() const
{
- // no subtracted volume exists
- if (!m_subtrVol.get()) return (this->bounds().inside(locpos,bchk));
- // subtracted volume exists, needs to be checked
- Vector3D gp(locpos.x(),locpos.y(),0.);
- if (m_shared) return (this->bounds().inside(locpos,bchk) && m_subtrVol->inside(gp,0.) );
- bool in(this->bounds().inside(locpos,bchk) && !m_subtrVol->inside(gp,0.)) ;
- return in;
+ return "Acts::SubtractedPlaneSurface";
}
- inline bool SubtractedPlaneSurface::shared() const { return m_shared;}
-
- inline std::shared_ptr<AreaExcluder> SubtractedPlaneSurface::subtractedVolume() const
- {
- return m_subtrVol;
- }
-
-} // end of namespace
-
-#endif // TRKGEOMETRYSURFACES_SUBTRACTEDPLANESURFACE_H
-
-
+protected:
+ std::shared_ptr<AreaExcluder> m_subtrVol;
+ bool m_shared;
+};
+
+inline bool
+SubtractedPlaneSurface::insideBounds(const Vector2D& locpos,
+ const BoundaryCheck& bchk) const
+{
+ // no subtracted volume exists
+ if (!m_subtrVol.get()) return (this->bounds().inside(locpos, bchk));
+ // subtracted volume exists, needs to be checked
+ Vector3D gp(locpos.x(), locpos.y(), 0.);
+ if (m_shared)
+ return (this->bounds().inside(locpos, bchk) && m_subtrVol->inside(gp, 0.));
+ bool in(this->bounds().inside(locpos, bchk) && !m_subtrVol->inside(gp, 0.));
+ return in;
+}
+
+inline bool
+SubtractedPlaneSurface::shared() const
+{
+ return m_shared;
+}
+
+inline std::shared_ptr<AreaExcluder>
+SubtractedPlaneSurface::subtractedVolume() const
+{
+ return m_subtrVol;
+}
+
+} // end of namespace
+
+#endif // TRKGEOMETRYSURFACES_SUBTRACTEDPLANESURFACE_H
diff --git a/Core/include/ACTS/Surfaces/Surface.hpp b/Core/include/ACTS/Surfaces/Surface.hpp
index 3f42be2c5..af0f35b93 100644
--- a/Core/include/ACTS/Surfaces/Surface.hpp
+++ b/Core/include/ACTS/Surfaces/Surface.hpp
@@ -13,329 +13,447 @@
#ifndef ACTS_SURFACES_SURFACE_H
#define ACTS_SURFACES_SURFACE_H 1
-#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Detector/DetectorElementBase.hpp"
#include "ACTS/Surfaces/BoundaryCheck.hpp"
#include "ACTS/Surfaces/SurfaceBounds.hpp"
-#include "ACTS/Detector/DetectorElementBase.hpp"
-#include "ACTS/Utilities/GeometryObject.hpp"
-#include "ACTS/Utilities/GeometryStatics.hpp"
-#include "ACTS/Utilities/Intersection.hpp"
#include "ACTS/Utilities/BinnedArray.hpp"
#include "ACTS/Utilities/BinningType.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Utilities/GeometryObject.hpp"
+#include "ACTS/Utilities/GeometryStatics.hpp"
#include "ACTS/Utilities/Identifier.hpp"
+#include "ACTS/Utilities/Intersection.hpp"
namespace Acts {
- class DetectorElementBase;
- class SurfaceBounds;
- class SurfaceMaterial;
- class Layer;
-
- /**
- @class Surface
-
- Abstract Base Class for tracking surfaces
-
- The creation of a Surface by passing a std::shared_ptr<Transform3D> through the constructor
- implies that the ownership of the Transform3D object is also passed to the Surface,
- therfor the memory is freed in the Surface destructor.
-
- For all isOnSurface, or positionOnSurface and insideBounds methods two tolerance parameters
- can be given which correspond to the two local natural coordinates of the surface loc1, loc2.
-
- */
-
- class Surface : public virtual GeometryObject {
-
- public:
-
- /** @enum SurfaceType
-
- This enumerator simplifies the persistency & calculations,
- by saving a dynamic_cast to happen.
-
- Other is reserved for the GeometrySurfaces implementation.
-
- */
- enum SurfaceType {
- Cone = 0,
- Cylinder = 1,
- Disc = 2,
- Perigee = 3,
- Plane = 4,
- Line = 5,
- Curvilinear = 6,
- Other = 7
- };
-
- /** Default Constructor - needed for inherited classes */
- Surface();
-
- /** Copy constructor - it invalidates the association to detector element and identifier */
- Surface(const Surface& sf);
-
- /** Copy constructor with shift */
- Surface(const Surface& sf, const Transform3D& transf);
-
- /** Constructor with Transform3D, surface often share transforms */
- Surface(std::shared_ptr<Transform3D> htrans);
-
- /** Constructor with Transform3D, by unique_ptr */
- Surface(std::unique_ptr<Transform3D> htrans);
-
- /** Constructor from TrkDetElement*/
- Surface(const DetectorElementBase& detelement);
-
- /** Constructor form TrkDetElement and Identifier*/
- Surface(const DetectorElementBase& detelement, const Identifier& id);
-
- /** Virtual Destructor*/
- virtual ~Surface();
-
- /** Assignment operator - the alssignment invalidates the link
- to detector element and identifier */
- Surface& operator=(const Surface& sf);
-
- /** Equality operator*/
- virtual bool operator==(const Surface& sf) const = 0;
-
- /** Non-equality operator*/
- virtual bool operator!=(const Surface& sf) const;
-
- /** Implicit constructor - uses the copy constructor
- - a new position can optionally be given */
- virtual Surface* clone(const Transform3D* shift = nullptr) const = 0;
-
- /** Returns the Surface type to avoid dynamic casts */
- virtual SurfaceType type() const = 0;
-
- /** Return the cached transformation directly, will create
- a new transform if it's not here. */
- std::shared_ptr<Transform3D> cachedTransform() const;
-
- /** Returns Transform3D by reference */
- virtual const Transform3D& transform() const;
-
- /** Returns the center position of the Surface */
- virtual const Vector3D& center() const;
-
- /** Returns the normal vector of the Surface */
- virtual const Vector3D& normal() const;
-
- /** Returns a normal vector at a specific local position */
- virtual const Vector3D normal(const Vector2D& lp) const;
-
- /** Returns a normal vector at a specific local position - no checking done on global position */
- virtual const Vector3D normal(const Vector3D& global) const;
-
- /** The binning position method - as default the center is given, but may be overloaded */
- virtual Vector3D binningPosition(BinningValue bValue) const override;
-
- /** return associated Detector Element */
- const DetectorElementBase* associatedDetectorElement() const;
-
- /** return Identifier of the associated Detector Element */
- const Identifier associatedDetectorElementIdentifier() const;
-
- /** return the associated Layer */
- const Layer* associatedLayer() const;
-
- /** The templated Parameters OnSurface method - checks on surface pointer first */
- template <class T> bool onSurface(const T& parameters, const BoundaryCheck& bchk = BoundaryCheck(true)) const;
-
- /** This method returns true if the GlobalPosition is on the Surface for both, within
- or without check of whether the local position is inside boundaries or not */
- virtual bool isOnSurface(const Vector3D& glopo, const BoundaryCheck& bchk=true) const;
-
- /** virtual methods to be overwritten by the inherited surfaces */
- virtual bool insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk) const;
-
- /** Specified by each surface type: LocalToGlobal method without dynamic memory allocation */
- virtual void localToGlobal(const Vector2D& locp, const Vector3D& mom, Vector3D& glob) const = 0;
-
- /** Specified by each surface type: GlobalToLocal method without dynamic memory allocation - boolean checks if on surface */
- virtual bool globalToLocal(const Vector3D& glob, const Vector3D& mom, Vector2D& loc) const = 0;
-
- /** the pathCorrection for derived classes with thickness - it reflects if the direction projection is positive or negative */
- virtual double pathCorrection(const Vector3D& pos, const Vector3D& mom) const;
-
- /** Return the measurement frame - this is needed for alignment, in particular for StraightLine and Perigee Surface
- - the default implementation is the the RotationMatrix3D of the transform */
- virtual const Acts::RotationMatrix3D measurementFrame(const Vector3D& glopos, const Vector3D& glomom) const;
-
- /** fst straight line intersection schema - templated for cvharged and neutral parameters */
- template <class T> Intersection intersectionEstimate(const T& pars, bool forceDir = false, Acts::BoundaryCheck bchk = false) const
- { return intersectionEstimate(pars.position(),pars.momentum().unit(),forceDir,bchk); }
-
- /** fast straight line intersection schema - standard: provides closest intersection and (signed) path length
- forceFwd is to provide the closest forward solution */
- virtual Intersection intersectionEstimate(const Vector3D& pos,
- const Vector3D& dir,
- bool forceDir = false,
- const BoundaryCheck& bchk = false) const = 0;
-
- /** Surface Bounds method */
- virtual const SurfaceBounds& bounds() const = 0;
-
- /** Returns 'true' if this surface is 'free', i.e. it does not belong to a detector element (and returns false otherwise*/
- bool isFree() const;
-
- void setSurfaceMaterial(std::shared_ptr<const SurfaceMaterial> material) const;
-
- /** Return 'true' if this surface is own by the detector element */
- bool isActive() const;
-
- /** set material layer */
- const SurfaceMaterial* surfaceMaterial() const;
-
- /** Output Method for std::ostream, to be overloaded by child classes */
- virtual std::ostream& dump(std::ostream& sl) const;
-
- /** Return properly formatted class name */
- virtual std::string name() const = 0;
-
- /**return number of surfaces currently created - needed for EDM monitor */
- static unsigned int numberOfInstantiations();
-
- /**return number of free surfaces currently created (i.e. those not belonging to a DE) - needed for EDM monitor */
- static unsigned int numberOfFreeInstantiations();
-
- /** method to associate the associated Acts::Layer which is alreay owned
- - only allowed by LayerBuilder
- - only done if no Layer is set already */
- void associateLayer(const Layer&) const;
-
- protected:
- /** Private members are in principle implemented as mutable pointers to objects for easy checks
- if they are already declared or not */
- std::shared_ptr<Transform3D> m_transform; //!< Transform3D w.r.t to global frame
- mutable Vector3D* m_center; //!< center position of the surface
- mutable Vector3D* m_normal; //!< normal vector of the surface
-
- /** Pointer to the a DetectorElementBase */
- const DetectorElementBase* m_associatedDetElement;
- Identifier m_associatedDetElementId;
-
- /** The associated layer Acts::Layer
- - layer in which the Surface is be embedded */
- mutable const Layer* m_associatedLayer;
-
- /** Possibility to attach a material descrption */
- mutable std::shared_ptr<const SurfaceMaterial> m_surfaceMaterial;
-
- /** number of objects of this type in memory - needed for EDM monitor*/
- static unsigned int s_numberOfInstantiations;
-
- /** number of objects of this type in memory which do not belong to a detector element - needed for EDM monitor*/
- static unsigned int s_numberOfFreeInstantiations;
+class DetectorElementBase;
+class SurfaceBounds;
+class SurfaceMaterial;
+class Layer;
+
+/**
+ @class Surface
+
+ Abstract Base Class for tracking surfaces
+
+ The creation of a Surface by passing a std::shared_ptr<Transform3D> through the
+ constructor
+ implies that the ownership of the Transform3D object is also passed to the
+ Surface,
+ therfor the memory is freed in the Surface destructor.
+
+ For all isOnSurface, or positionOnSurface and insideBounds methods two
+ tolerance parameters
+ can be given which correspond to the two local natural coordinates of the
+ surface loc1, loc2.
+
+ */
+
+class Surface : public virtual GeometryObject
+{
+public:
+ /** @enum SurfaceType
+
+ This enumerator simplifies the persistency & calculations,
+ by saving a dynamic_cast to happen.
+
+ Other is reserved for the GeometrySurfaces implementation.
+
+ */
+ enum SurfaceType {
+ Cone = 0,
+ Cylinder = 1,
+ Disc = 2,
+ Perigee = 3,
+ Plane = 4,
+ Line = 5,
+ Curvilinear = 6,
+ Other = 7
};
+ /** Default Constructor - needed for inherited classes */
+ Surface();
+
+ /** Copy constructor - it invalidates the association to detector element and
+ * identifier */
+ Surface(const Surface& sf);
+
+ /** Copy constructor with shift */
+ Surface(const Surface& sf, const Transform3D& transf);
- inline bool Surface::operator!=(const Surface& sf) const { return !((*this)==sf); }
-
- inline std::shared_ptr<Transform3D> Surface::cachedTransform() const
- {
- return m_transform;
- }
-
- inline const Transform3D& Surface::transform() const
- {
- if (m_transform.get()) return (*(m_transform.get()));
- if (m_associatedDetElement && m_associatedDetElementId.is_valid()) return m_associatedDetElement->transform(m_associatedDetElementId);
- if (m_associatedDetElement) return m_associatedDetElement->transform();
- return s_idTransform;
- }
-
- inline const Vector3D& Surface::center() const
- {
- if (m_transform.get() && !m_center) m_center = new Vector3D(m_transform->translation());
- if (m_center) return (*m_center);
- if (m_associatedDetElement && m_associatedDetElementId.is_valid()) return m_associatedDetElement->center(m_associatedDetElementId);
- if (m_associatedDetElement) return m_associatedDetElement->center();
- return s_origin;
- }
-
- inline const Vector3D& Surface::normal() const
+ /** Constructor with Transform3D, surface often share transforms */
+ Surface(std::shared_ptr<Transform3D> htrans);
+
+ /** Constructor with Transform3D, by unique_ptr */
+ Surface(std::unique_ptr<Transform3D> htrans);
+
+ /** Constructor from TrkDetElement*/
+ Surface(const DetectorElementBase& detelement);
+
+ /** Constructor form TrkDetElement and Identifier*/
+ Surface(const DetectorElementBase& detelement, const Identifier& id);
+
+ /** Virtual Destructor*/
+ virtual ~Surface();
+
+ /** Assignment operator - the alssignment invalidates the link
+ to detector element and identifier */
+ Surface&
+ operator=(const Surface& sf);
+
+ /** Equality operator*/
+ virtual bool
+ operator==(const Surface& sf) const = 0;
+
+ /** Non-equality operator*/
+ virtual bool
+ operator!=(const Surface& sf) const;
+
+ /** Implicit constructor - uses the copy constructor
+ - a new position can optionally be given */
+ virtual Surface*
+ clone(const Transform3D* shift = nullptr) const = 0;
+
+ /** Returns the Surface type to avoid dynamic casts */
+ virtual SurfaceType
+ type() const = 0;
+
+ /** Return the cached transformation directly, will create
+ a new transform if it's not here. */
+ std::shared_ptr<Transform3D>
+ cachedTransform() const;
+
+ /** Returns Transform3D by reference */
+ virtual const Transform3D&
+ transform() const;
+
+ /** Returns the center position of the Surface */
+ virtual const Vector3D&
+ center() const;
+
+ /** Returns the normal vector of the Surface */
+ virtual const Vector3D&
+ normal() const;
+
+ /** Returns a normal vector at a specific local position */
+ virtual const Vector3D
+ normal(const Vector2D& lp) const;
+
+ /** Returns a normal vector at a specific local position - no checking done on
+ * global position */
+ virtual const Vector3D
+ normal(const Vector3D& global) const;
+
+ /** The binning position method - as default the center is given, but may be
+ * overloaded */
+ virtual Vector3D
+ binningPosition(BinningValue bValue) const override;
+
+ /** return associated Detector Element */
+ const DetectorElementBase*
+ associatedDetectorElement() const;
+
+ /** return Identifier of the associated Detector Element */
+ const Identifier
+ associatedDetectorElementIdentifier() const;
+
+ /** return the associated Layer */
+ const Layer*
+ associatedLayer() const;
+
+ /** The templated Parameters OnSurface method - checks on surface pointer
+ * first */
+ template <class T>
+ bool
+ onSurface(const T& parameters,
+ const BoundaryCheck& bchk = BoundaryCheck(true)) const;
+
+ /** This method returns true if the GlobalPosition is on the Surface for both,
+ within
+ or without check of whether the local position is inside boundaries or not
+ */
+ virtual bool
+ isOnSurface(const Vector3D& glopo, const BoundaryCheck& bchk = true) const;
+
+ /** virtual methods to be overwritten by the inherited surfaces */
+ virtual bool
+ insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk) const;
+
+ /** Specified by each surface type: LocalToGlobal method without dynamic
+ * memory allocation */
+ virtual void
+ localToGlobal(const Vector2D& locp,
+ const Vector3D& mom,
+ Vector3D& glob) const = 0;
+
+ /** Specified by each surface type: GlobalToLocal method without dynamic
+ * memory allocation - boolean checks if on surface */
+ virtual bool
+ globalToLocal(const Vector3D& glob,
+ const Vector3D& mom,
+ Vector2D& loc) const = 0;
+
+ /** the pathCorrection for derived classes with thickness - it reflects if the
+ * direction projection is positive or negative */
+ virtual double
+ pathCorrection(const Vector3D& pos, const Vector3D& mom) const;
+
+ /** Return the measurement frame - this is needed for alignment, in particular
+ for StraightLine and Perigee Surface
+ - the default implementation is the the RotationMatrix3D of the transform
+ */
+ virtual const Acts::RotationMatrix3D
+ measurementFrame(const Vector3D& glopos, const Vector3D& glomom) const;
+
+ /** fst straight line intersection schema - templated for cvharged and neutral
+ * parameters */
+ template <class T>
+ Intersection
+ intersectionEstimate(const T& pars,
+ bool forceDir = false,
+ Acts::BoundaryCheck bchk = false) const
{
- if (m_transform.get() && m_normal==0) m_normal = new Vector3D(m_transform->rotation().col(2));
- if (m_normal) return (*m_normal);
- if (m_associatedDetElement && m_associatedDetElementId.is_valid()) return m_associatedDetElement->normal(m_associatedDetElementId);
- if (m_associatedDetElement) return m_associatedDetElement->normal();
- return s_zAxis;
+ return intersectionEstimate(
+ pars.position(), pars.momentum().unit(), forceDir, bchk);
}
- // return the binning position for ordering in the BinnedArray
- inline Vector3D Surface::binningPosition(BinningValue) const {
- // very simple binning directives following hte binning type
- // give the center as default for all of these binning types
- // binX, binY, binZ, binR, binPhi, binRPhi, binH, binEta
- return center();
+ /** fast straight line intersection schema - standard: provides closest
+ intersection and (signed) path length
+ forceFwd is to provide the closest forward solution */
+ virtual Intersection
+ intersectionEstimate(const Vector3D& pos,
+ const Vector3D& dir,
+ bool forceDir = false,
+ const BoundaryCheck& bchk = false) const = 0;
+
+ /** Surface Bounds method */
+ virtual const SurfaceBounds&
+ bounds() const = 0;
+
+ /** Returns 'true' if this surface is 'free', i.e. it does not belong to a
+ * detector element (and returns false otherwise*/
+ bool
+ isFree() const;
+
+ void
+ setSurfaceMaterial(std::shared_ptr<const SurfaceMaterial> material) const;
+
+ /** Return 'true' if this surface is own by the detector element */
+ bool
+ isActive() const;
+
+ /** set material layer */
+ const SurfaceMaterial*
+ surfaceMaterial() const;
+
+ /** Output Method for std::ostream, to be overloaded by child classes */
+ virtual std::ostream&
+ dump(std::ostream& sl) const;
+
+ /** Return properly formatted class name */
+ virtual std::string
+ name() const = 0;
+
+ /**return number of surfaces currently created - needed for EDM monitor */
+ static unsigned int
+ numberOfInstantiations();
+
+ /**return number of free surfaces currently created (i.e. those not belonging
+ * to a DE) - needed for EDM monitor */
+ static unsigned int
+ numberOfFreeInstantiations();
+
+ /** method to associate the associated Acts::Layer which is alreay owned
+ - only allowed by LayerBuilder
+ - only done if no Layer is set already */
+ void
+ associateLayer(const Layer&) const;
+
+protected:
+ /** Private members are in principle implemented as mutable pointers to
+ objects for easy checks
+ if they are already declared or not */
+ std::shared_ptr<Transform3D>
+ m_transform; //!< Transform3D w.r.t to global frame
+ mutable Vector3D* m_center; //!< center position of the surface
+ mutable Vector3D* m_normal; //!< normal vector of the surface
+
+ /** Pointer to the a DetectorElementBase */
+ const DetectorElementBase* m_associatedDetElement;
+ Identifier m_associatedDetElementId;
+
+ /** The associated layer Acts::Layer
+ - layer in which the Surface is be embedded */
+ mutable const Layer* m_associatedLayer;
+
+ /** Possibility to attach a material descrption */
+ mutable std::shared_ptr<const SurfaceMaterial> m_surfaceMaterial;
+
+ /** number of objects of this type in memory - needed for EDM monitor*/
+ static unsigned int s_numberOfInstantiations;
+
+ /** number of objects of this type in memory which do not belong to a detector
+ * element - needed for EDM monitor*/
+ static unsigned int s_numberOfFreeInstantiations;
+};
+
+inline bool
+Surface::operator!=(const Surface& sf) const
+{
+ return !((*this) == sf);
+}
+
+inline std::shared_ptr<Transform3D>
+Surface::cachedTransform() const
+{
+ return m_transform;
+}
+
+inline const Transform3D&
+Surface::transform() const
+{
+ if (m_transform.get()) return (*(m_transform.get()));
+ if (m_associatedDetElement && m_associatedDetElementId.is_valid())
+ return m_associatedDetElement->transform(m_associatedDetElementId);
+ if (m_associatedDetElement) return m_associatedDetElement->transform();
+ return s_idTransform;
+}
+
+inline const Vector3D&
+Surface::center() const
+{
+ if (m_transform.get() && !m_center)
+ m_center = new Vector3D(m_transform->translation());
+ if (m_center) return (*m_center);
+ if (m_associatedDetElement && m_associatedDetElementId.is_valid())
+ return m_associatedDetElement->center(m_associatedDetElementId);
+ if (m_associatedDetElement) return m_associatedDetElement->center();
+ return s_origin;
+}
+
+inline const Vector3D&
+Surface::normal() const
+{
+ if (m_transform.get() && m_normal == 0)
+ m_normal = new Vector3D(m_transform->rotation().col(2));
+ if (m_normal) return (*m_normal);
+ if (m_associatedDetElement && m_associatedDetElementId.is_valid())
+ return m_associatedDetElement->normal(m_associatedDetElementId);
+ if (m_associatedDetElement) return m_associatedDetElement->normal();
+ return s_zAxis;
+}
+
+// return the binning position for ordering in the BinnedArray
+inline Vector3D Surface::binningPosition(BinningValue) const
+{
+ // very simple binning directives following hte binning type
+ // give the center as default for all of these binning types
+ // binX, binY, binZ, binR, binPhi, binRPhi, binH, binEta
+ return center();
+}
+
+// common to planar surfaces
+inline double
+Surface::pathCorrection(const Vector3D&, const Vector3D& mom) const
+{
+ Vector3D dir(mom.unit());
+ double cosAlpha = dir.dot(normal());
+ return fabs(1. / cosAlpha);
+}
+
+//* the templated parameters on Surface method */
+template <class T>
+bool
+Surface::onSurface(const T& pars, const BoundaryCheck& bcheck) const
+{
+ // surface pointer comparison as a first fast check (w/o transform)
+ if ((&pars.associatedSurface() == this)) {
+ return (bcheck ? insideBounds(pars.localPosition(), bcheck) : true);
}
-
- // common to planar surfaces
- inline double Surface::pathCorrection(const Vector3D&, const Vector3D& mom) const
- {
- Vector3D dir(mom.unit());
- double cosAlpha = dir.dot(normal());
- return fabs(1./cosAlpha);
- }
-
- //* the templated parameters on Surface method */
- template <class T> bool Surface::onSurface(const T& pars, const BoundaryCheck& bcheck ) const
- {
- // surface pointer comparison as a first fast check (w/o transform)
- if ( (&pars.associatedSurface() == this ) ){
- return (bcheck ? insideBounds(pars.localPosition(),bcheck) : true);
- }
- return isOnSurface(pars.position(),bcheck);
- }
-
- inline bool Surface::insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk) const
- { return bounds().inside(locpos,bchk); }
-
- // take local position and return a normal direction, local position is ignored for planar surfaces
- inline const Vector3D Surface::normal(const Vector2D &) const
- { return normal(); }
-
- // take local position and return a normal direction, local position is ignored for planar surfaces
- inline const Vector3D Surface::normal(const Vector3D&) const
- { return normal(); }
-
- inline const DetectorElementBase* Surface::associatedDetectorElement() const
- { return m_associatedDetElement; }
-
- inline const Identifier Surface::associatedDetectorElementIdentifier() const
- {
- if (!m_associatedDetElement) return Identifier(); // in invalid state
- if (m_associatedDetElementId.is_valid()) return m_associatedDetElementId;
- return m_associatedDetElement->identify();
- }
-
- inline const Layer* Surface::associatedLayer() const
- { return (m_associatedLayer); }
-
- inline const SurfaceMaterial* Surface::surfaceMaterial() const
- { return m_surfaceMaterial.get(); }
-
- inline bool Surface::isActive() const
- { return (m_associatedDetElement != nullptr); }
-
- inline bool Surface::isFree() const
- { return (m_associatedDetElement == nullptr && m_associatedLayer == nullptr); }
-
- inline void Surface::setSurfaceMaterial(std::shared_ptr<const SurfaceMaterial> material) const
- { m_surfaceMaterial = material; }
-
- inline void Surface::associateLayer(const Layer& lay) const
- { m_associatedLayer = (&lay); }
-
-std::ostream& operator << ( std::ostream& sl, const Surface& sf);
-
-/** Surfaces are not constructed by shared_ptr factories as they are EDM objects,
+ return isOnSurface(pars.position(), bcheck);
+}
+
+inline bool
+Surface::insideBounds(const Vector2D& locpos, const BoundaryCheck& bchk) const
+{
+ return bounds().inside(locpos, bchk);
+}
+
+// take local position and return a normal direction, local position is ignored
+// for planar surfaces
+inline const Vector3D
+Surface::normal(const Vector2D&) const
+{
+ return normal();
+}
+
+// take local position and return a normal direction, local position is ignored
+// for planar surfaces
+inline const Vector3D
+Surface::normal(const Vector3D&) const
+{
+ return normal();
+}
+
+inline const DetectorElementBase*
+Surface::associatedDetectorElement() const
+{
+ return m_associatedDetElement;
+}
+
+inline const Identifier
+Surface::associatedDetectorElementIdentifier() const
+{
+ if (!m_associatedDetElement) return Identifier(); // in invalid state
+ if (m_associatedDetElementId.is_valid()) return m_associatedDetElementId;
+ return m_associatedDetElement->identify();
+}
+
+inline const Layer*
+Surface::associatedLayer() const
+{
+ return (m_associatedLayer);
+}
+
+inline const SurfaceMaterial*
+Surface::surfaceMaterial() const
+{
+ return m_surfaceMaterial.get();
+}
+
+inline bool
+Surface::isActive() const
+{
+ return (m_associatedDetElement != nullptr);
+}
+
+inline bool
+Surface::isFree() const
+{
+ return (m_associatedDetElement == nullptr && m_associatedLayer == nullptr);
+}
+
+inline void
+Surface::setSurfaceMaterial(
+ std::shared_ptr<const SurfaceMaterial> material) const
+{
+ m_surfaceMaterial = material;
+}
+
+inline void
+Surface::associateLayer(const Layer& lay) const
+{
+ m_associatedLayer = (&lay);
+}
+
+std::ostream&
+operator<<(std::ostream& sl, const Surface& sf);
+
+/** Surfaces are not constructed by shared_ptr factories as they are EDM
+ objects,
hence the SurfaceArray is defined as such: */
-typedef BinnedArray< const Surface* > SurfaceArray;
-
-} // end of namespace Acts
+typedef BinnedArray<const Surface*> SurfaceArray;
-#endif // ACTS_SURFACES_SURFACE_H
+} // end of namespace Acts
+#endif // ACTS_SURFACES_SURFACE_H
diff --git a/Core/include/ACTS/Surfaces/SurfaceBounds.hpp b/Core/include/ACTS/Surfaces/SurfaceBounds.hpp
index 595c62a07..6efdc21cc 100644
--- a/Core/include/ACTS/Surfaces/SurfaceBounds.hpp
+++ b/Core/include/ACTS/Surfaces/SurfaceBounds.hpp
@@ -14,112 +14,133 @@
#define ACTS_SURFACES_SURFACEBOUNDS_H 1
// STD/STL
-#include <iostream>
#include <iomanip>
+#include <iostream>
-#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Surfaces/BoundaryCheck.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
namespace Acts {
- /**
- @class SurfaceBounds
-
- Abstract base class for surface bounds to be specified.
-
- Surface bounds provide:
- - inside() checks
- - the BoundsType return type to avoid dynamic casting
- - an initCache() method
-
- */
-
-
- class SurfaceBounds {
- public:
-
- /** @enum BoundsType
-
- This enumerator simplifies the persistency,
- by saving a dynamic_cast to happen.
-
- Other is reserved for the GeometrySurfaces implementation.
-
- */
- enum BoundsType {
- Cone = 0,
- Cylinder = 1,
- Diamond = 2,
- Disc = 3,
- Ellipse = 5,
- Rectangle = 6,
- RotatedTrapezoid = 7,
- Trapezoid = 8,
- Triangle = 9,
- DiscTrapezoidal = 10,
- Other = 11
- };
-
- /**Default Constructor*/
- SurfaceBounds(){}
-
- /**Destructor*/
- virtual ~SurfaceBounds(){}
-
- /** clone() method to make deep copy in Surface copy constructor and for assigment operator
- of the Surface class.*/
- virtual SurfaceBounds* clone() const = 0;
-
- /**Equality operator*/
- virtual bool operator==(const SurfaceBounds& sb) const = 0;
-
- /**Non-Equality operator*/
- bool operator!=(const SurfaceBounds& sb) const;
-
- /** Return the bounds type - for persistency optimization */
- virtual BoundsType type() const = 0;
-
- /** Each Bounds has a method inside, which checks if a LocalPosition is inside the bounds.
- Inside can be called without/with tolerances. */
- virtual bool inside(const Vector2D& locpo, double tol1=0., double tol2=0.) const = 0;
- virtual bool inside(const Vector2D& locpo, const BoundaryCheck& bchk) const = 0;
-
- /** Extend the interface to for single inside Loc 1 / Loc2 tests
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc1(const Vector2D& locpo, double tol1=0.) const = 0;
-
- /** Extend the interface to for single inside Loc 1 / Loc2 tests
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc2(const Vector2D& locpo, double tol2=0.) const = 0;
-
- /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
- virtual double minDistance(const Vector2D& pos) const = 0;
-
- /** Interface method for the maximal extension or the radius*/
- virtual double r() const = 0;
-
- /** Output Method for std::ostream, to be overloaded by child classes */
- virtual std::ostream& dump(std::ostream& sl) const = 0;
-
- protected:
- /** Swap method to be called from DiscBounds or TrapezoidalBounds */
- void swap(double& b1, double& b2);
-
- /** virtual initCache method for object persistency */
- virtual void initCache() {}
+/**
+ @class SurfaceBounds
+
+ Abstract base class for surface bounds to be specified.
+
+ Surface bounds provide:
+ - inside() checks
+ - the BoundsType return type to avoid dynamic casting
+ - an initCache() method
+
+ */
+
+class SurfaceBounds
+{
+public:
+ /** @enum BoundsType
+
+ This enumerator simplifies the persistency,
+ by saving a dynamic_cast to happen.
+
+ Other is reserved for the GeometrySurfaces implementation.
+
+ */
+ enum BoundsType {
+ Cone = 0,
+ Cylinder = 1,
+ Diamond = 2,
+ Disc = 3,
+ Ellipse = 5,
+ Rectangle = 6,
+ RotatedTrapezoid = 7,
+ Trapezoid = 8,
+ Triangle = 9,
+ DiscTrapezoidal = 10,
+ Other = 11
};
- inline void SurfaceBounds::swap(double& b1, double& b2) {
- double tmp=b1;
- b1 = b2;
- b2 = tmp;
+ /**Default Constructor*/
+ SurfaceBounds() {}
+ /**Destructor*/
+ virtual ~SurfaceBounds() {}
+ /** clone() method to make deep copy in Surface copy constructor and for
+ assigment operator
+ of the Surface class.*/
+ virtual SurfaceBounds*
+ clone() const = 0;
+
+ /**Equality operator*/
+ virtual bool
+ operator==(const SurfaceBounds& sb) const = 0;
+
+ /**Non-Equality operator*/
+ bool
+ operator!=(const SurfaceBounds& sb) const;
+
+ /** Return the bounds type - for persistency optimization */
+ virtual BoundsType
+ type() const = 0;
+
+ /** Each Bounds has a method inside, which checks if a LocalPosition is inside
+ the bounds.
+ Inside can be called without/with tolerances. */
+ virtual bool
+ inside(const Vector2D& locpo, double tol1 = 0., double tol2 = 0.) const = 0;
+ virtual bool
+ inside(const Vector2D& locpo, const BoundaryCheck& bchk) const = 0;
+
+ /** Extend the interface to for single inside Loc 1 / Loc2 tests
+ - loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc1(const Vector2D& locpo, double tol1 = 0.) const = 0;
+
+ /** Extend the interface to for single inside Loc 1 / Loc2 tests
+ - loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc2(const Vector2D& locpo, double tol2 = 0.) const = 0;
+
+ /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
+ virtual double
+ minDistance(const Vector2D& pos) const = 0;
+
+ /** Interface method for the maximal extension or the radius*/
+ virtual double
+ r() const = 0;
+
+ /** Output Method for std::ostream, to be overloaded by child classes */
+ virtual std::ostream&
+ dump(std::ostream& sl) const = 0;
+
+protected:
+ /** Swap method to be called from DiscBounds or TrapezoidalBounds */
+ void
+ swap(double& b1, double& b2);
+
+ /** virtual initCache method for object persistency */
+ virtual void
+ initCache()
+ {
}
-
- inline bool SurfaceBounds::operator!=(const SurfaceBounds& sb) const { return !((*this)==sb);}
+};
+
+inline void
+SurfaceBounds::swap(double& b1, double& b2)
+{
+ double tmp = b1;
+ b1 = b2;
+ b2 = tmp;
+}
+
+inline bool
+SurfaceBounds::operator!=(const SurfaceBounds& sb) const
+{
+ return !((*this) == sb);
+}
/**Overload of << operator for std::ostream for debug output*/
-std::ostream& operator << ( std::ostream& sl, const SurfaceBounds& sb);
+std::ostream&
+operator<<(std::ostream& sl, const SurfaceBounds& sb);
-} // end of namespace
+} // end of namespace
-#endif // ACTS_SURFACES_SURFACEBOUNDS_H
+#endif // ACTS_SURFACES_SURFACEBOUNDS_H
diff --git a/Core/include/ACTS/Surfaces/TrapezoidBounds.hpp b/Core/include/ACTS/Surfaces/TrapezoidBounds.hpp
index 7674426bf..b6a68d099 100644
--- a/Core/include/ACTS/Surfaces/TrapezoidBounds.hpp
+++ b/Core/include/ACTS/Surfaces/TrapezoidBounds.hpp
@@ -13,251 +13,376 @@
#ifndef ACTS_SURFACES_TRAPEZOIDBOUNDS_H
#define ACTS_SURFACES_TRAPEZOIDBOUNDS_H 1
+#include <math.h>
#include "ACTS/Surfaces/PlanarBounds.hpp"
-#include "ACTS/Utilities/ParameterDefinitions.hpp"
#include "ACTS/Utilities/Definitions.hpp"
-#include <math.h>
+#include "ACTS/Utilities/ParameterDefinitions.hpp"
namespace Acts {
- /**
- @class TrapezoidBounds
- Bounds for a trapezoidal, planar Surface.
-
- @image html TrapezoidalBounds.gif
- <br>
- @image html SCT_Trapezoid.gif
-
- @todo can be speed optimized by calculating kappa/delta and caching it
-
- */
-
- class TrapezoidBounds : public PlanarBounds {
-
- public:
- /** @enum BoundValues - for readability */
- enum BoundValues {
- bv_minHalfX = 0,
- bv_maxHalfX = 1,
- bv_halfY = 2,
- bv_length = 3
- };
-
- /** Default Constructor, needed for persistency*/
- TrapezoidBounds();
-
- /** Constructor for symmetric Trapezoid*/
- TrapezoidBounds(double minhalex, double maxhalex, double haley);
-
- /** Constructor for arbitrary Trapezoid*/
- TrapezoidBounds(double minhalex, double haley, double alpha, double beta);
-
- /** Copy constructor*/
- TrapezoidBounds(const TrapezoidBounds& trabo);
-
- /** Destructor*/
- virtual ~TrapezoidBounds();
-
- /** Virtual constructor*/
- virtual TrapezoidBounds* clone() const override;
-
- /** Return the type of the bounds for persistency */
- virtual BoundsType type() const override { return SurfaceBounds::Trapezoid; }
-
- /** Assignment operator*/
- TrapezoidBounds& operator=(const TrapezoidBounds& sbo);
-
- /** Equality operator*/
- virtual bool operator==(const SurfaceBounds& trabo) const override;
-
- /** This method returns the minimal halflength in phi (first coordinate of local surface frame)*/
- double minHalflengthPhi() const;
-
- /** This method returns the maximal halflength in phi (first coordinate of local surface frame)*/
- double maxHalflengthPhi() const;
-
- /** This method returns the halflength in eta (second coordinate of local surface frame)*/
- double halflengthEta() const;
-
- /** This method returns the minimal halflength in X (first coordinate of local surface frame)*/
- double minHalflengthX() const;
-
- /** This method returns the maximal halflength in X (first coordinate of local surface frame)*/
- double maxHalflengthX() const;
+/**
+ @class TrapezoidBounds
+ Bounds for a trapezoidal, planar Surface.
- /** This method returns the halflength in Y (second coordinate of local surface frame)*/
- double halflengthY() const;
+ @image html TrapezoidalBounds.gif
+ <br>
+ @image html SCT_Trapezoid.gif
- /** This method returns the maximal extension on the local plane*/
- virtual double r() const override;
+ @todo can be speed optimized by calculating kappa/delta and caching it
- /** This method returns the opening angle alpha in point A (negative local phi) */
- double alpha() const;
-
- /** This method returns the opening angle beta in point B (positive local phi) */
- double beta() const;
-
- /** The orientation of the Trapezoid is according to the figure above,
- in words: the shorter of the two parallel sides of the trapezoid intersects
- with the negative @f$ y @f$ - axis of the local frame.
-
- <br>
- The cases are:<br>
- (0) @f$ y @f$ or @f$ x @f$ bounds are 0 || 0<br>
- (1) the local position is outside @f$ y @f$ bounds <br>
- (2) the local position is inside @f$ y @f$ bounds, but outside maximum @f$ x @f$ bounds <br>
- (3) the local position is inside @f$ y @f$ bounds AND inside minimum @f$ x @f$ bounds <br>
- (4) the local position is inside @f$ y @f$ bounds AND inside maximum @f$ x @f$ bounds, so that
- it depends on the @f$ eta @f$ coordinate
- (5) the local position fails test of (4) <br>
-
- The inside check is done using single equations of straight lines and one has to take care if a point
- lies on the positive @f$ x @f$ half area(I) or the negative one(II). Denoting @f$ |x_{min}| @f$ and
- @f$ | x_{max} | @f$ as \c minHalfX respectively \c maxHalfX, such as @f$ | y_{H} | @f$ as \c halfY,
- the equations for the straing lines in (I) and (II) can be written as:<br>
- <br>
- - (I): @f$ y = \kappa_{I} x + \delta_{I} @f$ <br>
- - (II): @f$ y = \kappa_{II} x + \delta_{II} @f$ ,<br>
- <br>
- where @f$ \kappa_{I} = - \kappa_{II} = 2 \frac{y_{H}}{x_{max} - x_{min}} @f$ <br>
- and @f$ \delta_{I} = \delta_{II} = - \frac{1}{2}\kappa_{I}(x_{max} + x_{min}) @f$ */
- virtual bool inside(const Vector2D& locpo, double tol1=0., double tol2=0.) const override;
- virtual bool inside(const Vector2D& locpo, const BoundaryCheck& bchk) const override;
-
- /** This method checks inside bounds in loc1
- - loc1/loc2 correspond to the natural coordinates of the surface
- - As loc1/loc2 are correlated the single check doesn't make sense :
- -> check is done on enclosing Rectangle ! */
-
- virtual bool insideLoc1(const Vector2D& locpo, double tol1=0.) const override;
-
- /** This method checks inside bounds in loc2
- - loc1/loc2 correspond to the natural coordinates of the surface
- - As loc1/loc2 are correlated the single check doesn't make sense :
- -> check is done on enclosing Rectangle ! */
- virtual bool insideLoc2(const Vector2D& locpo, double tol2=0.) const override;
-
-
- /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
- virtual double minDistance(const Vector2D& pos) const override;
-
- /** Return the vertices - or, the points of the extremas */
- virtual const std::vector< Vector2D > vertices() const override;
-
- /** Output Method for std::ostream */
- virtual std::ostream& dump(std::ostream& sl) const override;
-
- private:
- /** inside() method for a full symmetric trapezoid */
- bool insideFull(const Vector2D& locpo, double tol1=0., double tol2=0.) const;
-
- /** inside() method for the triangular exclude area for an arbitrary trapezoid */
- bool insideExclude(const Vector2D& locpo, double tol1=0., double tol2=0.) const;
-
- /** isAbove() method for checking whether a point lies above or under a straight line */
- bool isAbove(const Vector2D& locpo,
- double tol1,
- double tol2,
- double k,
- double d) const;
-
- std::vector<TDD_real_t> m_boundValues;
- TDD_real_t m_alpha;
- TDD_real_t m_beta;
+ */
+class TrapezoidBounds : public PlanarBounds
+{
+public:
+ /** @enum BoundValues - for readability */
+ enum BoundValues {
+ bv_minHalfX = 0,
+ bv_maxHalfX = 1,
+ bv_halfY = 2,
+ bv_length = 3
};
- inline TrapezoidBounds* TrapezoidBounds::clone() const { return new TrapezoidBounds(*this); }
-
- inline double TrapezoidBounds::minHalflengthX() const { return m_boundValues.at(TrapezoidBounds::bv_minHalfX); }
-
- inline double TrapezoidBounds::maxHalflengthX() const { return m_boundValues.at(TrapezoidBounds::bv_maxHalfX); }
-
- inline double TrapezoidBounds::halflengthY() const { return m_boundValues.at(TrapezoidBounds::bv_halfY); }
-
- inline double TrapezoidBounds::minHalflengthPhi() const { return minHalflengthX(); }
+ /** Default Constructor, needed for persistency*/
+ TrapezoidBounds();
- inline double TrapezoidBounds::maxHalflengthPhi() const { return maxHalflengthX(); }
+ /** Constructor for symmetric Trapezoid*/
+ TrapezoidBounds(double minhalex, double maxhalex, double haley);
- inline double TrapezoidBounds::halflengthEta() const { return halflengthY(); }
+ /** Constructor for arbitrary Trapezoid*/
+ TrapezoidBounds(double minhalex, double haley, double alpha, double beta);
- inline double TrapezoidBounds::alpha() const { return m_alpha; }
+ /** Copy constructor*/
+ TrapezoidBounds(const TrapezoidBounds& trabo);
- inline double TrapezoidBounds::beta() const { return m_beta; }
+ /** Destructor*/
+ virtual ~TrapezoidBounds();
- inline double TrapezoidBounds::r() const
- { return sqrt(m_boundValues.at(TrapezoidBounds::bv_maxHalfX)*m_boundValues.at(TrapezoidBounds::bv_maxHalfX)
- + m_boundValues.at(TrapezoidBounds::bv_halfY)*m_boundValues.at(TrapezoidBounds::bv_halfY)); }
+ /** Virtual constructor*/
+ virtual TrapezoidBounds*
+ clone() const override;
- inline bool TrapezoidBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
+ /** Return the type of the bounds for persistency */
+ virtual BoundsType
+ type() const override
{
- if(bchk.bcType==0) return TrapezoidBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
-
- // a fast FALSE
- double fabsY = fabs(locpo[Acts::eLOC_Y]);
- double max_ell = bchk.lCovariance(0,0) > bchk.lCovariance(1,1) ? bchk.lCovariance(0,0) :bchk.lCovariance(1,1);
- double limit = bchk.nSigmas*sqrt(max_ell);
- if (fabsY > ( m_boundValues.at(TrapezoidBounds::bv_halfY) + limit)) return false;
- // a fast FALSE
- double fabsX = fabs(locpo[Acts::eLOC_X]);
- if (fabsX > (m_boundValues.at(TrapezoidBounds::bv_maxHalfX) + limit)) return false;
- // a fast TRUE
- double min_ell = bchk.lCovariance(0,0) < bchk.lCovariance(1,1) ? bchk.lCovariance(0,0) : bchk.lCovariance(1,1);
- limit = bchk.nSigmas*sqrt(min_ell);
- if (fabsX < (m_boundValues.at(TrapezoidBounds::bv_minHalfX) + limit) && fabsY < (m_boundValues.at(TrapezoidBounds::bv_halfY) + limit)) return true;
-
- // compute KDOP and axes for surface polygon
- std::vector<KDOP> elementKDOP(3);
- std::vector<Vector2D> elementP(4);
- float theta = (bchk.lCovariance(1,0) != 0 && (bchk.lCovariance(1,1)-bchk.lCovariance(0,0))!=0 ) ? .5*bchk.FastArcTan( 2*bchk.lCovariance(1,0)/(bchk.lCovariance(1,1)-bchk.lCovariance(0,0)) ) : 0.;
- sincosCache scResult = bchk.FastSinCos(theta);
- ActsMatrixD<2,2> rotMatrix ;
- rotMatrix << scResult.cosC, scResult.sinC,
- -scResult.sinC, scResult.cosC;
- ActsMatrixD<2,2> normal ;
- normal << 0, -1,
- 1, 0;
- // ellipse is always at (0,0), surface is moved to ellipse position and then rotated
- Vector2D p;
- p << m_boundValues.at(TrapezoidBounds::bv_minHalfX),-m_boundValues.at(TrapezoidBounds::bv_halfY);
- elementP.at(0) =( rotMatrix * (p - locpo) );
- p << -m_boundValues.at(TrapezoidBounds::bv_minHalfX),-m_boundValues.at(TrapezoidBounds::bv_halfY);
- elementP.at(1) =( rotMatrix * (p - locpo) );
- scResult = bchk.FastSinCos(m_beta);
- p << m_boundValues.at(TrapezoidBounds::bv_minHalfX) + (2.*m_boundValues.at(TrapezoidBounds::bv_halfY))*(scResult.sinC/scResult.cosC),m_boundValues.at(TrapezoidBounds::bv_halfY);
- elementP.at(2) =( rotMatrix * (p - locpo) );
- scResult = bchk.FastSinCos(m_alpha);
- p << -(m_boundValues.at(TrapezoidBounds::bv_minHalfX) + (2.*m_boundValues[TrapezoidBounds::bv_halfY])*(scResult.sinC/scResult.cosC)),m_boundValues.at(TrapezoidBounds::bv_halfY);
- elementP.at(3) =( rotMatrix * (p - locpo) );
- std::vector<Vector2D> axis = {normal*(elementP.at(1)-elementP.at(0)), normal*(elementP.at(3)-elementP.at(1)), normal*(elementP.at(2)-elementP.at(0))};
- bchk.ComputeKDOP(elementP, axis, elementKDOP);
- // compute KDOP for error ellipse
- std::vector<KDOP> errelipseKDOP(3);
- bchk.ComputeKDOP(bchk.EllipseToPoly(3), axis, errelipseKDOP);
- // check if KDOPs overlap and return result
- return bchk.TestKDOPKDOP(elementKDOP, errelipseKDOP);
+ return SurfaceBounds::Trapezoid;
}
- inline bool TrapezoidBounds::insideLoc1(const Vector2D &locpo, double tol1) const
- { return (fabs(locpo[Acts::eLOC_X]) < m_boundValues.at(TrapezoidBounds::bv_maxHalfX) + tol1); }
-
- inline bool TrapezoidBounds::insideLoc2(const Vector2D &locpo, double tol2) const
- { return (fabs(locpo[Acts::eLOC_Y]) < m_boundValues.at(TrapezoidBounds::bv_halfY) + tol2); }
-
- inline const std::vector< Vector2D > TrapezoidBounds::vertices() const {
- // create the return vector
- std::vector< Vector2D > vertices;
- // fill the vertices
- vertices.reserve(4);
- vertices.push_back(Vector2D(m_boundValues.at(TrapezoidBounds::bv_minHalfX),-m_boundValues.at(TrapezoidBounds::bv_halfY))); // [0]
- vertices.push_back(Vector2D(m_boundValues.at(TrapezoidBounds::bv_maxHalfX), m_boundValues.at(TrapezoidBounds::bv_halfY))); // [1]
- vertices.push_back(Vector2D(-m_boundValues.at(TrapezoidBounds::bv_maxHalfX),m_boundValues.at(TrapezoidBounds::bv_halfY))); // [1]
- vertices.push_back(Vector2D(-m_boundValues.at(TrapezoidBounds::bv_minHalfX),-m_boundValues.at(TrapezoidBounds::bv_halfY))); // [3]
- return vertices;
-
- }
-
-} // end of namespace
-
-#endif // ACTS_SURFACES_TRAPEZOIDBOUNDS_H
-
+ /** Assignment operator*/
+ TrapezoidBounds&
+ operator=(const TrapezoidBounds& sbo);
+
+ /** Equality operator*/
+ virtual bool
+ operator==(const SurfaceBounds& trabo) const override;
+
+ /** This method returns the minimal halflength in phi (first coordinate of
+ * local surface frame)*/
+ double
+ minHalflengthPhi() const;
+
+ /** This method returns the maximal halflength in phi (first coordinate of
+ * local surface frame)*/
+ double
+ maxHalflengthPhi() const;
+
+ /** This method returns the halflength in eta (second coordinate of local
+ * surface frame)*/
+ double
+ halflengthEta() const;
+
+ /** This method returns the minimal halflength in X (first coordinate of local
+ * surface frame)*/
+ double
+ minHalflengthX() const;
+
+ /** This method returns the maximal halflength in X (first coordinate of local
+ * surface frame)*/
+ double
+ maxHalflengthX() const;
+
+ /** This method returns the halflength in Y (second coordinate of local
+ * surface frame)*/
+ double
+ halflengthY() const;
+
+ /** This method returns the maximal extension on the local plane*/
+ virtual double
+ r() const override;
+
+ /** This method returns the opening angle alpha in point A (negative local
+ * phi) */
+ double
+ alpha() const;
+
+ /** This method returns the opening angle beta in point B (positive local phi)
+ */
+ double
+ beta() const;
+
+ /** The orientation of the Trapezoid is according to the figure above,
+ in words: the shorter of the two parallel sides of the trapezoid intersects
+ with the negative @f$ y @f$ - axis of the local frame.
+
+ <br>
+ The cases are:<br>
+ (0) @f$ y @f$ or @f$ x @f$ bounds are 0 || 0<br>
+ (1) the local position is outside @f$ y @f$ bounds <br>
+ (2) the local position is inside @f$ y @f$ bounds, but outside maximum @f$ x
+ @f$ bounds <br>
+ (3) the local position is inside @f$ y @f$ bounds AND inside minimum @f$ x
+ @f$ bounds <br>
+ (4) the local position is inside @f$ y @f$ bounds AND inside maximum @f$ x
+ @f$ bounds, so that
+ it depends on the @f$ eta @f$ coordinate
+ (5) the local position fails test of (4) <br>
+
+ The inside check is done using single equations of straight lines and one has
+ to take care if a point
+ lies on the positive @f$ x @f$ half area(I) or the negative one(II). Denoting
+ @f$ |x_{min}| @f$ and
+ @f$ | x_{max} | @f$ as \c minHalfX respectively \c maxHalfX, such as @f$ |
+ y_{H} | @f$ as \c halfY,
+ the equations for the straing lines in (I) and (II) can be written as:<br>
+ <br>
+ - (I): @f$ y = \kappa_{I} x + \delta_{I} @f$ <br>
+ - (II): @f$ y = \kappa_{II} x + \delta_{II} @f$ ,<br>
+ <br>
+ where @f$ \kappa_{I} = - \kappa_{II} = 2 \frac{y_{H}}{x_{max} - x_{min}} @f$
+ <br>
+ and @f$ \delta_{I} = \delta_{II} = - \frac{1}{2}\kappa_{I}(x_{max} +
+ x_{min}) @f$ */
+ virtual bool
+ inside(const Vector2D& locpo,
+ double tol1 = 0.,
+ double tol2 = 0.) const override;
+ virtual bool
+ inside(const Vector2D& locpo, const BoundaryCheck& bchk) const override;
+
+ /** This method checks inside bounds in loc1
+ - loc1/loc2 correspond to the natural coordinates of the surface
+ - As loc1/loc2 are correlated the single check doesn't make sense :
+ -> check is done on enclosing Rectangle ! */
+
+ virtual bool
+ insideLoc1(const Vector2D& locpo, double tol1 = 0.) const override;
+
+ /** This method checks inside bounds in loc2
+ - loc1/loc2 correspond to the natural coordinates of the surface
+ - As loc1/loc2 are correlated the single check doesn't make sense :
+ -> check is done on enclosing Rectangle ! */
+ virtual bool
+ insideLoc2(const Vector2D& locpo, double tol2 = 0.) const override;
+
+ /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
+ virtual double
+ minDistance(const Vector2D& pos) const override;
+
+ /** Return the vertices - or, the points of the extremas */
+ virtual const std::vector<Vector2D>
+ vertices() const override;
+
+ /** Output Method for std::ostream */
+ virtual std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ /** inside() method for a full symmetric trapezoid */
+ bool
+ insideFull(const Vector2D& locpo, double tol1 = 0., double tol2 = 0.) const;
+
+ /** inside() method for the triangular exclude area for an arbitrary trapezoid
+ */
+ bool
+ insideExclude(const Vector2D& locpo,
+ double tol1 = 0.,
+ double tol2 = 0.) const;
+
+ /** isAbove() method for checking whether a point lies above or under a
+ * straight line */
+ bool
+ isAbove(const Vector2D& locpo, double tol1, double tol2, double k, double d)
+ const;
+
+ std::vector<TDD_real_t> m_boundValues;
+ TDD_real_t m_alpha;
+ TDD_real_t m_beta;
+};
+
+inline TrapezoidBounds*
+TrapezoidBounds::clone() const
+{
+ return new TrapezoidBounds(*this);
+}
+
+inline double
+TrapezoidBounds::minHalflengthX() const
+{
+ return m_boundValues.at(TrapezoidBounds::bv_minHalfX);
+}
+
+inline double
+TrapezoidBounds::maxHalflengthX() const
+{
+ return m_boundValues.at(TrapezoidBounds::bv_maxHalfX);
+}
+
+inline double
+TrapezoidBounds::halflengthY() const
+{
+ return m_boundValues.at(TrapezoidBounds::bv_halfY);
+}
+
+inline double
+TrapezoidBounds::minHalflengthPhi() const
+{
+ return minHalflengthX();
+}
+
+inline double
+TrapezoidBounds::maxHalflengthPhi() const
+{
+ return maxHalflengthX();
+}
+
+inline double
+TrapezoidBounds::halflengthEta() const
+{
+ return halflengthY();
+}
+
+inline double
+TrapezoidBounds::alpha() const
+{
+ return m_alpha;
+}
+
+inline double
+TrapezoidBounds::beta() const
+{
+ return m_beta;
+}
+
+inline double
+TrapezoidBounds::r() const
+{
+ return sqrt(m_boundValues.at(TrapezoidBounds::bv_maxHalfX)
+ * m_boundValues.at(TrapezoidBounds::bv_maxHalfX)
+ + m_boundValues.at(TrapezoidBounds::bv_halfY)
+ * m_boundValues.at(TrapezoidBounds::bv_halfY));
+}
+
+inline bool
+TrapezoidBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
+{
+ if (bchk.bcType == 0)
+ return TrapezoidBounds::inside(
+ locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
+
+ // a fast FALSE
+ double fabsY = fabs(locpo[Acts::eLOC_Y]);
+ double max_ell = bchk.lCovariance(0, 0) > bchk.lCovariance(1, 1)
+ ? bchk.lCovariance(0, 0)
+ : bchk.lCovariance(1, 1);
+ double limit = bchk.nSigmas * sqrt(max_ell);
+ if (fabsY > (m_boundValues.at(TrapezoidBounds::bv_halfY) + limit))
+ return false;
+ // a fast FALSE
+ double fabsX = fabs(locpo[Acts::eLOC_X]);
+ if (fabsX > (m_boundValues.at(TrapezoidBounds::bv_maxHalfX) + limit))
+ return false;
+ // a fast TRUE
+ double min_ell = bchk.lCovariance(0, 0) < bchk.lCovariance(1, 1)
+ ? bchk.lCovariance(0, 0)
+ : bchk.lCovariance(1, 1);
+ limit = bchk.nSigmas * sqrt(min_ell);
+ if (fabsX < (m_boundValues.at(TrapezoidBounds::bv_minHalfX) + limit)
+ && fabsY < (m_boundValues.at(TrapezoidBounds::bv_halfY) + limit))
+ return true;
+
+ // compute KDOP and axes for surface polygon
+ std::vector<KDOP> elementKDOP(3);
+ std::vector<Vector2D> elementP(4);
+ float theta = (bchk.lCovariance(1, 0) != 0
+ && (bchk.lCovariance(1, 1) - bchk.lCovariance(0, 0)) != 0)
+ ? .5
+ * bchk.FastArcTan(2 * bchk.lCovariance(1, 0)
+ / (bchk.lCovariance(1, 1) - bchk.lCovariance(0, 0)))
+ : 0.;
+ sincosCache scResult = bchk.FastSinCos(theta);
+ ActsMatrixD<2, 2> rotMatrix;
+ rotMatrix << scResult.cosC, scResult.sinC, -scResult.sinC, scResult.cosC;
+ ActsMatrixD<2, 2> normal;
+ normal << 0, -1, 1, 0;
+ // ellipse is always at (0,0), surface is moved to ellipse position and then
+ // rotated
+ Vector2D p;
+ p << m_boundValues.at(TrapezoidBounds::bv_minHalfX),
+ -m_boundValues.at(TrapezoidBounds::bv_halfY);
+ elementP.at(0) = (rotMatrix * (p - locpo));
+ p << -m_boundValues.at(TrapezoidBounds::bv_minHalfX),
+ -m_boundValues.at(TrapezoidBounds::bv_halfY);
+ elementP.at(1) = (rotMatrix * (p - locpo));
+ scResult = bchk.FastSinCos(m_beta);
+ p << m_boundValues.at(TrapezoidBounds::bv_minHalfX)
+ + (2. * m_boundValues.at(TrapezoidBounds::bv_halfY))
+ * (scResult.sinC / scResult.cosC),
+ m_boundValues.at(TrapezoidBounds::bv_halfY);
+ elementP.at(2) = (rotMatrix * (p - locpo));
+ scResult = bchk.FastSinCos(m_alpha);
+ p << -(m_boundValues.at(TrapezoidBounds::bv_minHalfX)
+ + (2. * m_boundValues[TrapezoidBounds::bv_halfY])
+ * (scResult.sinC / scResult.cosC)),
+ m_boundValues.at(TrapezoidBounds::bv_halfY);
+ elementP.at(3) = (rotMatrix * (p - locpo));
+ std::vector<Vector2D> axis = {normal * (elementP.at(1) - elementP.at(0)),
+ normal * (elementP.at(3) - elementP.at(1)),
+ normal * (elementP.at(2) - elementP.at(0))};
+ bchk.ComputeKDOP(elementP, axis, elementKDOP);
+ // compute KDOP for error ellipse
+ std::vector<KDOP> errelipseKDOP(3);
+ bchk.ComputeKDOP(bchk.EllipseToPoly(3), axis, errelipseKDOP);
+ // check if KDOPs overlap and return result
+ return bchk.TestKDOPKDOP(elementKDOP, errelipseKDOP);
+}
+
+inline bool
+TrapezoidBounds::insideLoc1(const Vector2D& locpo, double tol1) const
+{
+ return (fabs(locpo[Acts::eLOC_X])
+ < m_boundValues.at(TrapezoidBounds::bv_maxHalfX) + tol1);
+}
+
+inline bool
+TrapezoidBounds::insideLoc2(const Vector2D& locpo, double tol2) const
+{
+ return (fabs(locpo[Acts::eLOC_Y])
+ < m_boundValues.at(TrapezoidBounds::bv_halfY) + tol2);
+}
+
+inline const std::vector<Vector2D>
+TrapezoidBounds::vertices() const
+{
+ // create the return vector
+ std::vector<Vector2D> vertices;
+ // fill the vertices
+ vertices.reserve(4);
+ vertices.push_back(
+ Vector2D(m_boundValues.at(TrapezoidBounds::bv_minHalfX),
+ -m_boundValues.at(TrapezoidBounds::bv_halfY))); // [0]
+ vertices.push_back(
+ Vector2D(m_boundValues.at(TrapezoidBounds::bv_maxHalfX),
+ m_boundValues.at(TrapezoidBounds::bv_halfY))); // [1]
+ vertices.push_back(
+ Vector2D(-m_boundValues.at(TrapezoidBounds::bv_maxHalfX),
+ m_boundValues.at(TrapezoidBounds::bv_halfY))); // [1]
+ vertices.push_back(
+ Vector2D(-m_boundValues.at(TrapezoidBounds::bv_minHalfX),
+ -m_boundValues.at(TrapezoidBounds::bv_halfY))); // [3]
+ return vertices;
+}
+
+} // end of namespace
+
+#endif // ACTS_SURFACES_TRAPEZOIDBOUNDS_H
diff --git a/Core/include/ACTS/Surfaces/TriangleBounds.hpp b/Core/include/ACTS/Surfaces/TriangleBounds.hpp
index 51356d1cf..1f4dac565 100644
--- a/Core/include/ACTS/Surfaces/TriangleBounds.hpp
+++ b/Core/include/ACTS/Surfaces/TriangleBounds.hpp
@@ -13,193 +13,250 @@
#ifndef ACTS_SURFACESTRIANGLEBOUNDS_H
#define ACTS_SURFACESTRIANGLEBOUNDS_H
+#include <utility>
#include "ACTS/Surfaces/PlanarBounds.hpp"
-#include "ACTS/Utilities/ParameterDefinitions.hpp"
#include "ACTS/Utilities/Definitions.hpp"
-#include <utility>
+#include "ACTS/Utilities/ParameterDefinitions.hpp"
namespace Acts {
- /**
- @class TriangleBounds
-
- Bounds for a triangular, planar surface.
-
- @image html TriangularBounds.gif
- */
-
- class TriangleBounds : public PlanarBounds {
-
-
- public:
- /** @enum BoundValues for readability */
- enum BoundValues {
- bv_x1 = 0,
- bv_y1 = 1,
- bv_x2 = 2,
- bv_y2 = 3,
- bv_x3 = 4,
- bv_y3 = 5,
- bv_length = 6
- };
-
- /**Default Constructor - needed for persistency*/
- TriangleBounds();
-
- /**Constructor with coordinates of vertices - floats*/
- TriangleBounds( std::vector< std::pair<float,float> > );
-
- /**Constructor with coordinates of vertices - double*/
- TriangleBounds( std::vector< std::pair<double,double> > );
-
- /**Constructor from three 2 Vectors */
- TriangleBounds( const Vector2D& p1, const Vector2D& p2, const Vector2D& p3);
-
- /**Copy constructor*/
- TriangleBounds(const TriangleBounds& tribo);
-
- /**Destructor*/
- virtual ~TriangleBounds();
-
- /**Assignment Operator*/
- TriangleBounds& operator=(const TriangleBounds& recbo);
-
- /**Equality operator*/
- virtual bool operator==(const SurfaceBounds& sbo) const override;
-
- /**Virtual constructor*/
- virtual TriangleBounds* clone() const override;
-
- /** Return the type of the bounds for persistency */
- virtual BoundsType type() const override { return SurfaceBounds::Triangle; }
-
- /**This method checks if the provided local coordinates are inside the surface bounds*/
- virtual bool inside(const Vector2D &locpo, double tol1 = 0., double tol2 = 0.) const override;
- virtual bool inside(const Vector2D& locpo, const BoundaryCheck& bchk) const override;
+/**
+ @class TriangleBounds
+
+ Bounds for a triangular, planar surface.
+
+ @image html TriangularBounds.gif
+*/
+
+class TriangleBounds : public PlanarBounds
+{
+public:
+ /** @enum BoundValues for readability */
+ enum BoundValues {
+ bv_x1 = 0,
+ bv_y1 = 1,
+ bv_x2 = 2,
+ bv_y2 = 3,
+ bv_x3 = 4,
+ bv_y3 = 5,
+ bv_length = 6
+ };
- /** This method checks inside bounds in loc1
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc1(const Vector2D& locpo, double tol1=0.) const override;
+ /**Default Constructor - needed for persistency*/
+ TriangleBounds();
- /** This method checks inside bounds in loc2
- - loc1/loc2 correspond to the natural coordinates of the surface */
- virtual bool insideLoc2(const Vector2D& locpo, double tol2=0.) const override;
+ /**Constructor with coordinates of vertices - floats*/
+ TriangleBounds(std::vector<std::pair<float, float>>);
- /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
- virtual double minDistance(const Vector2D& pos) const override;
+ /**Constructor with coordinates of vertices - double*/
+ TriangleBounds(std::vector<std::pair<double, double>>);
- /**This method returns the coordinates of vertices */
- const std::vector< Vector2D > vertices() const override;
+ /**Constructor from three 2 Vectors */
+ TriangleBounds(const Vector2D& p1, const Vector2D& p2, const Vector2D& p3);
- /**This method returns the maximal extension on the local plane, i.e. @f$s\sqrt{h_{\phi}^2 + h_{\eta}^2}\f$*/
- virtual double r() const override;
+ /**Copy constructor*/
+ TriangleBounds(const TriangleBounds& tribo);
- /** Output Method for std::ostream */
- virtual std::ostream& dump(std::ostream& sl) const override;
+ /**Destructor*/
+ virtual ~TriangleBounds();
- private:
- std::vector<TDD_real_t> m_boundValues;
+ /**Assignment Operator*/
+ TriangleBounds&
+ operator=(const TriangleBounds& recbo);
- };
+ /**Equality operator*/
+ virtual bool
+ operator==(const SurfaceBounds& sbo) const override;
- inline TriangleBounds* TriangleBounds::clone() const
- { return new TriangleBounds(*this); }
-
- inline bool TriangleBounds::inside(const Vector2D &locpo, double tol1, double tol2) const {
- std::pair<double,double> locB(m_boundValues.at(TriangleBounds::bv_x2)-m_boundValues.at(TriangleBounds::bv_x1),
- m_boundValues.at(TriangleBounds::bv_y2)-m_boundValues.at(TriangleBounds::bv_y1));
- std::pair<double,double> locT(m_boundValues.at(TriangleBounds::bv_x3) -locpo[0],
- m_boundValues.at(TriangleBounds::bv_y3)-locpo[1]);
- std::pair<double,double> locV(m_boundValues.at(TriangleBounds::bv_x1) -locpo[0],
- m_boundValues.at(TriangleBounds::bv_y1)-locpo[1]);
-
- // special case :: third vertex ?
- if (locT.first*locT.first+locT.second*locT.second<tol1*tol1) return true;
-
- // special case : lies on base ?
- double db = locB.first*locV.second-locB.second*locV.first;
- if ( fabs(db)<tol1 ) {
- double a = (locB.first!=0) ? -locV.first/locB.first : -locV.second/locB.second;
- if ( a>-tol2 && a-1.<tol2 ) return true;
- return false;
- }
-
- double dn = locB.first*locT.second-locB.second*locT.first;
-
- if ( fabs(dn) > fabs(tol1) ) {
- double t = (locB.first*locV.second-locB.second*locV.first)/dn;
- if ( t > 0.) return false;
-
- double a = (locB.first!=0.) ? (t*locT.first - locV.first)/locB.first :
- (t*locT.second - locV.second)/locB.second ;
- if ( a < -tol2 || a-1.>tol2 ) return false;
- } else {
- return false;
- }
- return true;
- }
+ /**Virtual constructor*/
+ virtual TriangleBounds*
+ clone() const override;
- inline bool TriangleBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
+ /** Return the type of the bounds for persistency */
+ virtual BoundsType
+ type() const override
{
- if (bchk.bcType==0) return TriangleBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
-
- // a fast FALSE
- double fabsR = sqrt(locpo[Acts::eLOC_X]*locpo[Acts::eLOC_X]+locpo[Acts::eLOC_Y]*locpo[Acts::eLOC_Y]);
- double max_ell = bchk.lCovariance(0,0) > bchk.lCovariance(1,1) ? bchk.lCovariance(0,0) :bchk.lCovariance(1,1);
- double limit = bchk.nSigmas*sqrt(max_ell);
- double r_max = TriangleBounds::r();
- if (fabsR > ( r_max + limit)) return false;
-
- // compute KDOP and axes for surface polygon
- std::vector<KDOP> elementKDOP(3);
- std::vector<Vector2D> elementP(3);
- float theta = (bchk.lCovariance(1,0) != 0 && (bchk.lCovariance(1,1)-bchk.lCovariance(0,0))!=0 ) ? .5*bchk.FastArcTan( 2*bchk.lCovariance(1,0)/(bchk.lCovariance(1,1)-bchk.lCovariance(0,0)) ) : 0.;
- sincosCache scResult = bchk.FastSinCos(theta);
- ActsMatrixD<2,2> rotMatrix ;
- rotMatrix << scResult.cosC, scResult.sinC,
- -scResult.sinC, scResult.cosC;
- ActsMatrixD<2,2> normal ;
- normal << 0, -1,
- 1, 0;
- // ellipse is always at (0,0), surface is moved to ellipse position and then rotated
- Vector2D p;
- p << m_boundValues.at(TriangleBounds::bv_x1),m_boundValues.at(TriangleBounds::bv_y1);
- elementP.at(0) =( rotMatrix * (p - locpo) );
- p << m_boundValues.at(TriangleBounds::bv_x2),m_boundValues.at(TriangleBounds::bv_y2);
- elementP.at(1) =( rotMatrix * (p - locpo) );
- p << m_boundValues.at(TriangleBounds::bv_x3),m_boundValues.at(TriangleBounds::bv_y3);
- elementP.at(2) =( rotMatrix * (p - locpo) );
- std::vector<Vector2D> axis = {normal*(elementP.at(1)-elementP.at(0)), normal*(elementP.at(2)-elementP.at(1)), normal*(elementP.at(2)-elementP.at(0))};
- bchk.ComputeKDOP(elementP, axis, elementKDOP);
- // compute KDOP for error ellipse
- std::vector<KDOP> errelipseKDOP(3);
- bchk.ComputeKDOP(bchk.EllipseToPoly(3), axis, errelipseKDOP);
- // check if KDOPs overlap and return result
- return bchk.TestKDOPKDOP(elementKDOP, errelipseKDOP);
+ return SurfaceBounds::Triangle;
}
- inline bool TriangleBounds::insideLoc1(const Vector2D &locpo, double tol1) const
- { return inside(locpo,tol1,tol1); }
-
- inline bool TriangleBounds::insideLoc2(const Vector2D &locpo, double tol2) const
- { return inside(locpo,tol2,tol2); }
-
- inline const std::vector< Vector2D > TriangleBounds::vertices() const
- {
- std::vector< Vector2D > vertices;
- vertices.resize(3);
- for (size_t iv = 0; iv < 3 ; iv++)
- vertices.push_back(Vector2D(m_boundValues.at(2*iv),m_boundValues.at(2*iv+1)));
- return vertices;
- }
+ /**This method checks if the provided local coordinates are inside the surface
+ * bounds*/
+ virtual bool
+ inside(const Vector2D& locpo,
+ double tol1 = 0.,
+ double tol2 = 0.) const override;
+ virtual bool
+ inside(const Vector2D& locpo, const BoundaryCheck& bchk) const override;
+
+ /** This method checks inside bounds in loc1
+ - loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc1(const Vector2D& locpo, double tol1 = 0.) const override;
+
+ /** This method checks inside bounds in loc2
+ - loc1/loc2 correspond to the natural coordinates of the surface */
+ virtual bool
+ insideLoc2(const Vector2D& locpo, double tol2 = 0.) const override;
+
+ /** Minimal distance to boundary ( > 0 if outside and <=0 if inside) */
+ virtual double
+ minDistance(const Vector2D& pos) const override;
+
+ /**This method returns the coordinates of vertices */
+ const std::vector<Vector2D>
+ vertices() const override;
+
+ /**This method returns the maximal extension on the local plane, i.e.
+ * @f$s\sqrt{h_{\phi}^2 + h_{\eta}^2}\f$*/
+ virtual double
+ r() const override;
+
+ /** Output Method for std::ostream */
+ virtual std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ std::vector<TDD_real_t> m_boundValues;
+};
+
+inline TriangleBounds*
+TriangleBounds::clone() const
+{
+ return new TriangleBounds(*this);
+}
+
+inline bool
+TriangleBounds::inside(const Vector2D& locpo, double tol1, double tol2) const
+{
+ std::pair<double, double> locB(m_boundValues.at(TriangleBounds::bv_x2)
+ - m_boundValues.at(TriangleBounds::bv_x1),
+ m_boundValues.at(TriangleBounds::bv_y2)
+ - m_boundValues.at(TriangleBounds::bv_y1));
+ std::pair<double, double> locT(
+ m_boundValues.at(TriangleBounds::bv_x3) - locpo[0],
+ m_boundValues.at(TriangleBounds::bv_y3) - locpo[1]);
+ std::pair<double, double> locV(
+ m_boundValues.at(TriangleBounds::bv_x1) - locpo[0],
+ m_boundValues.at(TriangleBounds::bv_y1) - locpo[1]);
+
+ // special case :: third vertex ?
+ if (locT.first * locT.first + locT.second * locT.second < tol1 * tol1)
+ return true;
- inline double TriangleBounds::r() const {
- double rmax = 0.;
- for (size_t iv = 0; iv < 3 ; iv++)
- rmax = fmax(rmax, m_boundValues.at(2*iv)*m_boundValues.at(2*iv) + m_boundValues.at(2*iv+1)*m_boundValues.at(2*iv+1));
- return sqrt(rmax);
+ // special case : lies on base ?
+ double db = locB.first * locV.second - locB.second * locV.first;
+ if (fabs(db) < tol1) {
+ double a = (locB.first != 0) ? -locV.first / locB.first
+ : -locV.second / locB.second;
+ if (a > -tol2 && a - 1. < tol2) return true;
+ return false;
}
-} // end of namespace
+ double dn = locB.first * locT.second - locB.second * locT.first;
+
+ if (fabs(dn) > fabs(tol1)) {
+ double t = (locB.first * locV.second - locB.second * locV.first) / dn;
+ if (t > 0.) return false;
-#endif // ACTS_SURFACESRECTANGLEBOUNDS_H
+ double a = (locB.first != 0.)
+ ? (t * locT.first - locV.first) / locB.first
+ : (t * locT.second - locV.second) / locB.second;
+ if (a < -tol2 || a - 1. > tol2) return false;
+ } else {
+ return false;
+ }
+ return true;
+}
+
+inline bool
+TriangleBounds::inside(const Vector2D& locpo, const BoundaryCheck& bchk) const
+{
+ if (bchk.bcType == 0)
+ return TriangleBounds::inside(
+ locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
+
+ // a fast FALSE
+ double fabsR = sqrt(locpo[Acts::eLOC_X] * locpo[Acts::eLOC_X]
+ + locpo[Acts::eLOC_Y] * locpo[Acts::eLOC_Y]);
+ double max_ell = bchk.lCovariance(0, 0) > bchk.lCovariance(1, 1)
+ ? bchk.lCovariance(0, 0)
+ : bchk.lCovariance(1, 1);
+ double limit = bchk.nSigmas * sqrt(max_ell);
+ double r_max = TriangleBounds::r();
+ if (fabsR > (r_max + limit)) return false;
+
+ // compute KDOP and axes for surface polygon
+ std::vector<KDOP> elementKDOP(3);
+ std::vector<Vector2D> elementP(3);
+ float theta = (bchk.lCovariance(1, 0) != 0
+ && (bchk.lCovariance(1, 1) - bchk.lCovariance(0, 0)) != 0)
+ ? .5
+ * bchk.FastArcTan(2 * bchk.lCovariance(1, 0)
+ / (bchk.lCovariance(1, 1) - bchk.lCovariance(0, 0)))
+ : 0.;
+ sincosCache scResult = bchk.FastSinCos(theta);
+ ActsMatrixD<2, 2> rotMatrix;
+ rotMatrix << scResult.cosC, scResult.sinC, -scResult.sinC, scResult.cosC;
+ ActsMatrixD<2, 2> normal;
+ normal << 0, -1, 1, 0;
+ // ellipse is always at (0,0), surface is moved to ellipse position and then
+ // rotated
+ Vector2D p;
+ p << m_boundValues.at(TriangleBounds::bv_x1),
+ m_boundValues.at(TriangleBounds::bv_y1);
+ elementP.at(0) = (rotMatrix * (p - locpo));
+ p << m_boundValues.at(TriangleBounds::bv_x2),
+ m_boundValues.at(TriangleBounds::bv_y2);
+ elementP.at(1) = (rotMatrix * (p - locpo));
+ p << m_boundValues.at(TriangleBounds::bv_x3),
+ m_boundValues.at(TriangleBounds::bv_y3);
+ elementP.at(2) = (rotMatrix * (p - locpo));
+ std::vector<Vector2D> axis = {normal * (elementP.at(1) - elementP.at(0)),
+ normal * (elementP.at(2) - elementP.at(1)),
+ normal * (elementP.at(2) - elementP.at(0))};
+ bchk.ComputeKDOP(elementP, axis, elementKDOP);
+ // compute KDOP for error ellipse
+ std::vector<KDOP> errelipseKDOP(3);
+ bchk.ComputeKDOP(bchk.EllipseToPoly(3), axis, errelipseKDOP);
+ // check if KDOPs overlap and return result
+ return bchk.TestKDOPKDOP(elementKDOP, errelipseKDOP);
+}
+
+inline bool
+TriangleBounds::insideLoc1(const Vector2D& locpo, double tol1) const
+{
+ return inside(locpo, tol1, tol1);
+}
+
+inline bool
+TriangleBounds::insideLoc2(const Vector2D& locpo, double tol2) const
+{
+ return inside(locpo, tol2, tol2);
+}
+
+inline const std::vector<Vector2D>
+TriangleBounds::vertices() const
+{
+ std::vector<Vector2D> vertices;
+ vertices.resize(3);
+ for (size_t iv = 0; iv < 3; iv++)
+ vertices.push_back(
+ Vector2D(m_boundValues.at(2 * iv), m_boundValues.at(2 * iv + 1)));
+ return vertices;
+}
+
+inline double
+TriangleBounds::r() const
+{
+ double rmax = 0.;
+ for (size_t iv = 0; iv < 3; iv++)
+ rmax = fmax(rmax,
+ m_boundValues.at(2 * iv) * m_boundValues.at(2 * iv)
+ + m_boundValues.at(2 * iv + 1)
+ * m_boundValues.at(2 * iv + 1));
+ return sqrt(rmax);
+}
+
+} // end of namespace
+
+#endif // ACTS_SURFACESRECTANGLEBOUNDS_H
diff --git a/Core/include/ACTS/Tools/CylinderGeometryBuilder.hpp b/Core/include/ACTS/Tools/CylinderGeometryBuilder.hpp
index 52403510f..51d75c3c4 100644
--- a/Core/include/ACTS/Tools/CylinderGeometryBuilder.hpp
+++ b/Core/include/ACTS/Tools/CylinderGeometryBuilder.hpp
@@ -6,7 +6,7 @@
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
- ///////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////
// CylinderGeometryBuilder.h, ACTS project
///////////////////////////////////////////////////////////////////
@@ -14,75 +14,88 @@
#define ACTS_GEOMETRYTOOLS_TRACKINGGEOMETRYBUILDER_H 1
// STL include(s)
-#include <memory>
#include <list>
+#include <memory>
-#include "ACTS/Utilities/Definitions.hpp"
-#include "ACTS/Utilities/Logger.hpp"
#include "ACTS/Tools/ITrackingGeometryBuilder.hpp"
#include "ACTS/Tools/ITrackingVolumeBuilder.hpp"
#include "ACTS/Tools/ITrackingVolumeHelper.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Utilities/Logger.hpp"
-namespace Acts
-{
- class TrackingGeometry;
+namespace Acts {
+class TrackingGeometry;
- /** @class GeometryBuilder
+/** @class GeometryBuilder
- The Acts::TrackingGeometry Builder for volumes that wrap around another
+ The Acts::TrackingGeometry Builder for volumes that wrap around another
- It retrieves ITrackingVolumeBuilders as configured and builds one
- detector around the other one.
+ It retrieves ITrackingVolumeBuilders as configured and builds one
+ detector around the other one.
- */
+*/
- class CylinderGeometryBuilder : public ITrackingGeometryBuilder
+class CylinderGeometryBuilder : public ITrackingGeometryBuilder
+{
+public:
+ /** @struct Config
+ Configuration for the CylinderVolumeBuilder */
+ struct Config
{
- public:
- /** @struct Config
- Configuration for the CylinderVolumeBuilder */
- struct Config {
-
- std::shared_ptr<Logger> logger; //! logging instance
- std::shared_ptr<ITrackingVolumeBuilder> beamPipeBuilder; //!< a special builder for the beam pipe (for post-insertion)
- std::list<std::shared_ptr<ITrackingVolumeBuilder> > trackingVolumeBuilders; //!< the sub detector TrackingVolume builder
- std::shared_ptr<ITrackingVolumeHelper> trackingVolumeHelper; //!< used for creating a container
-
- Config() :
- logger(getDefaultLogger("CylinderGeometryBuilder",Logging::INFO)),
- beamPipeBuilder(nullptr),
- trackingVolumeBuilders(),
- trackingVolumeHelper(nullptr)
- {}
- };
-
- /** Constructor */
- CylinderGeometryBuilder(const Config& cgbConfig);
-
- /** Destructor */
- virtual ~CylinderGeometryBuilder() = default;
+ std::shared_ptr<Logger> logger; //! logging instance
+ std::shared_ptr<ITrackingVolumeBuilder> beamPipeBuilder; //!< a special
+ //!builder for the
+ //!beam pipe (for
+ //!post-insertion)
+ std::list<std::shared_ptr<ITrackingVolumeBuilder>>
+ trackingVolumeBuilders; //!< the sub detector TrackingVolume builder
+ std::shared_ptr<ITrackingVolumeHelper>
+ trackingVolumeHelper; //!< used for creating a container
+
+ Config()
+ : logger(getDefaultLogger("CylinderGeometryBuilder", Logging::INFO))
+ , beamPipeBuilder(nullptr)
+ , trackingVolumeBuilders()
+ , trackingVolumeHelper(nullptr)
+ {
+ }
+ };
- /** TrackingGeometry Interface method */
- virtual std::unique_ptr<TrackingGeometry> trackingGeometry() const override;
+ /** Constructor */
+ CylinderGeometryBuilder(const Config& cgbConfig);
- /** Set configuration method */
- void setConfiguration(const Config& cgbConfig);
+ /** Destructor */
+ virtual ~CylinderGeometryBuilder() = default;
- /** Get configuration method */
- Config getConfiguration() const;
+ /** TrackingGeometry Interface method */
+ virtual std::unique_ptr<TrackingGeometry>
+ trackingGeometry() const override;
- private:
- /** Configuration member */
- Config m_config;
+ /** Set configuration method */
+ void
+ setConfiguration(const Config& cgbConfig);
- const Logger& logger() const {return *m_config.logger;}
+ /** Get configuration method */
+ Config
+ getConfiguration() const;
- };
+private:
+ /** Configuration member */
+ Config m_config;
- inline CylinderGeometryBuilder::Config CylinderGeometryBuilder::getConfiguration() const
- { return m_config; }
+ const Logger&
+ logger() const
+ {
+ return *m_config.logger;
+ }
+};
-} // end of namespace
+inline CylinderGeometryBuilder::Config
+CylinderGeometryBuilder::getConfiguration() const
+{
+ return m_config;
+}
-#endif // ACTS_GEOMETRYTOOLS_TRACKINGGEOMETRYBUILDER_H
+} // end of namespace
+#endif // ACTS_GEOMETRYTOOLS_TRACKINGGEOMETRYBUILDER_H
diff --git a/Core/include/ACTS/Tools/CylinderVolumeBuilder.hpp b/Core/include/ACTS/Tools/CylinderVolumeBuilder.hpp
index b557112c8..c812643ca 100644
--- a/Core/include/ACTS/Tools/CylinderVolumeBuilder.hpp
+++ b/Core/include/ACTS/Tools/CylinderVolumeBuilder.hpp
@@ -14,113 +14,150 @@
#define ACTS_GEOMETRYTOOLS_CYLINDERVOLUMEBUILDER_H 1
// Geometry module
-#include "ACTS/Tools/ITrackingVolumeBuilder.hpp"
#include "ACTS/Material/Material.hpp"
-#include "ACTS/Tools/ITrackingVolumeHelper.hpp"
#include "ACTS/Tools/ILayerBuilder.hpp"
+#include "ACTS/Tools/ITrackingVolumeBuilder.hpp"
+#include "ACTS/Tools/ITrackingVolumeHelper.hpp"
#include "ACTS/Utilities/BinningType.hpp"
#include "ACTS/Utilities/Logger.hpp"
#ifndef ATAS_GEOMETRYTOOLS_TAKESMALLERBIGGER
#define ATAS_GEOMETRYTOOLS_TAKESMALLERBIGGER
-#define takeSmaller(current,test) current = current < test ? current : test
-#define takeBigger(current,test) current = current > test ? current : test
-#define takeSmallerBigger(cSmallest, cBiggest, test) takeSmaller(cSmallest, test); takeBigger(cBiggest, test)
+#define takeSmaller(current, test) current = current < test ? current : test
+#define takeBigger(current, test) current = current > test ? current : test
+#define takeSmallerBigger(cSmallest, cBiggest, test) \
+ takeSmaller(cSmallest, test); \
+ takeBigger(cBiggest, test)
#endif
namespace Acts {
- class TrackingVolume;
- class VolumeBounds;
-
- /** @ LayerSetup struct to understand the layer setup */
- struct LayerSetup {
-
- bool present; //!< layers are present
- BinningValue binningValue; //!< in what way they are binned
-
- std::pair<double,double> rBoundaries; //!< raidal boundaries
- std::pair<double,double> zBoundaries; //!< zBoundaries
-
- //std::vector<double> ringBoundaries; //!< ring boundaries if present //!< @TODO insert ring layout
- LayerSetup() :
- present(false),
- binningValue(binR),
- rBoundaries(std::pair<double,double>(10e10,-10e10)),
- zBoundaries(std::pair<double,double>(10e10,-10e10))
- {}
-
- /** Conversion operator to bool */
- operator bool() const { return present; }
-
- };
-
- /** @class CylinderVolumeBuilder
-
- A simple cylindrical volume builder to be used for building a concentrical cylindrical volume
- - a) configured volume
- - b) wrapping around a cylindrical/disk layer setup
-
- All are optionally wrapped around a given volume which has to by a cylinder volume
- and which has to be center at z == 0
-
- To receive the tracking volume it is possible to also hand over a triple of layers, which is a C++ tuple of three pointers to layer vectors (defined in the ITrackingVolumeBuilder). This functionality is needed for a possible translation of an geometry existing in another format. The first entry represents the layers of the negative endcap, the second the layers of the barrel and the third the layers of the positive endcap. If the one of these pointers is a nullptr no layers will be created for this volume
- Another functionality needed to translate an already existing geometry is to hand over a volume triple, which is a triple of shared pointers of volumes (defined in the ITrackingVolumeBuilder). The first entry contains the negative endcap volume, the second the barrel volume and the third one the positive endcap volume. This volumes are then used to get the internal boundaries of the current hierarchy.
-
- */
-
- class CylinderVolumeBuilder : public ITrackingVolumeBuilder{
- public:
- /** @struct Config
- Configuration struct for this CylinderVolumeBuilder */
- struct Config {
- std::shared_ptr<Logger> logger; //!< logging instance
- std::shared_ptr<ITrackingVolumeHelper> trackingVolumeHelper; //!< the tracking volume creator for container volume creation
- std::string volumeName; //!< the name of the volume to be created
- std::vector< double > volumeDimension; //!< The dimensions of the manually created world
- std::shared_ptr<Material> volumeMaterial; //!< the world material
- bool volumeToBeamPipe; //!< build the volume to the beam pipe
- std::shared_ptr<ILayerBuilder> layerBuilder; //!< needed to build layers within the volume
- double layerEnvelopeR; //!< the envelope covering the potential layers
- double layerEnvelopeZ; //!< the envelope covering the potential layers
- int volumeSignature; //!< the volume signature
-
- Config():
- logger(getDefaultLogger("CylinderVolumeBuilder",Logging::INFO))
- {}
- };
-
- /** Constructor */
- CylinderVolumeBuilder(const Config& cvbConfig);
-
- /** Destructor */
- virtual ~CylinderVolumeBuilder();
-
- /** CylinderVolumeBuilder interface method - returns the volumes of Volumes */
- TrackingVolumePtr trackingVolume(TrackingVolumePtr insideVolume = nullptr,
- VolumeBoundsPtr outsideBounds = nullptr,
- const LayerTriple* layerTriple = nullptr,
- const VolumeTriple* volumeTriple = nullptr) const override;
-
- /** Set configuration method */
- void setConfiguration(const Config& cvbConfig);
-
- /** Get configuration method */
- Config getConfiguration() const;
-
- private:
- /** Configuration struct */
- Config m_config;
-
- const Logger& logger() const {return *m_config.logger;}
- /** analyse the layer setup */
- LayerSetup analyzeLayerSetup(const LayerVector lVector) const;
-
+class TrackingVolume;
+class VolumeBounds;
+
+/** @ LayerSetup struct to understand the layer setup */
+struct LayerSetup
+{
+ bool present; //!< layers are present
+ BinningValue binningValue; //!< in what way they are binned
+
+ std::pair<double, double> rBoundaries; //!< raidal boundaries
+ std::pair<double, double> zBoundaries; //!< zBoundaries
+
+ // std::vector<double> ringBoundaries; //!< ring boundaries if
+ // present //!< @TODO insert ring layout
+ LayerSetup()
+ : present(false)
+ , binningValue(binR)
+ , rBoundaries(std::pair<double, double>(10e10, -10e10))
+ , zBoundaries(std::pair<double, double>(10e10, -10e10))
+ {
+ }
+
+ /** Conversion operator to bool */
+ operator bool() const { return present; }
+};
+
+/** @class CylinderVolumeBuilder
+
+ A simple cylindrical volume builder to be used for building a concentrical
+ cylindrical volume
+ - a) configured volume
+ - b) wrapping around a cylindrical/disk layer setup
+
+ All are optionally wrapped around a given volume which has to by a cylinder
+ volume
+ and which has to be center at z == 0
+
+ To receive the tracking volume it is possible to also hand over a triple of
+ layers, which is a C++ tuple of three pointers to layer vectors (defined in
+ the ITrackingVolumeBuilder). This functionality is needed for a possible
+ translation of an geometry existing in another format. The first entry
+ represents the layers of the negative endcap, the second the layers of the
+ barrel and the third the layers of the positive endcap. If the one of these
+ pointers is a nullptr no layers will be created for this volume
+ Another functionality needed to translate an already existing geometry is to
+ hand over a volume triple, which is a triple of shared pointers of volumes
+ (defined in the ITrackingVolumeBuilder). The first entry contains the
+ negative endcap volume, the second the barrel volume and the third one the
+ positive endcap volume. This volumes are then used to get the internal
+ boundaries of the current hierarchy.
+
+*/
+
+class CylinderVolumeBuilder : public ITrackingVolumeBuilder
+{
+public:
+ /** @struct Config
+ Configuration struct for this CylinderVolumeBuilder */
+ struct Config
+ {
+ std::shared_ptr<Logger> logger; //!< logging instance
+ std::shared_ptr<ITrackingVolumeHelper> trackingVolumeHelper; //!< the
+ //!tracking
+ //!volume
+ //!creator for
+ //!container
+ //!volume
+ //!creation
+ std::string volumeName; //!< the name of the volume to be created
+ std::vector<double>
+ volumeDimension; //!< The dimensions of the manually created world
+ std::shared_ptr<Material> volumeMaterial; //!< the world material
+ bool volumeToBeamPipe; //!< build the volume to the beam pipe
+ std::shared_ptr<ILayerBuilder>
+ layerBuilder; //!< needed to build layers within the volume
+ double layerEnvelopeR; //!< the envelope covering the potential layers
+ double layerEnvelopeZ; //!< the envelope covering the potential layers
+ int volumeSignature; //!< the volume signature
+
+ Config() : logger(getDefaultLogger("CylinderVolumeBuilder", Logging::INFO))
+ {
+ }
};
- /** Return the configuration object */
- inline CylinderVolumeBuilder::Config CylinderVolumeBuilder::getConfiguration() const { return m_config; }
-
-} // end of namespace
-
-#endif // ACTS_GEOMETRYINTERFACES_WORLDVOLUMEBUILDER_H
+ /** Constructor */
+ CylinderVolumeBuilder(const Config& cvbConfig);
+
+ /** Destructor */
+ virtual ~CylinderVolumeBuilder();
+
+ /** CylinderVolumeBuilder interface method - returns the volumes of Volumes */
+ TrackingVolumePtr
+ trackingVolume(TrackingVolumePtr insideVolume = nullptr,
+ VolumeBoundsPtr outsideBounds = nullptr,
+ const LayerTriple* layerTriple = nullptr,
+ const VolumeTriple* volumeTriple = nullptr) const override;
+
+ /** Set configuration method */
+ void
+ setConfiguration(const Config& cvbConfig);
+
+ /** Get configuration method */
+ Config
+ getConfiguration() const;
+
+private:
+ /** Configuration struct */
+ Config m_config;
+
+ const Logger&
+ logger() const
+ {
+ return *m_config.logger;
+ }
+ /** analyse the layer setup */
+ LayerSetup
+ analyzeLayerSetup(const LayerVector lVector) const;
+};
+
+/** Return the configuration object */
+inline CylinderVolumeBuilder::Config
+CylinderVolumeBuilder::getConfiguration() const
+{
+ return m_config;
+}
+
+} // end of namespace
+
+#endif // ACTS_GEOMETRYINTERFACES_WORLDVOLUMEBUILDER_H
diff --git a/Core/include/ACTS/Tools/CylinderVolumeHelper.hpp b/Core/include/ACTS/Tools/CylinderVolumeHelper.hpp
index e9e396c46..f0b95f5ce 100644
--- a/Core/include/ACTS/Tools/CylinderVolumeHelper.hpp
+++ b/Core/include/ACTS/Tools/CylinderVolumeHelper.hpp
@@ -15,169 +15,216 @@
#ifndef TRKDETDESCR_TAKESMALLERBIGGER
#define TRKDETDESCR_TAKESMALLERBIGGER
-#define takeSmaller(current,test) current = current < test ? current : test
-#define takeBigger(current,test) current = current > test ? current : test
-#define takeSmallerBigger(cSmallest, cBiggest, test) takeSmaller(cSmallest, test); takeBigger(cBiggest, test)
+#define takeSmaller(current, test) current = current < test ? current : test
+#define takeBigger(current, test) current = current > test ? current : test
+#define takeSmallerBigger(cSmallest, cBiggest, test) \
+ takeSmaller(cSmallest, test); \
+ takeBigger(cBiggest, test)
#endif
// Geometry module
-#include "ACTS/Tools/ITrackingVolumeHelper.hpp"
-#include "ACTS/Volumes/BoundarySurfaceFace.hpp"
#include "ACTS/Tools/ILayerArrayCreator.hpp"
#include "ACTS/Tools/ITrackingVolumeArrayCreator.hpp"
+#include "ACTS/Tools/ITrackingVolumeHelper.hpp"
#include "ACTS/Utilities/Logger.hpp"
+#include "ACTS/Volumes/BoundarySurfaceFace.hpp"
// STL
+#include <memory>
#include <string>
#include <vector>
-#include <memory>
-namespace Acts
-{
- class Layer;
- class TrackingVolume;
- class VolumeBounds;
- class CylinderVolumeBounds;
- class Material;
+namespace Acts {
+class Layer;
+class TrackingVolume;
+class VolumeBounds;
+class CylinderVolumeBounds;
+class Material;
- /** @class CylinderVolumeHelper
+/** @class CylinderVolumeHelper
- The concrete implementation for cylindrical TrackingVolume
- objects of the ITrackingVolumeCreator interface
+ The concrete implementation for cylindrical TrackingVolume
+ objects of the ITrackingVolumeCreator interface
- */
+*/
- class CylinderVolumeHelper : public ITrackingVolumeHelper
+class CylinderVolumeHelper : public ITrackingVolumeHelper
+{
+public:
+ /** @struct Config
+ Configuration struct for this CylinderVolumeHelper */
+ struct Config
{
- public:
- /** @struct Config
- Configuration struct for this CylinderVolumeHelper */
- struct Config {
- std::shared_ptr<Logger> logger; //!< logging instance
- std::shared_ptr<ILayerArrayCreator> layerArrayCreator; //!< A Tool for coherent LayerArray creation
- std::shared_ptr<ITrackingVolumeArrayCreator> trackingVolumeArrayCreator; //!< Helper Tool to create TrackingVolume Arrays
- double passiveLayerThickness; //!< thickness of passive layers
- int passiveLayerPhiBins; //!< bins in phi for the passive layer
- int passiveLayerRzBins; //!< bins in r/z for the passive layer
-
- Config() :
- logger(getDefaultLogger("CylinderVolumeHelper",Logging::INFO)),
- layerArrayCreator(nullptr),
- trackingVolumeArrayCreator(nullptr),
- passiveLayerThickness(1),
- passiveLayerPhiBins(1),
- passiveLayerRzBins(100)
- {}
- };
-
- /** Constructor */
- CylinderVolumeHelper(const Config& cvhConfig);
-
- /** Destructor */
- virtual ~CylinderVolumeHelper() = default;
-
- /** @copydoc ITrackingVolumeCreator::createTrackingVolume(const LayerVector&, std::shared_ptr<const Material> matprop, VolumeBounds*, Transform3D*,bool, const std::string&) const; */
- TrackingVolumePtr createTrackingVolume(const LayerVector& layers,
- std::shared_ptr<Material> matprop,
- VolumeBoundsPtr volBounds,
- std::shared_ptr<Transform3D> transform = nullptr,
- const std::string& volumeName = "UndefinedVolume",
- BinningType btype = arbitrary) const;
-
- /** @copydoc ITrackingVolumeCreator::createTrackingVolume(const std::vector<const Layer*>& , std::shared_ptr<const Material>, ,double,double,double,double,bool,const std::string&) const;
- */
- TrackingVolumePtr createTrackingVolume(const LayerVector& layers,
- std::shared_ptr<Material> matprop,
- double loc1Min, double loc1Max,
- double loc2Min, double loc2Max,
- const std::string& volumeName = "UndefinedVolume",
- BinningType btype = arbitrary) const;
-
- /** @copydoc ITrackingVolumeCreator::createGapTrackingVolume(std::shared_ptr<const Material>, double,double,double,double,int,bool,const std::string&) const; */
- TrackingVolumePtr createGapTrackingVolume(std::shared_ptr<Material> matprop,
- double rMin, double rMax,
- double zMin, double zMax,
- unsigned int materialLayers,
- bool cylinder = true,
- const std::string& volumeName = "UndefinedVolume") const;
-
- /** @copydoc ITrackingVolumeCreator::createGaoTrackingVolume(std::shared_ptr<const Material>,,std::vector<double>&,int,bool,const std::string&) const; */
- TrackingVolumePtr createGapTrackingVolume(std::shared_ptr<Material> matprop,
- 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;
-
- /** Create a container volumes from sub volumes, input volumes are ordered in R or Z by convention */
- TrackingVolumePtr createContainerTrackingVolume(const TrackingVolumeVector& volumes) const;
-
- /** Set configuration method */
- void setConfiguration(const Config& cvbConfig);
-
- /** Get configuration method */
- Config getConfiguration() const;
-
- protected:
- /** Configuration object */
- Config m_config;
-
- private:
- const Logger& logger() const {return *m_config.logger;}
- /** Private method - it estimates the CylinderBounds and Translation of layers,
- if given, these are checked against the layer positions/dimensions. */
- bool estimateAndCheckDimension(const LayerVector& layers,
- const Acts::CylinderVolumeBounds*& cylBounds,
- std::shared_ptr<Transform3D>& transform,
- double& rMinClean, double& rMaxClean,
- double& zMinClean, double& zMaxClean,
- BinningValue& bValue,
- BinningType bType = arbitrary) const;
-
- /** Private method - interglue all volumes contained by a TrackingVolume
- and set the outside glue volumes in the descriptor */
- bool interGlueTrackingVolume(TrackingVolumePtr tVolume,
- bool rBinned,
- double rMin, double rMax,
- double zMin, double zMax) const;
-
- /** Private method - glue volume to the other -- use trackingVolume helper */
- void glueTrackingVolumes(TrackingVolumePtr volumeOne,
- BoundarySurfaceFace faceOne,
- TrackingVolumePtr volumeTwo,
- BoundarySurfaceFace faceTwod,
- double rMin, double rMax,
- double zMin, double zMax) const;
-
-
- /** Private method - helper method not to duplicate code */
- void addFaceVolumes(TrackingVolumePtr tVolume,
- Acts::BoundarySurfaceFace bsf,
- TrackingVolumeVector& vols) const;
-
-
- /** Private method - helper method to save some code */
- LayerPtr createCylinderLayer(double z,
- double r,
- double halflength,
- double thickness,
- int binsPhi,
- int binsZ) const;
-
- /** Private method - helper method to save some code */
- LayerPtr createDiscLayer(double z,
- double rMin, double rMax,
- double thickness,
- int binsPhi,
- int binsR) const;
-
-
+ std::shared_ptr<Logger> logger; //!< logging instance
+ std::shared_ptr<ILayerArrayCreator>
+ layerArrayCreator; //!< A Tool for coherent LayerArray creation
+ std::shared_ptr<ITrackingVolumeArrayCreator>
+ trackingVolumeArrayCreator; //!< Helper Tool to create TrackingVolume
+ //!Arrays
+ double passiveLayerThickness; //!< thickness of passive layers
+ int passiveLayerPhiBins; //!< bins in phi for the passive layer
+ int passiveLayerRzBins; //!< bins in r/z for the passive layer
+
+ Config()
+ : logger(getDefaultLogger("CylinderVolumeHelper", Logging::INFO))
+ , layerArrayCreator(nullptr)
+ , trackingVolumeArrayCreator(nullptr)
+ , passiveLayerThickness(1)
+ , passiveLayerPhiBins(1)
+ , passiveLayerRzBins(100)
+ {
+ }
};
- /** Return the configuration object */
- inline CylinderVolumeHelper::Config CylinderVolumeHelper::getConfiguration() const { return m_config; }
+ /** Constructor */
+ CylinderVolumeHelper(const Config& cvhConfig);
+
+ /** Destructor */
+ virtual ~CylinderVolumeHelper() = default;
+
+ /** @copydoc ITrackingVolumeCreator::createTrackingVolume(const LayerVector&,
+ * std::shared_ptr<const Material> matprop, VolumeBounds*, Transform3D*,bool,
+ * const std::string&) const; */
+ TrackingVolumePtr
+ createTrackingVolume(const LayerVector& layers,
+ std::shared_ptr<Material> matprop,
+ VolumeBoundsPtr volBounds,
+ std::shared_ptr<Transform3D> transform = nullptr,
+ const std::string& volumeName = "UndefinedVolume",
+ BinningType btype = arbitrary) const;
+
+ /** @copydoc ITrackingVolumeCreator::createTrackingVolume(const
+ * std::vector<const Layer*>& , std::shared_ptr<const Material>,
+ * ,double,double,double,double,bool,const std::string&) const;
+ */
+ TrackingVolumePtr
+ createTrackingVolume(const LayerVector& layers,
+ std::shared_ptr<Material> matprop,
+ double loc1Min,
+ double loc1Max,
+ double loc2Min,
+ double loc2Max,
+ const std::string& volumeName = "UndefinedVolume",
+ BinningType btype = arbitrary) const;
+
+ /** @copydoc
+ * ITrackingVolumeCreator::createGapTrackingVolume(std::shared_ptr<const
+ * Material>, double,double,double,double,int,bool,const std::string&) const;
+ */
+ TrackingVolumePtr
+ createGapTrackingVolume(std::shared_ptr<Material> matprop,
+ double rMin,
+ double rMax,
+ double zMin,
+ double zMax,
+ unsigned int materialLayers,
+ bool cylinder = true,
+ const std::string& volumeName
+ = "UndefinedVolume") const;
+
+ /** @copydoc
+ * ITrackingVolumeCreator::createGaoTrackingVolume(std::shared_ptr<const
+ * Material>,,std::vector<double>&,int,bool,const std::string&) const; */
+ TrackingVolumePtr
+ createGapTrackingVolume(std::shared_ptr<Material> matprop,
+ 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;
+
+ /** Create a container volumes from sub volumes, input volumes are ordered in
+ * R or Z by convention */
+ TrackingVolumePtr
+ createContainerTrackingVolume(const TrackingVolumeVector& volumes) const;
+
+ /** Set configuration method */
+ void
+ setConfiguration(const Config& cvbConfig);
+
+ /** Get configuration method */
+ Config
+ getConfiguration() const;
+
+protected:
+ /** Configuration object */
+ Config m_config;
+
+private:
+ const Logger&
+ logger() const
+ {
+ return *m_config.logger;
+ }
+ /** Private method - it estimates the CylinderBounds and Translation of
+layers,
+if given, these are checked against the layer positions/dimensions. */
+ bool
+ estimateAndCheckDimension(const LayerVector& layers,
+ const Acts::CylinderVolumeBounds*& cylBounds,
+ std::shared_ptr<Transform3D>& transform,
+ double& rMinClean,
+ double& rMaxClean,
+ double& zMinClean,
+ double& zMaxClean,
+ BinningValue& bValue,
+ BinningType bType = arbitrary) const;
+
+ /** Private method - interglue all volumes contained by a TrackingVolume
+and set the outside glue volumes in the descriptor */
+ bool
+ interGlueTrackingVolume(TrackingVolumePtr tVolume,
+ bool rBinned,
+ double rMin,
+ double rMax,
+ double zMin,
+ double zMax) const;
+
+ /** Private method - glue volume to the other -- use trackingVolume helper */
+ void
+ glueTrackingVolumes(TrackingVolumePtr volumeOne,
+ BoundarySurfaceFace faceOne,
+ TrackingVolumePtr volumeTwo,
+ BoundarySurfaceFace faceTwod,
+ double rMin,
+ double rMax,
+ double zMin,
+ double zMax) const;
+
+ /** Private method - helper method not to duplicate code */
+ void
+ addFaceVolumes(TrackingVolumePtr tVolume,
+ Acts::BoundarySurfaceFace bsf,
+ TrackingVolumeVector& vols) const;
+
+ /** Private method - helper method to save some code */
+ LayerPtr
+ createCylinderLayer(double z,
+ double r,
+ double halflength,
+ double thickness,
+ int binsPhi,
+ int binsZ) const;
+
+ /** Private method - helper method to save some code */
+ LayerPtr
+ createDiscLayer(double z,
+ double rMin,
+ double rMax,
+ double thickness,
+ int binsPhi,
+ int binsR) const;
+};
+
+/** Return the configuration object */
+inline CylinderVolumeHelper::Config
+CylinderVolumeHelper::getConfiguration() const
+{
+ return m_config;
+}
}
#endif
-
diff --git a/Core/include/ACTS/Tools/ILayerArrayCreator.hpp b/Core/include/ACTS/Tools/ILayerArrayCreator.hpp
index a25d429ef..a1778ccc9 100644
--- a/Core/include/ACTS/Tools/ILayerArrayCreator.hpp
+++ b/Core/include/ACTS/Tools/ILayerArrayCreator.hpp
@@ -17,43 +17,41 @@
#include "ACTS/Utilities/BinnedArray.hpp"
#include "ACTS/Utilities/BinningType.hpp"
// STL
-#include <vector>
#include <memory>
+#include <vector>
+
+namespace Acts {
+/** forward declarations*/
+class Layer;
+typedef std::shared_ptr<const Layer> LayerPtr;
+
+/** @typedef LayerArray and LayerVector */
+typedef BinnedArray<LayerPtr> LayerArray;
+typedef std::vector<LayerPtr> LayerVector;
+
+/** @class ILayerArrayCreator
-namespace Acts
+ Interface class ILayerArrayCreators, it inherits from IAlgTool.
+
+ It receives the LayerVector and creaets an array with NaivgationLayer objects
+ filled in between.
+
+*/
+
+class ILayerArrayCreator
{
- /** forward declarations*/
- class Layer;
- typedef std::shared_ptr<const Layer> LayerPtr;
-
- /** @typedef LayerArray and LayerVector */
- typedef BinnedArray< LayerPtr > LayerArray;
- typedef std::vector< LayerPtr > LayerVector;
-
- /** @class ILayerArrayCreator
-
- Interface class ILayerArrayCreators, it inherits from IAlgTool.
-
- It receives the LayerVector and creaets an array with NaivgationLayer objects
- filled in between.
-
- */
-
- class ILayerArrayCreator
- {
- public:
- /**Virtual destructor*/
- virtual ~ILayerArrayCreator() = default;
-
- /** LayerArraycreator interface method */
- virtual std::unique_ptr<const LayerArray> layerArray(const LayerVector& layers,
- double min,
- double max,
- BinningType btype = arbitrary,
- BinningValue bv = binX) const = 0;
-
- };
-} // end of namespace
-
-
-#endif // ACTS_GEOMETRYINTERFACES_ILAYERARRAYCREATOR_H
+public:
+ /**Virtual destructor*/
+ virtual ~ILayerArrayCreator() = default;
+
+ /** LayerArraycreator interface method */
+ virtual std::unique_ptr<const LayerArray>
+ layerArray(const LayerVector& layers,
+ double min,
+ double max,
+ BinningType btype = arbitrary,
+ BinningValue bv = binX) const = 0;
+};
+} // end of namespace
+
+#endif // ACTS_GEOMETRYINTERFACES_ILAYERARRAYCREATOR_H
diff --git a/Core/include/ACTS/Tools/ILayerBuilder.hpp b/Core/include/ACTS/Tools/ILayerBuilder.hpp
index a2085d91d..1dcbc5c32 100644
--- a/Core/include/ACTS/Tools/ILayerBuilder.hpp
+++ b/Core/include/ACTS/Tools/ILayerBuilder.hpp
@@ -14,43 +14,45 @@
#define ACTS_GEOMETRYINTERFACES_ILAYERBUILDER_H 1
// STL
-#include <vector>
-#include <string>
#include <memory>
+#include <string>
+#include <vector>
namespace Acts {
- class Layer;
- typedef std::shared_ptr<const Layer> LayerPtr;
- typedef std::vector< LayerPtr > LayerVector;
-
- /** @class ILayerBuilder
-
- Interface class for ILayerBuilders in a typical
- | EC- | Central | EC+ |
- detector setup.
-
- */
- class ILayerBuilder
- {
- public:
- /**Virtual destructor*/
- virtual ~ILayerBuilder(){}
-
- /** LayerBuilder interface method - returning the layers at negative side */
- virtual const LayerVector negativeLayers() const = 0;
-
- /** LayerBuilder interface method - returning the central layers */
- virtual const LayerVector centralLayers() const = 0;
-
- /** LayerBuilder interface method - returning the layers at negative side */
- virtual const LayerVector positiveLayers() const = 0;
-
- /** Name identification */
- virtual const std::string& identification() const = 0;
-
- };
-
-} // end of namespace
-
-#endif // ACTS_GEOMETRYINTERFACES_ILAYERBUILDER_H
+class Layer;
+typedef std::shared_ptr<const Layer> LayerPtr;
+typedef std::vector<LayerPtr> LayerVector;
+
+/** @class ILayerBuilder
+
+ Interface class for ILayerBuilders in a typical
+ | EC- | Central | EC+ |
+ detector setup.
+
+ */
+class ILayerBuilder
+{
+public:
+ /**Virtual destructor*/
+ virtual ~ILayerBuilder() {}
+ /** LayerBuilder interface method - returning the layers at negative side */
+ virtual const LayerVector
+ negativeLayers() const = 0;
+
+ /** LayerBuilder interface method - returning the central layers */
+ virtual const LayerVector
+ centralLayers() const = 0;
+
+ /** LayerBuilder interface method - returning the layers at negative side */
+ virtual const LayerVector
+ positiveLayers() const = 0;
+
+ /** Name identification */
+ virtual const std::string&
+ identification() const = 0;
+};
+
+} // end of namespace
+
+#endif // ACTS_GEOMETRYINTERFACES_ILAYERBUILDER_H
diff --git a/Core/include/ACTS/Tools/ILayerCreator.hpp b/Core/include/ACTS/Tools/ILayerCreator.hpp
index 8f4e48ac7..1167282f7 100644
--- a/Core/include/ACTS/Tools/ILayerCreator.hpp
+++ b/Core/include/ACTS/Tools/ILayerCreator.hpp
@@ -1,11 +1,11 @@
-// This file is part of the ACTS project.
-//
-// Copyright (C) 2016 ACTS project team
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
+// This file is part of the ACTS project.
+//
+// Copyright (C) 2016 ACTS project team
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
///////////////////////////////////////////////////////////////////
// ILayerCreator.h, ACTS project
///////////////////////////////////////////////////////////////////
@@ -14,45 +14,53 @@
#define ACTS_GEOMETRYINTERFACES_ILAYERCREATOR_H 1
// STL
-#include <vector>
-#include <string>
#include <memory>
+#include <string>
+#include <vector>
namespace Acts {
- class Surface;
- class Layer;
- typedef std::shared_ptr<const Layer> LayerPtr;
-
- /** @class ILayerCreator
-
- Interface class for LayerCreator from DetectorElements
-
- */
- class ILayerCreator {
-
- public:
- /**Virtual destructor*/
- virtual ~ILayerCreator(){}
-
- /** ILayerCreator interface method - returning a cylindrical layer */
- virtual LayerPtr cylinderLayer(const std::vector<const Surface*>& surfaces,
- double envelopeR, double evelopeZ,
- size_t binsPhi, size_t binsZ) const = 0;
-
- /** ILayerCreator interface method - returning a disc layer */
- virtual LayerPtr discLayer(const std::vector<const Surface*>& surfaces,
- double envelopeMinR, double envelopeMaxR, double envelopeZ,
- size_t binsR, size_t binsPhi,
- const std::vector<double>& rBoundaries = {}) const = 0;
-
- /** ILayerCreator interface method - returning a plane layer */
- virtual LayerPtr planeLayer(const std::vector<const Surface*>& surfaces,
- double envelopeXY, double envelopeZ,
- size_t binsX, size_t binsY) const = 0;
-
- };
-
-} // end of namespace
-
-#endif // ACTS_GEOMETRYINTERFACES_ILAYERCREATOR_H
+class Surface;
+class Layer;
+typedef std::shared_ptr<const Layer> LayerPtr;
+
+/** @class ILayerCreator
+
+ Interface class for LayerCreator from DetectorElements
+
+ */
+class ILayerCreator
+{
+public:
+ /**Virtual destructor*/
+ virtual ~ILayerCreator() {}
+ /** ILayerCreator interface method - returning a cylindrical layer */
+ virtual LayerPtr
+ cylinderLayer(const std::vector<const Surface*>& surfaces,
+ double envelopeR,
+ double evelopeZ,
+ size_t binsPhi,
+ size_t binsZ) const = 0;
+
+ /** ILayerCreator interface method - returning a disc layer */
+ virtual LayerPtr
+ discLayer(const std::vector<const Surface*>& surfaces,
+ double envelopeMinR,
+ double envelopeMaxR,
+ double envelopeZ,
+ size_t binsR,
+ size_t binsPhi,
+ const std::vector<double>& rBoundaries = {}) const = 0;
+
+ /** ILayerCreator interface method - returning a plane layer */
+ virtual LayerPtr
+ planeLayer(const std::vector<const Surface*>& surfaces,
+ double envelopeXY,
+ double envelopeZ,
+ size_t binsX,
+ size_t binsY) const = 0;
+};
+
+} // end of namespace
+
+#endif // ACTS_GEOMETRYINTERFACES_ILAYERCREATOR_H
diff --git a/Core/include/ACTS/Tools/ISurfaceArrayCreator.hpp b/Core/include/ACTS/Tools/ISurfaceArrayCreator.hpp
index dd8569741..627edd1d2 100644
--- a/Core/include/ACTS/Tools/ISurfaceArrayCreator.hpp
+++ b/Core/include/ACTS/Tools/ISurfaceArrayCreator.hpp
@@ -21,45 +21,59 @@
namespace Acts {
- /** forward declarations & typedef */
- class Surface;
- typedef BinnedArray<const Surface*> SurfaceArray;
-
- /** @class ISurfaceArrayCreator
-
- Interface class ISurfaceArrayCreators, it inherits from IAlgTool.
-
- */
-
- class ISurfaceArrayCreator {
-
- public:
- /**Virtual destructor*/
- virtual ~ISurfaceArrayCreator(){}
+/** forward declarations & typedef */
+class Surface;
+typedef BinnedArray<const Surface*> SurfaceArray;
- /** SurfaceArrayCreator interface method - create an array in a cylinder, binned in phi, z */
- virtual std::unique_ptr<SurfaceArray> surfaceArrayOnCylinder(const std::vector<const Surface*>& surfaces,
- double R, double minPhi, double maxPhi, double halfZ,
- size_t binsPhi, size_t binsZ,
- std::shared_ptr<Transform3D> transform = nullptr) const = 0;
+/** @class ISurfaceArrayCreator
- /** SurfaceArrayCreator interface method - create an array on a disc, binned in r, phi */
- virtual std::unique_ptr<SurfaceArray> surfaceArrayOnDisc(const std::vector<const Surface*>& surfaces,
- double rMin, double rMax, double minPhi, double maxPhi,
- size_t binsR, size_t binsZ,
- const std::vector<double>& rBoundaries = {},
- std::shared_ptr<Transform3D> transform = nullptr) const = 0;
+ Interface class ISurfaceArrayCreators, it inherits from IAlgTool.
- /** SurfaceArrayCreator interface method - create an array on a plane */
- virtual std::unique_ptr<SurfaceArray> surfaceArrayOnPlane(const std::vector<const Surface*>& surfaces,
- double halflengthX, double halflengthY,
- size_t binsX, size_t binsY,
- std::shared_ptr<Transform3D> transform = nullptr) const = 0;
-
- };
+*/
+class ISurfaceArrayCreator
+{
+public:
+ /**Virtual destructor*/
+ virtual ~ISurfaceArrayCreator() {}
+ /** SurfaceArrayCreator interface method - create an array in a cylinder,
+ * binned in phi, z */
+ virtual std::unique_ptr<SurfaceArray>
+ surfaceArrayOnCylinder(const std::vector<const Surface*>& surfaces,
+ double R,
+ double minPhi,
+ double maxPhi,
+ double halfZ,
+ size_t binsPhi,
+ size_t binsZ,
+ std::shared_ptr<Transform3D> transform
+ = nullptr) const = 0;
-} // end of namespace
+ /** SurfaceArrayCreator interface method - create an array on a disc, binned
+ * in r, phi */
+ virtual std::unique_ptr<SurfaceArray>
+ surfaceArrayOnDisc(const std::vector<const Surface*>& surfaces,
+ double rMin,
+ double rMax,
+ double minPhi,
+ double maxPhi,
+ size_t binsR,
+ size_t binsZ,
+ const std::vector<double>& rBoundaries = {},
+ std::shared_ptr<Transform3D> transform
+ = nullptr) const = 0;
+ /** SurfaceArrayCreator interface method - create an array on a plane */
+ virtual std::unique_ptr<SurfaceArray>
+ surfaceArrayOnPlane(const std::vector<const Surface*>& surfaces,
+ double halflengthX,
+ double halflengthY,
+ size_t binsX,
+ size_t binsY,
+ std::shared_ptr<Transform3D> transform
+ = nullptr) const = 0;
+};
-#endif // ACTS_GEOMETRYINTERFACES_ISURFACEARRAYCREATOR_H
\ No newline at end of file
+} // end of namespace
+
+#endif // ACTS_GEOMETRYINTERFACES_ISURFACEARRAYCREATOR_H
\ No newline at end of file
diff --git a/Core/include/ACTS/Tools/ITrackingGeometryBuilder.hpp b/Core/include/ACTS/Tools/ITrackingGeometryBuilder.hpp
index df6cedf53..9036d11f5 100644
--- a/Core/include/ACTS/Tools/ITrackingGeometryBuilder.hpp
+++ b/Core/include/ACTS/Tools/ITrackingGeometryBuilder.hpp
@@ -13,33 +13,33 @@
#ifndef ACTS_GEOMETRYINTERFACES_ITRACKINGGEOMETRYBUILDER_H
#define ACTS_GEOMETRYINTERFACES_ITRACKINGGEOMETRYBUILDER_H 1
-#include<memory>
+#include <memory>
-namespace Acts
+namespace Acts {
+class TrackingGeometry;
+
+/** @class ITrackingGeometryBuilder
+
+ Interface class for the TrackingGeometry building,
+ this is used by the TrackingGeometrySvc to build the geoemtry.
+
+ The TrackingGeometry is written to the detector store and thus not created
+ as a std::shared_ptr.
+
+ The TrackingGeometry is returned as a non-const object in order to recreate
+ from conditions callback if necessary.
+
+ */
+class ITrackingGeometryBuilder
{
- class TrackingGeometry;
-
- /** @class ITrackingGeometryBuilder
-
- Interface class for the TrackingGeometry building,
- this is used by the TrackingGeometrySvc to build the geoemtry.
-
- The TrackingGeometry is written to the detector store and thus not created
- as a std::shared_ptr.
-
- The TrackingGeometry is returned as a non-const object in order to recreate
- from conditions callback if necessary.
-
- */
- class ITrackingGeometryBuilder
- {
- public:
- /**Virtual destructor*/
- virtual ~ITrackingGeometryBuilder() = default;
-
- /** TrackingGeometry Interface methode */
- virtual std::unique_ptr<TrackingGeometry> trackingGeometry() const = 0;
- };
-} // end of namespace
-
-#endif // ACTS_GEOMETRYINTERFACES_IGEOMETRYBUILDER_H
+public:
+ /**Virtual destructor*/
+ virtual ~ITrackingGeometryBuilder() = default;
+
+ /** TrackingGeometry Interface methode */
+ virtual std::unique_ptr<TrackingGeometry>
+ trackingGeometry() const = 0;
+};
+} // end of namespace
+
+#endif // ACTS_GEOMETRYINTERFACES_IGEOMETRYBUILDER_H
diff --git a/Core/include/ACTS/Tools/ITrackingVolumeArrayCreator.hpp b/Core/include/ACTS/Tools/ITrackingVolumeArrayCreator.hpp
index 646645b63..c78664656 100644
--- a/Core/include/ACTS/Tools/ITrackingVolumeArrayCreator.hpp
+++ b/Core/include/ACTS/Tools/ITrackingVolumeArrayCreator.hpp
@@ -17,43 +17,44 @@
#include "ACTS/Utilities/BinnedArray.hpp"
#include "ACTS/Utilities/BinningType.hpp"
// STL
-#include <vector>
#include <memory>
+#include <vector>
+
+namespace Acts {
+/** forward declarations*/
+class TrackingVolume;
+typedef std::shared_ptr<const TrackingVolume> TrackingVolumePtr;
+
+/** @typedef TrackingVolumeArray */
+typedef BinnedArray<TrackingVolumePtr> TrackingVolumeArray;
+typedef std::vector<TrackingVolumePtr> TrackingVolumeVector;
+
+/** @class ITrackingVolumeArrayCreator
-namespace Acts
+ Interface class ITrackingVolumeArrayCreators It inherits from IAlgTool.
+
+ It is designed to centralize the code to create
+ Arrays of Tracking Volumes for both:
+
+ - confinement in another TrackingVolume
+ - navigation and glueing
+
+ Arrays for glueing and confinement are often the same,
+ therefore the newly created TrackingVolumeArray is done by a shared_ptr
+
+ */
+class ITrackingVolumeArrayCreator
{
- /** forward declarations*/
- class TrackingVolume;
- typedef std::shared_ptr< const TrackingVolume > TrackingVolumePtr;
-
- /** @typedef TrackingVolumeArray */
- typedef BinnedArray< TrackingVolumePtr > TrackingVolumeArray;
- typedef std::vector< TrackingVolumePtr > TrackingVolumeVector;
-
- /** @class ITrackingVolumeArrayCreator
-
- Interface class ITrackingVolumeArrayCreators It inherits from IAlgTool.
-
- It is designed to centralize the code to create
- Arrays of Tracking Volumes for both:
-
- - confinement in another TrackingVolume
- - navigation and glueing
-
- Arrays for glueing and confinement are often the same,
- therefore the newly created TrackingVolumeArray is done by a shared_ptr
-
- */
- class ITrackingVolumeArrayCreator
- {
- public:
- /**Virtual destructor*/
- virtual ~ITrackingVolumeArrayCreator() = default;
-
- /** TrackingVolumeArrayCreator interface method - creates array depending on the binning type */
- virtual std::shared_ptr<const TrackingVolumeArray> trackingVolumeArray(const TrackingVolumeVector& vols, BinningValue bVal) const = 0;
- };
-} // end of namespace
+public:
+ /**Virtual destructor*/
+ virtual ~ITrackingVolumeArrayCreator() = default;
+
+ /** TrackingVolumeArrayCreator interface method - creates array depending on
+ * the binning type */
+ virtual std::shared_ptr<const TrackingVolumeArray>
+ trackingVolumeArray(const TrackingVolumeVector& vols,
+ BinningValue bVal) const = 0;
+};
+} // end of namespace
#endif
-
diff --git a/Core/include/ACTS/Tools/ITrackingVolumeBuilder.hpp b/Core/include/ACTS/Tools/ITrackingVolumeBuilder.hpp
index 7a25c6b42..522c9c349 100644
--- a/Core/include/ACTS/Tools/ITrackingVolumeBuilder.hpp
+++ b/Core/include/ACTS/Tools/ITrackingVolumeBuilder.hpp
@@ -13,49 +13,50 @@
#ifndef ACTS_GEOMETRYINTERFACES_ITRACKINGVOLUMEBUILDER_H
#define ACTS_GEOMETRYINTERFACES_ITRACKINGVOLUMEBUILDER_H 1
-#include <tuple>
#include <memory>
+#include <tuple>
#include <vector>
namespace Acts {
- class VolumeBounds;
- class TrackingVolume;
- class Layer;
- class Volume;
- typedef std::shared_ptr<const TrackingVolume> TrackingVolumePtr;
- typedef std::shared_ptr<const VolumeBounds> VolumeBoundsPtr;
- typedef std::shared_ptr<const Volume> VolumePtr;
- typedef std::shared_ptr<const Layer> LayerPtr;
- typedef std::vector< LayerPtr > LayerVector;
- typedef std::tuple< LayerVector, LayerVector, LayerVector > LayerTriple;
- typedef std::tuple< VolumePtr, VolumePtr, VolumePtr> VolumeTriple;
-
- /** @class ITrackingVolumeBuilder
-
- Interface class ITrackingVolumeBuilders & inherits from IAlgTool
-
- this returns the sub-detector tracking volume that is wrapped by the next outer one
- in the TrackingGeometry building process
-
- If an innerVolume is given, this is wrapped
- If a VolumeBounds object is given this defines the maximum extent.
-
- */
- class ITrackingVolumeBuilder
- {
-
- public:
- /**Virtual destructor*/
- virtual ~ITrackingVolumeBuilder() = default;
-
- /** TrackingVolumeBuilder interface method - returns the volumes of Volumes */
- virtual TrackingVolumePtr trackingVolume(TrackingVolumePtr insideVolume = nullptr,
- VolumeBoundsPtr outsideBounds = nullptr,
- const LayerTriple* layerTriple = nullptr,
- const VolumeTriple* volumeTriple = nullptr) const = 0;
- };
-
-} // end of namespace
-
-#endif // ACTS_GEOMETRYINTERFACES_IITRACKINGVOLUMEBUILDER_H
+class VolumeBounds;
+class TrackingVolume;
+class Layer;
+class Volume;
+typedef std::shared_ptr<const TrackingVolume> TrackingVolumePtr;
+typedef std::shared_ptr<const VolumeBounds> VolumeBoundsPtr;
+typedef std::shared_ptr<const Volume> VolumePtr;
+typedef std::shared_ptr<const Layer> LayerPtr;
+typedef std::vector<LayerPtr> LayerVector;
+typedef std::tuple<LayerVector, LayerVector, LayerVector> LayerTriple;
+typedef std::tuple<VolumePtr, VolumePtr, VolumePtr> VolumeTriple;
+
+/** @class ITrackingVolumeBuilder
+
+ Interface class ITrackingVolumeBuilders & inherits from IAlgTool
+
+ this returns the sub-detector tracking volume that is wrapped by the next
+ outer one
+ in the TrackingGeometry building process
+
+ If an innerVolume is given, this is wrapped
+ If a VolumeBounds object is given this defines the maximum extent.
+
+ */
+class ITrackingVolumeBuilder
+{
+public:
+ /**Virtual destructor*/
+ virtual ~ITrackingVolumeBuilder() = default;
+
+ /** TrackingVolumeBuilder interface method - returns the volumes of Volumes */
+ virtual TrackingVolumePtr
+ trackingVolume(TrackingVolumePtr insideVolume = nullptr,
+ VolumeBoundsPtr outsideBounds = nullptr,
+ const LayerTriple* layerTriple = nullptr,
+ const VolumeTriple* volumeTriple = nullptr) const = 0;
+};
+
+} // end of namespace
+
+#endif // ACTS_GEOMETRYINTERFACES_IITRACKINGVOLUMEBUILDER_H
diff --git a/Core/include/ACTS/Tools/ITrackingVolumeHelper.hpp b/Core/include/ACTS/Tools/ITrackingVolumeHelper.hpp
index 4878a9bd5..ca0ce959c 100644
--- a/Core/include/ACTS/Tools/ITrackingVolumeHelper.hpp
+++ b/Core/include/ACTS/Tools/ITrackingVolumeHelper.hpp
@@ -16,122 +16,131 @@
// Geometry module
#include "ACTS/Utilities/BinningType.hpp"
// Core module
+#include <memory>
#include <string>
#include <vector>
-#include <memory>
#include "ACTS/Utilities/Definitions.hpp"
namespace Acts {
- class Layer;
- class TrackingVolume;
- class VolumeBounds;
- class Material;
-
- typedef std::shared_ptr<const Layer> LayerPtr;
- typedef std::shared_ptr<const TrackingVolume> TrackingVolumePtr;
- typedef std::shared_ptr<const VolumeBounds> VolumeBoundsPtr;
-
- typedef std::vector< LayerPtr > LayerVector;
- typedef std::vector< TrackingVolumePtr > TrackingVolumeVector;
-
- /** @class ITrackingVolumeHelper
-
- Interface class ITrackingVolumeHelper tools, it inherits from IAlgTool.
- The ITrackingVolumeHelper is a tool to pack a set of layers into a volume,
- or - to wrap several volumes into a container volume.
-
- TrackingVolumes only exist as std::shared_ptr
-
- */
- class ITrackingVolumeHelper
- {
- public:
- /**Virtual destructor*/
- virtual ~ITrackingVolumeHelper() = default;
-
- /** create a TrackingVolume* from a set of layers and (optional) parameters
-
- @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 volBounds : (optional) bounds of this TrackingVolume - ownership given
- @param transform : (optional) placement of this TrackingVolume - ownership given
- @param entryLayers : switch to build entry layers
- @param volumeName : volume name to be given
- */
- virtual TrackingVolumePtr createTrackingVolume(const LayerVector& layers,
- std::shared_ptr<Material> matprop,
- VolumeBoundsPtr volBounds,
- std::shared_ptr<Transform3D> transform = nullptr,
- const std::string& volumeName = "UndefinedVolume",
- BinningType btype = arbitrary) const = 0;
-
- /** create a TrackingVolume* from a set of layers and (optional) parameters
-
- @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 loc1Min, loc1Max, loc2Min, loc2Max : local position in space,
- this TrackingVolume is restricted to Translation only
- @param volumeName : volume name to be given
- */
- virtual TrackingVolumePtr createTrackingVolume(const LayerVector& layers,
- std::shared_ptr<Material> matprop,
- double loc1Min, double loc1Max,
- double loc2Min, double loc2Max,
- const std::string& volumeName = "UndefinedVolume",
- BinningType btype = arbitrary) const = 0;
-
-
- /** create a gap volume from dimensions and
-
- @param matprop : dense material properties for this TrackingVolume
- @param loc1Min, loc1Max, loc2Min, loc2Max : local position in space,
- this TrackingVolume is restricted to Translation only
- @param materialLayers : number of material layers (aequidistant binning)
- @param cylinder : type of layers
- @param volumeName : volume name to be given
-
- */
- virtual TrackingVolumePtr createGapTrackingVolume(std::shared_ptr<Material> matprop,
- double loc1Min, double loc1Max,
- double loc2Min, double loc2Max,
- unsigned int materialLayers,
- bool cylinder = true,
- const std::string& volumeName = "UndefinedVolume") const = 0;
-
- /** create a gap volume from dimensions and
-
- @param matprop : dense material properties for this TrackingVolume
- @param layerPositions : custom layer positions
- @param materialLayers : number of material layers (aequidistant binning)
- @param cylinder : type of layers
- @param volumeName : volume name to be given
-
- */
- virtual TrackingVolumePtr createGapTrackingVolume(std::shared_ptr<Material> matprop,
- double loc1Min, double loc1Max,
- double loc2Min, double loc2Max,
- const std::vector<double>& layerPositions,
- bool cylinder = true,
- const std::string& volumeName = "UndefinedVolume",
- BinningType btype = arbitrary) const = 0;
-
- /** Create a one level higher TrackingVolue
-
- @param volumes : the volumes to be comnbined
- @param matprop : dense material properties for this TrackingVolume
- @param volumeName : volume name to be given
-
- */
- virtual TrackingVolumePtr createContainerTrackingVolume(const TrackingVolumeVector& volumes) const = 0;
-
-
- };
-
-} // end of namespace
-
-#endif // ACTS_GEOMETRYINTERFACES_ITRACKINGVOLUMECREATOR_H
+class Layer;
+class TrackingVolume;
+class VolumeBounds;
+class Material;
+
+typedef std::shared_ptr<const Layer> LayerPtr;
+typedef std::shared_ptr<const TrackingVolume> TrackingVolumePtr;
+typedef std::shared_ptr<const VolumeBounds> VolumeBoundsPtr;
+
+typedef std::vector<LayerPtr> LayerVector;
+typedef std::vector<TrackingVolumePtr> TrackingVolumeVector;
+
+/** @class ITrackingVolumeHelper
+
+ Interface class ITrackingVolumeHelper tools, it inherits from IAlgTool.
+ The ITrackingVolumeHelper is a tool to pack a set of layers into a volume,
+ or - to wrap several volumes into a container volume.
+
+ TrackingVolumes only exist as std::shared_ptr
+
+ */
+class ITrackingVolumeHelper
+{
+public:
+ /**Virtual destructor*/
+ virtual ~ITrackingVolumeHelper() = default;
+
+ /** create a TrackingVolume* from a set of layers and (optional) parameters
+
+@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 volBounds : (optional) bounds of this TrackingVolume - ownership given
+@param transform : (optional) placement of this TrackingVolume - ownership given
+@param entryLayers : switch to build entry layers
+@param volumeName : volume name to be given
+ */
+ virtual TrackingVolumePtr
+ createTrackingVolume(const LayerVector& layers,
+ std::shared_ptr<Material> matprop,
+ VolumeBoundsPtr volBounds,
+ std::shared_ptr<Transform3D> transform = nullptr,
+ const std::string& volumeName = "UndefinedVolume",
+ BinningType btype = arbitrary) const = 0;
+
+ /** create a TrackingVolume* from a set of layers and (optional) parameters
+
+@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 loc1Min, loc1Max, loc2Min, loc2Max : local position in space,
+this TrackingVolume is restricted to Translation only
+@param volumeName : volume name to be given
+ */
+ virtual TrackingVolumePtr
+ createTrackingVolume(const LayerVector& layers,
+ std::shared_ptr<Material> matprop,
+ double loc1Min,
+ double loc1Max,
+ double loc2Min,
+ double loc2Max,
+ const std::string& volumeName = "UndefinedVolume",
+ BinningType btype = arbitrary) const = 0;
+
+ /** create a gap volume from dimensions and
+
+@param matprop : dense material properties for this TrackingVolume
+@param loc1Min, loc1Max, loc2Min, loc2Max : local position in space,
+this TrackingVolume is restricted to Translation only
+@param materialLayers : number of material layers (aequidistant binning)
+@param cylinder : type of layers
+@param volumeName : volume name to be given
+
+ */
+ virtual TrackingVolumePtr
+ createGapTrackingVolume(std::shared_ptr<Material> matprop,
+ double loc1Min,
+ double loc1Max,
+ double loc2Min,
+ double loc2Max,
+ unsigned int materialLayers,
+ bool cylinder = true,
+ const std::string& volumeName
+ = "UndefinedVolume") const = 0;
+
+ /** create a gap volume from dimensions and
+
+@param matprop : dense material properties for this TrackingVolume
+@param layerPositions : custom layer positions
+@param materialLayers : number of material layers (aequidistant binning)
+@param cylinder : type of layers
+@param volumeName : volume name to be given
+
+ */
+ virtual TrackingVolumePtr
+ createGapTrackingVolume(std::shared_ptr<Material> matprop,
+ double loc1Min,
+ double loc1Max,
+ double loc2Min,
+ double loc2Max,
+ const std::vector<double>& layerPositions,
+ bool cylinder = true,
+ const std::string& volumeName = "UndefinedVolume",
+ BinningType btype = arbitrary) const = 0;
+
+ /** Create a one level higher TrackingVolue
+
+@param volumes : the volumes to be comnbined
+@param matprop : dense material properties for this TrackingVolume
+@param volumeName : volume name to be given
+
+ */
+ virtual TrackingVolumePtr
+ createContainerTrackingVolume(const TrackingVolumeVector& volumes) const = 0;
+};
+
+} // end of namespace
+
+#endif // ACTS_GEOMETRYINTERFACES_ITRACKINGVOLUMECREATOR_H
diff --git a/Core/include/ACTS/Tools/LayerArrayCreator.hpp b/Core/include/ACTS/Tools/LayerArrayCreator.hpp
index fd99713b7..524fd22fe 100644
--- a/Core/include/ACTS/Tools/LayerArrayCreator.hpp
+++ b/Core/include/ACTS/Tools/LayerArrayCreator.hpp
@@ -15,9 +15,11 @@
#ifndef TRKDETDESCR_TAKESMALLERBIGGER
#define TRKDETDESCR_TAKESMALLERBIGGER
-#define takeSmaller(current,test) current = current < test ? current : test
-#define takeBigger(current,test) current = current > test ? current : test
-#define takeSmallerBigger(cSmallest, cBiggest, test) takeSmaller(cSmallest, test); takeBigger(cBiggest, test)
+#define takeSmaller(current, test) current = current < test ? current : test
+#define takeBigger(current, test) current = current > test ? current : test
+#define takeSmallerBigger(cSmallest, cBiggest, test) \
+ takeSmaller(cSmallest, test); \
+ takeBigger(cBiggest, test)
#endif
// Core module
@@ -30,66 +32,77 @@
namespace Acts {
- class Surface;
- class Layer;
+class Surface;
+class Layer;
- /** @class LayerArrayCreator
+/** @class LayerArrayCreator
- The LayerArrayCreator is a simple Tool that helps to construct
- LayerArrays from std::vector of Acts::CylinderLayer, Acts::DiscLayer, Acts::PlaneLayer.
+ The LayerArrayCreator is a simple Tool that helps to construct
+ LayerArrays from std::vector of Acts::CylinderLayer, Acts::DiscLayer,
+ Acts::PlaneLayer.
- It fills the gaps automatically with Acts::NavigationLayer to be processed easily in the
- Navigation of the Extrapolation process.
+ It fills the gaps automatically with Acts::NavigationLayer to be processed
+ easily in the
+ Navigation of the Extrapolation process.
- @TODO Julia: make private tools private again after Gaudi update (bug in Gaudi), marked with //b
-
- */
+ @TODO Julia: make private tools private again after Gaudi update (bug in
+ Gaudi), marked with //b
+
+ */
+
+class LayerArrayCreator : public ILayerArrayCreator
+{
+public:
+ struct Config
+ {
+ std::shared_ptr<Logger> logger; //!< logging instance
- class LayerArrayCreator : public ILayerArrayCreator {
-
- public:
- struct Config
- {
- std::shared_ptr<Logger> logger; //!< logging instance
-
- Config():
- logger(getDefaultLogger("LayerArrayCreator",Logging::INFO))
- {}
- };
-
- /** Constructor */
- LayerArrayCreator(const Config& c):
- m_config(c)
- {}
-
- /** Destructor */
- virtual ~LayerArrayCreator() = default;
-
- /** LayerArraycreator interface method
- - we assume the layer thickness to be used together with the binning value */
- std::unique_ptr<const LayerArray> layerArray(const LayerVector& layers,
- double min,
- double max,
- BinningType btype = arbitrary,
- BinningValue bvalue = binX) const override;
-
- /** Set configuration method */
- void setConfiguration(const Config& c)
- {
- m_config = c;
- }
-
- /** Get configuration method */
- Config getConfiguration() const {return m_config;}
-
- private:
- const Logger& logger() const {return *m_config.logger;}
-
- Config m_config;
- Surface* createNavigationSurface(const Layer& layer, BinningValue bvalue, double offset) const;
- };
-
-} // end of namespace
-
-#endif // ACTS_GEOMETRYTOOLS_LAYERARRAYCREATOR_H
+ Config() : logger(getDefaultLogger("LayerArrayCreator", Logging::INFO)) {}
+ };
+ /** Constructor */
+ LayerArrayCreator(const Config& c) : m_config(c) {}
+ /** Destructor */
+ virtual ~LayerArrayCreator() = default;
+
+ /** LayerArraycreator interface method
+ - we assume the layer thickness to be used together with the binning value
+ */
+ std::unique_ptr<const LayerArray>
+ layerArray(const LayerVector& layers,
+ double min,
+ double max,
+ BinningType btype = arbitrary,
+ BinningValue bvalue = binX) const override;
+
+ /** Set configuration method */
+ void
+ setConfiguration(const Config& c)
+ {
+ m_config = c;
+ }
+
+ /** Get configuration method */
+ Config
+ getConfiguration() const
+ {
+ return m_config;
+ }
+
+private:
+ const Logger&
+ logger() const
+ {
+ return *m_config.logger;
+ }
+
+ Config m_config;
+ Surface*
+ createNavigationSurface(const Layer& layer,
+ BinningValue bvalue,
+ double offset) const;
+};
+
+} // end of namespace
+
+#endif // ACTS_GEOMETRYTOOLS_LAYERARRAYCREATOR_H
diff --git a/Core/include/ACTS/Tools/LayerCreator.hpp b/Core/include/ACTS/Tools/LayerCreator.hpp
index 3e2413ac5..1a782a585 100644
--- a/Core/include/ACTS/Tools/LayerCreator.hpp
+++ b/Core/include/ACTS/Tools/LayerCreator.hpp
@@ -20,82 +20,112 @@
#ifndef ACTS_LAYERCREATOR_TAKESMALLERBIGGER
#define ACTS_LAYERCREATOR_TAKESMALLERBIGGER
-#define takeSmaller(current,test) current = current < test ? current : test
-#define takeBigger(current,test) current = current > test ? current : test
-#define takeSmallerBigger(cSmallest, cBiggest, test) takeSmaller(cSmallest, test); takeBigger(cBiggest, test)
+#define takeSmaller(current, test) current = current < test ? current : test
+#define takeBigger(current, test) current = current > test ? current : test
+#define takeSmallerBigger(cSmallest, cBiggest, test) \
+ takeSmaller(cSmallest, test); \
+ takeBigger(cBiggest, test)
#endif
namespace Acts {
-
- class ISurfaceArrayCreator;
-
- /** @class LayerCreator
-
- The LayerCreator is able to build cylinde, disc layers or plane layers from detector elements
-
- */
-
- class LayerCreator : public ILayerCreator {
-
- public:
- /** @struct Config
- Configuration for the LayerCreator */
- struct Config {
- std::shared_ptr<Logger> logger; //!< logging instance
- std::shared_ptr<ISurfaceArrayCreator> surfaceArrayCreator; //!< geometry tool binning the surfaces into arrays
-
- Config() :
- logger(getDefaultLogger("LayerCreator",Logging::INFO)),
- surfaceArrayCreator(nullptr)
- {}
- };
- /** constructor */
- LayerCreator(const Config& lcConfig);
-
- /** destructor */
- ~LayerCreator() = default;
-
- /** ILayerCreator interface method - returning a cylindrical layer */
- LayerPtr cylinderLayer(const std::vector<const Surface*>& surfaces,
- double envelopeR, double evelopeZ,
- size_t binsPhi, size_t binsZ) const override;
-
- /** ILayerCreator interface method - returning a disc layer */
- LayerPtr discLayer(const std::vector<const Surface*>& surfaces,
- double envelopeMinR, double envelopeMaxR, double envelopeZ,
- size_t binsR, size_t binsZ,
- const std::vector<double>& rBoundaries = {}) const override;
-
- /** ILayerCreator interface method - returning a plane layer */
- LayerPtr planeLayer(const std::vector<const Surface*>& surfaces,
- double envelopeXY, double envelopeZ,
- size_t binMultiplierX, size_t binMultiplierY) const override;
-
- /* set the configuration object**/
- void setConfiguration(const Config& lcConfig);
- /** access th configuration object */
- Config getConfiguration() const;
-
- private:
-
- /** method to get the global extends in space for the module */
- void moduleExtend(const Surface& sf,
- double& minR, double& maxR,
- double& minPhi, double& maxPhi,
- double& minZ, double& maxZ) const;
-
- /** calculates the closest radial distance of a line */
- double radialDistance(const Vector3D& pos1, const Vector3D& pos2) const;
-
- /** configuration object */
- Config m_config;
- const Logger& logger() const {return *m_config.logger;}
-
- };
-
- inline LayerCreator::Config LayerCreator::getConfiguration() const
- { return m_config; }
-
-} //end of namespace
-
-#endif // ACTS_GEOMETRYTOOLS_LAYERCREATOR_H
+
+class ISurfaceArrayCreator;
+
+/** @class LayerCreator
+
+ The LayerCreator is able to build cylinde, disc layers or plane layers from
+ detector elements
+
+ */
+
+class LayerCreator : public ILayerCreator
+{
+public:
+ /** @struct Config
+ Configuration for the LayerCreator */
+ struct Config
+ {
+ std::shared_ptr<Logger> logger; //!< logging instance
+ std::shared_ptr<ISurfaceArrayCreator> surfaceArrayCreator; //!< geometry
+ //!tool binning
+ //!the surfaces
+ //!into arrays
+
+ Config()
+ : logger(getDefaultLogger("LayerCreator", Logging::INFO))
+ , surfaceArrayCreator(nullptr)
+ {
+ }
+ };
+ /** constructor */
+ LayerCreator(const Config& lcConfig);
+
+ /** destructor */
+ ~LayerCreator() = default;
+
+ /** ILayerCreator interface method - returning a cylindrical layer */
+ LayerPtr
+ cylinderLayer(const std::vector<const Surface*>& surfaces,
+ double envelopeR,
+ double evelopeZ,
+ size_t binsPhi,
+ size_t binsZ) const override;
+
+ /** ILayerCreator interface method - returning a disc layer */
+ LayerPtr
+ discLayer(const std::vector<const Surface*>& surfaces,
+ double envelopeMinR,
+ double envelopeMaxR,
+ double envelopeZ,
+ size_t binsR,
+ size_t binsZ,
+ const std::vector<double>& rBoundaries = {}) const override;
+
+ /** ILayerCreator interface method - returning a plane layer */
+ LayerPtr
+ planeLayer(const std::vector<const Surface*>& surfaces,
+ double envelopeXY,
+ double envelopeZ,
+ size_t binMultiplierX,
+ size_t binMultiplierY) const override;
+
+ /* set the configuration object**/
+ void
+ setConfiguration(const Config& lcConfig);
+ /** access th configuration object */
+ Config
+ getConfiguration() const;
+
+private:
+ /** method to get the global extends in space for the module */
+ void
+ moduleExtend(const Surface& sf,
+ double& minR,
+ double& maxR,
+ double& minPhi,
+ double& maxPhi,
+ double& minZ,
+ double& maxZ) const;
+
+ /** calculates the closest radial distance of a line */
+ double
+ radialDistance(const Vector3D& pos1, const Vector3D& pos2) const;
+
+ /** configuration object */
+ Config m_config;
+ const Logger&
+ logger() const
+ {
+ return *m_config.logger;
+ }
+};
+
+inline LayerCreator::Config
+LayerCreator::getConfiguration() const
+{
+ return m_config;
+}
+
+} // end of namespace
+
+#endif // ACTS_GEOMETRYTOOLS_LAYERCREATOR_H
diff --git a/Core/include/ACTS/Tools/PassiveLayerBuilder.hpp b/Core/include/ACTS/Tools/PassiveLayerBuilder.hpp
index 354d98688..292277385 100644
--- a/Core/include/ACTS/Tools/PassiveLayerBuilder.hpp
+++ b/Core/include/ACTS/Tools/PassiveLayerBuilder.hpp
@@ -14,102 +14,135 @@
#define ACTS_GEOMETRYTOOLS_PASSIVELAYERBUILDER_H 1
// Geoemtry module
-#include "ACTS/Tools/ILayerBuilder.hpp"
#include "ACTS/Layers/Layer.hpp"
+#include "ACTS/Tools/ILayerBuilder.hpp"
#include "ACTS/Utilities/Logger.hpp"
namespace Acts {
- /** @class PassiveLayerBuilder
-
- The PassiveLayerBuilder is able to build cylinder & disc layers with given detector
-
- @TODO Julia: make private tools private again after Gaudi update (bug in Gaudi), marked with //b
-
- */
-
- class PassiveLayerBuilder : public ILayerBuilder {
-
- public:
- /** @struct Config
- Configuration struct for the passive layer builder */
- struct Config {
- std::shared_ptr<Logger> logger; //!< logging instance
- std::string layerIdentification;
-
- std::vector<double> centralLayerRadii;
- std::vector<double> centralLayerHalflengthZ;
- std::vector<double> centralLayerThickness;
- std::vector<double> centralLayerMaterialX0;
- std::vector<double> centralLayerMaterialL0;
- std::vector<double> centralLayerMaterialA;
- std::vector<double> centralLayerMaterialZ;
- std::vector<double> centralLayerMaterialRho;
-
- // the layers at p/e side
- std::vector<double> posnegLayerPositionZ;
- std::vector<double> posnegLayerRmin;
- std::vector<double> posnegLayerRmax;
- std::vector<double> posnegLayerThickness;
- std::vector<double> posnegLayerMaterialX0;
- std::vector<double> posnegLayerMaterialL0;
- std::vector<double> posnegLayerMaterialA;
- std::vector<double> posnegLayerMaterialZ;
- std::vector<double> posnegLayerMaterialRho;
-
- Config():
- logger(getDefaultLogger("PassiveLayerBuilder",Logging::INFO))
- {}
- };
-
- /** constructor */
- PassiveLayerBuilder(const Config& plConfig);
-
- /** destructor */
- virtual ~PassiveLayerBuilder() = default;
-
- /** LayerBuilder interface method - returning the layers at negative side */
- const LayerVector negativeLayers() const override;
-
- /** LayerBuilder interface method - returning the central layers */
- const LayerVector centralLayers() const override;
-
- /** LayerBuilder interface method - returning the layers at negative side */
- const LayerVector positiveLayers() const override;
-
- /**ILayerBuilder method*/
- const std::string& identification() const override { return m_config.layerIdentification; }
-
- /** Set configuration method */
- void setConfiguration(const Config& meConfig);
-
- /** Get configuration method */
- Config getConfiguration() const;
-
- protected:
- Config m_config; //!< configuration
-
- private:
-
- const Logger& logger() const {return *m_config.logger;}
- bool constructLayers() const;
-
- mutable LayerVector m_nLayers; //!< layers on negative side
- mutable LayerVector m_cLayers; //!< layers on central side
- mutable LayerVector m_pLayers; //!< layers on positive side
-
- mutable bool m_constructionFlag; //!< indicator if the layer construction has been done already
-
+/** @class PassiveLayerBuilder
+
+ The PassiveLayerBuilder is able to build cylinder & disc layers with given
+ detector
+
+ @TODO Julia: make private tools private again after Gaudi update (bug in
+ Gaudi), marked with //b
+
+*/
+
+class PassiveLayerBuilder : public ILayerBuilder
+{
+public:
+ /** @struct Config
+ Configuration struct for the passive layer builder */
+ struct Config
+ {
+ std::shared_ptr<Logger> logger; //!< logging instance
+ std::string layerIdentification;
+
+ std::vector<double> centralLayerRadii;
+ std::vector<double> centralLayerHalflengthZ;
+ std::vector<double> centralLayerThickness;
+ std::vector<double> centralLayerMaterialX0;
+ std::vector<double> centralLayerMaterialL0;
+ std::vector<double> centralLayerMaterialA;
+ std::vector<double> centralLayerMaterialZ;
+ std::vector<double> centralLayerMaterialRho;
+
+ // the layers at p/e side
+ std::vector<double> posnegLayerPositionZ;
+ std::vector<double> posnegLayerRmin;
+ std::vector<double> posnegLayerRmax;
+ std::vector<double> posnegLayerThickness;
+ std::vector<double> posnegLayerMaterialX0;
+ std::vector<double> posnegLayerMaterialL0;
+ std::vector<double> posnegLayerMaterialA;
+ std::vector<double> posnegLayerMaterialZ;
+ std::vector<double> posnegLayerMaterialRho;
+
+ Config() : logger(getDefaultLogger("PassiveLayerBuilder", Logging::INFO)) {}
};
- inline PassiveLayerBuilder::Config PassiveLayerBuilder::getConfiguration() const { return m_config; }
-
- inline const LayerVector PassiveLayerBuilder::positiveLayers() const { if(not m_constructionFlag) constructLayers(); return m_pLayers; }
-
- inline const LayerVector PassiveLayerBuilder::negativeLayers() const { if(not m_constructionFlag) constructLayers(); return m_nLayers; }
-
- inline const LayerVector PassiveLayerBuilder::centralLayers() const { if(not m_constructionFlag) constructLayers(); return m_cLayers; }
-
-} //end of namespace
-
-#endif // ACTS_GEOMETRYTOOLS_PASSIVELAYERBUILDER_H
+ /** constructor */
+ PassiveLayerBuilder(const Config& plConfig);
+
+ /** destructor */
+ virtual ~PassiveLayerBuilder() = default;
+
+ /** LayerBuilder interface method - returning the layers at negative side */
+ const LayerVector
+ negativeLayers() const override;
+
+ /** LayerBuilder interface method - returning the central layers */
+ const LayerVector
+ centralLayers() const override;
+
+ /** LayerBuilder interface method - returning the layers at negative side */
+ const LayerVector
+ positiveLayers() const override;
+
+ /**ILayerBuilder method*/
+ const std::string&
+ identification() const override
+ {
+ return m_config.layerIdentification;
+ }
+
+ /** Set configuration method */
+ void
+ setConfiguration(const Config& meConfig);
+
+ /** Get configuration method */
+ Config
+ getConfiguration() const;
+
+protected:
+ Config m_config; //!< configuration
+
+private:
+ const Logger&
+ logger() const
+ {
+ return *m_config.logger;
+ }
+ bool
+ constructLayers() const;
+
+ mutable LayerVector m_nLayers; //!< layers on negative side
+ mutable LayerVector m_cLayers; //!< layers on central side
+ mutable LayerVector m_pLayers; //!< layers on positive side
+
+ mutable bool m_constructionFlag; //!< indicator if the layer construction has
+ //!been done already
+};
+
+inline PassiveLayerBuilder::Config
+PassiveLayerBuilder::getConfiguration() const
+{
+ return m_config;
+}
+
+inline const LayerVector
+PassiveLayerBuilder::positiveLayers() const
+{
+ if (not m_constructionFlag) constructLayers();
+ return m_pLayers;
+}
+
+inline const LayerVector
+PassiveLayerBuilder::negativeLayers() const
+{
+ if (not m_constructionFlag) constructLayers();
+ return m_nLayers;
+}
+
+inline const LayerVector
+PassiveLayerBuilder::centralLayers() const
+{
+ if (not m_constructionFlag) constructLayers();
+ return m_cLayers;
+}
+
+} // end of namespace
+
+#endif // ACTS_GEOMETRYTOOLS_PASSIVELAYERBUILDER_H
diff --git a/Core/include/ACTS/Tools/SurfaceArrayCreator.hpp b/Core/include/ACTS/Tools/SurfaceArrayCreator.hpp
index efaa7554a..82ef782f2 100644
--- a/Core/include/ACTS/Tools/SurfaceArrayCreator.hpp
+++ b/Core/include/ACTS/Tools/SurfaceArrayCreator.hpp
@@ -19,82 +19,109 @@
#include "ACTS/Tools/ISurfaceArrayCreator.hpp"
#include "ACTS/Utilities/Logger.hpp"
-
namespace Acts {
- class Surface;
- class BinUtility;
-
- typedef std::pair<const Surface*, Vector3D> SurfacePosition;
- typedef std::pair< SurfacePosition, Vector3D> SurfacePositionDirection;
-
-
- /** @class SurfaceArrayCreator
-
- It is designed create sub surface arrays to be ordered on Surfaces
-
- */
-
- class SurfaceArrayCreator : virtual public ISurfaceArrayCreator {
-
- public:
- struct Config
- {
- std::shared_ptr<Logger> logger; //!< logging instance
- Config():
- logger(getDefaultLogger("SurfaceArrayCreator",Logging::INFO))
- {}
- };
-
- /** Constructor */
- SurfaceArrayCreator(const Config& c):
- m_config(c)
- {}
-
- /** Destructor */
- virtual ~SurfaceArrayCreator() = default;
-
- /** SurfaceArrayCreator interface method - create an array in a cylinder, binned in phi, z */
- std::unique_ptr<SurfaceArray> surfaceArrayOnCylinder(const std::vector<const Surface*>& surfaces,
- double R, double minPhi, double maxPhi, double halfZ,
- size_t binsPhi, size_t binsZ,
- std::shared_ptr<Transform3D> transform = nullptr) const final;
-
- /** SurfaceArrayCreator interface method - create an array on a disc, binned in r, phi */
- std::unique_ptr<SurfaceArray> surfaceArrayOnDisc(const std::vector<const Surface*>& surfaces,
- double rMin, double rMax, double minPhi, double maxPhi,
- size_t binsR, size_t binsZ,
- const std::vector<double>& rBoundaries = {},
- std::shared_ptr<Transform3D> transform = nullptr) const final;
-
- /** SurfaceArrayCreator interface method - create an array on a plane */
- std::unique_ptr<SurfaceArray> surfaceArrayOnPlane(const std::vector<const Surface*>& surfaces,
- double halflengthX, double halflengthY,
- size_t binsX, size_t binsY,
- std::shared_ptr<Transform3D> transform = nullptr) const final;
-
- void setConfiguration(const Config& c) {m_config = c;}
-
- /** Get configuration method */
- Config getConfiguration() const {return m_config;}
-
- private:
- /** Configuration struct */
- Config m_config;
- const Logger& logger() const {return *m_config.logger;}
-
- void completeBinning(const std::vector<const Surface*>& surfaces,
- const BinUtility& binUtility,
- std::vector<SurfacePosition>& sVector,
- std::vector< std::vector<SurfacePositionDirection> >& binSystem) const;
-
- /** Register the neighbours on a Grid - needs to be a BinnedArray1D or BinnedArray2D type binning */
- void registerNeighboursGrid(const std::vector< std::vector < const Surface* > >& surfaceArrayObjects, bool open0, bool open1) const;
-
-
- };
-
-} // end of namespace
-
-#endif // ACTS_GEOMETRYTOOLS_SURFACERARRAYCREATOR_H
-
+class Surface;
+class BinUtility;
+
+typedef std::pair<const Surface*, Vector3D> SurfacePosition;
+typedef std::pair<SurfacePosition, Vector3D> SurfacePositionDirection;
+
+/** @class SurfaceArrayCreator
+
+ It is designed create sub surface arrays to be ordered on Surfaces
+
+ */
+
+class SurfaceArrayCreator : virtual public ISurfaceArrayCreator
+{
+public:
+ struct Config
+ {
+ std::shared_ptr<Logger> logger; //!< logging instance
+ Config() : logger(getDefaultLogger("SurfaceArrayCreator", Logging::INFO)) {}
+ };
+
+ /** Constructor */
+ SurfaceArrayCreator(const Config& c) : m_config(c) {}
+ /** Destructor */
+ virtual ~SurfaceArrayCreator() = default;
+
+ /** SurfaceArrayCreator interface method - create an array in a cylinder,
+ * binned in phi, z */
+ std::unique_ptr<SurfaceArray>
+ surfaceArrayOnCylinder(const std::vector<const Surface*>& surfaces,
+ double R,
+ double minPhi,
+ double maxPhi,
+ double halfZ,
+ size_t binsPhi,
+ size_t binsZ,
+ std::shared_ptr<Transform3D> transform
+ = nullptr) const final;
+
+ /** SurfaceArrayCreator interface method - create an array on a disc, binned
+ * in r, phi */
+ std::unique_ptr<SurfaceArray>
+ surfaceArrayOnDisc(const std::vector<const Surface*>& surfaces,
+ double rMin,
+ double rMax,
+ double minPhi,
+ double maxPhi,
+ size_t binsR,
+ size_t binsZ,
+ const std::vector<double>& rBoundaries = {},
+ std::shared_ptr<Transform3D> transform
+ = nullptr) const final;
+
+ /** SurfaceArrayCreator interface method - create an array on a plane */
+ std::unique_ptr<SurfaceArray>
+ surfaceArrayOnPlane(const std::vector<const Surface*>& surfaces,
+ double halflengthX,
+ double halflengthY,
+ size_t binsX,
+ size_t binsY,
+ std::shared_ptr<Transform3D> transform
+ = nullptr) const final;
+
+ void
+ setConfiguration(const Config& c)
+ {
+ m_config = c;
+ }
+
+ /** Get configuration method */
+ Config
+ getConfiguration() const
+ {
+ return m_config;
+ }
+
+private:
+ /** Configuration struct */
+ Config m_config;
+ const Logger&
+ logger() const
+ {
+ return *m_config.logger;
+ }
+
+ void
+ completeBinning(
+ const std::vector<const Surface*>& surfaces,
+ const BinUtility& binUtility,
+ std::vector<SurfacePosition>& sVector,
+ std::vector<std::vector<SurfacePositionDirection>>& binSystem) const;
+
+ /** Register the neighbours on a Grid - needs to be a BinnedArray1D or
+ * BinnedArray2D type binning */
+ void
+ registerNeighboursGrid(
+ const std::vector<std::vector<const Surface*>>& surfaceArrayObjects,
+ bool open0,
+ bool open1) const;
+};
+
+} // end of namespace
+
+#endif // ACTS_GEOMETRYTOOLS_SURFACERARRAYCREATOR_H
diff --git a/Core/include/ACTS/Tools/TrackingVolumeArrayCreator.hpp b/Core/include/ACTS/Tools/TrackingVolumeArrayCreator.hpp
index a6c128e43..5e6a2f53e 100644
--- a/Core/include/ACTS/Tools/TrackingVolumeArrayCreator.hpp
+++ b/Core/include/ACTS/Tools/TrackingVolumeArrayCreator.hpp
@@ -23,54 +23,61 @@
namespace Acts {
- class Layer;
- class TrackingVolume;
-
- typedef std::pair< TrackingVolumePtr, Vector3D> TrackingVolumeOrderPosition;
-
- /** @class TrackingVolumeArrayCreator
-
- The TrackingVolumeArrayCreator is a simple Tool that helps to construct
- binned arrays of TrackingVolumes for both, confinement in another volume
- and navigation issues.
-
- */
-
- class TrackingVolumeArrayCreator : public ITrackingVolumeArrayCreator {
-
- public:
- struct Config
- {
- std::shared_ptr<Logger> logger; //!< logging instance
-
- Config():
- logger(getDefaultLogger("LayerArrayCreator",Logging::INFO))
- {}
- };
-
- /** Constructor */
- TrackingVolumeArrayCreator(const Config& c):
- m_config(c)
- {}
-
- /** Destructor */
- virtual ~TrackingVolumeArrayCreator() = default;
-
- /** create a tracking volume array */
- std::shared_ptr<const TrackingVolumeArray> trackingVolumeArray(const TrackingVolumeVector& vols, BinningValue bVal) const;
-
- void setConfiguration(const Config& c) {m_config = c;}
-
- /** Get configuration method */
- Config getConfiguration() const {return m_config;}
-
- private:
- /** Configuration struct */
- Config m_config;
- const Logger& logger() const {return *m_config.logger;}
-
- };
+class Layer;
+class TrackingVolume;
+
+typedef std::pair<TrackingVolumePtr, Vector3D> TrackingVolumeOrderPosition;
+
+/** @class TrackingVolumeArrayCreator
+
+ The TrackingVolumeArrayCreator is a simple Tool that helps to construct
+ binned arrays of TrackingVolumes for both, confinement in another volume
+ and navigation issues.
+
+ */
+
+class TrackingVolumeArrayCreator : public ITrackingVolumeArrayCreator
+{
+public:
+ struct Config
+ {
+ std::shared_ptr<Logger> logger; //!< logging instance
+
+ Config() : logger(getDefaultLogger("LayerArrayCreator", Logging::INFO)) {}
+ };
+
+ /** Constructor */
+ TrackingVolumeArrayCreator(const Config& c) : m_config(c) {}
+ /** Destructor */
+ virtual ~TrackingVolumeArrayCreator() = default;
+
+ /** create a tracking volume array */
+ std::shared_ptr<const TrackingVolumeArray>
+ trackingVolumeArray(const TrackingVolumeVector& vols,
+ BinningValue bVal) const;
+
+ void
+ setConfiguration(const Config& c)
+ {
+ m_config = c;
+ }
+
+ /** Get configuration method */
+ Config
+ getConfiguration() const
+ {
+ return m_config;
+ }
+
+private:
+ /** Configuration struct */
+ Config m_config;
+ const Logger&
+ logger() const
+ {
+ return *m_config.logger;
+ }
+};
}
#endif
-
diff --git a/Core/include/ACTS/Utilities/ApproachDescriptor.hpp b/Core/include/ACTS/Utilities/ApproachDescriptor.hpp
index f9c2871d3..804b390a8 100644
--- a/Core/include/ACTS/Utilities/ApproachDescriptor.hpp
+++ b/Core/include/ACTS/Utilities/ApproachDescriptor.hpp
@@ -19,43 +19,46 @@
namespace Acts {
- class Surface;
- class Layer;
- class BoundaryCheck;
- class ICompatibilityEstimator;
-
- typedef ObjectIntersection<Surface> SurfaceIntersection;
-
- /**
- @class ApproachDescriptor
-
- Virtual base class to decide and return which approaching surface to be taken,
- the surfaces are std::shared_ptr, as they can be the boundary surfaces of the
- representingVolume of the Layer
-
- */
-
- class ApproachDescriptor {
- public:
- /** Default constructor */
- ApproachDescriptor(){}
-
- /** Virtual destructor */
- virtual ~ApproachDescriptor(){}
-
- /** register Layer */
- virtual void registerLayer(const Layer& lay) = 0;
-
- /** get the surface on approach - nullptr means that there's no surface on approach */
- virtual const SurfaceIntersection approachSurface(const Vector3D& pos,
- const Vector3D& dir,
- const BoundaryCheck& bchk,
- const ICompatibilityEstimator* ice = nullptr) const = 0;
-
- /** return all contained surfaces of this approach descriptor */
- virtual const std::vector< const Surface* >& containedSurfaces() const = 0;
-
- };
+class Surface;
+class Layer;
+class BoundaryCheck;
+class ICompatibilityEstimator;
+
+typedef ObjectIntersection<Surface> SurfaceIntersection;
+
+/**
+@class ApproachDescriptor
+
+Virtual base class to decide and return which approaching surface to be taken,
+the surfaces are std::shared_ptr, as they can be the boundary surfaces of the
+representingVolume of the Layer
+
+*/
+
+class ApproachDescriptor
+{
+public:
+ /** Default constructor */
+ ApproachDescriptor() {}
+ /** Virtual destructor */
+ virtual ~ApproachDescriptor() {}
+ /** register Layer */
+ virtual void
+ registerLayer(const Layer& lay)
+ = 0;
+
+ /** get the surface on approach - nullptr means that there's no surface on
+ * approach */
+ virtual const SurfaceIntersection
+ approachSurface(const Vector3D& pos,
+ const Vector3D& dir,
+ const BoundaryCheck& bchk,
+ const ICompatibilityEstimator* ice = nullptr) const = 0;
+
+ /** return all contained surfaces of this approach descriptor */
+ virtual const std::vector<const Surface*>&
+ containedSurfaces() const = 0;
+};
}
-#endif // ACTS_GEOMETRYUTILS_APPROACHDESCRIPTOR_H
+#endif // ACTS_GEOMETRYUTILS_APPROACHDESCRIPTOR_H
diff --git a/Core/include/ACTS/Utilities/AreaExcluder.hpp b/Core/include/ACTS/Utilities/AreaExcluder.hpp
index 21f0d7ac9..0128d5d2e 100644
--- a/Core/include/ACTS/Utilities/AreaExcluder.hpp
+++ b/Core/include/ACTS/Utilities/AreaExcluder.hpp
@@ -23,24 +23,22 @@ namespace Acts {
*/
- class AreaExcluder {
-
- public:
- /** Default constructor */
- AreaExcluder(){}
-
- /** Virtual Destructor */
- virtual ~AreaExcluder(){}
-
- /** Implizit Constructor */
- virtual AreaExcluder* clone() const = 0;
-
- /** First bin from global position */
- virtual bool inside(const Vector3D& gp, double tol=0.) const = 0;
-
- };
-
-} // end of namespace Acts
-
-#endif // TRKDETDESCRUTILS_AREAEXCLUDER_H
-
+class AreaExcluder
+{
+public:
+ /** Default constructor */
+ AreaExcluder() {}
+ /** Virtual Destructor */
+ virtual ~AreaExcluder() {}
+ /** Implizit Constructor */
+ virtual AreaExcluder*
+ clone() const = 0;
+
+ /** First bin from global position */
+ virtual bool
+ inside(const Vector3D& gp, double tol = 0.) const = 0;
+};
+
+} // end of namespace Acts
+
+#endif // TRKDETDESCRUTILS_AREAEXCLUDER_H
diff --git a/Core/include/ACTS/Utilities/BinStepping.hpp b/Core/include/ACTS/Utilities/BinStepping.hpp
index 2d6aa37ca..0cd0d1337 100644
--- a/Core/include/ACTS/Utilities/BinStepping.hpp
+++ b/Core/include/ACTS/Utilities/BinStepping.hpp
@@ -16,18 +16,22 @@
/** Very simple binStepping class to deal with open and closed bins */
namespace Acts {
-
- static bool decrement(size_t& bin, size_t nBins, bool openBin) {
- if (openBin && !bin) return false;
- bin = bin ? bin-1 : nBins-1;
- return true;
- }
-
- static bool increment(size_t& bin, size_t nBins, bool openBin) {
- if (openBin && (bin+1==nBins)) return false;
- bin = (bin==nBins-1) ? 0 : bin+1;
- return true;
- }
+
+static bool
+decrement(size_t& bin, size_t nBins, bool openBin)
+{
+ if (openBin && !bin) return false;
+ bin = bin ? bin - 1 : nBins - 1;
+ return true;
+}
+
+static bool
+increment(size_t& bin, size_t nBins, bool openBin)
+{
+ if (openBin && (bin + 1 == nBins)) return false;
+ bin = (bin == nBins - 1) ? 0 : bin + 1;
+ return true;
+}
}
#endif
diff --git a/Core/include/ACTS/Utilities/BinUtility.hpp b/Core/include/ACTS/Utilities/BinUtility.hpp
index 443b85835..38d792ceb 100644
--- a/Core/include/ACTS/Utilities/BinUtility.hpp
+++ b/Core/include/ACTS/Utilities/BinUtility.hpp
@@ -17,258 +17,332 @@
#include "ACTS/Utilities/BinningData.hpp"
#include "ACTS/Utilities/BinningType.hpp"
// STL
-#include <vector>
#include <memory>
+#include <vector>
#include "Definitions.hpp"
-//debug
+// debug
#include <iostream>
namespace Acts {
/** @class BinUtility
-
- The BinUtility class that translated global and local position into a bins of a BinnedArray,
- most performant is equidistant binning without a transform, however,
+
+ The BinUtility class that translated global and local position into a bins
+ of a BinnedArray,
+ most performant is equidistant binning without a transform, however,
optionally a transform can be provided, e.g. for binning on shifted object,
- the transform is usually shared with the geometric object the Array is defined on,
+ the transform is usually shared with the geometric object the Array is
+ defined on,
for performance reasons, also the inverse transform is stored.
-
+
*/
- class BinUtility {
-
- public:
- /** Constructor for equidistant */
- BinUtility() :
- m_binningData(),
- m_transform(nullptr),
- m_itransform(nullptr)
- {
- m_binningData.reserve(3);
- }
-
- /** Constructor from BinningData directly */
- BinUtility(const BinningData& bData, std::shared_ptr<Transform3D> tForm=nullptr) :
- m_binningData(),
- m_transform(tForm),
- m_itransform(tForm ? new Transform3D(tForm->inverse()) : nullptr)
- {
- m_binningData.reserve(3);
- m_binningData.push_back(bData);
- }
-
- /** Constructor for equidistant */
- BinUtility(size_t bins, float min, float max, BinningOption opt = open, BinningValue value = binX, std::shared_ptr<Transform3D> tForm=nullptr) :
- m_binningData(),
- m_transform(tForm),
- m_itransform(tForm ? new Transform3D(tForm->inverse()) : nullptr)
- {
- m_binningData.reserve(3);
- m_binningData.push_back(BinningData(opt, value, bins, min, max));
- }
-
- /** Constructor for arbitrary */
- BinUtility(std::vector<float>& bValues, BinningOption opt = open, BinningValue value = binPhi, std::shared_ptr<Transform3D> tForm=nullptr) :
- m_binningData(),
- m_transform(tForm),
- m_itransform(tForm ? new Transform3D(tForm->inverse()) : nullptr)
- {
- m_binningData.reserve(3);
- m_binningData.push_back(BinningData(opt, value, bValues));
- }
-
- /** Constructor for binH */
- BinUtility(float phiRef, std::vector<std::pair<int,float> >& bValues, std::shared_ptr<Transform3D> tForm=nullptr) :
- m_binningData(),
- m_transform(tForm),
- m_itransform(tForm ? new Transform3D(tForm->inverse()) : nullptr)
- {
- m_binningData.reserve(3);
- m_binningData.push_back(BinningData(open,phiRef,bValues));
- }
-
- /** Copy constructor */
- BinUtility(const BinUtility& sbu ) :
- m_binningData(sbu.m_binningData),
- m_transform(sbu.m_transform),
- m_itransform(sbu.m_transform ? new Transform3D(sbu.m_transform->inverse()) : nullptr)
- {}
-
- /** Assignment operator Constructor */
- BinUtility& operator=(const BinUtility& sbu ){
- if ( this != &sbu ){
- m_binningData = sbu.m_binningData;
- m_transform = sbu.m_transform;
- m_itransform = sbu.m_transform ? std::unique_ptr<Transform3D>(new Transform3D(sbu.m_transform->inverse())) : nullptr;
- }
- return (*this);
- }
-
- /** Operator++ to make multidimensional BinUtility */
- BinUtility& operator+= ( const BinUtility& gbu) throw (std::string) {
- const std::vector<BinningData>& bData = gbu.binningData();
- if (m_binningData.size() + bData.size() > 3)
- throw "BinUtility does not support dim > 3";
- m_binningData.insert(m_binningData.end(), bData.begin(), bData.end());
- return (*this);
- }
-
- /** Virtual Destructor */
- virtual ~BinUtility(){}
-
- /** Implizit Constructor */
- virtual BinUtility* clone() const { return new BinUtility(*this); }
-
- /** return the binning data */
- const std::vector<BinningData>& binningData() const { return m_binningData; }
-
- /** Bin from a 3D vector (already in binning frame) - optionally the itransform is applied */
- size_t bin(const Vector3D& position, size_t ba=0) const throw (std::string)
- {
- if (ba >= m_binningData.size())
- throw "dimension out of bounds";
- size_t bEval = m_itransform ? m_binningData[ba].searchGlobal((*m_itransform)*position) : m_binningData[ba].searchGlobal(position);
- return ( bEval > bins(ba)-1 ? bins(ba)-1 : bEval ); //!< @TODO ST additional protection : DEBUG source
- }
-
- /** Bin neighbour range */
- std::vector<size_t> neighbourRange(const Vector3D& position, size_t ba=0) const
- {
- std::vector<size_t> neighbourRange;
- size_t cbin = bin(position,ba);
- size_t pbin = cbin ? cbin-1 : ( ( m_binningData[ba].option == open ) ? cbin : m_binningData[ba].bins()-1 );
- size_t nbin = (cbin < m_binningData[ba].bins()-1) ? cbin+1 : 0;
- if (pbin != cbin ) neighbourRange.push_back(pbin);
- neighbourRange.push_back(cbin);
- if (nbin != cbin ) neighbourRange.push_back(nbin);
- return neighbourRange;
- }
-
- /** Bin from a 3D vector (already in binning frame) */
- size_t entry(const Vector3D& position, size_t ba=0) const throw (std::string)
- { if (ba >= m_binningData.size())
- throw "dimension out of bounds";
- return (m_itransform ? m_binningData[ba].entry((*m_itransform)*position) : m_binningData[ba].entry(position));
- }
-
- /** Bin from a 3D vector (already in binning frame) */
- size_t next(const Vector3D& position, const Vector3D& direction, size_t ba=0) const throw (std::string)
- { if (ba >= m_binningData.size())
- throw "dimension out of bounds";
- return (m_itransform ? m_binningData[ba].next((*m_itransform)*position, (m_itransform->linear())*direction) : m_binningData[ba].next(position, direction));
- }
-
- /** Return the oder direciton for fast interlinking */
- int nextDirection(const Vector3D& position, const Vector3D& direction, size_t ba=0) const throw (std::string) {
- if (ba >= m_binningData.size())
- throw "dimension out of bounds";
- return m_binningData[ba].nextDirection(position, direction);
- }
-
- /** Distance estimate to next bin */
- std::pair<size_t,float> distanceToNext(const Vector3D& position, const Vector3D& direction, size_t ba=0) const throw (std::string)
- { if (ba >= m_binningData.size())
- throw "dimension out of bounds";
- return (m_itransform ? m_binningData[ba].distanceToNext((*m_itransform)*position, (m_itransform->linear())*direction) : m_binningData[ba].distanceToNext(position, direction));
- }
-
- /** Bin from a 2D vector (following local parameters defintitions) - no optional transform applied
- - USE WITH CARE !!
- You need to check if your local position is actually in the binning frame of the BinUtility */
- size_t bin(const Vector2D& lposition, size_t ba=0) const throw (std::string)
- {
- if (ba >= m_binningData.size())
- throw "dimension out of bounds";
- return m_binningData[ba].searchLocal(lposition);
- }
-
- /** Check if bin is inside from Vector3D - optional transform applied */
- bool inside(const Vector3D& position ) const {
- std::vector<BinningData>::const_iterator bdIter = m_binningData.begin();
- for ( ; bdIter != m_binningData.end(); ++bdIter) {
- if (m_itransform && !(*bdIter).inside((*m_itransform)*position)) return false;
- else if ( !(*bdIter).inside(position)) return false;
- }
- return true;
- }
-
- /** Check if bin is inside from Vector2D - no optional transform applied */
- bool inside(const Vector2D& lposition) const {
- return true;
- std::vector<BinningData>::const_iterator bdIter = m_binningData.begin();
- for ( ; bdIter != m_binningData.end(); ++bdIter)
- if ( !(*bdIter).inside(lposition)) return false;
- return true;
- }
-
- /** First bin maximal value */
- size_t dimensions() const {
- return m_binningData.size();
- }
-
- /** First bin maximal value */
- size_t max(size_t ba=0) const {
- if (ba >= m_binningData.size()) return 0;
- return (m_binningData[ba].bins()-1);
- }
-
- /** Number of bins */
- size_t bins(size_t ba=0) const {
- if (ba >= m_binningData.size()) return 0;
- return (m_binningData[ba].bins());
- }
-
- /** The type/value of the binning */
- BinningValue binningValue(size_t ba=0) const throw (std::string) {
- if (ba >= m_binningData.size())
- throw "dimension out of bounds";
- return (m_binningData[ba].binvalue);
- }
-
- /** bin->BinningValue navigation : pos=+-1. edges/ 0. bin center */
- float binPosition( size_t bin, float pos, size_t ba=0 ) const {
- if (ba >= m_binningData.size())
- throw "dimension out of bounds";
- return (m_binningData[ba].binPosition( bin, pos ));
- }
-
- /** Clear the data. */
- void clear() { m_binningData.clear(); }
-
- /** Output Method for std::ostream, to be overloaded by child classes */
- std::ostream& dump(std::ostream& sl) const {
- sl << "BinUtility for " << m_binningData.size() << "- dimensional array:" << std::endl;
- std::vector<BinningData>::const_iterator bdIter = m_binningData.begin();
- for (size_t ibd = 0 ; bdIter != m_binningData.end(); ++bdIter, ++ibd ){
- sl << "dimension : " << ibd << std::endl;
- sl << " - type : " << size_t((*bdIter).type) << std::endl;
- sl << " - option : " << size_t((*bdIter).option) << std::endl;
- sl << " - value : " << size_t((*bdIter).binvalue) << std::endl;
- sl << " - bins : " << (*bdIter).bins() << std::endl;
- sl << " - min/max : " << (*bdIter).min << " / " << (*bdIter).max << std::endl;
- if ((*bdIter).type == equidistant)
- sl << " - step : " << (*bdIter).step << std::endl;
- sl << " - boundaries : | ";
- std::vector<float>::const_iterator bIter = (*bdIter).boundaries().begin();
- for ( ; bIter != (*bdIter).boundaries().end(); ++bIter )
- sl << (*bIter) << " | ";
- sl << std::endl;
- }
- return sl;
- }
-
- private :
- std::vector<BinningData> m_binningData;
- std::shared_ptr<Transform3D> m_transform;
- std::unique_ptr<Transform3D> m_itransform;
-
- };
+class BinUtility
+{
+public:
+ /** Constructor for equidistant */
+ BinUtility() : m_binningData(), m_transform(nullptr), m_itransform(nullptr)
+ {
+ m_binningData.reserve(3);
+ }
+
+ /** Constructor from BinningData directly */
+ BinUtility(const BinningData& bData,
+ std::shared_ptr<Transform3D> tForm = nullptr)
+ : m_binningData()
+ , m_transform(tForm)
+ , m_itransform(tForm ? new Transform3D(tForm->inverse()) : nullptr)
+ {
+ m_binningData.reserve(3);
+ m_binningData.push_back(bData);
+ }
+
+ /** Constructor for equidistant */
+ BinUtility(size_t bins,
+ float min,
+ float max,
+ BinningOption opt = open,
+ BinningValue value = binX,
+ std::shared_ptr<Transform3D> tForm = nullptr)
+ : m_binningData()
+ , m_transform(tForm)
+ , m_itransform(tForm ? new Transform3D(tForm->inverse()) : nullptr)
+ {
+ m_binningData.reserve(3);
+ m_binningData.push_back(BinningData(opt, value, bins, min, max));
+ }
+
+ /** Constructor for arbitrary */
+ BinUtility(std::vector<float>& bValues,
+ BinningOption opt = open,
+ BinningValue value = binPhi,
+ std::shared_ptr<Transform3D> tForm = nullptr)
+ : m_binningData()
+ , m_transform(tForm)
+ , m_itransform(tForm ? new Transform3D(tForm->inverse()) : nullptr)
+ {
+ m_binningData.reserve(3);
+ m_binningData.push_back(BinningData(opt, value, bValues));
+ }
+
+ /** Constructor for binH */
+ BinUtility(float phiRef,
+ std::vector<std::pair<int, float>>& bValues,
+ std::shared_ptr<Transform3D> tForm = nullptr)
+ : m_binningData()
+ , m_transform(tForm)
+ , m_itransform(tForm ? new Transform3D(tForm->inverse()) : nullptr)
+ {
+ m_binningData.reserve(3);
+ m_binningData.push_back(BinningData(open, phiRef, bValues));
+ }
+
+ /** Copy constructor */
+ BinUtility(const BinUtility& sbu)
+ : m_binningData(sbu.m_binningData)
+ , m_transform(sbu.m_transform)
+ , m_itransform(sbu.m_transform ? new Transform3D(sbu.m_transform->inverse())
+ : nullptr)
+ {
+ }
+
+ /** Assignment operator Constructor */
+ BinUtility&
+ operator=(const BinUtility& sbu)
+ {
+ if (this != &sbu) {
+ m_binningData = sbu.m_binningData;
+ m_transform = sbu.m_transform;
+ m_itransform = sbu.m_transform
+ ? std::unique_ptr<Transform3D>(
+ new Transform3D(sbu.m_transform->inverse()))
+ : nullptr;
+ }
+ return (*this);
+ }
+
+ /** Operator++ to make multidimensional BinUtility */
+ BinUtility&
+ operator+=(const BinUtility& gbu) throw(std::string)
+ {
+ const std::vector<BinningData>& bData = gbu.binningData();
+ if (m_binningData.size() + bData.size() > 3)
+ throw "BinUtility does not support dim > 3";
+ m_binningData.insert(m_binningData.end(), bData.begin(), bData.end());
+ return (*this);
+ }
+
+ /** Virtual Destructor */
+ virtual ~BinUtility() {}
+ /** Implizit Constructor */
+ virtual BinUtility*
+ clone() const
+ {
+ return new BinUtility(*this);
+ }
+
+ /** return the binning data */
+ const std::vector<BinningData>&
+ binningData() const
+ {
+ return m_binningData;
+ }
+
+ /** Bin from a 3D vector (already in binning frame) - optionally the
+ * itransform is applied */
+ size_t
+ bin(const Vector3D& position, size_t ba = 0) const throw(std::string)
+ {
+ if (ba >= m_binningData.size()) throw "dimension out of bounds";
+ size_t bEval = m_itransform
+ ? m_binningData[ba].searchGlobal((*m_itransform) * position)
+ : m_binningData[ba].searchGlobal(position);
+ return (bEval > bins(ba) - 1
+ ? bins(ba) - 1
+ : bEval); //!< @TODO ST additional protection : DEBUG source
+ }
+
+ /** Bin neighbour range */
+ std::vector<size_t>
+ neighbourRange(const Vector3D& position, size_t ba = 0) const
+ {
+ std::vector<size_t> neighbourRange;
+ size_t cbin = bin(position, ba);
+ size_t pbin = cbin ? cbin - 1 : ((m_binningData[ba].option == open)
+ ? cbin
+ : m_binningData[ba].bins() - 1);
+ size_t nbin = (cbin < m_binningData[ba].bins() - 1) ? cbin + 1 : 0;
+ if (pbin != cbin) neighbourRange.push_back(pbin);
+ neighbourRange.push_back(cbin);
+ if (nbin != cbin) neighbourRange.push_back(nbin);
+ return neighbourRange;
+ }
+
+ /** Bin from a 3D vector (already in binning frame) */
+ size_t
+ entry(const Vector3D& position, size_t ba = 0) const throw(std::string)
+ {
+ if (ba >= m_binningData.size()) throw "dimension out of bounds";
+ return (m_itransform ? m_binningData[ba].entry((*m_itransform) * position)
+ : m_binningData[ba].entry(position));
+ }
+
+ /** Bin from a 3D vector (already in binning frame) */
+ size_t
+ next(const Vector3D& position, const Vector3D& direction, size_t ba = 0) const
+ throw(std::string)
+ {
+ if (ba >= m_binningData.size()) throw "dimension out of bounds";
+ return (m_itransform
+ ? m_binningData[ba].next((*m_itransform) * position,
+ (m_itransform->linear()) * direction)
+ : m_binningData[ba].next(position, direction));
+ }
+
+ /** Return the oder direciton for fast interlinking */
+ int
+ nextDirection(const Vector3D& position,
+ const Vector3D& direction,
+ size_t ba = 0) const throw(std::string)
+ {
+ if (ba >= m_binningData.size()) throw "dimension out of bounds";
+ return m_binningData[ba].nextDirection(position, direction);
+ }
+
+ /** Distance estimate to next bin */
+ std::pair<size_t, float>
+ distanceToNext(const Vector3D& position,
+ const Vector3D& direction,
+ size_t ba = 0) const throw(std::string)
+ {
+ if (ba >= m_binningData.size()) throw "dimension out of bounds";
+ return (m_itransform
+ ? m_binningData[ba].distanceToNext((*m_itransform) * position,
+ (m_itransform->linear())
+ * direction)
+ : m_binningData[ba].distanceToNext(position, direction));
+ }
+
+ /** Bin from a 2D vector (following local parameters defintitions) - no
+ optional transform applied
+ - USE WITH CARE !!
+ You need to check if your local position is actually in the binning
+ frame of the BinUtility */
+ size_t
+ bin(const Vector2D& lposition, size_t ba = 0) const throw(std::string)
+ {
+ if (ba >= m_binningData.size()) throw "dimension out of bounds";
+ return m_binningData[ba].searchLocal(lposition);
+ }
+
+ /** Check if bin is inside from Vector3D - optional transform applied */
+ bool
+ inside(const Vector3D& position) const
+ {
+ std::vector<BinningData>::const_iterator bdIter = m_binningData.begin();
+ for (; bdIter != m_binningData.end(); ++bdIter) {
+ if (m_itransform && !(*bdIter).inside((*m_itransform) * position))
+ return false;
+ else if (!(*bdIter).inside(position))
+ return false;
+ }
+ return true;
+ }
+
+ /** Check if bin is inside from Vector2D - no optional transform applied */
+ bool
+ inside(const Vector2D& lposition) const
+ {
+ return true;
+ std::vector<BinningData>::const_iterator bdIter = m_binningData.begin();
+ for (; bdIter != m_binningData.end(); ++bdIter)
+ if (!(*bdIter).inside(lposition)) return false;
+ return true;
+ }
+
+ /** First bin maximal value */
+ size_t
+ dimensions() const
+ {
+ return m_binningData.size();
+ }
+
+ /** First bin maximal value */
+ size_t
+ max(size_t ba = 0) const
+ {
+ if (ba >= m_binningData.size()) return 0;
+ return (m_binningData[ba].bins() - 1);
+ }
+
+ /** Number of bins */
+ size_t
+ bins(size_t ba = 0) const
+ {
+ if (ba >= m_binningData.size()) return 0;
+ return (m_binningData[ba].bins());
+ }
+
+ /** The type/value of the binning */
+ BinningValue
+ binningValue(size_t ba = 0) const throw(std::string)
+ {
+ if (ba >= m_binningData.size()) throw "dimension out of bounds";
+ return (m_binningData[ba].binvalue);
+ }
+
+ /** bin->BinningValue navigation : pos=+-1. edges/ 0. bin center */
+ float
+ binPosition(size_t bin, float pos, size_t ba = 0) const
+ {
+ if (ba >= m_binningData.size()) throw "dimension out of bounds";
+ return (m_binningData[ba].binPosition(bin, pos));
+ }
+
+ /** Clear the data. */
+ void
+ clear()
+ {
+ m_binningData.clear();
+ }
+
+ /** Output Method for std::ostream, to be overloaded by child classes */
+ std::ostream&
+ dump(std::ostream& sl) const
+ {
+ sl << "BinUtility for " << m_binningData.size()
+ << "- dimensional array:" << std::endl;
+ std::vector<BinningData>::const_iterator bdIter = m_binningData.begin();
+ for (size_t ibd = 0; bdIter != m_binningData.end(); ++bdIter, ++ibd) {
+ sl << "dimension : " << ibd << std::endl;
+ sl << " - type : " << size_t((*bdIter).type) << std::endl;
+ sl << " - option : " << size_t((*bdIter).option) << std::endl;
+ sl << " - value : " << size_t((*bdIter).binvalue) << std::endl;
+ sl << " - bins : " << (*bdIter).bins() << std::endl;
+ sl << " - min/max : " << (*bdIter).min << " / " << (*bdIter).max
+ << std::endl;
+ if ((*bdIter).type == equidistant)
+ sl << " - step : " << (*bdIter).step << std::endl;
+ sl << " - boundaries : | ";
+ std::vector<float>::const_iterator bIter = (*bdIter).boundaries().begin();
+ for (; bIter != (*bdIter).boundaries().end(); ++bIter)
+ sl << (*bIter) << " | ";
+ sl << std::endl;
+ }
+ return sl;
+ }
+
+private:
+ std::vector<BinningData> m_binningData;
+ std::shared_ptr<Transform3D> m_transform;
+ std::unique_ptr<Transform3D> m_itransform;
+};
/**Overload of << operator for std::ostream for debug output*/
-std::ostream& operator << ( std::ostream& sl, const BinUtility& bgen);
-
-} // end of namespace Acts
+std::ostream&
+operator<<(std::ostream& sl, const BinUtility& bgen);
-#endif // ACTS_GEOMETRYUTILS_BINUTILITY_H
+} // end of namespace Acts
+#endif // ACTS_GEOMETRYUTILS_BINUTILITY_H
diff --git a/Core/include/ACTS/Utilities/BinnedArray.hpp b/Core/include/ACTS/Utilities/BinnedArray.hpp
index 6727e237c..baa03e25a 100644
--- a/Core/include/ACTS/Utilities/BinnedArray.hpp
+++ b/Core/include/ACTS/Utilities/BinnedArray.hpp
@@ -30,43 +30,48 @@ namespace Acts {
*/
- template <class T> class BinnedArray {
-
- public:
- /** Default Constructor - needed for inherited classes */
- BinnedArray() {}
-
- /** Default Constructor - needed for inherited classes */
- BinnedArray(const BinnedArray<T>& ba) :
- m_arrayObjects(ba.m_arrayObjects)
- {}
-
- /**Virtual Destructor*/
- virtual ~BinnedArray(){}
-
- /** Implicit constructor */
- virtual BinnedArray* clone() const = 0;
-
- /** Returns the object in the associated bin according the local position */
- virtual T object(const Vector2D& lp) const = 0;
-
- /** Returns the object in the associated bin according the global position */
- virtual T object(const Vector3D& gp) const = 0;
-
- /** Returns the pointer to the templated class object from the BinnedArray - entry point*/
- virtual T entryObject(const Vector3D&) const = 0;
-
- /** Return all objects of the Array - in one */
- virtual const std::vector< T >& arrayObjects() const { return m_arrayObjects; };
-
- /** Return the BinUtility*/
- virtual const BinUtility* binUtility() const = 0;
+template <class T>
+class BinnedArray
+{
+public:
+ /** Default Constructor - needed for inherited classes */
+ BinnedArray() {}
+ /** Default Constructor - needed for inherited classes */
+ BinnedArray(const BinnedArray<T>& ba) : m_arrayObjects(ba.m_arrayObjects) {}
+ /**Virtual Destructor*/
+ virtual ~BinnedArray() {}
+ /** Implicit constructor */
+ virtual BinnedArray*
+ clone() const = 0;
+
+ /** Returns the object in the associated bin according the local position */
+ virtual T
+ object(const Vector2D& lp) const = 0;
+
+ /** Returns the object in the associated bin according the global position */
+ virtual T
+ object(const Vector3D& gp) const = 0;
+
+ /** Returns the pointer to the templated class object from the BinnedArray -
+ * entry point*/
+ virtual T
+ entryObject(const Vector3D&) const = 0;
+
+ /** Return all objects of the Array - in one */
+ virtual const std::vector<T>&
+ arrayObjects() const
+ {
+ return m_arrayObjects;
+ };
- protected:
- std::vector< T > m_arrayObjects;
+ /** Return the BinUtility*/
+ virtual const BinUtility*
+ binUtility() const = 0;
- };
+protected:
+ std::vector<T> m_arrayObjects;
+};
-} // end of namespace Acts
+} // end of namespace Acts
-#endif // ACTS_GEOMETRYUTILS_BINNEDARRAY_H
+#endif // ACTS_GEOMETRYUTILS_BINNEDARRAY_H
diff --git a/Core/include/ACTS/Utilities/BinnedArray0D.hpp b/Core/include/ACTS/Utilities/BinnedArray0D.hpp
index cea8f1dd7..63981c4cc 100644
--- a/Core/include/ACTS/Utilities/BinnedArray0D.hpp
+++ b/Core/include/ACTS/Utilities/BinnedArray0D.hpp
@@ -30,61 +30,75 @@ namespace Acts {
*/
- template <class T> class BinnedArray0D : public BinnedArray<T> {
-
- public:
- /**Default Constructor - needed for inherited classes */
- BinnedArray0D():
- BinnedArray<T>()
- {}
-
- /**Constructor from oneobject */
- BinnedArray0D(T obj):
- BinnedArray<T>(),
- m_object(obj)
- {
- BinnedArray<T>::m_arrayObjects.push_back(obj);
- }
-
- /**Copy Constructor - copies only pointers !*/
- BinnedArray0D(const BinnedArray0D& barr):
- BinnedArray<T>(barr),
- m_object(barr.m_object)
- {}
-
- /**Assignment operator*/
- BinnedArray0D& operator=(const BinnedArray0D& barr)
- {
- if (this != &barr){
- m_object = barr.m_object;
- }
- return *this;
- }
-
- /** Implizit Constructor */
- BinnedArray0D* clone() const final
- { return new BinnedArray0D(*this); }
-
- /**Virtual Destructor*/
- ~BinnedArray0D(){}
-
- /** Returns the single contained object */
- T object(const Vector2D&) const final { return m_object; }
-
- /** Returns the single contained object */
- T object(const Vector3D&) const final { return m_object; }
-
- /** Returns the single contained object */
- T entryObject(const Vector3D&) const final { return m_object; }
-
- /** Return the BinUtility*/
- const BinUtility* binUtility() const { return nullptr; }
-
- private:
- T m_object; //!< the single contained object
-
- };
-
-} // end of namespace Acts
-
-#endif // ACTS_GEOMETRYUTILS_BINNEDARRAY0D_H
+template <class T>
+class BinnedArray0D : public BinnedArray<T>
+{
+public:
+ /**Default Constructor - needed for inherited classes */
+ BinnedArray0D() : BinnedArray<T>() {}
+ /**Constructor from oneobject */
+ BinnedArray0D(T obj) : BinnedArray<T>(), m_object(obj)
+ {
+ BinnedArray<T>::m_arrayObjects.push_back(obj);
+ }
+
+ /**Copy Constructor - copies only pointers !*/
+ BinnedArray0D(const BinnedArray0D& barr)
+ : BinnedArray<T>(barr), m_object(barr.m_object)
+ {
+ }
+
+ /**Assignment operator*/
+ BinnedArray0D&
+ operator=(const BinnedArray0D& barr)
+ {
+ if (this != &barr) {
+ m_object = barr.m_object;
+ }
+ return *this;
+ }
+
+ /** Implizit Constructor */
+ BinnedArray0D*
+ clone() const final
+ {
+ return new BinnedArray0D(*this);
+ }
+
+ /**Virtual Destructor*/
+ ~BinnedArray0D() {}
+ /** Returns the single contained object */
+ T
+ object(const Vector2D&) const final
+ {
+ return m_object;
+ }
+
+ /** Returns the single contained object */
+ T
+ object(const Vector3D&) const final
+ {
+ return m_object;
+ }
+
+ /** Returns the single contained object */
+ T
+ entryObject(const Vector3D&) const final
+ {
+ return m_object;
+ }
+
+ /** Return the BinUtility*/
+ const BinUtility*
+ binUtility() const
+ {
+ return nullptr;
+ }
+
+private:
+ T m_object; //!< the single contained object
+};
+
+} // end of namespace Acts
+
+#endif // ACTS_GEOMETRYUTILS_BINNEDARRAY0D_H
diff --git a/Core/include/ACTS/Utilities/BinnedArray1D.hpp b/Core/include/ACTS/Utilities/BinnedArray1D.hpp
index b9eefb7d0..783e57cd7 100644
--- a/Core/include/ACTS/Utilities/BinnedArray1D.hpp
+++ b/Core/include/ACTS/Utilities/BinnedArray1D.hpp
@@ -14,9 +14,9 @@
#define ACTS_GEOMETRYUTILS_BINNEDARRAY1D_H 1
// Geometry module
-#include "ACTS/Utilities/BinnedArray.hpp"
#include "ACTS/Utilities/BinUtility.hpp"
-//STL
+#include "ACTS/Utilities/BinnedArray.hpp"
+// STL
#include <vector>
namespace Acts {
@@ -27,91 +27,103 @@ namespace Acts {
*/
- template <class T> class BinnedArray1D : public BinnedArray<T> {
-
- public:
- /**Default Constructor - needed for inherited classes */
- BinnedArray1D():
- BinnedArray<T>(),
- m_binUtility(0)
- {}
-
- /** Constructor with std::vector< pair < object, position> > and a BinUtility to sort the objects into the bin */
- BinnedArray1D(const std::vector< std::pair< T, Vector3D > >& tclassvector, BinUtility* bingen) throw (std::string) :
- BinnedArray<T>(),
- m_binUtility(bingen)
- {
- // prepare the binned Array
- if (bingen){
- // get the size of the object array and reserve accoridngly
- size_t vecsize = tclassvector.size();
- BinnedArray<T>::m_arrayObjects = std::vector<T>(vecsize, nullptr);
- // fill into the new
- for (size_t ivec = 0; ivec < vecsize; ++ivec){
- Vector3D currentGlobal(((tclassvector[ivec]).second));
- if (bingen->inside(currentGlobal))
- BinnedArray<T>::m_arrayObjects[bingen->bin(currentGlobal,0)] = ((tclassvector)[ivec]).first;
- else
- throw "Object outside bounds";
- }
- }
- }
-
- /**Copy Constructor - copies only pointers !*/
- BinnedArray1D(const BinnedArray1D& barr) throw (std::string) :
- BinnedArray<T>(barr),
- m_binUtility(nullptr)
- {
- // clone the Bin utility for the copy constructor
- if (barr.m_binUtility)
- m_binUtility = barr.m_binUtility->clone();
- else
- throw "No BinUtility provided";
- }
-
- /**Assignment operator*/
- BinnedArray1D& operator=(const BinnedArray1D& barr)
- {
- if (this != &barr){
- // now refill
- m_binUtility = (barr.m_binUtility) ? barr.m_binUtility->clone() : nullptr;
- BinnedArray<T>::m_arrayObjects = barr.m_arrayObjects;
- }
- return *this;
- }
-
- /** Implicit Constructor */
- BinnedArray1D* clone() const final
- { return new BinnedArray1D(*this); }
-
- /**Virtual Destructor*/
- ~BinnedArray1D()
- {
- delete m_binUtility;
- }
-
- /** Returns the pointer to the templated class object from the BinnedArray,
- it returns nullptr if not defined */
- T object(const Vector2D& lp) const final
- { return (BinnedArray<T>::m_arrayObjects[m_binUtility->bin(lp, 0)]); }
-
- /** Returns the pointer to the templated class object from the BinnedArray
- it returns nullptr if not defined */
- T object(const Vector3D& gp) const final
- { return (BinnedArray<T>::m_arrayObjects[m_binUtility->bin(gp, 0)]); }
-
- /** Returns the pointer to the templated class object from the BinnedArray - entry point*/
- T entryObject(const Vector3D& gp) const final
- { return (BinnedArray<T>::m_arrayObjects[m_binUtility->entry(gp, 0)]); }
-
- /** Return the BinUtility*/
- const BinUtility* binUtility() const { return(m_binUtility); }
-
- private:
- BinUtility* m_binUtility; //!< binUtility for retrieving and filling the Array
-
- };
-
-} // end of namespace Acts
-
-#endif // ACTS_GEOMETRYUTILS_BINNEDARRAY1D_H
+template <class T>
+class BinnedArray1D : public BinnedArray<T>
+{
+public:
+ /**Default Constructor - needed for inherited classes */
+ BinnedArray1D() : BinnedArray<T>(), m_binUtility(0) {}
+ /** Constructor with std::vector< pair < object, position> > and a BinUtility
+ * to sort the objects into the bin */
+ BinnedArray1D(const std::vector<std::pair<T, Vector3D>>& tclassvector,
+ BinUtility* bingen) throw(std::string)
+ : BinnedArray<T>(), m_binUtility(bingen)
+ {
+ // prepare the binned Array
+ if (bingen) {
+ // get the size of the object array and reserve accoridngly
+ size_t vecsize = tclassvector.size();
+ BinnedArray<T>::m_arrayObjects = std::vector<T>(vecsize, nullptr);
+ // fill into the new
+ for (size_t ivec = 0; ivec < vecsize; ++ivec) {
+ Vector3D currentGlobal(((tclassvector[ivec]).second));
+ if (bingen->inside(currentGlobal))
+ BinnedArray<T>::m_arrayObjects[bingen->bin(currentGlobal, 0)]
+ = ((tclassvector)[ivec]).first;
+ else
+ throw "Object outside bounds";
+ }
+ }
+ }
+
+ /**Copy Constructor - copies only pointers !*/
+ BinnedArray1D(const BinnedArray1D& barr) throw(std::string)
+ : BinnedArray<T>(barr), m_binUtility(nullptr)
+ {
+ // clone the Bin utility for the copy constructor
+ if (barr.m_binUtility)
+ m_binUtility = barr.m_binUtility->clone();
+ else
+ throw "No BinUtility provided";
+ }
+
+ /**Assignment operator*/
+ BinnedArray1D&
+ operator=(const BinnedArray1D& barr)
+ {
+ if (this != &barr) {
+ // now refill
+ m_binUtility = (barr.m_binUtility) ? barr.m_binUtility->clone() : nullptr;
+ BinnedArray<T>::m_arrayObjects = barr.m_arrayObjects;
+ }
+ return *this;
+ }
+
+ /** Implicit Constructor */
+ BinnedArray1D*
+ clone() const final
+ {
+ return new BinnedArray1D(*this);
+ }
+
+ /**Virtual Destructor*/
+ ~BinnedArray1D() { delete m_binUtility; }
+ /** Returns the pointer to the templated class object from the BinnedArray,
+ it returns nullptr if not defined */
+ T
+ object(const Vector2D& lp) const final
+ {
+ return (BinnedArray<T>::m_arrayObjects[m_binUtility->bin(lp, 0)]);
+ }
+
+ /** Returns the pointer to the templated class object from the BinnedArray
+ it returns nullptr if not defined */
+ T
+ object(const Vector3D& gp) const final
+ {
+ return (BinnedArray<T>::m_arrayObjects[m_binUtility->bin(gp, 0)]);
+ }
+
+ /** Returns the pointer to the templated class object from the BinnedArray -
+ * entry point*/
+ T
+ entryObject(const Vector3D& gp) const final
+ {
+ return (BinnedArray<T>::m_arrayObjects[m_binUtility->entry(gp, 0)]);
+ }
+
+ /** Return the BinUtility*/
+ const BinUtility*
+ binUtility() const
+ {
+ return (m_binUtility);
+ }
+
+private:
+ BinUtility*
+ m_binUtility; //!< binUtility for retrieving and filling the Array
+};
+
+} // end of namespace Acts
+
+#endif // ACTS_GEOMETRYUTILS_BINNEDARRAY1D_H
diff --git a/Core/include/ACTS/Utilities/BinnedArray2D.hpp b/Core/include/ACTS/Utilities/BinnedArray2D.hpp
index 7b5248354..d09b2dfe2 100644
--- a/Core/include/ACTS/Utilities/BinnedArray2D.hpp
+++ b/Core/include/ACTS/Utilities/BinnedArray2D.hpp
@@ -14,131 +14,141 @@
#define ACTS_GEOMETRYUTILS_BINNEDARRAY2D_H 1
// Geometry module
-#include "ACTS/Utilities/BinnedArray.hpp"
#include "ACTS/Utilities/BinUtility.hpp"
+#include "ACTS/Utilities/BinnedArray.hpp"
// STL
#include <vector>
-//debug
+// debug
#include <iostream>
class MsgStream;
namespace Acts {
-
- /** @class BinnedArray2D
-
- Avoiding a map search, the templated BinnedArray class can help
- ordereing geometrical objects by providing a dedicated BinUtility.
-
- dedicated for 2-dim regular binning
-
- */
-
- template <class T> class BinnedArray2D : public BinnedArray<T> {
-
- public:
-
- /**Default Constructor - needed for inherited classes */
- BinnedArray2D() :
- BinnedArray<T>(),
- m_binUtility(0)
- {}
-
- /**Constructor with std::vector and a BinUtility - reference counted, will delete objects at the end,
- if this deletion should be turned off, the boolean deletion should be switched to false
- the global position is given by object! */
- BinnedArray2D(const std::vector< std::pair< T, Vector3D > >& tclassvector, BinUtility* bingen) :
- BinnedArray<T>(),
- m_binUtility(bingen)
- {
- if (bingen){
- m_array = std::vector< std::vector< T > >(bingen->bins(1));
- for (size_t i=0; i < bingen->bins(1); ++i)
- m_array[i] = std::vector< T >(bingen->bins(0),nullptr);
- // fill the Volume vector into the array
- size_t vecsize = tclassvector.size();
- for (size_t ivec = 0; ivec < vecsize; ++ivec) {
- Vector3D currentGlobal(((tclassvector[ivec]).second));
- if (bingen->inside(currentGlobal)){
- // the object
- T object = ((tclassvector)[ivec]).first;
- // assign to the array store
- ((m_array)[bingen->bin(currentGlobal,1)])[bingen->bin(currentGlobal,0)] = object;
- // also fill the one-dimensional store - only if unique ones though
- auto beginIter = BinnedArray<T>::m_arrayObjects.begin();
- auto endIter = BinnedArray<T>::m_arrayObjects.end();
- if (std::find(beginIter,endIter,object) == endIter)
- BinnedArray<T>::m_arrayObjects.push_back(object);
- } else throw "BinnedArray2D";
- }
- } else throw "BinnedArray2D";
- }
-
- /**Copy Constructor - copies only pointers !*/
- BinnedArray2D(const BinnedArray2D& barr) :
- BinnedArray<T>(barr),
- m_array(barr.m_array),
- m_binUtility(nullptr)
- {
- m_binUtility = (barr.m_binUtility) ? barr.m_binUtility->clone() : nullptr;
- }
-
- /**Assignment operator*/
- BinnedArray2D& operator=(const BinnedArray2D& barr)
- {
- if (this != &barr){
- delete m_binUtility;
- // now refill - copy
- m_binUtility = (barr.m_binUtility) ? barr.m_binUtility->clone() : 0;
- // array copying
- m_array = barr.m_array;
- BinnedArray<T>::m_arrayObjects = barr.m_arrayObjects;
- }
- return *this;
- }
-
- /** Implizit Constructor */
- BinnedArray2D* clone() const
- { return new BinnedArray2D(*this); }
-
- /**Virtual Destructor*/
- ~BinnedArray2D()
- {
- delete m_binUtility;
- }
-
- /** Returns the object in the array from a local position */
- T object(const Vector2D& lp) const final
- {
- return (((m_array)[m_binUtility->bin(lp, 1)]))[m_binUtility->bin(lp, 0)];
- }
-
- /** Returns the object in the array from a global position */
- T object(const Vector3D& gp) const final
- {
- return (((m_array)[m_binUtility->bin(gp, 1)]))[m_binUtility->bin(gp, 0)];
- }
-
- /** Returns the entry object in the array from a global position */
- T entryObject(const Vector3D& pos) const final
- {
- return (((m_array)[m_binUtility->entry(pos, 1)]))[m_binUtility->entry(pos, 0)];
- }
-
- /** Returns the objects in an odered fashion */
- const std::vector< std::vector< T > >& arrayObjectsOrdered() const { return m_array; }
-
- /** Return the BinUtility*/
- const BinUtility* binUtility() const { return(m_binUtility); }
-
- private:
-
- std::vector< std::vector< T > > m_array; //!< vector of pointers to the class T
- BinUtility* m_binUtility; //!< binUtility for retrieving and filling the Array
-
- };
-
-
-} // end of namespace Acts
-
-#endif // ACTS_GEOMETRYUTILS_BINNEDARRAY2D_H
+
+/** @class BinnedArray2D
+
+ Avoiding a map search, the templated BinnedArray class can help
+ ordereing geometrical objects by providing a dedicated BinUtility.
+
+ dedicated for 2-dim regular binning
+
+ */
+
+template <class T>
+class BinnedArray2D : public BinnedArray<T>
+{
+public:
+ /**Default Constructor - needed for inherited classes */
+ BinnedArray2D() : BinnedArray<T>(), m_binUtility(0) {}
+ /**Constructor with std::vector and a BinUtility - reference counted, will
+ delete objects at the end,
+ if this deletion should be turned off, the boolean deletion should be
+ switched to false
+ the global position is given by object! */
+ BinnedArray2D(const std::vector<std::pair<T, Vector3D>>& tclassvector,
+ BinUtility* bingen)
+ : BinnedArray<T>(), m_binUtility(bingen)
+ {
+ if (bingen) {
+ m_array = std::vector<std::vector<T>>(bingen->bins(1));
+ for (size_t i = 0; i < bingen->bins(1); ++i)
+ m_array[i] = std::vector<T>(bingen->bins(0), nullptr);
+ // fill the Volume vector into the array
+ size_t vecsize = tclassvector.size();
+ for (size_t ivec = 0; ivec < vecsize; ++ivec) {
+ Vector3D currentGlobal(((tclassvector[ivec]).second));
+ if (bingen->inside(currentGlobal)) {
+ // the object
+ T object = ((tclassvector)[ivec]).first;
+ // assign to the array store
+ ((m_array)[bingen->bin(currentGlobal, 1)])[bingen->bin(currentGlobal,
+ 0)]
+ = object;
+ // also fill the one-dimensional store - only if unique ones though
+ auto beginIter = BinnedArray<T>::m_arrayObjects.begin();
+ auto endIter = BinnedArray<T>::m_arrayObjects.end();
+ if (std::find(beginIter, endIter, object) == endIter)
+ BinnedArray<T>::m_arrayObjects.push_back(object);
+ } else
+ throw "BinnedArray2D";
+ }
+ } else
+ throw "BinnedArray2D";
+ }
+
+ /**Copy Constructor - copies only pointers !*/
+ BinnedArray2D(const BinnedArray2D& barr)
+ : BinnedArray<T>(barr), m_array(barr.m_array), m_binUtility(nullptr)
+ {
+ m_binUtility = (barr.m_binUtility) ? barr.m_binUtility->clone() : nullptr;
+ }
+
+ /**Assignment operator*/
+ BinnedArray2D&
+ operator=(const BinnedArray2D& barr)
+ {
+ if (this != &barr) {
+ delete m_binUtility;
+ // now refill - copy
+ m_binUtility = (barr.m_binUtility) ? barr.m_binUtility->clone() : 0;
+ // array copying
+ m_array = barr.m_array;
+ BinnedArray<T>::m_arrayObjects = barr.m_arrayObjects;
+ }
+ return *this;
+ }
+
+ /** Implizit Constructor */
+ BinnedArray2D*
+ clone() const
+ {
+ return new BinnedArray2D(*this);
+ }
+
+ /**Virtual Destructor*/
+ ~BinnedArray2D() { delete m_binUtility; }
+ /** Returns the object in the array from a local position */
+ T
+ object(const Vector2D& lp) const final
+ {
+ return (((m_array)[m_binUtility->bin(lp, 1)]))[m_binUtility->bin(lp, 0)];
+ }
+
+ /** Returns the object in the array from a global position */
+ T
+ object(const Vector3D& gp) const final
+ {
+ return (((m_array)[m_binUtility->bin(gp, 1)]))[m_binUtility->bin(gp, 0)];
+ }
+
+ /** Returns the entry object in the array from a global position */
+ T
+ entryObject(const Vector3D& pos) const final
+ {
+ return (
+ ((m_array)[m_binUtility->entry(pos, 1)]))[m_binUtility->entry(pos, 0)];
+ }
+
+ /** Returns the objects in an odered fashion */
+ const std::vector<std::vector<T>>&
+ arrayObjectsOrdered() const
+ {
+ return m_array;
+ }
+
+ /** Return the BinUtility*/
+ const BinUtility*
+ binUtility() const
+ {
+ return (m_binUtility);
+ }
+
+private:
+ std::vector<std::vector<T>> m_array; //!< vector of pointers to the class T
+ BinUtility*
+ m_binUtility; //!< binUtility for retrieving and filling the Array
+};
+
+} // end of namespace Acts
+
+#endif // ACTS_GEOMETRYUTILS_BINNEDARRAY2D_H
diff --git a/Core/include/ACTS/Utilities/BinningData.hpp b/Core/include/ACTS/Utilities/BinningData.hpp
index c29408fe8..140786233 100644
--- a/Core/include/ACTS/Utilities/BinningData.hpp
+++ b/Core/include/ACTS/Utilities/BinningData.hpp
@@ -15,537 +15,642 @@
// Core module
#include "ACTS/Utilities/BinningType.hpp"
-#include <vector>
-#include <utility>
#include <cmath>
+#include <utility>
+#include <vector>
#include "Definitions.hpp"
-//debug
+// debug
#include <iostream>
namespace Acts {
- /** @class BinningData
-
- This class holds all the data necessary for the bin calculation
-
- phi has a very particular behaviour:
- - there's the change around +/- PI
-
- @TODO add description of convention for sub structure - it can be multiplicative or additive
- multiplicative : each bin has the same sub structure, i.e. first binnning structure is equidistant
- additive : sub structure replaces one bin (and one bin only)
-
- */
-
- class BinningData {
-
- public :
- /** holding all the data for binning calculatuion */
- BinningType type;
- BinningOption option;
- BinningValue binvalue;
- float min;
- float max;
- float step;
- // specialized for H binning @TODO write documetnation
- float refphi; // ref Phi for binH
- std::vector<std::pair<int,float> > hbounds; // boundary for binH
- // sub structure
- BinningData* subBinningData; // describe some sub binning structure
- bool subBinningAdditive; // sub binnint is either additive or multipicative
-
- /** Constructor for equidistant binning - and optional sub structure can be mulitplicative or additive */
- BinningData ( BinningOption bOption,
- BinningValue bValue,
- size_t bBins,
- float bMin,
- float bMax,
- BinningData* sBinData = nullptr,
- bool sBinAdditive = false) :
- type(equidistant),
- option(bOption),
- binvalue(bValue),
- min(bMin),
- max(bMax),
- step( (bMax-bMin)/bBins ),
- refphi(0.),
- hbounds(std::vector<std::pair<int,float> >()),
- subBinningData( sBinData ),
- subBinningAdditive(sBinAdditive),
- m_bins(bBins),
- m_boundaries(std::vector<float>()),
- m_totalBins(bBins),
- m_totalBoundaries(std::vector<float>()),
- m_functionPtr(nullptr),
- m_mixPtr(nullptr)
- {
- // set to equidistant search
+/** @class BinningData
+
+ This class holds all the data necessary for the bin calculation
+
+ phi has a very particular behaviour:
+ - there's the change around +/- PI
+
+ @TODO add description of convention for sub structure - it can be
+ multiplicative or additive
+ multiplicative : each bin has the same sub structure, i.e. first binnning
+ structure is equidistant
+ additive : sub structure replaces one bin (and one bin only)
+
+*/
+
+class BinningData
+{
+public:
+ /** holding all the data for binning calculatuion */
+ BinningType type;
+ BinningOption option;
+ BinningValue binvalue;
+ float min;
+ float max;
+ float step;
+ // specialized for H binning @TODO write documetnation
+ float refphi; // ref Phi for binH
+ std::vector<std::pair<int, float>> hbounds; // boundary for binH
+ // sub structure
+ BinningData* subBinningData; // describe some sub binning structure
+ bool subBinningAdditive; // sub binnint is either additive or multipicative
+
+ /** Constructor for equidistant binning - and optional sub structure can be
+ * mulitplicative or additive */
+ BinningData(BinningOption bOption,
+ BinningValue bValue,
+ size_t bBins,
+ float bMin,
+ float bMax,
+ BinningData* sBinData = nullptr,
+ bool sBinAdditive = false)
+ : type(equidistant)
+ , option(bOption)
+ , binvalue(bValue)
+ , min(bMin)
+ , max(bMax)
+ , step((bMax - bMin) / bBins)
+ , refphi(0.)
+ , hbounds(std::vector<std::pair<int, float>>())
+ , subBinningData(sBinData)
+ , subBinningAdditive(sBinAdditive)
+ , m_bins(bBins)
+ , m_boundaries(std::vector<float>())
+ , m_totalBins(bBins)
+ , m_totalBoundaries(std::vector<float>())
+ , m_functionPtr(nullptr)
+ , m_mixPtr(nullptr)
+ {
+ // set to equidistant search
+ m_functionPtr = &searchEquidstantWithBoundary;
+ // fill the boundary vector for fast access to center & boundaries
+ m_boundaries.reserve(m_bins + 1);
+ for (size_t ib = 0; ib < m_bins + 1; ++ib)
+ m_boundaries.push_back(min + ib * step);
+ // the binning data has sub structure - multiplicative or additive
+ checkSubStructure();
+ }
+
+ /** Constructor for equidistant binning - and optional sub structure can only
+ * be additive */
+ BinningData(BinningOption bOption,
+ BinningValue bValue,
+ const std::vector<float> bBoundaries,
+ BinningData* sBinData = nullptr)
+ : type(arbitrary)
+ , option(bOption)
+ , binvalue(bValue)
+ , min(0.)
+ , max(0.)
+ , step(0.)
+ , refphi(0.)
+ , hbounds(std::vector<std::pair<int, float>>())
+ , subBinningData(sBinData)
+ , subBinningAdditive(true)
+ , m_bins(bBoundaries.size() - 1)
+ , m_boundaries(bBoundaries)
+ , m_totalBins(bBoundaries.size())
+ , m_totalBoundaries(bBoundaries)
+ , m_functionPtr(nullptr)
+ , m_mixPtr(nullptr)
+ {
+ // assert a no-size case
+ assert(m_boundaries.size() > 1);
+ min = m_boundaries[0];
+ max = m_boundaries[m_boundaries.size() - 1];
+ // set to equidistant search
+ m_functionPtr
+ = m_bins < 50 ? &searchInVectorWithBoundary : &binarySearchWithBoundary;
+ // the binning data has sub structure - multiplicative
+ checkSubStructure();
+ }
+
+ /** Constructor for binH type : non-equidistant binning assumed */
+ BinningData(BinningOption bOption,
+ float bRefPhi,
+ const std::vector<std::pair<int, float>>& bBoundaries)
+ : type(arbitrary)
+ , option(bOption)
+ , binvalue(binH)
+ , min(bBoundaries.front().second)
+ , max(bBoundaries.back().second)
+ , step(1.)
+ , // non-zero value needed for next()
+ refphi(bRefPhi)
+ , hbounds(bBoundaries)
+ , subBinningData(nullptr)
+ , subBinningAdditive(false)
+ , m_bins(bOption == open ? bBoundaries.size() - 1 : bBoundaries.size())
+ , m_boundaries(std::vector<float>())
+ , m_totalBins(0)
+ , m_totalBoundaries(std::vector<float>())
+ , m_functionPtr(nullptr)
+ , m_mixPtr(&searchInVectorWithMixedBoundary)
+ {
+ }
+
+ /** Copy constructor */
+ BinningData(const BinningData& bdata)
+ : type(bdata.type)
+ , option(bdata.option)
+ , binvalue(bdata.binvalue)
+ , min(bdata.min)
+ , max(bdata.max)
+ , step(bdata.step)
+ , // non-zero value needed for next()
+ refphi(bdata.refphi)
+ , hbounds(bdata.hbounds)
+ , subBinningData(nullptr)
+ , subBinningAdditive(bdata.subBinningAdditive)
+ , m_bins(bdata.m_bins)
+ , m_boundaries(bdata.m_boundaries)
+ , m_totalBins(bdata.m_totalBins)
+ , m_totalBoundaries(bdata.m_totalBoundaries)
+ , m_functionPtr(nullptr)
+ , m_mixPtr(nullptr)
+ {
+ // get the binning data
+ subBinningData = bdata.subBinningData
+ ? new BinningData(*bdata.subBinningData)
+ : nullptr;
+ // set the pointer depending on the type
+ if (binvalue == binH) {
+ // set the mixed function ptr
+ m_mixPtr = &searchInVectorWithMixedBoundary;
+ } else {
+ // set the correct function pointer
+ if (type == equidistant)
m_functionPtr = &searchEquidstantWithBoundary;
- // fill the boundary vector for fast access to center & boundaries
- m_boundaries.reserve(m_bins+1);
- for (size_t ib=0; ib < m_bins+1; ++ib)
- m_boundaries.push_back(min+ib*step);
- // the binning data has sub structure - multiplicative or additive
- checkSubStructure();
- }
-
- /** Constructor for equidistant binning - and optional sub structure can only be additive */
- BinningData ( BinningOption bOption,
- BinningValue bValue,
- const std::vector<float> bBoundaries,
- BinningData* sBinData = nullptr) :
- type(arbitrary),
- option(bOption),
- binvalue(bValue),
- min(0.),
- max(0.),
- step(0.),
- refphi(0.),
- hbounds(std::vector<std::pair<int,float> >()),
- subBinningData( sBinData ),
- subBinningAdditive(true),
- m_bins(bBoundaries.size()-1),
- m_boundaries(bBoundaries),
- m_totalBins(bBoundaries.size()),
- m_totalBoundaries(bBoundaries),
- m_functionPtr(nullptr),
- m_mixPtr(nullptr)
- {
- // assert a no-size case
- assert(m_boundaries.size()>1);
- min = m_boundaries[0];
- max = m_boundaries[m_boundaries.size()-1];
- // set to equidistant search
- m_functionPtr = m_bins < 50 ? &searchInVectorWithBoundary : &binarySearchWithBoundary;
- // the binning data has sub structure - multiplicative
- checkSubStructure();
- }
-
- /** Constructor for binH type : non-equidistant binning assumed */
- BinningData ( BinningOption bOption, float bRefPhi,
- const std::vector< std::pair<int,float> >& bBoundaries) :
- type(arbitrary),
- option(bOption),
- binvalue(binH),
- min(bBoundaries.front().second),
- max(bBoundaries.back().second),
- step(1.), // non-zero value needed for next()
- refphi(bRefPhi),
- hbounds(bBoundaries),
- subBinningData(nullptr),
- subBinningAdditive(false),
- m_bins(bOption==open? bBoundaries.size()-1 : bBoundaries.size()),
- m_boundaries(std::vector<float>()),
- m_totalBins(0),
- m_totalBoundaries(std::vector<float>()),
- m_functionPtr( nullptr ),
- m_mixPtr( &searchInVectorWithMixedBoundary )
- {}
-
- /** Copy constructor */
- BinningData (const BinningData& bdata) :
- type(bdata.type),
- option(bdata.option),
- binvalue(bdata.binvalue),
- min(bdata.min),
- max(bdata.max),
- step(bdata.step), // non-zero value needed for next()
- refphi(bdata.refphi),
- hbounds(bdata.hbounds),
- subBinningData ( nullptr ),
- subBinningAdditive(bdata.subBinningAdditive),
- m_bins(bdata.m_bins),
- m_boundaries(bdata.m_boundaries),
- m_totalBins(bdata.m_totalBins),
- m_totalBoundaries(bdata.m_totalBoundaries),
- m_functionPtr( nullptr ),
- m_mixPtr( nullptr )
- {
- // get the binning data
- subBinningData = bdata.subBinningData ? new BinningData(*bdata.subBinningData) : nullptr;
- // set the pointer depending on the type
- if (binvalue == binH){
- // set the mixed function ptr
- m_mixPtr = &searchInVectorWithMixedBoundary;
- } else {
- // set the correct function pointer
- if (type == equidistant) m_functionPtr = &searchEquidstantWithBoundary;
- else m_functionPtr = m_bins < 50 ? &searchInVectorWithBoundary : &binarySearchWithBoundary;
+ else
+ m_functionPtr = m_bins < 50 ? &searchInVectorWithBoundary
+ : &binarySearchWithBoundary;
+ }
+ }
+
+ /** assignment operator */
+ BinningData&
+ operator=(const BinningData& bdata)
+ {
+ if (this != &bdata) {
+ type = bdata.type;
+ option = bdata.option;
+ binvalue = bdata.binvalue;
+ min = bdata.min;
+ max = bdata.max;
+ step = bdata.step;
+ refphi = bdata.refphi;
+ hbounds = bdata.hbounds;
+ subBinningAdditive = bdata.subBinningAdditive;
+ subBinningData = bdata.subBinningData
+ ? new BinningData(*bdata.subBinningData)
+ : nullptr;
+ m_bins = bdata.m_bins;
+ m_boundaries = bdata.m_boundaries;
+ m_totalBins = bdata.m_totalBins;
+ m_totalBoundaries = bdata.m_totalBoundaries;
+ // set the pointer depending on the type
+ if (binvalue == binH) {
+ // set the mixed function ptr
+ m_mixPtr = &searchInVectorWithMixedBoundary;
+ } else {
+ // set the correct function pointer
+ if (type == equidistant)
+ m_functionPtr = &searchEquidstantWithBoundary;
+ else
+ m_functionPtr = m_bins < 50 ? &searchInVectorWithBoundary
+ : &binarySearchWithBoundary;
+ }
+ }
+ return (*this);
+ }
+
+ /** Destructor */
+ ~BinningData() { delete subBinningData; }
+ /** return the number of bins - including sub bins */
+ size_t
+ bins() const
+ {
+ return m_totalBins;
+ }
+
+ /** return the boundaries - including sub boundaries */
+ const std::vector<float>&
+ boundaries() const
+ {
+ if (subBinningData) return m_totalBoundaries;
+ return m_boundaries;
+ }
+
+ /** take the right float value - assumes the correct local position expression
+ */
+ float
+ value(const Vector2D& lposition) const
+ {
+ // ordered after occurence
+ if (binvalue == binR || binvalue == binRPhi || binvalue == binX
+ || binvalue == binH)
+ return lposition[0];
+ if (binvalue == binPhi) return gaugePhi(lposition[1]);
+ return lposition[1];
+ }
+
+ /** take the right float value */
+ float
+ value(const Vector3D& position) const
+ {
+ // ordered after occurence
+ if (binvalue == binR || binvalue == binH) return (position.perp());
+ if (binvalue == binRPhi) return (position.perp() * position.phi());
+ if (binvalue == binEta) return (position.eta());
+ if (binvalue < 3) return (position[binvalue]);
+ // phi gauging
+ return gaugePhi(position.phi());
+ }
+
+ /** gauge phi */
+ float
+ gaugePhi(float phi) const
+ {
+ if (max > M_PI && phi < min && phi < 0.) {
+ phi += 2. * M_PI;
+ }
+ return phi;
+ }
+
+ /** take float values for binH */
+ std::pair<float, float>
+ valueH(const Vector2D& lposition) const
+ {
+ return (std::pair<double, double>(
+ lposition[0], lposition[0] * cos(fabs(refphi - lposition[1]))));
+ }
+
+ /** take float values for binH */
+ std::pair<float, float>
+ valueH(const Vector3D& position) const
+ {
+ return (std::pair<double, double>(
+ position.perp(), position.perp() * cos(fabs(position.phi() - refphi))));
+ }
+
+ /** Check if bin is inside from Vector3D */
+ bool
+ inside(const Vector3D& position) const
+ {
+ // closed one is always inside
+ if (option == closed) return true;
+ // all other options except value H
+ if (binvalue != binH) {
+ float val = value(position);
+ return (val > min - 0.001 && val < max + 0.001);
+ }
+ // value H case
+ std::pair<double, double> valH = valueH(position);
+ float valmin = hbounds.front().first == 0 ? valH.first : valH.second;
+ float valmax = hbounds.back().first == 0 ? valH.first : valH.second;
+ return (valmin > min - 0.001 && valmax < max + 0.001);
+ }
+
+ /** Check if bin is inside from Vector2D */
+ bool
+ inside(const Vector2D& lp) const
+ {
+ if (option == closed) return true;
+ if (binvalue != binH) {
+ float val = value(lp);
+ return (val > min - 0.001 && val < max + 0.001);
+ }
+ std::pair<double, double> valH = valueH(lp);
+ float valmin = hbounds.front().first == 0 ? valH.first : valH.second;
+ float valmax = hbounds.back().first == 0 ? valH.first : valH.second;
+ return (valmin > min - 0.001 && valmax < max + 0.001);
+ }
+
+ /** generic search from a 2D position --- corresponds to local coordinate
+ * schema */
+ size_t
+ searchLocal(const Vector2D& lposition) const
+ {
+ return (binvalue == binH) ? searchH(valueH(lposition))
+ : search(value(lposition));
+ }
+
+ /** generic search from a 3D position */
+ size_t
+ searchGlobal(const Vector3D& position) const
+ {
+ return (binvalue == binH) ? searchH(valueH(position))
+ : search(value(position));
+ }
+
+ /** generic search - forwards to correct function pointer */
+ size_t
+ search(float value) const
+ {
+ assert(m_functionPtr != nullptr);
+ return (!subBinningData) ? (*m_functionPtr)(value, *this)
+ : searchWithSubStructure(value);
+ }
+
+ /** generic search sub structure - forwards to correct function pointer */
+ size_t
+ searchWithSubStructure(float value) const
+ {
+ // find the masterbin with the correct function pointer
+ size_t masterbin = (*m_functionPtr)(value, *this);
+ // additive sub binning -
+ if (subBinningAdditive) {
+ // no gauging done, for additive sub structure
+ return masterbin + subBinningData->search(value);
+ }
+ // gauge the value to the subBinData
+ float gvalue
+ = value - masterbin * (subBinningData->max - subBinningData->min);
+ // now go / additive or multiplicative
+ size_t subbin = subBinningData->search(gvalue);
+ // now return
+ return masterbin * subBinningData->bins() + subbin;
+ }
+
+ /** generic search - forwards to correct function pointer */
+ size_t
+ searchH(std::pair<double, double> value) const
+ {
+ assert(m_mixPtr != nullptr);
+ return (*m_mixPtr)(value, *this);
+ }
+
+ /** the entry bin */
+ size_t
+ entry(const Vector3D& position) const
+ {
+ size_t bin = (binvalue == binH) ? searchH(valueH(position))
+ : search(value(position));
+ return (bin < m_bins - bin) ? bin : m_bins - 1;
+ }
+
+ /** layer next direction is needed */
+ int
+ nextDirection(const Vector3D& position, const Vector3D& dir) const
+ {
+ float val = (binvalue == binH) ? valueH(position).first : value(position);
+ Vector3D probe = position + dir.normalized();
+ float nextval = (binvalue == binH) ? valueH(probe).first : value(probe);
+ return (nextval > val) ? 1 : -1;
+ }
+
+ /** the next bin : gives -1 if the next one is outside */
+ size_t
+ next(const Vector3D& position, const Vector3D& dir) const
+ {
+ float val = value(position);
+ Vector3D probe = position + 0.5 * step * dir.normalized();
+ float nextval = value(probe);
+ int bin = (binvalue == binH) ? searchH(valueH(position)) : search(val);
+ bin = (nextval > val && bin != int(m_bins - 1)) ? bin + 1 : (bin) ? bin - 1
+ : 0;
+ // closed setup
+ if (option == closed)
+ return (bin < 0 || bin + 1 > int(m_bins)) ? ((bin < 0) ? m_bins - 1 : 0)
+ : bin;
+ // open setup
+ return bin;
+ }
+
+ /** distance to the next bin : gives -1 if the next one is outside */
+ std::pair<size_t, float>
+ distanceToNext(const Vector3D& position, const Vector3D& dir) const
+ {
+ // current value
+ float val = (binvalue == binH) ? valueH(position).first : value(position);
+ // probe value
+ Vector3D probe = position + 0.5 * step * dir.normalized();
+ float nextval = (binvalue == binH) ? valueH(probe).first : value(probe);
+ // current bin
+ int bin0 = (binvalue == binH) ? searchH(valueH(position)) : search(val);
+ // next bin
+ int bin = (nextval - val) > 0. ? bin0 + 1 : bin0 - 1;
+ if (bin > int(m_bins) - 1) bin = (option == closed) ? 0 : bin0;
+ if (bin < 0) bin = (option == closed) ? m_bins - 1 : 0;
+
+ // boundary value
+ float bval = 0.;
+ if (binvalue == binH) {
+ bval = (nextval > val) ? hbounds[bin0 + 1].second
+ : hbounds[bin0].second; // non-equidistant
+
+ // may need to recalculate current value and probe
+ if (nextval > val) {
+ if (hbounds[bin0 + 1].first > 0) {
+ val = valueH(position).second;
+ nextval = valueH(probe).second;
+ }
+ } else {
+ if (hbounds[bin0].first > 0) {
+ val = valueH(position).second;
+ nextval = valueH(probe).second;
}
- }
-
- /** assignment operator */
- BinningData& operator=(const BinningData& bdata)
- {
- if (this!=&bdata){
- type = bdata.type;
- option = bdata.option;
- binvalue = bdata.binvalue;
- min = bdata.min;
- max = bdata.max;
- step = bdata.step;
- refphi = bdata.refphi;
- hbounds = bdata.hbounds;
- subBinningAdditive = bdata.subBinningAdditive;
- subBinningData = bdata.subBinningData ? new BinningData(*bdata.subBinningData) : nullptr;
- m_bins = bdata.m_bins;
- m_boundaries = bdata.m_boundaries;
- m_totalBins = bdata.m_totalBins;
- m_totalBoundaries = bdata.m_totalBoundaries;
- // set the pointer depending on the type
- if (binvalue == binH){
- // set the mixed function ptr
- m_mixPtr = &searchInVectorWithMixedBoundary;
- } else {
- // set the correct function pointer
- if (type == equidistant) m_functionPtr = &searchEquidstantWithBoundary;
- else m_functionPtr = m_bins < 50 ? &searchInVectorWithBoundary : &binarySearchWithBoundary;
- }
- }
- return (*this);
}
-
- /** Destructor */
- ~BinningData(){
- delete subBinningData;
- }
-
- /** return the number of bins - including sub bins */
- size_t bins() const { return m_totalBins; }
-
- /** return the boundaries - including sub boundaries */
- const std::vector<float>& boundaries() const {
- if (subBinningData) return m_totalBoundaries;
- return m_boundaries;
- }
-
- /** take the right float value - assumes the correct local position expression */
- float value(const Vector2D& lposition) const {
- // ordered after occurence
- if ( binvalue == binR || binvalue == binRPhi || binvalue == binX || binvalue == binH ) return lposition[0];
- if ( binvalue == binPhi ) return gaugePhi(lposition[1]);
- return lposition[1];
- }
-
- /** take the right float value */
- float value(const Vector3D& position) const {
- // ordered after occurence
- if ( binvalue == binR || binvalue == binH ) return (position.perp());
- if ( binvalue == binRPhi ) return (position.perp()*position.phi());
- if ( binvalue == binEta ) return (position.eta());
- if ( binvalue < 3 ) return (position[binvalue]);
- // phi gauging
- return gaugePhi(position.phi());
- }
-
- /** gauge phi */
- float gaugePhi(float phi) const {
- if (max > M_PI && phi < min && phi < 0.){
- phi += 2.*M_PI;
- }
- return phi;
- }
-
- /** take float values for binH */
- std::pair<float,float> valueH(const Vector2D& lposition ) const {
- return (std::pair<double,double> (lposition[0],lposition[0]*cos(fabs(refphi-lposition[1]))));
- }
-
- /** take float values for binH */
- std::pair<float,float> valueH(const Vector3D& position ) const {
- return (std::pair<double,double> (position.perp(),position.perp()*cos(fabs(position.phi()-refphi))));
- }
-
- /** Check if bin is inside from Vector3D */
- bool inside(const Vector3D& position) const {
- // closed one is always inside
- if (option == closed) return true;
- // all other options except value H
- if ( binvalue != binH ) {
- float val = value(position);
- return ( val > min-0.001 && val < max+0.001);
- }
- // value H case
- std::pair<double,double> valH = valueH(position);
- float valmin = hbounds.front().first==0 ? valH.first : valH.second;
- float valmax = hbounds.back().first==0 ? valH.first : valH.second;
- return ( valmin > min-0.001 && valmax < max+0.001);
- }
-
- /** Check if bin is inside from Vector2D */
- bool inside(const Vector2D& lp) const {
- if (option == closed) return true;
- if ( binvalue != binH ) {
- float val = value(lp);
- return ( val > min-0.001 && val < max+0.001);
- }
- std::pair<double,double> valH = valueH(lp);
- float valmin = hbounds.front().first==0 ? valH.first : valH.second;
- float valmax = hbounds.back().first==0 ? valH.first : valH.second;
- return ( valmin > min-0.001 && valmax < max+0.001);
- }
-
- /** generic search from a 2D position --- corresponds to local coordinate schema */
- size_t searchLocal(const Vector2D& lposition) const {
- return (binvalue==binH) ? searchH(valueH(lposition)) : search(value(lposition));
- }
-
- /** generic search from a 3D position */
- size_t searchGlobal(const Vector3D& position) const {
- return (binvalue==binH) ? searchH(valueH(position)) : search(value(position));
- }
-
- /** generic search - forwards to correct function pointer */
- size_t search(float value) const {
- assert(m_functionPtr != nullptr);
- return (!subBinningData) ? (*m_functionPtr)(value, *this) : searchWithSubStructure(value);
- }
-
- /** generic search sub structure - forwards to correct function pointer */
- size_t searchWithSubStructure(float value) const {
- // find the masterbin with the correct function pointer
- size_t masterbin = (*m_functionPtr)(value, *this);
- // additive sub binning -
- if (subBinningAdditive) {
- // no gauging done, for additive sub structure
- return masterbin + subBinningData->search(value);
- }
- // gauge the value to the subBinData
- float gvalue = value - masterbin*(subBinningData->max-subBinningData->min);
- // now go / additive or multiplicative
- size_t subbin = subBinningData->search(gvalue);
- // now return
- return masterbin*subBinningData->bins() + subbin;
- }
-
- /** generic search - forwards to correct function pointer */
- size_t searchH(std::pair<double,double> value) const { assert(m_mixPtr != nullptr); return (*m_mixPtr)(value, *this); }
-
- /** the entry bin */
- size_t entry(const Vector3D& position ) const {
- size_t bin = (binvalue==binH) ? searchH(valueH(position)) : search(value(position));
- return (bin < m_bins-bin) ? bin : m_bins-1;
- }
-
- /** layer next direction is needed */
- int nextDirection(const Vector3D& position, const Vector3D& dir) const {
- float val = (binvalue==binH) ? valueH(position).first : value(position);
- Vector3D probe = position+dir.normalized();
- float nextval = (binvalue==binH) ? valueH(probe).first : value(probe);
- return (nextval > val ) ? 1 : -1;
- }
-
- /** the next bin : gives -1 if the next one is outside */
- size_t next(const Vector3D& position, const Vector3D& dir) const {
- float val = value(position);
- Vector3D probe = position+0.5*step*dir.normalized();
- float nextval = value( probe);
- int bin = (binvalue==binH) ? searchH(valueH(position)) : search(val);
- bin = (nextval > val && bin != int(m_bins-1)) ? bin+1 : (bin) ? bin-1 : 0;
- // closed setup
- if ( option == closed)
- return ( bin < 0 || bin+1 > int(m_bins) ) ? ( (bin < 0 ) ? m_bins-1 : 0 ) : bin;
- // open setup
- return bin;
- }
-
- /** distance to the next bin : gives -1 if the next one is outside */
- std::pair<size_t, float> distanceToNext(const Vector3D& position, const Vector3D& dir) const {
- // current value
- float val = (binvalue==binH) ? valueH(position).first : value(position);
- // probe value
- Vector3D probe = position+0.5*step*dir.normalized();
- float nextval = (binvalue==binH) ? valueH(probe).first : value(probe);
- // current bin
- int bin0 = (binvalue==binH) ? searchH(valueH(position)) : search(val);
- // next bin
- int bin = (nextval-val) >0. ? bin0+1 : bin0-1;
- if (bin > int(m_bins)-1) bin = (option==closed) ? 0 : bin0;
- if (bin < 0) bin = (option==closed) ? m_bins-1 : 0;
-
- // boundary value
- float bval = 0.;
- if (binvalue==binH) {
- bval = (nextval >val) ? hbounds[bin0+1].second : hbounds[bin0].second; // non-equidistant
-
- // may need to recalculate current value and probe
- if (nextval>val) {
- if ( hbounds[bin0+1].first>0 ) {
- val = valueH(position).second;
- nextval = valueH(probe).second;
- }
- } else {
- if ( hbounds[bin0].first>0 ) {
- val = valueH(position).second;
- nextval = valueH(probe).second;
- }
- }
- } else {
- bval = (nextval >val) ? m_boundaries[bin0+1] : m_boundaries[bin0]; // non-equidistant
- if (type == equidistant ) bval = min+bin0*step;
- }
- // differential
- float dd = 2*(nextval-val)/step;
- // distance estimate
- float dist = fabs(dd)>1.e-06 ? (bval-val)/dd : 1.e06 ;
- return std::pair<size_t, float> (bin,dist);
- }
-
- /** bin->BinningValue navigation : pos=+-1. edges/ 0. bin center */
- float binPosition( size_t bin, float pos ) const {
-
- float bmin = (binvalue==binH) ? hbounds[bin].second : m_boundaries[bin] ;
- float bmax = (binvalue==binH) ? hbounds[bin+1].second :
- bin+1<m_boundaries.size() ? m_boundaries[bin+1] : m_boundaries[bin]+step ;
-
- return ( bmin + 0.5*(pos+1.)*(bmax-bmin) );
-
- }
-
-
- private:
- /** Private members */
- size_t m_bins;
- std::vector<float> m_boundaries;
- size_t m_totalBins; //!< including potential substructure
- std::vector<float> m_totalBoundaries; //!< including potential substructure
- /** the pointer to the function to be used */
- size_t (*m_functionPtr) (float, const BinningData&);
- size_t (*m_mixPtr) (std::pair<float,float>, const BinningData&);
-
- /** helper method to set the sub structure */
- void checkSubStructure(){
- // sub structure is only checked when sBinData is ndefined
- if (subBinningData){
- m_totalBoundaries.clear();
- // (A) additive sub structure
- if (subBinningAdditive){
- // one bin is replaced by the sub bins
- m_totalBins = m_bins+subBinningData->bins()-1;
- // the tricky one - exchange one bin by many others
- m_totalBoundaries.reserve(m_totalBins+1);
- // get the sub bin boundaries
- const std::vector<float>& subBinBoundaries = subBinningData->boundaries();
- float sBinMin = subBinBoundaries[0];
- // get the min value of the sub bin boundaries
- std::vector<float>::const_iterator mbvalue = m_boundaries.begin();
- for (; mbvalue != m_boundaries.end(); ++mbvalue){
- // should define numerically stable
- if (fabs((*mbvalue)-sBinMin)<10e-10){
- // copy the sub bin boundaries into the vector
- m_totalBoundaries.insert(m_totalBoundaries.begin(),subBinBoundaries.begin(),subBinBoundaries.end());
- ++mbvalue;
- } else
- m_totalBoundaries.push_back(*mbvalue);
- }
- } else { // (B) multiplicative sub structure
- // every bin is just repaced by the sub binning structure
- m_totalBins = m_bins*subBinningData->bins();
- m_totalBoundaries.reserve(m_totalBins+1);
- // get the sub bin boundaries if there are any
- const std::vector<float>& subBinBoundaries = subBinningData->boundaries();
- // create the boundary vector
- m_totalBoundaries.push_back(min);
- for (size_t ib = 0; ib < m_bins; ++ib){
- float offset = ib*step;
- for (size_t isb = 1; isb < subBinBoundaries.size(); ++isb)
- m_totalBoundaries.push_back(offset+subBinBoundaries[isb]);
- }
- }
- // sort the total boundary vector
- std::sort(m_totalBoundaries.begin(),m_totalBoundaries.end());
- }
+ } else {
+ bval = (nextval > val) ? m_boundaries[bin0 + 1]
+ : m_boundaries[bin0]; // non-equidistant
+ if (type == equidistant) bval = min + bin0 * step;
+ }
+ // differential
+ float dd = 2 * (nextval - val) / step;
+ // distance estimate
+ float dist = fabs(dd) > 1.e-06 ? (bval - val) / dd : 1.e06;
+ return std::pair<size_t, float>(bin, dist);
+ }
+
+ /** bin->BinningValue navigation : pos=+-1. edges/ 0. bin center */
+ float
+ binPosition(size_t bin, float pos) const
+ {
+ float bmin = (binvalue == binH) ? hbounds[bin].second : m_boundaries[bin];
+ float bmax = (binvalue == binH)
+ ? hbounds[bin + 1].second
+ : bin + 1 < m_boundaries.size() ? m_boundaries[bin + 1]
+ : m_boundaries[bin] + step;
+
+ return (bmin + 0.5 * (pos + 1.) * (bmax - bmin));
+ }
+
+private:
+ /** Private members */
+ size_t m_bins;
+ std::vector<float> m_boundaries;
+ size_t m_totalBins; //!< including potential substructure
+ std::vector<float> m_totalBoundaries; //!< including potential substructure
+ /** the pointer to the function to be used */
+ size_t (*m_functionPtr)(float, const BinningData&);
+ size_t (*m_mixPtr)(std::pair<float, float>, const BinningData&);
+
+ /** helper method to set the sub structure */
+ void
+ checkSubStructure()
+ {
+ // sub structure is only checked when sBinData is ndefined
+ if (subBinningData) {
+ m_totalBoundaries.clear();
+ // (A) additive sub structure
+ if (subBinningAdditive) {
+ // one bin is replaced by the sub bins
+ m_totalBins = m_bins + subBinningData->bins() - 1;
+ // the tricky one - exchange one bin by many others
+ m_totalBoundaries.reserve(m_totalBins + 1);
+ // get the sub bin boundaries
+ const std::vector<float>& subBinBoundaries
+ = subBinningData->boundaries();
+ float sBinMin = subBinBoundaries[0];
+ // get the min value of the sub bin boundaries
+ std::vector<float>::const_iterator mbvalue = m_boundaries.begin();
+ for (; mbvalue != m_boundaries.end(); ++mbvalue) {
+ // should define numerically stable
+ if (fabs((*mbvalue) - sBinMin) < 10e-10) {
+ // copy the sub bin boundaries into the vector
+ m_totalBoundaries.insert(m_totalBoundaries.begin(),
+ subBinBoundaries.begin(),
+ subBinBoundaries.end());
+ ++mbvalue;
+ } else
+ m_totalBoundaries.push_back(*mbvalue);
+ }
+ } else { // (B) multiplicative sub structure
+ // every bin is just repaced by the sub binning structure
+ m_totalBins = m_bins * subBinningData->bins();
+ m_totalBoundaries.reserve(m_totalBins + 1);
+ // get the sub bin boundaries if there are any
+ const std::vector<float>& subBinBoundaries
+ = subBinningData->boundaries();
+ // create the boundary vector
+ m_totalBoundaries.push_back(min);
+ for (size_t ib = 0; ib < m_bins; ++ib) {
+ float offset = ib * step;
+ for (size_t isb = 1; isb < subBinBoundaries.size(); ++isb)
+ m_totalBoundaries.push_back(offset + subBinBoundaries[isb]);
+ }
}
-
- /** Equidistant search : equidist 0 */
- static size_t searchEquidstantWithBoundary(float value, const BinningData& bData) {
-
- int bin = ((value-bData.min)/bData.step);
- // special treatment of the 0 bin for closed
- if ( bData.option == closed){
- if (value < bData.min) return (bData.m_bins-1);
- if (value > bData.max) return 0;
- }
- // if outside boundary : return boundary for open, opposite bin for closed
- bin = bin < 0 ? ( ( bData.option == open) ? 0 : (bData.m_bins-1) ) : bin ;
- return size_t((bin <= int(bData.m_bins-1)) ? bin : ( (bData.option == open) ? (bData.m_bins-1) : 0 ));
- }
-
- /** Linear search in vector - superior in O(10) searches: arbitraty 2*/
- static size_t searchInVectorWithBoundary(float value, const BinningData& bData)
- {
- if (bData.binvalue == binPhi) while (value<bData.m_boundaries[0]) value += 2*M_PI;
- if (bData.binvalue == binPhi) while (value>bData.max) value -= 2*M_PI;
- // lower boundary
- if ( value <= bData.m_boundaries[0] ) {
- return ( bData.option==closed ) ? (bData.m_bins-1) : 0;
- }
- // higher boundary
- if ( value >= bData.max ) return ( bData.option==closed ) ? 0 : (bData.m_bins-1);
- // search
- auto vIter = bData.m_boundaries.begin();
- size_t bin = 0;
- for ( ; vIter != bData.m_boundaries.end() ; ++vIter, ++bin )
- if ((*vIter) > value) break;
- return (bin-1);
- }
-
- /** A binary search with underflow/overflow - faster than vector search for O(50) objects*/
- static size_t binarySearchWithBoundary(float value, const BinningData& bData)
- {
- // Binary search in an array of n values to locate value
- //!< @TODO exchange acos(-1) with a const value
- if (bData.binvalue == binPhi) while (value<bData.m_boundaries[0]) value+= 2*acos(-1.);
- if (bData.binvalue == binPhi) while (value>bData.max) value-= 2*acos(-1.);
- // underflow
- if ( value <= bData.m_boundaries[0] ) return ( bData.option==closed ) ? (bData.m_bins-1) : 0;
- size_t nabove, nbelow, middle;
- // overflow
- nabove = bData.m_boundaries.size()+1;
- if ( value >= bData.max) return ( bData.option==closed ) ? 0 : nabove-2;
- // binary search
- nbelow = 0;
- while(nabove-nbelow > 1) {
- middle = (nabove+nbelow)/2;
- if (value == bData.m_boundaries[middle-1]) return middle-1;
- if (value < bData.m_boundaries[middle-1]) nabove = middle;
- else nbelow = middle;
- }
- return nbelow-1;
- }
-
- /** Search in mixed vector - linear in O-10 m_bins, otherwise binary */
- static size_t searchInVectorWithMixedBoundary(std::pair<float,float> val, const BinningData& bData)
- {
- if ( (bData.hbounds[0].first==0 ? val.first:val.second) < bData.hbounds[0].second ) return ( bData.option==closed ) ? (bData.m_bins-1) : 0;
- if ( (bData.hbounds.back().first==0 ? val.first:val.second) >= bData.max ) return ( bData.option==closed ) ? 0 : (bData.m_bins-1);
-
- if ( bData.hbounds.size()<10 ) {
- auto vBeg = bData.hbounds.begin();
- auto vIter = vBeg+1;
- for ( ; vIter != bData.hbounds.end() ; ++vIter )
- if ((*vIter).second > ((*vIter).first==0 ? val.first:val.second) ) break;
- return ( vIter!= bData.hbounds.end() ? vIter-vBeg-1 : bData.m_bins-1 ) ;
- }
-
- // Binary search in an array of n values to locate value
- size_t nabove, nbelow, middle;
- nabove = bData.hbounds.size();
- // binary search
- nbelow = 0;
- while(nabove-nbelow > 1) {
- middle = (nabove+nbelow)/2;
- float valm = bData.hbounds[middle].first==0 ? val.first:val.second;
- if (valm == bData.hbounds[middle].second) { nbelow = middle; break;}
- if (valm < bData.hbounds[middle].second) nabove = middle;
- else nbelow = middle;
- }
-
- if (nbelow > bData.m_bins-1 ) return bData.m_bins-1;
- return nbelow;
- }
- };
-
+ // sort the total boundary vector
+ std::sort(m_totalBoundaries.begin(), m_totalBoundaries.end());
+ }
+ }
+
+ /** Equidistant search : equidist 0 */
+ static size_t
+ searchEquidstantWithBoundary(float value, const BinningData& bData)
+ {
+ int bin = ((value - bData.min) / bData.step);
+ // special treatment of the 0 bin for closed
+ if (bData.option == closed) {
+ if (value < bData.min) return (bData.m_bins - 1);
+ if (value > bData.max) return 0;
+ }
+ // if outside boundary : return boundary for open, opposite bin for closed
+ bin = bin < 0 ? ((bData.option == open) ? 0 : (bData.m_bins - 1)) : bin;
+ return size_t((bin <= int(bData.m_bins - 1))
+ ? bin
+ : ((bData.option == open) ? (bData.m_bins - 1) : 0));
+ }
+
+ /** Linear search in vector - superior in O(10) searches: arbitraty 2*/
+ static size_t
+ searchInVectorWithBoundary(float value, const BinningData& bData)
+ {
+ if (bData.binvalue == binPhi)
+ while (value < bData.m_boundaries[0]) value += 2 * M_PI;
+ if (bData.binvalue == binPhi)
+ while (value > bData.max) value -= 2 * M_PI;
+ // lower boundary
+ if (value <= bData.m_boundaries[0]) {
+ return (bData.option == closed) ? (bData.m_bins - 1) : 0;
+ }
+ // higher boundary
+ if (value >= bData.max)
+ return (bData.option == closed) ? 0 : (bData.m_bins - 1);
+ // search
+ auto vIter = bData.m_boundaries.begin();
+ size_t bin = 0;
+ for (; vIter != bData.m_boundaries.end(); ++vIter, ++bin)
+ if ((*vIter) > value) break;
+ return (bin - 1);
+ }
+
+ /** A binary search with underflow/overflow - faster than vector search for
+ * O(50) objects*/
+ static size_t
+ binarySearchWithBoundary(float value, const BinningData& bData)
+ {
+ // Binary search in an array of n values to locate value
+ //!< @TODO exchange acos(-1) with a const value
+ if (bData.binvalue == binPhi)
+ while (value < bData.m_boundaries[0]) value += 2 * acos(-1.);
+ if (bData.binvalue == binPhi)
+ while (value > bData.max) value -= 2 * acos(-1.);
+ // underflow
+ if (value <= bData.m_boundaries[0])
+ return (bData.option == closed) ? (bData.m_bins - 1) : 0;
+ size_t nabove, nbelow, middle;
+ // overflow
+ nabove = bData.m_boundaries.size() + 1;
+ if (value >= bData.max) return (bData.option == closed) ? 0 : nabove - 2;
+ // binary search
+ nbelow = 0;
+ while (nabove - nbelow > 1) {
+ middle = (nabove + nbelow) / 2;
+ if (value == bData.m_boundaries[middle - 1]) return middle - 1;
+ if (value < bData.m_boundaries[middle - 1])
+ nabove = middle;
+ else
+ nbelow = middle;
+ }
+ return nbelow - 1;
+ }
+
+ /** Search in mixed vector - linear in O-10 m_bins, otherwise binary */
+ static size_t
+ searchInVectorWithMixedBoundary(std::pair<float, float> val,
+ const BinningData& bData)
+ {
+ if ((bData.hbounds[0].first == 0 ? val.first : val.second)
+ < bData.hbounds[0].second)
+ return (bData.option == closed) ? (bData.m_bins - 1) : 0;
+ if ((bData.hbounds.back().first == 0 ? val.first : val.second) >= bData.max)
+ return (bData.option == closed) ? 0 : (bData.m_bins - 1);
+
+ if (bData.hbounds.size() < 10) {
+ auto vBeg = bData.hbounds.begin();
+ auto vIter = vBeg + 1;
+ for (; vIter != bData.hbounds.end(); ++vIter)
+ if ((*vIter).second > ((*vIter).first == 0 ? val.first : val.second))
+ break;
+ return (vIter != bData.hbounds.end() ? vIter - vBeg - 1
+ : bData.m_bins - 1);
+ }
+
+ // Binary search in an array of n values to locate value
+ size_t nabove, nbelow, middle;
+ nabove = bData.hbounds.size();
+ // binary search
+ nbelow = 0;
+ while (nabove - nbelow > 1) {
+ middle = (nabove + nbelow) / 2;
+ float valm = bData.hbounds[middle].first == 0 ? val.first : val.second;
+ if (valm == bData.hbounds[middle].second) {
+ nbelow = middle;
+ break;
+ }
+ if (valm < bData.hbounds[middle].second)
+ nabove = middle;
+ else
+ nbelow = middle;
+ }
+
+ if (nbelow > bData.m_bins - 1) return bData.m_bins - 1;
+ return nbelow;
+ }
+};
}
-#endif // ACTS_GEOMETRYUTILS_BINNINGDATA_H
+#endif // ACTS_GEOMETRYUTILS_BINNINGDATA_H
diff --git a/Core/include/ACTS/Utilities/BinningType.hpp b/Core/include/ACTS/Utilities/BinningType.hpp
index cdc47f483..6bcda45b9 100644
--- a/Core/include/ACTS/Utilities/BinningType.hpp
+++ b/Core/include/ACTS/Utilities/BinningType.hpp
@@ -14,37 +14,36 @@
#define ACTS_GEOMETRYUTILS_BINNINGTYPE_H 1
// STL include(s)
-#include <vector>
#include <string>
+#include <vector>
namespace Acts {
- /** @enum BinningType, BinningOption & BinningAccess
+/** @enum BinningType, BinningOption & BinningAccess
- - BinningType:
+ - BinningType:
- Enumeration to qualify the binning type for the use of the
- LayerArrayCreator and the TrackingVolumeArrayCreator
+ Enumeration to qualify the binning type for the use of the
+ LayerArrayCreator and the TrackingVolumeArrayCreator
- - BinningOption:
- open: [0,max]
- closed: 0 -> nextbin -> max -> 0
+ - BinningOption:
+ open: [0,max]
+ closed: 0 -> nextbin -> max -> 0
- - BinningValue
- necessary access to global positions
+ - BinningValue
+ necessary access to global positions
- */
- enum BinningType { equidistant, arbitrary };
+ */
+enum BinningType { equidistant, arbitrary };
- /** enum BinValue */
- enum BinningOption { open, closed };
+/** enum BinValue */
+enum BinningOption { open, closed };
- /** how to take the global / local position */
- enum BinningValue { binX, binY, binZ, binR, binPhi, binRPhi, binH, binEta };
-
- /** screen output option */
- static std::vector< std::string > binningValueNames = { "binX", "binY", "binZ", "binR", "binPhi", "binRPhi", "binH", "binEta" };
+/** how to take the global / local position */
+enum BinningValue { binX, binY, binZ, binR, binPhi, binRPhi, binH, binEta };
+/** screen output option */
+static std::vector<std::string> binningValueNames
+ = {"binX", "binY", "binZ", "binR", "binPhi", "binRPhi", "binH", "binEta"};
}
-#endif // ACTS_GEOMETRYUTILS_BINNINGTYPE_H
-
+#endif // ACTS_GEOMETRYUTILS_BINNINGTYPE_H
diff --git a/Core/include/ACTS/Utilities/Definitions.hpp b/Core/include/ACTS/Utilities/Definitions.hpp
index 0f28f80c6..ebf4c204d 100644
--- a/Core/include/ACTS/Utilities/Definitions.hpp
+++ b/Core/include/ACTS/Utilities/Definitions.hpp
@@ -20,7 +20,6 @@
#include <Eigen/Dense>
#pragma GCC diagnostic pop
-
#ifdef TRKDETDESCR_USEFLOATPRECISON
typedef float TDD_real_t;
#else
@@ -29,116 +28,115 @@ typedef double TDD_real_t;
#define TDD_max_bound_value 10e10
-namespace Acts
-{
- /** Tolerance for being on Surface */
- static const double s_onSurfaceTolerance = 10e-5;
-
- /** @enum PropDirection
- PropDirection, enum for direction of the propagation.
-
- */
- enum PropDirection {alongMomentum = 1,
- oppositeMomentum =-1,
- anyDirection = 0,
- mappingMode = 2};
-
- /** @enum SearDirection
- Simple enum for searching Surfaces
- */
- enum SearchDirection {outside=1,
- inside=-1,
- bothway=0,
- undefinedDirection=0};
-
- /** This is a steering enum to tell which material update stage:
- - preUpdate : when reaching a layer before layer is resolved
- - fullUpdate : just pass through the layer
- - postUpdate : when leaving the layer
- */
- enum MaterialUpdateStage {preUpdate = -1,
- fullUpdate = 0,
- postUpdate = 1};
-
- template<typename T, unsigned int rows, unsigned int cols>
- using ActsMatrix = Eigen::Matrix<T,rows,cols>;
-
- template<unsigned int rows, unsigned int cols>
- using ActsMatrixD = ActsMatrix<double,rows,cols>;
-
- template<unsigned int rows, unsigned int cols>
- using ActsMatrixF = ActsMatrix<float,rows,cols>;
-
- template<typename T, unsigned int rows>
- using ActsSymMatrix = Eigen::Matrix<T,rows,rows>;
-
- template<unsigned int rows>
- using ActsSymMatrixD = ActsSymMatrix<double,rows>;
-
- template<unsigned int rows>
- using ActsSymMatrixF = ActsSymMatrix<float,rows>;
-
- template<typename T, unsigned int rows>
- using ActsVector = Eigen::Matrix<T,rows,1>;
+namespace Acts {
+/** Tolerance for being on Surface */
+static const double s_onSurfaceTolerance = 10e-5;
- template<unsigned int rows>
- using ActsVectorD = ActsVector<double,rows>;
+/** @enum PropDirection
+ PropDirection, enum for direction of the propagation.
- template<unsigned int rows>
- using ActsVectorF = ActsVector<float,rows>;
-
- template<typename T, unsigned int cols>
- using ActsRowVector = Eigen::Matrix<T,1,cols>;
-
- template<unsigned int cols>
- using ActsRowVectorD = ActsRowVector<double,cols>;
-
- template<unsigned int cols>
- using ActsRowVectorF = ActsRowVector<float,cols>;
-
- template<typename T>
- using ActsMatrixX = Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>;
-
- using ActsMatrixXd = ActsMatrixX<double>;
- using ActsMatrixXf = ActsMatrixX<float>;
-
- template<typename T>
- using ActsVectorX = Eigen::Matrix<T, Eigen::Dynamic, 1>;
-
- using ActsVectorXd = ActsVectorX<double>;
- using ActsVectorXf = ActsVectorX<float>;
-
- template<typename T>
- using ActsRowVectorX = Eigen::Matrix<T, 1, Eigen::Dynamic>;
-
- using ActsRowVectorXd = ActsRowVectorX<double>;
- using ActsRowVectorXf = ActsRowVectorX<float>;
-
-
- /** elment for code readability
- - please use these for access to the member variables if needed, e.g.
- double z = position[Acts::eZ];
- double px = momentum[Acts::ePX];
*/
- enum AxisDefs {
- // position access
- eX = 0,
- eY = 1,
- eZ = 2,
- // momentum access
- ePX = 0,
- ePY = 1,
- ePZ = 2
- };
-
- typedef Eigen::Quaternion<double> Rotation3D;
- typedef Eigen::Translation<double, 3> Translation3D;
- typedef Eigen::AngleAxisd AngleAxis3D;
- typedef Eigen::Affine3d Transform3D;
- typedef Eigen::Matrix<double, 3, 1> Vector3D;
- typedef Eigen::Matrix<double, 2, 1> Vector2D;
- typedef Eigen::Matrix<double, 3, 3> RotationMatrix3D;
-
+enum PropDirection {
+ alongMomentum = 1,
+ oppositeMomentum = -1,
+ anyDirection = 0,
+ mappingMode = 2
+};
+
+/** @enum SearDirection
+ Simple enum for searching Surfaces
+ */
+enum SearchDirection {
+ outside = 1,
+ inside = -1,
+ bothway = 0,
+ undefinedDirection = 0
+};
+
+/** This is a steering enum to tell which material update stage:
+ - preUpdate : when reaching a layer before layer is resolved
+ - fullUpdate : just pass through the layer
+ - postUpdate : when leaving the layer
+ */
+enum MaterialUpdateStage { preUpdate = -1, fullUpdate = 0, postUpdate = 1 };
+
+template <typename T, unsigned int rows, unsigned int cols>
+using ActsMatrix = Eigen::Matrix<T, rows, cols>;
+
+template <unsigned int rows, unsigned int cols>
+using ActsMatrixD = ActsMatrix<double, rows, cols>;
+
+template <unsigned int rows, unsigned int cols>
+using ActsMatrixF = ActsMatrix<float, rows, cols>;
+
+template <typename T, unsigned int rows>
+using ActsSymMatrix = Eigen::Matrix<T, rows, rows>;
+
+template <unsigned int rows>
+using ActsSymMatrixD = ActsSymMatrix<double, rows>;
+
+template <unsigned int rows>
+using ActsSymMatrixF = ActsSymMatrix<float, rows>;
+
+template <typename T, unsigned int rows>
+using ActsVector = Eigen::Matrix<T, rows, 1>;
+
+template <unsigned int rows>
+using ActsVectorD = ActsVector<double, rows>;
+
+template <unsigned int rows>
+using ActsVectorF = ActsVector<float, rows>;
+
+template <typename T, unsigned int cols>
+using ActsRowVector = Eigen::Matrix<T, 1, cols>;
+
+template <unsigned int cols>
+using ActsRowVectorD = ActsRowVector<double, cols>;
+
+template <unsigned int cols>
+using ActsRowVectorF = ActsRowVector<float, cols>;
+
+template <typename T>
+using ActsMatrixX = Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>;
+
+using ActsMatrixXd = ActsMatrixX<double>;
+using ActsMatrixXf = ActsMatrixX<float>;
+
+template <typename T>
+using ActsVectorX = Eigen::Matrix<T, Eigen::Dynamic, 1>;
+
+using ActsVectorXd = ActsVectorX<double>;
+using ActsVectorXf = ActsVectorX<float>;
+
+template <typename T>
+using ActsRowVectorX = Eigen::Matrix<T, 1, Eigen::Dynamic>;
+
+using ActsRowVectorXd = ActsRowVectorX<double>;
+using ActsRowVectorXf = ActsRowVectorX<float>;
+
+/** elment for code readability
+ - please use these for access to the member variables if needed, e.g.
+ double z = position[Acts::eZ];
+ double px = momentum[Acts::ePX];
+*/
+enum AxisDefs {
+ // position access
+ eX = 0,
+ eY = 1,
+ eZ = 2,
+ // momentum access
+ ePX = 0,
+ ePY = 1,
+ ePZ = 2
+};
+
+typedef Eigen::Quaternion<double> Rotation3D;
+typedef Eigen::Translation<double, 3> Translation3D;
+typedef Eigen::AngleAxisd AngleAxis3D;
+typedef Eigen::Affine3d Transform3D;
+typedef Eigen::Matrix<double, 3, 1> Vector3D;
+typedef Eigen::Matrix<double, 2, 1> Vector2D;
+typedef Eigen::Matrix<double, 3, 3> RotationMatrix3D;
} // end of namespace Acts
diff --git a/Core/include/ACTS/Utilities/GeometryID.hpp b/Core/include/ACTS/Utilities/GeometryID.hpp
index 6258cfce3..23498ce5f 100644
--- a/Core/include/ACTS/Utilities/GeometryID.hpp
+++ b/Core/include/ACTS/Utilities/GeometryID.hpp
@@ -18,58 +18,64 @@
namespace Acts {
- typedef uint64_t geo_id_value;
-
- /** @class GeometryID
-
- Identifier for Geometry nodes - packing the
- - (Sensitive) Surfaces - uses IdentiferHash
- - (Approach) Surfaces - uses simple counting through confinedLayers() or confinedArbitraryLayers()
- - (Layer) Surfaces - uses simple counting through approachSurfaces()
- - (Boundary) Surfaces - uses simple counting through boundarySurfaces()
- - Volumes - AtlasDetector region and AtlasSubDetector enum and static counter
- */
-
- class GeometryID {
- public:
- /** constructor from a ready-made value */
- GeometryID(geo_id_value id_value = 0) :
- m_value(id_value)
- {}
-
- /** Copy constructor */
- GeometryID(const GeometryID& tddID) :
- m_value(tddID.m_value)
- {}
-
- /** Assignement operator */
- GeometryID& operator=(const GeometryID& tddID)
- {
- if (&tddID != this){
- m_value = tddID.m_value;
- }
- return (*this);
- }
-
- /** return the value */
- geo_id_value value() const;
-
- private:
- geo_id_value m_value;
-
- };
-
- inline geo_id_value GeometryID::value() const { return m_value; }
-
- /** Overload of operator< | <= | > | >= for the usage in a map */
- bool operator< ( const GeometryID& one, const GeometryID& two );
- bool operator<=( const GeometryID& one, const GeometryID& two );
- bool operator> ( const GeometryID& one, const GeometryID& two );
- bool 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);
+typedef uint64_t geo_id_value;
+
+/** @class GeometryID
+
+ Identifier for Geometry nodes - packing the
+ - (Sensitive) Surfaces - uses IdentiferHash
+ - (Approach) Surfaces - uses simple counting through confinedLayers() or
+ confinedArbitraryLayers()
+ - (Layer) Surfaces - uses simple counting through approachSurfaces()
+ - (Boundary) Surfaces - uses simple counting through boundarySurfaces()
+ - Volumes - AtlasDetector region and AtlasSubDetector enum
+ and static counter
+*/
+
+class GeometryID
+{
+public:
+ /** constructor from a ready-made value */
+ GeometryID(geo_id_value id_value = 0) : m_value(id_value) {}
+ /** Copy constructor */
+ GeometryID(const GeometryID& tddID) : m_value(tddID.m_value) {}
+ /** Assignement operator */
+ GeometryID&
+ operator=(const GeometryID& tddID)
+ {
+ if (&tddID != this) {
+ m_value = tddID.m_value;
+ }
+ return (*this);
+ }
+
+ /** return the value */
+ geo_id_value
+ value() const;
+
+private:
+ geo_id_value m_value;
+};
+
+inline geo_id_value
+GeometryID::value() const
+{
+ return m_value;
+}
+/** Overload of operator< | <= | > | >= for the usage in a map */
+bool
+operator<(const GeometryID& one, const GeometryID& two);
+bool
+operator<=(const GeometryID& one, const GeometryID& two);
+bool
+operator>(const GeometryID& one, const GeometryID& two);
+bool
+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);
}
-#endif // ACTS_GEOMETRYUTILS_GEOMETRYID_H
+#endif // ACTS_GEOMETRYUTILS_GEOMETRYID_H
diff --git a/Core/include/ACTS/Utilities/GeometryObject.hpp b/Core/include/ACTS/Utilities/GeometryObject.hpp
index c62b1b544..6b0bd7a34 100644
--- a/Core/include/ACTS/Utilities/GeometryObject.hpp
+++ b/Core/include/ACTS/Utilities/GeometryObject.hpp
@@ -14,77 +14,86 @@
#define ACTS_GEOMETRYUTILS_GEOMETRYOBJECT_H
// Geometry module
-#include "ACTS/Utilities/GeometryID.hpp"
#include "ACTS/Utilities/BinningType.hpp"
+#include "ACTS/Utilities/GeometryID.hpp"
// Core module
#include "Definitions.hpp"
-
namespace Acts {
+/** @class GeometryObject
- /** @class GeometryObject
-
- Base class to provide GeometryID interface:
- - simple set and get
-
- It also provides the binningPosition method for
- Geometry geometrical object to be binned in BinnedArrays
-
- */
-
- class GeometryObject {
- public:
- /** constructor from a ready-made value */
- GeometryObject() :
- m_geoID()
- {}
-
- /** return the value */
- const GeometryID& geoID() const;
-
- /** set the value */
- void assignGeoID(const GeometryID& geoID) const;
-
- /** force a binning position method */
- virtual Vector3D binningPosition(BinningValue bValue) const = 0;
-
- /** implement the binningValue */
- double binningPositionValue(BinningValue bValue) const;
-
- protected:
- mutable GeometryID m_geoID;
- };
-
- inline const GeometryID& GeometryObject::geoID() const { return m_geoID; }
-
- inline void GeometryObject::assignGeoID(const GeometryID& geoID) const { m_geoID = geoID; }
-
- inline double GeometryObject::binningPositionValue(BinningValue bValue) const {
- // now switch
- switch (bValue) {
- // case x
- case Acts::binX : {
- return binningPosition(bValue).x();
- } break;
- // case y
- case Acts::binY : {
- return binningPosition(bValue).y();
- } break;
- // case z
- case Acts::binZ : {
- return binningPosition(bValue).z();
- } break;
- // case
- case Acts::binR : {
- return binningPosition(bValue).perp();
- } break;
- // do nothing for the default
- default : return 0;
- }
- }
+ Base class to provide GeometryID interface:
+ - simple set and get
+
+ It also provides the binningPosition method for
+ Geometry geometrical object to be binned in BinnedArrays
+
+ */
+
+class GeometryObject
+{
+public:
+ /** constructor from a ready-made value */
+ GeometryObject() : m_geoID() {}
+ /** return the value */
+ const GeometryID&
+ geoID() const;
+
+ /** set the value */
+ void
+ assignGeoID(const GeometryID& geoID) const;
+ /** force a binning position method */
+ virtual Vector3D
+ binningPosition(BinningValue bValue) const = 0;
+ /** implement the binningValue */
+ double
+ binningPositionValue(BinningValue bValue) const;
+
+protected:
+ mutable GeometryID m_geoID;
+};
+
+inline const GeometryID&
+GeometryObject::geoID() const
+{
+ return m_geoID;
+}
+
+inline void
+GeometryObject::assignGeoID(const GeometryID& geoID) const
+{
+ m_geoID = geoID;
+}
+
+inline double
+GeometryObject::binningPositionValue(BinningValue bValue) const
+{
+ // now switch
+ switch (bValue) {
+ // case x
+ case Acts::binX: {
+ return binningPosition(bValue).x();
+ } break;
+ // case y
+ case Acts::binY: {
+ return binningPosition(bValue).y();
+ } break;
+ // case z
+ case Acts::binZ: {
+ return binningPosition(bValue).z();
+ } break;
+ // case
+ case Acts::binR: {
+ return binningPosition(bValue).perp();
+ } break;
+ // do nothing for the default
+ default:
+ return 0;
+ }
+}
}
#endif
diff --git a/Core/include/ACTS/Utilities/GeometryObjectSorter.hpp b/Core/include/ACTS/Utilities/GeometryObjectSorter.hpp
index 9c7fa4a70..07c016319 100644
--- a/Core/include/ACTS/Utilities/GeometryObjectSorter.hpp
+++ b/Core/include/ACTS/Utilities/GeometryObjectSorter.hpp
@@ -16,49 +16,70 @@
#include "Definitions.hpp"
namespace Acts {
- /** @class GeometryObjectSorter
+/** @class GeometryObjectSorter
- */
- template <class T> class GeometryObjectSorterT : public std::binary_function<T, T, bool> {
+ */
+template <class T>
+class GeometryObjectSorterT : public std::binary_function<T, T, bool>
+{
+public:
+ /** Constructor from a binning value */
+ GeometryObjectSorterT(BinningValue bValue,
+ std::shared_ptr<Transform3D> transform = nullptr)
+ : m_binningValue(bValue), m_transform(transform)
+ {
+ }
- public:
- /** Constructor from a binning value */
- GeometryObjectSorterT(BinningValue bValue, std::shared_ptr<Transform3D> transform = nullptr ) :
- m_binningValue(bValue),
- m_transform(transform)
- {}
-
- /** the comparison */
- bool operator() (T one, T two) const
- {
- // get the pos one / pos two
- Vector3D posOne = m_transform ? m_transform->inverse()*one->binningPosition(m_binningValue) : one->binningPosition(m_binningValue);
- Vector3D posTwo = m_transform ? m_transform->inverse()*two->binningPosition(m_binningValue) : two->binningPosition(m_binningValue);
-
- // switch the binning value
- // - binX, binY, binZ, binR, binPhi, binRPhi, binH, binEta
- switch (m_binningValue) {
- // compare on x
- case binX : { return (posOne.x() < posTwo.x()); }
- // compare on y
- case binY : { return (posOne.y() < posTwo.y()); }
- // compare on z
- case binZ : { return (posOne.z() < posTwo.z()); }
- // compare on r
- case binR : { return (posOne.perp() < posTwo.perp()); }
- // compare on phi
- case binPhi : { return (posOne.phi() < posTwo.phi()); }
- // compare on eta
- case binEta : { return (posOne.eta() < posTwo.eta()); }
- // default for the moment
- default : { return (posOne.mag() < posTwo.mag()); }
- }
- }
-
- protected:
- BinningValue m_binningValue;
- std::shared_ptr<Transform3D> m_transform;
- };
+ /** the comparison */
+ bool
+ operator()(T one, T two) const
+ {
+ // get the pos one / pos two
+ Vector3D posOne = m_transform
+ ? m_transform->inverse() * one->binningPosition(m_binningValue)
+ : one->binningPosition(m_binningValue);
+ Vector3D posTwo = m_transform
+ ? m_transform->inverse() * two->binningPosition(m_binningValue)
+ : two->binningPosition(m_binningValue);
+
+ // switch the binning value
+ // - binX, binY, binZ, binR, binPhi, binRPhi, binH, binEta
+ switch (m_binningValue) {
+ // compare on x
+ case binX: {
+ return (posOne.x() < posTwo.x());
+ }
+ // compare on y
+ case binY: {
+ return (posOne.y() < posTwo.y());
+ }
+ // compare on z
+ case binZ: {
+ return (posOne.z() < posTwo.z());
+ }
+ // compare on r
+ case binR: {
+ return (posOne.perp() < posTwo.perp());
+ }
+ // compare on phi
+ case binPhi: {
+ return (posOne.phi() < posTwo.phi());
+ }
+ // compare on eta
+ case binEta: {
+ return (posOne.eta() < posTwo.eta());
+ }
+ // default for the moment
+ default: {
+ return (posOne.mag() < posTwo.mag());
+ }
+ }
+ }
+
+protected:
+ BinningValue m_binningValue;
+ std::shared_ptr<Transform3D> m_transform;
+};
}
-#endif // ACTS_GEOMETRYUTILS_GEOMETRYOBJECTSORTER_H
+#endif // ACTS_GEOMETRYUTILS_GEOMETRYOBJECTSORTER_H
diff --git a/Core/include/ACTS/Utilities/GeometrySignature.hpp b/Core/include/ACTS/Utilities/GeometrySignature.hpp
index ff0290f9d..7484257ba 100644
--- a/Core/include/ACTS/Utilities/GeometrySignature.hpp
+++ b/Core/include/ACTS/Utilities/GeometrySignature.hpp
@@ -10,42 +10,41 @@
// GeometrySignature.h, ACTS project
///////////////////////////////////////////////////////////////////
-#ifndef ACTS_GEOMETRYUTILS_GEOMETRYSIGNATURE_H
+#ifndef ACTS_GEOMETRYUTILS_GEOMETRYSIGNATURE_H
#define ACTS_GEOMETRYUTILS_GEOMETRYSIGNATURE_H 1
namespace Acts {
- /** @class GeometrySignature
-
- An enumeration object that puts the signature
- of a GeometryBuilder to all subvolumes
-
- @TODO will be in the future be replace by GeometryID mechanism
-
-
- */
-
- enum GeometrySignature {
- Global = 0,
- ID = 1,
- BeamPipe = 2,
- Calo = 3,
- MS = 4,
- Cavern = 5,
- NumberOfSignatures = 6,
- Unsigned = 99
- };
-
- enum GeometryType {
- Static = 0,
- Dense = 1,
- DenseWithLayers = 1,
- Detached = 2,
- Master = 3,
- NumberOfGeometryTypes = 3
- };
-
-
-} // end of namespace
-
-#endif // ACTS_GEOMETRYUTILS_GEOMETRYSIGNATURE_H
+/** @class GeometrySignature
+
+ An enumeration object that puts the signature
+ of a GeometryBuilder to all subvolumes
+
+ @TODO will be in the future be replace by GeometryID mechanism
+
+
+ */
+
+enum GeometrySignature {
+ Global = 0,
+ ID = 1,
+ BeamPipe = 2,
+ Calo = 3,
+ MS = 4,
+ Cavern = 5,
+ NumberOfSignatures = 6,
+ Unsigned = 99
+};
+
+enum GeometryType {
+ Static = 0,
+ Dense = 1,
+ DenseWithLayers = 1,
+ Detached = 2,
+ Master = 3,
+ NumberOfGeometryTypes = 3
+};
+
+} // end of namespace
+
+#endif // ACTS_GEOMETRYUTILS_GEOMETRYSIGNATURE_H
diff --git a/Core/include/ACTS/Utilities/GeometryStatics.hpp b/Core/include/ACTS/Utilities/GeometryStatics.hpp
index d1a6d9084..669044aec 100644
--- a/Core/include/ACTS/Utilities/GeometryStatics.hpp
+++ b/Core/include/ACTS/Utilities/GeometryStatics.hpp
@@ -21,23 +21,24 @@ namespace Acts {
// transformations
- static Transform3D s_idTransform = Transform3D::Identity(); //!< idendity transformation
- static Rotation3D s_idRotation = Acts::Rotation3D::Identity(); //!< idendity rotation
-
- // axis system
-
- static Vector3D s_xAxis(1,0,0); //!< global x Axis;
- static Vector3D s_yAxis(0,1,0); //!< global y Axis;
- static Vector3D s_zAxis(0,0,1); //!< global z Axis;
-
- // origin
-
- static Vector3D s_origin(0,0,0); //!< origin position
-
- static double helper[9] = {0.,1.,0.,1.,0.,0.,0.,0.,-1.};
-
- static Acts::RotationMatrix3D s_idRotationZinverse(helper);
+static Transform3D s_idTransform
+ = Transform3D::Identity(); //!< idendity transformation
+static Rotation3D s_idRotation
+ = Acts::Rotation3D::Identity(); //!< idendity rotation
+// axis system
+
+static Vector3D s_xAxis(1, 0, 0); //!< global x Axis;
+static Vector3D s_yAxis(0, 1, 0); //!< global y Axis;
+static Vector3D s_zAxis(0, 0, 1); //!< global z Axis;
+
+// origin
+
+static Vector3D s_origin(0, 0, 0); //!< origin position
+
+static double helper[9] = {0., 1., 0., 1., 0., 0., 0., 0., -1.};
+
+static Acts::RotationMatrix3D s_idRotationZinverse(helper);
}
-#endif // ACTS_GEOMETYRUTILS_GEOMETRYSTATICS_H
+#endif // ACTS_GEOMETYRUTILS_GEOMETRYSTATICS_H
diff --git a/Core/include/ACTS/Utilities/Helpers.hpp b/Core/include/ACTS/Utilities/Helpers.hpp
index 7ee965155..f0246ec7f 100644
--- a/Core/include/ACTS/Utilities/Helpers.hpp
+++ b/Core/include/ACTS/Utilities/Helpers.hpp
@@ -15,8 +15,8 @@
// STL include(s)
#include <cmath>
-#include <iostream>
#include <iomanip>
+#include <iostream>
#include <string>
// ACTS include(s)
@@ -25,271 +25,313 @@
/** Geometry primitives helper functions
*/
-namespace Acts
-{
- /** EventPrimitvesToStringConverter
-
- inline methods for conversion of EventPrimitives (Matrix)
- to std::string.
-
- This is to enhance formatted screen ouput and for ASCII based
- testing.
+namespace Acts {
+/** EventPrimitvesToStringConverter
- The offset can be used to offset the lines (starting from line 2) wrt to the
- zero position for formatting reasons.
+ inline methods for conversion of EventPrimitives (Matrix)
+ to std::string.
+ This is to enhance formatted screen ouput and for ASCII based
+ testing.
- */
+ The offset can be used to offset the lines (starting from line 2) wrt to the
+ zero position for formatting reasons.
+ */
+inline double
+roundWithPrecision(double val, int precision)
+{
+ if (val < 0 && fabs(val) * std::pow(10, precision) < 1.) return -val;
+ return val;
+}
- inline double roundWithPrecision( double val, int precision ) {
- if( val < 0 && fabs(val)*std::pow(10,precision) < 1. ) return -val;
- return val;
- }
-
- inline std::string toString( const ActsMatrixXd& matrix, int precision = 4, std::string offset="" ){
- std::ostringstream sout;
-
- sout << std::setiosflags(std::ios::fixed) << std::setprecision(precision);
- if( matrix.cols() == 1 ){
- sout << "(";
- for( int i=0;i<matrix.rows();++i ){
- double val = roundWithPrecision(matrix(i,0),precision);
+inline std::string
+toString(const ActsMatrixXd& matrix, int precision = 4, std::string offset = "")
+{
+ std::ostringstream sout;
+
+ sout << std::setiosflags(std::ios::fixed) << std::setprecision(precision);
+ if (matrix.cols() == 1) {
+ sout << "(";
+ for (int i = 0; i < matrix.rows(); ++i) {
+ double val = roundWithPrecision(matrix(i, 0), precision);
+ sout << val;
+ if (i != matrix.rows() - 1) sout << ", ";
+ }
+ sout << ")";
+ } else {
+ for (int i = 0; i < matrix.rows(); ++i) {
+ for (int j = 0; j < matrix.cols(); ++j) {
+ if (j == 0) sout << "(";
+ double val = roundWithPrecision(matrix(i, j), precision);
sout << val;
- if( i != matrix.rows() - 1 ) sout << ", ";
+ if (j == matrix.cols() - 1)
+ sout << ")";
+ else
+ sout << ", ";
}
- sout << ")";
- }else{
- for( int i=0;i<matrix.rows();++i ){
- for( int j=0;j<matrix.cols();++j ){
- if( j == 0 ) sout << "(";
- double val = roundWithPrecision(matrix(i,j),precision);
- sout << val;
- if( j == matrix.cols() - 1 ) sout << ")";
- else sout << ", ";
- }
- if( i != matrix.rows() - 1 )
- { // make the end line and the offset in the next line
- sout << std::endl;
- sout << offset;
- }
+ if (i
+ != matrix.rows()
+ - 1) { // make the end line and the offset in the next line
+ sout << std::endl;
+ sout << offset;
}
}
- return sout.str();
- }
-
-
- inline std::string toString( const Acts::Translation3D& translation, int precision = 4 ){
- Acts::Vector3D trans;
- trans[0] = translation.x();
- trans[1] = translation.y();
- trans[2] = translation.z();
- return toString( trans, precision );
- }
-
- inline std::string toString( const Acts::Transform3D& transform, int precision = 4, std::string offset="" ){
- std::ostringstream sout;
- sout << "Translation : " << toString( transform.translation(), precision ) << std::endl;
- std::string rotationOffset = offset + " ";
- sout << offset << "Rotation : " << toString( transform.rotation(), precision+2, rotationOffset );
- return sout.str();
- }
-
- /** calculates the opening angle between two vectors */
- inline double angle(const Acts::Vector3D& v1, const Acts::Vector3D& v2) {
- double dp = v1.dot(v2);
- dp /= v1.mag() * v2.mag();
- if (dp > 1)
- dp = 1;
- if (dp < -1)
- dp = -1;
- return acos(dp);
}
+ return sout.str();
+}
- /** calculates the squared distance between two point in 3D space */
- inline float distance2(const Acts::Vector3D& p1, const Acts::Vector3D& p2) {
- float dx = p2.x()-p1.x(), dy = p2.y()-p1.y(), dz = p2.z()-p1.z();
- return dx*dx + dy*dy + dz*dz;
- }
-
- /** calculates the distance between two point in 3D space */
- inline float distance(const Acts::Vector3D& p1, const Acts::Vector3D& p2) {
- return std::sqrt( distance2(p1, p2) );
- }
-
- /** sets the phi angle of a vector without changing theta nor the magnitude */
- inline void setPhi(Acts::Vector3D& v, double phi) {
- double xy = v.perp();
- v[0] = xy * cos(phi);
- v[1] = xy * sin(phi);
- }
-
- /** sets the theta and phi angle of a vector without changing the magnitude */
- inline void setThetaPhi(Acts::Vector3D& v, double theta, double phi) {
- double mag = v.mag();
- v[0] = mag * sin(theta) * cos(phi);
- v[1] = mag * sin(theta) * sin(phi);
- v[2] = mag * cos(theta);
- }
+inline std::string
+toString(const Acts::Translation3D& translation, int precision = 4)
+{
+ Acts::Vector3D trans;
+ trans[0] = translation.x();
+ trans[1] = translation.y();
+ trans[2] = translation.z();
+ return toString(trans, precision);
+}
+
+inline std::string
+toString(const Acts::Transform3D& transform,
+ int precision = 4,
+ std::string offset = "")
+{
+ std::ostringstream sout;
+ sout << "Translation : " << toString(transform.translation(), precision)
+ << std::endl;
+ std::string rotationOffset = offset + " ";
+ sout << offset << "Rotation : "
+ << toString(transform.rotation(), precision + 2, rotationOffset);
+ return sout.str();
+}
+
+/** calculates the opening angle between two vectors */
+inline double
+angle(const Acts::Vector3D& v1, const Acts::Vector3D& v2)
+{
+ double dp = v1.dot(v2);
+ dp /= v1.mag() * v2.mag();
+ if (dp > 1) dp = 1;
+ if (dp < -1) dp = -1;
+ return acos(dp);
+}
+
+/** calculates the squared distance between two point in 3D space */
+inline float
+distance2(const Acts::Vector3D& p1, const Acts::Vector3D& p2)
+{
+ float dx = p2.x() - p1.x(), dy = p2.y() - p1.y(), dz = p2.z() - p1.z();
+ return dx * dx + dy * dy + dz * dz;
+}
- /** sets radius, the theta and phi angle of a vector. Angles are measured in RADIANS */
- inline void setRThetaPhi(Acts::Vector3D& v, double r, double theta, double phi) {
- v[0] = r * sin(theta) * cos(phi);
- v[1] = r * sin(theta) * sin(phi);
- v[2] = r * cos(theta);
- }
+/** calculates the distance between two point in 3D space */
+inline float
+distance(const Acts::Vector3D& p1, const Acts::Vector3D& p2)
+{
+ return std::sqrt(distance2(p1, p2));
+}
- /** sets the theta of a vector without changing phi nor the magnitude */
- inline void setTheta(Acts::Vector3D& v, double theta) {
- setThetaPhi(v, theta, v.phi());
- }
+/** sets the phi angle of a vector without changing theta nor the magnitude */
+inline void
+setPhi(Acts::Vector3D& v, double phi)
+{
+ double xy = v.perp();
+ v[0] = xy * cos(phi);
+ v[1] = xy * sin(phi);
+}
+
+/** sets the theta and phi angle of a vector without changing the magnitude */
+inline void
+setThetaPhi(Acts::Vector3D& v, double theta, double phi)
+{
+ double mag = v.mag();
+ v[0] = mag * sin(theta) * cos(phi);
+ v[1] = mag * sin(theta) * sin(phi);
+ v[2] = mag * cos(theta);
+}
+
+/** sets radius, the theta and phi angle of a vector. Angles are measured in
+ * RADIANS */
+inline void
+setRThetaPhi(Acts::Vector3D& v, double r, double theta, double phi)
+{
+ v[0] = r * sin(theta) * cos(phi);
+ v[1] = r * sin(theta) * sin(phi);
+ v[2] = r * cos(theta);
+}
+
+/** sets the theta of a vector without changing phi nor the magnitude */
+inline void
+setTheta(Acts::Vector3D& v, double theta)
+{
+ setThetaPhi(v, theta, v.phi());
+}
- /** scales the vector in the xy plane without changing the z coordinate nor the angles */
- inline void setPerp(Acts::Vector3D& v, double perp) {
- double p = v.perp();
- if (p != 0.0) {
- double scale = perp / p;
- v[0] *= scale;
- v[1] *= scale;
- }
+/** scales the vector in the xy plane without changing the z coordinate nor the
+ * angles */
+inline void
+setPerp(Acts::Vector3D& v, double perp)
+{
+ double p = v.perp();
+ if (p != 0.0) {
+ double scale = perp / p;
+ v[0] *= scale;
+ v[1] *= scale;
}
+}
- /** scales the vector length without changing the angles */
- inline void setMag(Acts::Vector3D& v, double mag) {
- double p = v.mag();
- if (p != 0.0) {
- double scale = mag / p;
- v[0] *= scale;
- v[1] *= scale;
- v[2] *= scale;
- }
- }
- inline double deltaPhi(const Acts::Vector3D& v1, const Acts::Vector3D& v2) {
- double dphi = v2.phi() - v1.phi();
- if (dphi > M_PI) {
- dphi -= M_PI*2;
- } else if (dphi <= -M_PI) {
- dphi += M_PI*2;
- }
- return dphi;
- }
- inline double deltaR(const Acts::Vector3D& v1, const Acts::Vector3D& v2){
- double a = v1.eta() - v2.eta();
- double b = deltaPhi(v1,v2);
- return sqrt(a*a + b*b);
+/** scales the vector length without changing the angles */
+inline void
+setMag(Acts::Vector3D& v, double mag)
+{
+ double p = v.mag();
+ if (p != 0.0) {
+ double scale = mag / p;
+ v[0] *= scale;
+ v[1] *= scale;
+ v[2] *= scale;
}
-
-
- /*
- * the analogous to CLHEP HepGeom::Transform3D trans (localRot, theSurface.transform().translation());
- */
- inline Acts::Transform3D getTransformFromRotTransl(Acts::RotationMatrix3D rot, Acts::Vector3D transl_vec )
- {
- Acts::Transform3D trans = Acts::Transform3D::Identity();
- trans = trans * rot;
- trans.translation() = transl_vec;
- return trans;
+}
+inline double
+deltaPhi(const Acts::Vector3D& v1, const Acts::Vector3D& v2)
+{
+ double dphi = v2.phi() - v1.phi();
+ if (dphi > M_PI) {
+ dphi -= M_PI * 2;
+ } else if (dphi <= -M_PI) {
+ dphi += M_PI * 2;
}
-
- /*
- * Replacing the CLHEP::HepRotation::getAngleAxis() functionality
- *
- * Note:
- * CLHEP has a 'HepRotation::getAngleAxis()' function, e.g.:
- * ---
- * CLHEP::HepRotation rotation = transform.getRotation();
- * CLHEP::Hep3Vector rotationAxis;
- * double rotationAngle;
- * rotation.getAngleAxis(rotationAngle,rotationAxis);
- * ---
- */
- inline void getAngleAxisFromRotation(Acts::RotationMatrix3D& rotation, double& rotationAngle, Acts::Vector3D& rotationAxis)
- {
- rotationAngle = 0.;
-
- double xx = rotation(0,0);
- double yy = rotation(1,1);
- double zz = rotation(2,2);
-
- double cosa = 0.5 * (xx + yy + zz - 1);
- double cosa1 = 1 - cosa;
-
- if (cosa1 <= 0) {
- rotationAngle = 0;
- rotationAxis = Acts::Vector3D(0,0,1);
- }
- else{
- double x=0, y=0, z=0;
- if (xx > cosa) x = sqrt((xx-cosa)/cosa1);
- if (yy > cosa) y = sqrt((yy-cosa)/cosa1);
- if (zz > cosa) z = sqrt((zz-cosa)/cosa1);
- if (rotation(2,1) < rotation(1,2)) x = -x;
- if (rotation(0,2) < rotation(2,0)) y = -y;
- if (rotation(1,0) < rotation(0,1)) z = -z;
- rotationAngle = (cosa < -1.) ? acos(-1.) : acos(cosa);
- rotationAxis = Acts::Vector3D(x,y,z);
- }
-
- return;
+ return dphi;
+}
+inline double
+deltaR(const Acts::Vector3D& v1, const Acts::Vector3D& v2)
+{
+ double a = v1.eta() - v2.eta();
+ double b = deltaPhi(v1, v2);
+ return sqrt(a * a + b * b);
+}
+
+/*
+ * the analogous to CLHEP HepGeom::Transform3D trans (localRot,
+ * theSurface.transform().translation());
+ */
+inline Acts::Transform3D
+getTransformFromRotTransl(Acts::RotationMatrix3D rot, Acts::Vector3D transl_vec)
+{
+ Acts::Transform3D trans = Acts::Transform3D::Identity();
+ trans = trans * rot;
+ trans.translation() = transl_vec;
+ return trans;
+}
+
+/*
+ * Replacing the CLHEP::HepRotation::getAngleAxis() functionality
+ *
+ * Note:
+ * CLHEP has a 'HepRotation::getAngleAxis()' function, e.g.:
+ * ---
+ * CLHEP::HepRotation rotation = transform.getRotation();
+ * CLHEP::Hep3Vector rotationAxis;
+ * double rotationAngle;
+ * rotation.getAngleAxis(rotationAngle,rotationAxis);
+ * ---
+ */
+inline void
+getAngleAxisFromRotation(Acts::RotationMatrix3D& rotation,
+ double& rotationAngle,
+ Acts::Vector3D& rotationAxis)
+{
+ rotationAngle = 0.;
+
+ double xx = rotation(0, 0);
+ double yy = rotation(1, 1);
+ double zz = rotation(2, 2);
+
+ double cosa = 0.5 * (xx + yy + zz - 1);
+ double cosa1 = 1 - cosa;
+
+ if (cosa1 <= 0) {
+ rotationAngle = 0;
+ rotationAxis = Acts::Vector3D(0, 0, 1);
+ } else {
+ double x = 0, y = 0, z = 0;
+ if (xx > cosa) x = sqrt((xx - cosa) / cosa1);
+ if (yy > cosa) y = sqrt((yy - cosa) / cosa1);
+ if (zz > cosa) z = sqrt((zz - cosa) / cosa1);
+ if (rotation(2, 1) < rotation(1, 2)) x = -x;
+ if (rotation(0, 2) < rotation(2, 0)) y = -y;
+ if (rotation(1, 0) < rotation(0, 1)) z = -z;
+ rotationAngle = (cosa < -1.) ? acos(-1.) : acos(cosa);
+ rotationAxis = Acts::Vector3D(x, y, z);
}
- /**
- * Get the Translation vector out of a Transformation
- */
- inline Acts::Vector3D getTranslationVectorFromTransform(const Acts::Transform3D& tr) {
- return Acts::Vector3D(tr(0,3),tr(1,3),tr(2,3));
- } // TODO: check! it's perhaps useless, you acn use the transform.translation() method
-
-
+ return;
+}
- /**
- * get a AngleAxis from an angle and an axis.
- *
- * to replace the CLHEP constructor:
- * CLHEP::Rotate3D::Rotate3D(double a, cconst Vector3D< double > & v)
- */
- inline Acts::Rotation3D getRotation3DfromAngleAxis(double angle, Acts::Vector3D& axis)
- {
- AngleAxis3D t;
- t = Eigen::AngleAxis<double>(angle,axis);
-
- Acts::Rotation3D rot;
- rot = t;
+/**
+ * Get the Translation vector out of a Transformation
+ */
+inline Acts::Vector3D
+getTranslationVectorFromTransform(const Acts::Transform3D& tr)
+{
+ return Acts::Vector3D(tr(0, 3), tr(1, 3), tr(2, 3));
+} // TODO: check! it's perhaps useless, you acn use the transform.translation()
+ // method
+
+/**
+ * get a AngleAxis from an angle and an axis.
+ *
+ * to replace the CLHEP constructor:
+ * CLHEP::Rotate3D::Rotate3D(double a, cconst Vector3D< double > & v)
+ */
+inline Acts::Rotation3D
+getRotation3DfromAngleAxis(double angle, Acts::Vector3D& axis)
+{
+ AngleAxis3D t;
+ t = Eigen::AngleAxis<double>(angle, axis);
- return rot;
- }
+ Acts::Rotation3D rot;
+ rot = t;
+ return rot;
+}
- /**
- * get a rotation transformation around X-axis
- */
- inline Acts::Transform3D getRotateX3D(double angle) {
- Acts::Transform3D transf;
- Acts::AngleAxis3D angleaxis(angle, Acts::Vector3D(1.,0.,0.));
- transf = angleaxis;
- return transf;
- }
- /**
- * get a rotation transformation around Y-axis
- */
- inline Acts::Transform3D getRotateY3D(double angle) {
- Acts::Transform3D transf;
- Acts::AngleAxis3D angleaxis(angle, Acts::Vector3D(0.,1.,0.));
- transf = angleaxis;
- return transf;
- }
- /**
- * get a rotation transformation around Z-axis
- */
- inline Acts::Transform3D getRotateZ3D(double angle) {
- Acts::Transform3D transf;
- Acts::AngleAxis3D angleaxis(angle, Acts::Vector3D(0.,0.,1.));
- transf = angleaxis;
- return transf;
- }
+/**
+ * get a rotation transformation around X-axis
+ */
+inline Acts::Transform3D
+getRotateX3D(double angle)
+{
+ Acts::Transform3D transf;
+ Acts::AngleAxis3D angleaxis(angle, Acts::Vector3D(1., 0., 0.));
+ transf = angleaxis;
+ return transf;
+}
+/**
+ * get a rotation transformation around Y-axis
+ */
+inline Acts::Transform3D
+getRotateY3D(double angle)
+{
+ Acts::Transform3D transf;
+ Acts::AngleAxis3D angleaxis(angle, Acts::Vector3D(0., 1., 0.));
+ transf = angleaxis;
+ return transf;
+}
+/**
+ * get a rotation transformation around Z-axis
+ */
+inline Acts::Transform3D
+getRotateZ3D(double angle)
+{
+ Acts::Transform3D transf;
+ Acts::AngleAxis3D angleaxis(angle, Acts::Vector3D(0., 0., 1.));
+ transf = angleaxis;
+ return transf;
+}
-} // end of Acts namespace
+} // end of Acts namespace
#endif
diff --git a/Core/include/ACTS/Utilities/Identifier.hpp b/Core/include/ACTS/Utilities/Identifier.hpp
index bd4498012..f7cc089e6 100644
--- a/Core/include/ACTS/Utilities/Identifier.hpp
+++ b/Core/include/ACTS/Utilities/Identifier.hpp
@@ -13,7 +13,6 @@
#ifndef ACTS_CORE_IDENTIFIER_H
#define ACTS_CORE_IDENTIFIER_H 1
-
#ifdef ACTS_CORE_IDENTIFIER_PLUGIN
#include ACTS_CORE_IDENTIFIER_PLUGIN
#else
@@ -23,7 +22,7 @@
#include <string>
-/** @class Identifier
+/** @class Identifier
minimum implementation of an Identifier,
please use the ACTS_CORE_IDENTIFIER_PLUGING in to use instead if
@@ -31,76 +30,82 @@
*/
-
-class Identifier {
-
- public:
-
- ///----------------------------------------------------------------
- /// Define public typedefs
- ///----------------------------------------------------------------
- typedef Identifier id_type;
- typedef IDENTIFIER_TYPE value_type;
- typedef IDENTIFIER_DIFF_TYPE diff_type;
- typedef IDENTIFIER_TYPE size_type;
-
- typedef enum
- {
- NBITS = sizeof(value_type) * 8, // bits per byte
- MAX_BIT = (static_cast<value_type>(1) << (NBITS - 1)),
- ALL_BITS = ~(static_cast<value_type>(0))
- } bit_defs;
-
- ///----------------------------------------------------------------
- /// Constructors
- ///----------------------------------------------------------------
-
- /// Default constructor
- Identifier ();
-
- /// Constructor from value_type
- explicit Identifier (value_type value);
-
- /// Copy constructor
- Identifier (const Identifier& other);
-
- ///----------------------------------------------------------------
- /// Modifications
- ///----------------------------------------------------------------
- Identifier& operator |= (value_type value);
- Identifier& operator &= (value_type value);
-
- ///----------------------------------------------------------------
- /// Assignment operator
- ///----------------------------------------------------------------
- Identifier& operator = (const Identifier& old);
- Identifier& operator = (value_type value);
-
- ///----------------------------------------------------------------
- /// Comparison operators
- ///----------------------------------------------------------------
- bool operator == (const Identifier& other) const;
- bool operator != (const Identifier& other) const;
- bool operator < (const Identifier& other) const;
- bool operator > (const Identifier& other) const;
- bool operator <= (const Identifier& other) const;
- bool operator >= (const Identifier& other) const;
-
- /// Check if id is in a valid state
- bool is_valid () const;
-
- private:
-
- //----------------------------------------------------------------
- // The compact identifier data.
- //----------------------------------------------------------------
- value_type m_id;
-
- typedef enum {
- //max_value = 0xFFFFFFFFFFFFFFFFULL
- max_value = ~(static_cast<value_type>(0))
- } max_value_type;
-
+class Identifier
+{
+public:
+ ///----------------------------------------------------------------
+ /// Define public typedefs
+ ///----------------------------------------------------------------
+ typedef Identifier id_type;
+ typedef IDENTIFIER_TYPE value_type;
+ typedef IDENTIFIER_DIFF_TYPE diff_type;
+ typedef IDENTIFIER_TYPE size_type;
+
+ typedef enum {
+ NBITS = sizeof(value_type) * 8, // bits per byte
+ MAX_BIT = (static_cast<value_type>(1) << (NBITS - 1)),
+ ALL_BITS = ~(static_cast<value_type>(0))
+ } bit_defs;
+
+ ///----------------------------------------------------------------
+ /// Constructors
+ ///----------------------------------------------------------------
+
+ /// Default constructor
+ Identifier();
+
+ /// Constructor from value_type
+ explicit Identifier(value_type value);
+
+ /// Copy constructor
+ Identifier(const Identifier& other);
+
+ ///----------------------------------------------------------------
+ /// Modifications
+ ///----------------------------------------------------------------
+ Identifier&
+ operator|=(value_type value);
+ Identifier&
+ operator&=(value_type value);
+
+ ///----------------------------------------------------------------
+ /// Assignment operator
+ ///----------------------------------------------------------------
+ Identifier&
+ operator=(const Identifier& old);
+ Identifier&
+ operator=(value_type value);
+
+ ///----------------------------------------------------------------
+ /// Comparison operators
+ ///----------------------------------------------------------------
+ bool
+ operator==(const Identifier& other) const;
+ bool
+ operator!=(const Identifier& other) const;
+ bool
+ operator<(const Identifier& other) const;
+ bool
+ operator>(const Identifier& other) const;
+ bool
+ operator<=(const Identifier& other) const;
+ bool
+ operator>=(const Identifier& other) const;
+
+ /// Check if id is in a valid state
+ bool
+ is_valid() const;
+
+private:
+ //----------------------------------------------------------------
+ // The compact identifier data.
+ //----------------------------------------------------------------
+ value_type m_id;
+
+ typedef enum {
+ // max_value = 0xFFFFFFFFFFFFFFFFULL
+ max_value = ~(static_cast<value_type>(0))
+ } max_value_type;
};
//-----------------------------------------------
@@ -108,99 +113,103 @@ class Identifier {
// Constructors
//-----------------------------------------------
-inline Identifier::Identifier ()
- : m_id(max_value)
-{}
+inline Identifier::Identifier() : m_id(max_value)
+{
+}
//-----------------------------------------------
-inline Identifier::Identifier (const Identifier& other)
- : m_id(other.m_id)
-{}
+inline Identifier::Identifier(const Identifier& other) : m_id(other.m_id)
+{
+}
//-----------------------------------------------
-inline Identifier::Identifier (value_type value)
- : m_id(value)
-{}
+inline Identifier::Identifier(value_type value) : m_id(value)
+{
+}
// Modifications
//-----------------------------------------------
-inline Identifier& Identifier::operator = (const Identifier& other) {
+inline Identifier&
+Identifier::operator=(const Identifier& other)
+{
if (&other != this) {
- m_id = other.m_id;
+ m_id = other.m_id;
}
return (*this);
}
-inline Identifier& Identifier::operator = (value_type value)
+inline Identifier&
+Identifier::operator=(value_type value)
{
- m_id = value;
- return (*this);
+ m_id = value;
+ return (*this);
}
-inline Identifier&
-Identifier::operator |= (value_type value)
+inline Identifier&
+Identifier::operator|=(value_type value)
{
- m_id |= value;
- return (*this);
+ m_id |= value;
+ return (*this);
}
-inline Identifier&
-Identifier::operator &= (value_type value)
+inline Identifier&
+Identifier::operator&=(value_type value)
{
- m_id &= value;
- return (*this);
+ m_id &= value;
+ return (*this);
}
// Comparison operators
//----------------------------------------------------------------
-inline bool
-Identifier::operator == (const Identifier& other) const
+inline bool
+Identifier::operator==(const Identifier& other) const
{
- return (m_id == other.m_id);
+ return (m_id == other.m_id);
}
//----------------------------------------------------------------
-inline bool
-Identifier::operator != (const Identifier& other) const
+inline bool
+Identifier::operator!=(const Identifier& other) const
{
- return (m_id != other.m_id);
+ return (m_id != other.m_id);
}
//-----------------------------------------------
-inline bool
-Identifier::operator < (const Identifier& other) const
+inline bool
+Identifier::operator<(const Identifier& other) const
{
- return (m_id < other.m_id);
+ return (m_id < other.m_id);
}
//-----------------------------------------------
-inline bool
-Identifier::operator > (const Identifier& other) const
+inline bool
+Identifier::operator>(const Identifier& other) const
{
- return (m_id > other.m_id);
+ return (m_id > other.m_id);
}
//-----------------------------------------------
-inline bool
-Identifier::operator <= (const Identifier& other) const
+inline bool
+Identifier::operator<=(const Identifier& other) const
{
- return (m_id <= other.m_id);
+ return (m_id <= other.m_id);
}
//-----------------------------------------------
-inline bool
-Identifier::operator >= (const Identifier& other) const
+inline bool
+Identifier::operator>=(const Identifier& other) const
{
- return (m_id >= other.m_id);
+ return (m_id >= other.m_id);
}
//----------------------------------------------------------------
-inline bool Identifier::is_valid () const
+inline bool
+Identifier::is_valid() const
{
- return (!(max_value == m_id));
+ return (!(max_value == m_id));
}
-#endif // ACTS_CORE_IDENTIFIER_PLUGIN
+#endif // ACTS_CORE_IDENTIFIER_PLUGIN
-#endif // ACTS_CORE_IDENTIFIER_H
+#endif // ACTS_CORE_IDENTIFIER_H
diff --git a/Core/include/ACTS/Utilities/Intersection.hpp b/Core/include/ACTS/Utilities/Intersection.hpp
index 368a2e836..ebb813f55 100644
--- a/Core/include/ACTS/Utilities/Intersection.hpp
+++ b/Core/include/ACTS/Utilities/Intersection.hpp
@@ -16,99 +16,97 @@
#include "Definitions.hpp"
namespace Acts {
-
- /**
- @struct Intersection
-
- */
-
- struct Intersection {
-
- Vector3D position;
- double pathLength;
- double distance;
- bool valid;
-
- Intersection(const Vector3D& sinter,
- double slenght,
- bool svalid,
- double dist = 0.) :
- position(sinter),
- pathLength(slenght),
- distance(dist),
- valid(svalid)
- {}
-
- Intersection() :
- position(Vector3D(0.,0.,0.)),
- pathLength(0.),
- distance(0.),
- valid(false)
- {}
-
- // smaller operator for sorting
- bool operator< (const Intersection& si ) const
- { return (valid && pathLength < si.pathLength); }
- };
-
-
- /** class extensions to return also the object */
- template <class T> class ObjectIntersection {
- public:
- Intersection intersection;
- mutable const T* object;
- int pDirection;
-
- /** Default constructor */
- ObjectIntersection():
- intersection(),
- object(nullptr),
- pDirection(0)
- {}
-
- /** Object intersection */
- ObjectIntersection(const Intersection& sInter,
- const T* sObject,
- int dir = 1):
- intersection(sInter),
- object(sObject),
- pDirection(dir)
- {}
-
- /** smaller operator for ordering & sorting */
- bool operator< ( const ObjectIntersection<T>& oi ) const {
- return ( intersection < oi.intersection );
- }
- };
-
- /** Class extension to return the object, a represenation & the result */
- template <class T, class R, class S> class FullIntersection {
- public:
- Intersection intersection;
- mutable const T* object;
- mutable const R* representation;
- mutable const S* result;
- int pDirection;
-
- /** Full intersection */
- FullIntersection(const Intersection& sInter,
- const T* sObject,
- const R* sRepresentation,
- const S* sResult,
- int dir=1):
- intersection(sInter),
- object(sObject),
- representation(sRepresentation),
- result(sResult),
- pDirection(dir)
- {}
-
- /** smaller operator for ordering & sorting */
- bool operator< ( const FullIntersection<T,R, S>& oi ) const {
- return ( intersection < oi.intersection );
- }
- };
+/**
+ @struct Intersection
+
+ */
+
+struct Intersection
+{
+ Vector3D position;
+ double pathLength;
+ double distance;
+ bool valid;
+
+ Intersection(const Vector3D& sinter,
+ double slenght,
+ bool svalid,
+ double dist = 0.)
+ : position(sinter), pathLength(slenght), distance(dist), valid(svalid)
+ {
+ }
+
+ Intersection()
+ : position(Vector3D(0., 0., 0.)), pathLength(0.), distance(0.), valid(false)
+ {
+ }
+
+ // smaller operator for sorting
+ bool
+ operator<(const Intersection& si) const
+ {
+ return (valid && pathLength < si.pathLength);
+ }
+};
+
+/** class extensions to return also the object */
+template <class T>
+class ObjectIntersection
+{
+public:
+ Intersection intersection;
+ mutable const T* object;
+ int pDirection;
+
+ /** Default constructor */
+ ObjectIntersection() : intersection(), object(nullptr), pDirection(0) {}
+ /** Object intersection */
+ ObjectIntersection(const Intersection& sInter, const T* sObject, int dir = 1)
+ : intersection(sInter), object(sObject), pDirection(dir)
+ {
+ }
+
+ /** smaller operator for ordering & sorting */
+ bool
+ operator<(const ObjectIntersection<T>& oi) const
+ {
+ return (intersection < oi.intersection);
+ }
+};
+
+/** Class extension to return the object, a represenation & the result */
+template <class T, class R, class S>
+class FullIntersection
+{
+public:
+ Intersection intersection;
+ mutable const T* object;
+ mutable const R* representation;
+ mutable const S* result;
+ int pDirection;
+
+ /** Full intersection */
+ FullIntersection(const Intersection& sInter,
+ const T* sObject,
+ const R* sRepresentation,
+ const S* sResult,
+ int dir = 1)
+ : intersection(sInter)
+ , object(sObject)
+ , representation(sRepresentation)
+ , result(sResult)
+ , pDirection(dir)
+ {
+ }
+
+ /** smaller operator for ordering & sorting */
+ bool
+ operator<(const FullIntersection<T, R, S>& oi) const
+ {
+ return (intersection < oi.intersection);
+ }
+};
}
-#endif // ACTS_GEOMETRYUTILS_INTERSECTION_H
+#endif // ACTS_GEOMETRYUTILS_INTERSECTION_H
diff --git a/Core/include/ACTS/Utilities/Logger.hpp b/Core/include/ACTS/Utilities/Logger.hpp
index 041fb1161..a0b58ef0a 100644
--- a/Core/include/ACTS/Utilities/Logger.hpp
+++ b/Core/include/ACTS/Utilities/Logger.hpp
@@ -10,261 +10,291 @@
#define ACTS_LOGGER_H 1
// STL include(s)
-#include <sstream>
#include <cstdio>
-#include <ios>
-#include <iomanip>
#include <ctime>
-#include <string>
#include <functional>
-#include <ostream>
+#include <iomanip>
+#include <ios>
#include <memory>
+#include <ostream>
+#include <sstream>
+#include <string>
#include <thread>
-#define ACTS_VERBOSE(x) if(logger().print(Acts::Logging::VERBOSE)) logger().log(Acts::Logging::VERBOSE) << x;
-#define ACTS_DEBUG(x) if(logger().print(Acts::Logging::DEBUG) ) logger().log(Acts::Logging::DEBUG) << x;
-#define ACTS_INFO(x) if(logger().print(Acts::Logging::INFO) ) logger().log(Acts::Logging::INFO) << x;
-#define ACTS_WARNING(x) if(logger().print(Acts::Logging::WARNING)) logger().log(Acts::Logging::WARNING) << x;
-#define ACTS_ERROR(x) if(logger().print(Acts::Logging::ERROR) ) logger().log(Acts::Logging::ERROR) << x;
-#define ACTS_FATAL(x) if(logger().print(Acts::Logging::FATAL) ) logger().log(Acts::Logging::FATAL) << x;
+#define ACTS_VERBOSE(x) \
+ if (logger().print(Acts::Logging::VERBOSE)) \
+ logger().log(Acts::Logging::VERBOSE) << x;
+#define ACTS_DEBUG(x) \
+ if (logger().print(Acts::Logging::DEBUG)) \
+ logger().log(Acts::Logging::DEBUG) << x;
+#define ACTS_INFO(x) \
+ if (logger().print(Acts::Logging::INFO)) \
+ logger().log(Acts::Logging::INFO) << x;
+#define ACTS_WARNING(x) \
+ if (logger().print(Acts::Logging::WARNING)) \
+ logger().log(Acts::Logging::WARNING) << x;
+#define ACTS_ERROR(x) \
+ if (logger().print(Acts::Logging::ERROR)) \
+ logger().log(Acts::Logging::ERROR) << x;
+#define ACTS_FATAL(x) \
+ if (logger().print(Acts::Logging::FATAL)) \
+ logger().log(Acts::Logging::FATAL) << x;
+
+namespace Acts {
+/**
+ * @brief logging related helper classes
+ */
+namespace Logging {
+ /**
+ * @enum Level
+ *
+ * @brief different logging levels
+ */
+ enum Level { VERBOSE = 0, DEBUG, INFO, WARNING, ERROR, FATAL };
+
+ /**
+ * @brief abstract base class for logging output policy
+ */
+ class OutputPolicy
+ {
+ public:
+ virtual ~OutputPolicy() = default;
+
+ virtual void
+ flush(const Level& lvl, const std::ostringstream& input)
+ = 0;
+ };
+
+ /**
+ * @brief abstract base class for logging printing policy
+ */
+ class PrintPolicy
+ {
+ public:
+ virtual ~PrintPolicy() = default;
+
+ virtual bool
+ doPrint(const Level& lvl) const = 0;
+ };
-namespace Acts
-{
/**
- * @brief logging related helper classes
+ * @brief thread-safe output stream
*/
- namespace Logging
+ class OutStream
{
- /**
- * @enum Level
- *
- * @brief different logging levels
- */
- enum Level {VERBOSE = 0, DEBUG, INFO, WARNING, ERROR, FATAL};
-
- /**
- * @brief abstract base class for logging output policy
- */
- class OutputPolicy
+ typedef std::function<void(const std::ostringstream&)> OutputFunc;
+
+ public:
+ OutStream(OutputFunc output) : m_stream(), m_outputFunctor(output) {}
+ OutStream(const OutStream& copy)
+ : m_stream(), m_outputFunctor(copy.m_outputFunctor)
{
- public:
- virtual ~OutputPolicy() = default;
+ m_stream << copy.m_stream.str();
+ }
- virtual void flush(const Level& lvl,const std::ostringstream& input) = 0;
- };
+ ~OutStream() { m_outputFunctor(m_stream); }
+ template <typename T>
+ OutStream&
+ operator<<(T&& input)
+ {
+ m_stream << std::forward<T>(input);
+ return *this;
+ }
- /**
- * @brief abstract base class for logging printing policy
- */
- class PrintPolicy
+ template <typename T>
+ OutStream&
+ operator<<(T& (*f)(T&))
{
- public:
- virtual ~PrintPolicy() = default;
+ f(m_stream);
+ return *this;
+ }
- virtual bool doPrint(const Level& lvl) const = 0;
- };
+ private:
+ std::ostringstream m_stream;
+ OutputFunc m_outputFunctor;
+ };
- /**
- * @brief thread-safe output stream
- */
- class OutStream
+ class DefaultPrintPolicy : public PrintPolicy
+ {
+ public:
+ DefaultPrintPolicy(const Level& lvl) : m_level(lvl) {}
+ bool
+ doPrint(const Level& lvl) const override
{
- typedef std::function<void(const std::ostringstream&)> OutputFunc;
- public:
- OutStream(OutputFunc output):
- m_stream(),
- m_outputFunctor(output)
- {}
-
- OutStream(const OutStream& copy):
- m_stream(),
- m_outputFunctor(copy.m_outputFunctor)
- {
- m_stream << copy.m_stream.str();
- }
-
- ~OutStream()
- {
- m_outputFunctor(m_stream);
- }
-
- template<typename T>
- OutStream& operator<<(T&& input)
- {
- m_stream << std::forward<T>(input);
- return *this;
- }
-
- template<typename T>
- OutStream& operator<<(T& (*f)(T&))
- {
- f(m_stream);
- return *this;
- }
-
- private:
- std::ostringstream m_stream;
- OutputFunc m_outputFunctor;
- };
-
- class DefaultPrintPolicy: public PrintPolicy
+ return m_level <= lvl;
+ }
+
+ private:
+ Level m_level;
+ };
+
+ class OutputDecorator : public OutputPolicy
+ {
+ public:
+ OutputDecorator(std::unique_ptr<OutputPolicy> wrappee)
+ : m_wrappee(std::move(wrappee))
{
- public:
- DefaultPrintPolicy(const Level& lvl):
- m_level(lvl)
- {}
+ }
- bool doPrint(const Level& lvl) const override {return m_level <= lvl;}
+ void
+ flush(const Level& lvl, const std::ostringstream& input) override
+ {
+ m_wrappee->flush(lvl, input);
+ }
- private:
- Level m_level;
- };
+ private:
+ std::unique_ptr<OutputPolicy> m_wrappee;
+ };
- class OutputDecorator: public OutputPolicy
+ class NamedOutputDecorator final : public OutputDecorator
+ {
+ public:
+ NamedOutputDecorator(std::unique_ptr<OutputPolicy> wrappee,
+ const std::string& name,
+ unsigned int maxWidth = 15)
+ : OutputDecorator(std::move(wrappee)), m_name(name), m_maxWidth(maxWidth)
{
- public:
- OutputDecorator(std::unique_ptr<OutputPolicy> wrappee):
- m_wrappee(std::move(wrappee))
- {}
+ }
- void flush(const Level& lvl,const std::ostringstream& input) override
- {
- m_wrappee->flush(lvl,input);
- }
+ void
+ flush(const Level& lvl, const std::ostringstream& input) override
+ {
+ std::ostringstream os;
+ os << std::left << std::setw(m_maxWidth)
+ << m_name.substr(0, m_maxWidth - 3) << input.str();
+ OutputDecorator::flush(lvl, os);
+ }
- private:
- std::unique_ptr<OutputPolicy> m_wrappee;
- };
+ private:
+ std::string m_name;
+ unsigned int m_maxWidth;
+ };
- class NamedOutputDecorator final : public OutputDecorator
+ class TimedOutputDecorator final : public OutputDecorator
+ {
+ public:
+ TimedOutputDecorator(std::unique_ptr<OutputPolicy> wrappee,
+ const std::string& format = "%X")
+ : OutputDecorator(std::move(wrappee)), m_format(format)
{
- public:
- NamedOutputDecorator(std::unique_ptr<OutputPolicy> wrappee,const std::string& name,unsigned int maxWidth=15):
- OutputDecorator(std::move(wrappee)),
- m_name(name),
- m_maxWidth(maxWidth)
- {}
-
- void flush(const Level& lvl,const std::ostringstream& input) override
- {
- std::ostringstream os;
- os << std::left << std::setw(m_maxWidth) << m_name.substr(0,m_maxWidth - 3) << input.str();
- OutputDecorator::flush(lvl,os);
- }
-
- private:
- std::string m_name;
- unsigned int m_maxWidth;
- };
-
- class TimedOutputDecorator final : public OutputDecorator
+ }
+
+ void
+ flush(const Level& lvl, const std::ostringstream& input) override
{
- public:
- TimedOutputDecorator(std::unique_ptr<OutputPolicy> wrappee,const std::string& format = "%X"):
- OutputDecorator(std::move(wrappee)),
- m_format(format)
- {}
-
- void flush(const Level& lvl,const std::ostringstream& input) override
- {
- std::ostringstream os;
- os << std::left << std::setw(12) << now() << input.str();
- OutputDecorator::flush(lvl,os);
- }
-
- private:
- std::string now() const
- {
- char buffer[20];
- time_t t;
- std::time(&t);
- std::strftime(buffer, sizeof(buffer), m_format.c_str(), localtime(&t));
- return buffer;
- }
-
- std::string m_format;
- };
-
- class ThreadOutputDecorator final : public OutputDecorator
+ std::ostringstream os;
+ os << std::left << std::setw(12) << now() << input.str();
+ OutputDecorator::flush(lvl, os);
+ }
+
+ private:
+ std::string
+ now() const
{
- public:
- ThreadOutputDecorator(std::unique_ptr<OutputPolicy> wrappee):
- OutputDecorator(std::move(wrappee))
- {}
-
- void flush(const Level& lvl,const std::ostringstream& input) override
- {
- std::ostringstream os;
- os << std::left << std::setw(20) << std::this_thread::get_id() << input.str();
- OutputDecorator::flush(lvl,os);
- }
- };
-
- class LevelOutputDecorator final : public OutputDecorator
+ char buffer[20];
+ time_t t;
+ std::time(&t);
+ std::strftime(buffer, sizeof(buffer), m_format.c_str(), localtime(&t));
+ return buffer;
+ }
+
+ std::string m_format;
+ };
+
+ class ThreadOutputDecorator final : public OutputDecorator
+ {
+ public:
+ ThreadOutputDecorator(std::unique_ptr<OutputPolicy> wrappee)
+ : OutputDecorator(std::move(wrappee))
{
- public:
- LevelOutputDecorator(std::unique_ptr<OutputPolicy> wrappee):
- OutputDecorator(std::move(wrappee))
- {}
-
- void flush(const Level& lvl,const std::ostringstream& input) override
- {
- std::ostringstream os;
- os << std::left << std::setw(10) << toString(lvl) << input.str();
- OutputDecorator::flush(lvl,os);
- }
-
- private:
- std::string toString(const Level& lvl) const
- {
- static const char* const buffer[] = {"VERBOSE", "DEBUG", "INFO", "WARNING", "ERROR", "FATAL"};
- return buffer[lvl];
- }
- };
-
- class DefaultOutputPolicy: public OutputPolicy
+ }
+
+ void
+ flush(const Level& lvl, const std::ostringstream& input) override
{
- public:
- DefaultOutputPolicy(std::FILE* out = stdout):
- m_out(out)
- {}
-
- void flush(const Level&,const std::ostringstream& input) final
- {
- fprintf(m_out, "%s\n", input.str().c_str());
- fflush(m_out);
- }
-
- private:
- std::FILE* m_out;
- };
- } // end of namespace Logging
+ std::ostringstream os;
+ os << std::left << std::setw(20) << std::this_thread::get_id()
+ << input.str();
+ OutputDecorator::flush(lvl, os);
+ }
+ };
- /**
- * @brief logging class
- */
- class Logger
+ class LevelOutputDecorator final : public OutputDecorator
{
public:
- template<typename Output,typename Print>
- Logger(std::unique_ptr<Output> pOutput,std::unique_ptr<Print> pPrint):
- m_outputPolicy(std::move(pOutput)),
- m_printPolicy(std::move(pPrint))
- {}
+ LevelOutputDecorator(std::unique_ptr<OutputPolicy> wrappee)
+ : OutputDecorator(std::move(wrappee))
+ {
+ }
- bool print(const Logging::Level& lvl) const {return m_printPolicy->doPrint(lvl);}
+ void
+ flush(const Level& lvl, const std::ostringstream& input) override
+ {
+ std::ostringstream os;
+ os << std::left << std::setw(10) << toString(lvl) << input.str();
+ OutputDecorator::flush(lvl, os);
+ }
- Logging::OutStream log(const Logging::Level& lvl) const
+ private:
+ std::string
+ toString(const Level& lvl) const
{
- return Logging::OutStream(std::bind(&Logging::OutputPolicy::flush,m_outputPolicy.get(),lvl,std::placeholders::_1));
+ static const char* const buffer[]
+ = {"VERBOSE", "DEBUG", "INFO", "WARNING", "ERROR", "FATAL"};
+ return buffer[lvl];
+ }
+ };
+
+ class DefaultOutputPolicy : public OutputPolicy
+ {
+ public:
+ DefaultOutputPolicy(std::FILE* out = stdout) : m_out(out) {}
+ void
+ flush(const Level&, const std::ostringstream& input) final
+ {
+ fprintf(m_out, "%s\n", input.str().c_str());
+ fflush(m_out);
}
private:
- std::unique_ptr<Logging::OutputPolicy> m_outputPolicy;
- std::unique_ptr<Logging::PrintPolicy> m_printPolicy;
+ std::FILE* m_out;
};
+} // end of namespace Logging
- std::unique_ptr<Logger> getDefaultLogger(const std::string& name,const Logging::Level& lvl);
+/**
+ * @brief logging class
+ */
+class Logger
+{
+public:
+ template <typename Output, typename Print>
+ Logger(std::unique_ptr<Output> pOutput, std::unique_ptr<Print> pPrint)
+ : m_outputPolicy(std::move(pOutput)), m_printPolicy(std::move(pPrint))
+ {
+ }
+
+ bool
+ print(const Logging::Level& lvl) const
+ {
+ return m_printPolicy->doPrint(lvl);
+ }
+
+ Logging::OutStream
+ log(const Logging::Level& lvl) const
+ {
+ return Logging::OutStream(std::bind(&Logging::OutputPolicy::flush,
+ m_outputPolicy.get(),
+ lvl,
+ std::placeholders::_1));
+ }
+
+private:
+ std::unique_ptr<Logging::OutputPolicy> m_outputPolicy;
+ std::unique_ptr<Logging::PrintPolicy> m_printPolicy;
+};
+
+std::unique_ptr<Logger>
+getDefaultLogger(const std::string& name, const Logging::Level& lvl);
} // end of namespace Acts
-#endif // ACTS_LOGGER_H
+#endif // ACTS_LOGGER_H
diff --git a/Core/include/ACTS/Utilities/MsgMacros.hpp b/Core/include/ACTS/Utilities/MsgMacros.hpp
index 03633cfe3..60fcabf3e 100644
--- a/Core/include/ACTS/Utilities/MsgMacros.hpp
+++ b/Core/include/ACTS/Utilities/MsgMacros.hpp
@@ -12,7 +12,7 @@
#ifdef ACTS_MSG_MACROS_PLUGIN
#include ACTS_MSG_MACROS_PLUGIN
#else
- static_assert(false,"no message macros defined");
+static_assert(false, "no message macros defined");
#endif
-#endif // ACTS_MSG_MACROS_H
+#endif // ACTS_MSG_MACROS_H
diff --git a/Core/include/ACTS/Utilities/OverlapDescriptor.hpp b/Core/include/ACTS/Utilities/OverlapDescriptor.hpp
index c61292636..63d38a054 100644
--- a/Core/include/ACTS/Utilities/OverlapDescriptor.hpp
+++ b/Core/include/ACTS/Utilities/OverlapDescriptor.hpp
@@ -14,58 +14,55 @@
#define ACTS_DETECTOR_IOVERLAPDESCRIPTOR_H
// Core module
-#include "ACTS/Utilities/Intersection.hpp"
#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Utilities/Intersection.hpp"
// STD
#include <vector>
namespace Acts {
- class Surface;
+class Surface;
- /**
- @class OverlapDescriptor
-
- BaseClass to be overloaded for describing overlaps
- and next-by elements for the sub-detector implementations.
+/**
+@class OverlapDescriptor
- It allows to describe the potentially reachable surfaces
+BaseClass to be overloaded for describing overlaps
+and next-by elements for the sub-detector implementations.
- */
+It allows to describe the potentially reachable surfaces
- class OverlapDescriptor {
- public:
- /**Default constructor*/
- OverlapDescriptor(){}
-
- /**Virtual destructor*/
- virtual ~OverlapDescriptor(){}
-
- /**Pseudo-constructor*/
- virtual OverlapDescriptor* clone() const = 0;
-
- /** get the compatible surfaces
- - return : a boolean indicating if an actual intersection had been tried
- - fill vector of intersections
- - primary bin surface : sf
- - position & direction : pos, dir
-
- Possible search type given by the Layer :
- 1,2 - provide bin surface and registered neighbours and bin mates
- 3,4 - provide bin surface and next bin surfaces (if they differ)
- 5 - whatever the overlap descriptor returns with this
-
- */
- virtual bool reachableSurfaces(std::vector<const Surface*>& cSurfaces,
- const Surface& sf,
- const Vector3D& pos,
- const Vector3D& dir,
- int searchType) const = 0;
-
- };
+*/
-}
+class OverlapDescriptor
+{
+public:
+ /**Default constructor*/
+ OverlapDescriptor() {}
+ /**Virtual destructor*/
+ virtual ~OverlapDescriptor() {}
+ /**Pseudo-constructor*/
+ virtual OverlapDescriptor*
+ clone() const = 0;
-#endif
+ /** get the compatible surfaces
+ - return : a boolean indicating if an actual intersection had been tried
+ - fill vector of intersections
+ - primary bin surface : sf
+ - position & direction : pos, dir
+ Possible search type given by the Layer :
+ 1,2 - provide bin surface and registered neighbours and bin mates
+ 3,4 - provide bin surface and next bin surfaces (if they differ)
+ 5 - whatever the overlap descriptor returns with this
+ */
+ virtual bool
+ reachableSurfaces(std::vector<const Surface*>& cSurfaces,
+ const Surface& sf,
+ const Vector3D& pos,
+ const Vector3D& dir,
+ int searchType) const = 0;
+};
+}
+
+#endif
diff --git a/Core/include/ACTS/Utilities/ParameterDefinitions.hpp b/Core/include/ACTS/Utilities/ParameterDefinitions.hpp
index 25fff46cc..0f14f7c07 100644
--- a/Core/include/ACTS/Utilities/ParameterDefinitions.hpp
+++ b/Core/include/ACTS/Utilities/ParameterDefinitions.hpp
@@ -17,27 +17,42 @@
#include <type_traits>
// typedefs for parameter identifier and parameter value must be present
-static_assert(std::is_enum<Acts::ParID_t>::value,"'ParID_t' is not an enum type");
-static_assert(std::is_floating_point<Acts::ParValue_t>::value,"'ParValue_t' is not floating point type");
+static_assert(std::is_enum<Acts::ParID_t>::value,
+ "'ParID_t' is not an enum type");
+static_assert(std::is_floating_point<Acts::ParValue_t>::value,
+ "'ParValue_t' is not floating point type");
// parameter ID type must be convertible to unsigned int
-static_assert(std::is_convertible<Acts::ParID_t,unsigned int>::value,"'ParID_t' is not convertible to unsigned int");
+static_assert(std::is_convertible<Acts::ParID_t, unsigned int>::value,
+ "'ParID_t' is not convertible to unsigned int");
// number of global parameter must be at least 2 (for the two local parameters)
-static_assert(Acts::NGlobalPars > 1,"total number of global parameters must be >= 2");
+static_assert(Acts::NGlobalPars > 1,
+ "total number of global parameters must be >= 2");
// several constants for the local parameters need to be defined
-static_assert(Acts::eLOC_1 != Acts::eLOC_2,"local parameters must have different IDs");
-static_assert(Acts::eLOC_R == Acts::eLOC_1 or Acts::eLOC_R == Acts::eLOC_2,"local radius must be a local parameter");
-static_assert(Acts::eLOC_PHI == Acts::eLOC_1 or Acts::eLOC_PHI == Acts::eLOC_2,"local phi must be a local parameter");
-static_assert(Acts::eLOC_RPHI == Acts::eLOC_1 or Acts::eLOC_RPHI == Acts::eLOC_2,"local r x phi must be a local parameter");
-static_assert(Acts::eLOC_Z == Acts::eLOC_1 or Acts::eLOC_Z == Acts::eLOC_2,"local z must be a local parameter");
-static_assert(Acts::eLOC_X == Acts::eLOC_1 or Acts::eLOC_X == Acts::eLOC_2,"local x must be a local parameter");
-static_assert(Acts::eLOC_Y == Acts::eLOC_1 or Acts::eLOC_Y == Acts::eLOC_2,"local y must be a local parameter");
-static_assert(Acts::eLOC_D0 == Acts::eLOC_1 or Acts::eLOC_D0 == Acts::eLOC_2,"d0 must be a local parameter");
-static_assert(Acts::eLOC_Z0 == Acts::eLOC_1 or Acts::eLOC_Z0 == Acts::eLOC_2,"z0 must be a local parameter");
+static_assert(Acts::eLOC_1 != Acts::eLOC_2,
+ "local parameters must have different IDs");
+static_assert(Acts::eLOC_R == Acts::eLOC_1 or Acts::eLOC_R == Acts::eLOC_2,
+ "local radius must be a local parameter");
+static_assert(Acts::eLOC_PHI == Acts::eLOC_1 or Acts::eLOC_PHI == Acts::eLOC_2,
+ "local phi must be a local parameter");
+static_assert(Acts::eLOC_RPHI == Acts::eLOC_1
+ or Acts::eLOC_RPHI == Acts::eLOC_2,
+ "local r x phi must be a local parameter");
+static_assert(Acts::eLOC_Z == Acts::eLOC_1 or Acts::eLOC_Z == Acts::eLOC_2,
+ "local z must be a local parameter");
+static_assert(Acts::eLOC_X == Acts::eLOC_1 or Acts::eLOC_X == Acts::eLOC_2,
+ "local x must be a local parameter");
+static_assert(Acts::eLOC_Y == Acts::eLOC_1 or Acts::eLOC_Y == Acts::eLOC_2,
+ "local y must be a local parameter");
+static_assert(Acts::eLOC_D0 == Acts::eLOC_1 or Acts::eLOC_D0 == Acts::eLOC_2,
+ "d0 must be a local parameter");
+static_assert(Acts::eLOC_Z0 == Acts::eLOC_1 or Acts::eLOC_Z0 == Acts::eLOC_2,
+ "z0 must be a local parameter");
// check for par_type_t definition
-static_assert(sizeof(Acts::par_type_t<Acts::eLOC_1>) > 0,"'par_type_t' is not defined");
+static_assert(sizeof(Acts::par_type_t<Acts::eLOC_1>) > 0,
+ "'par_type_t' is not defined");
-#endif // ACTS_PARAMETERDEFINITIONS_H
+#endif // ACTS_PARAMETERDEFINITIONS_H
diff --git a/Core/include/ACTS/Utilities/ParameterTypes.hpp b/Core/include/ACTS/Utilities/ParameterTypes.hpp
index 0f9c3c565..f9abb7f38 100644
--- a/Core/include/ACTS/Utilities/ParameterTypes.hpp
+++ b/Core/include/ACTS/Utilities/ParameterTypes.hpp
@@ -13,140 +13,166 @@
#include <algorithm>
#include <cmath>
-namespace Acts
+namespace Acts {
+/**
+ * @brief type for parameters with unrestricted value range
+ */
+struct unbound_parameter
{
+ static constexpr bool may_modify_value{
+ false}; ///< parameter values need no adjustment
+
/**
- * @brief type for parameters with unrestricted value range
+ * @brief retrieve value for unconstrained parameter value ranges
+ *
+ * @tparam T type of the input parameter
+ * @param input input parameter value
+ *
+ * @return identical input parameter value
*/
- struct unbound_parameter
+ template <typename T>
+ static T
+ getValue(const T& input)
{
- static constexpr bool may_modify_value {false}; ///< parameter values need no adjustment
+ return input;
+ }
- /**
- * @brief retrieve value for unconstrained parameter value ranges
- *
- * @tparam T type of the input parameter
- * @param input input parameter value
- *
- * @return identical input parameter value
- */
- template<typename T>
- static T getValue(const T& input)
- {
- return input;
- }
+ template <typename T>
+ static T
+ getDifference(const T& first, const T& second)
+ {
+ return first - second;
+ }
+};
- template<typename T>
- static T getDifference(const T& first,const T& second)
- {
- return first - second;
- }
- };
+/**
+ * @brief type for local parameters bound to a surface
+ */
+struct local_parameter : public unbound_parameter
+{
+};
- /**
- * @brief type for local parameters bound to a surface
- */
- struct local_parameter : public unbound_parameter {};
+/**
+ * @brief type for parameter with restricted value range
+ *
+ * This parameter type could be useful to describe parameter with physical
+ * meaningful bounds (e.g. radius).
+ *
+ * @tparam T type for boundary value (usually @c double)
+ * @tparam MIN pointer to a @c constexpr function returning the lower bound of
+ * the value range
+ * @tparam MAX pointer to a @c constexpr function returning the upper bound of
+ * the value range
+ */
+template <typename T, T (*MIN)(), T (*MAX)()>
+struct bound_parameter
+{
+ static constexpr bool may_modify_value{
+ true}; ///< parameter values may need adjustment
+ static constexpr T min{MIN()}; ///< lower bound of range
+ static constexpr T max{MAX()}; ///< upper bound of range
/**
- * @brief type for parameter with restricted value range
+ * @brief retrieve value for constrained parameter value ranges
*
- * This parameter type could be useful to describe parameter with physical meaningful bounds (e.g. radius).
+ * @tparam U type of the input parameter
+ * @param input input parameter value
*
- * @tparam T type for boundary value (usually @c double)
- * @tparam MIN pointer to a @c constexpr function returning the lower bound of the value range
- * @tparam MAX pointer to a @c constexpr function returning the upper bound of the value range
+ * @return input parameter value cut of at the boundaries @c
+ * bound_parameter<U<MIN<MAX>::min and
+ * @c bound_parameter<U,MIN,MAX>::max.
*/
- template<typename T,T(*MIN)(),T(*MAX)()>
- struct bound_parameter
+ template <typename U>
+ static U
+ getValue(const U& input)
{
- static constexpr bool may_modify_value {true}; ///< parameter values may need adjustment
- static constexpr T min {MIN()}; ///< lower bound of range
- static constexpr T max {MAX()}; ///< upper bound of range
+ return (input > max) ? max : ((input < min) ? min : input);
+ }
- /**
- * @brief retrieve value for constrained parameter value ranges
- *
- * @tparam U type of the input parameter
- * @param input input parameter value
- *
- * @return input parameter value cut of at the boundaries @c bound_parameter<U<MIN<MAX>::min and
- * @c bound_parameter<U,MIN,MAX>::max.
- */
- template<typename U>
- static U getValue(const U& input)
- {
- return (input > max) ? max : ((input < min) ? min : input);
- }
+ template <typename U>
+ static U
+ getDifference(const U& first, const U& second)
+ {
+ return getValue(first) - getValue(second);
+ }
+};
- template<typename U>
- static U getDifference(const U& first,const U& second)
- {
- return getValue(first) - getValue(second);
- }
- };
+/**
+ * @brief type for parameter with cyclic value range
+ *
+ * This parameter type is useful to e.g. describe angles.
+ *
+ * @tparam T type for boundary value (usually @c double)
+ * @tparam MIN pointer to a @c constexpr function returning the lower bound of
+ * the value range
+ * @tparam MAX pointer to a @c constexpr function returning the upper bound of
+ * the value range
+ */
+template <typename T, T (*MIN)(), T (*MAX)()>
+struct cyclic_parameter
+{
+ static constexpr bool may_modify_value{
+ true}; ///< parameter values may need adjustment
+ static constexpr T min{MIN()}; ///< lower bound of range
+ static constexpr T max{MAX()}; ///< upper bound of range
/**
- * @brief type for parameter with cyclic value range
+ * @brief retrieve value for constrained cyclic parameter value ranges
*
- * This parameter type is useful to e.g. describe angles.
+ * @tparam U type of the input parameter
+ * @param input input parameter value
*
- * @tparam T type for boundary value (usually @c double)
- * @tparam MIN pointer to a @c constexpr function returning the lower bound of the value range
- * @tparam MAX pointer to a @c constexpr function returning the upper bound of the value range
+ * @return parameter value in the range [@c bound_parameter<U,MIN,MAX>::min,
+ * @c bound_parameter<U,MIN,MAX>::max] taking into account the cycle
+ * of this
+ * parameter type.
*/
- template<typename T,T(*MIN)(),T(*MAX)()>
- struct cyclic_parameter
+ template <typename U>
+ static U
+ getValue(const U& input)
{
- static constexpr bool may_modify_value {true}; ///< parameter values may need adjustment
- static constexpr T min {MIN()}; ///< lower bound of range
- static constexpr T max {MAX()}; ///< upper bound of range
-
- /**
- * @brief retrieve value for constrained cyclic parameter value ranges
- *
- * @tparam U type of the input parameter
- * @param input input parameter value
- *
- * @return parameter value in the range [@c bound_parameter<U,MIN,MAX>::min,
- * @c bound_parameter<U,MIN,MAX>::max] taking into account the cycle of this
- * parameter type.
- */
- template<typename U>
- static U getValue(const U& input)
- {
- if (min <= input && input < max)
- return input;
- else
- return input - (max - min) * std::floor((input - min)/(max - min));
- }
+ if (min <= input && input < max)
+ return input;
+ else
+ return input - (max - min) * std::floor((input - min) / (max - min));
+ }
- template<typename U>
- static U getDifference(const U& first,const U& second)
- {
- static constexpr U half_period = (max - min)/2;
- U tmp = getValue(first) - getValue(second);
- return (tmp < -half_period ? tmp + 2 * half_period : (tmp > half_period ? tmp - 2 * half_period : tmp ));
- }
+ template <typename U>
+ static U
+ getDifference(const U& first, const U& second)
+ {
+ static constexpr U half_period = (max - min) / 2;
+ U tmp = getValue(first) - getValue(second);
+ return (tmp < -half_period
+ ? tmp + 2 * half_period
+ : (tmp > half_period ? tmp - 2 * half_period : tmp));
+ }
};
- /**
- * @brief parameter traits class
- *
- * The user needs to provide a specialization of this class for his parameter definitions.
- * The specialization must include a @c typedef with the name @c parameter_type. This type
- * must fulfill the following requirements:
- * * `parameter_type::getValue` must be a valid expression excepting one parameter value
- * as input and returning a valid parameter value (possibly mapped onto some restricted/
- * cyclic value range).
- * * A static boolean constant with the name `may_modify_value` must exist which indicates
- * whether the `getValue` function may actually return a value different from the output.
- *
- * @tparam ParameterPolicy struct or class containing the parameter definitions
- * @tparam parID identifier for the parameter
- */
-// template<typename ParameterPolicy,typename ParameterPolicy::par_id_type parID>
+/**
+ * @brief parameter traits class
+ *
+ * The user needs to provide a specialization of this class for his parameter
+ * definitions.
+ * The specialization must include a @c typedef with the name @c parameter_type.
+ * This type
+ * must fulfill the following requirements:
+ * * `parameter_type::getValue` must be a valid expression excepting one
+ * parameter value
+ * as input and returning a valid parameter value (possibly mapped onto some
+ * restricted/
+ * cyclic value range).
+ * * A static boolean constant with the name `may_modify_value` must exist
+ * which indicates
+ * whether the `getValue` function may actually return a value different
+ * from the output.
+ *
+ * @tparam ParameterPolicy struct or class containing the parameter definitions
+ * @tparam parID identifier for the parameter
+ */
+// template<typename ParameterPolicy,typename ParameterPolicy::par_id_type
+// parID>
// struct parameter_traits;
} // end of namespace Acts
-#endif // ACTS_PARAMETERTYPES
+#endif // ACTS_PARAMETERTYPES
diff --git a/Core/include/ACTS/Utilities/detail/DefaultMsgMacros.hpp b/Core/include/ACTS/Utilities/detail/DefaultMsgMacros.hpp
index afd9e2206..635c0729a 100644
--- a/Core/include/ACTS/Utilities/detail/DefaultMsgMacros.hpp
+++ b/Core/include/ACTS/Utilities/detail/DefaultMsgMacros.hpp
@@ -12,14 +12,13 @@
// STL include(s)
#include <iostream>
-namespace Acts
-{
-#define MSG_VERBOSE(x) // std::cout << "VERBOSE " << x << std::endl;
-#define MSG_DEBUG(x) // std::cout << "DEBUG " << x << std::endl;
-#define MSG_INFO(x) std::cout << "INFO " << x << std::endl;
-#define MSG_ERROR(x) std::cout << "ERROR " << x << std::endl;
+namespace Acts {
+#define MSG_VERBOSE(x) // std::cout << "VERBOSE " << x << std::endl;
+#define MSG_DEBUG(x) // std::cout << "DEBUG " << x << std::endl;
+#define MSG_INFO(x) std::cout << "INFO " << x << std::endl;
+#define MSG_ERROR(x) std::cout << "ERROR " << x << std::endl;
#define MSG_WARNING(x) std::cout << "WARNING " << x << std::endl;
-#define MSG_FATAL(x) std::cout << "FATAL " << x << std::endl;
+#define MSG_FATAL(x) std::cout << "FATAL " << x << std::endl;
} // end of namespace Acts
-#endif // ACTS_DEFAULT_MSG_MACROS_H
+#endif // ACTS_DEFAULT_MSG_MACROS_H
diff --git a/Core/include/ACTS/Utilities/detail/DefaultParameterDefinitions.hpp b/Core/include/ACTS/Utilities/detail/DefaultParameterDefinitions.hpp
index 1b475857a..cf27d4a20 100644
--- a/Core/include/ACTS/Utilities/detail/DefaultParameterDefinitions.hpp
+++ b/Core/include/ACTS/Utilities/detail/DefaultParameterDefinitions.hpp
@@ -15,68 +15,83 @@
// ACTS includes
#include "ACTS/Utilities/ParameterTypes.hpp"
-namespace Acts
-{
- enum ParDef : unsigned int
- {
- eLOC_1 = 0, ///< first coordinate in local surface frame
- eLOC_2 = 1, ///< second coordinate in local surface frame
- eLOC_R = eLOC_1,
- eLOC_PHI = eLOC_2,
- eLOC_RPHI = eLOC_1,
- eLOC_Z = eLOC_2,
- eLOC_X = eLOC_1,
- eLOC_Y = eLOC_2,
- eLOC_D0 = eLOC_1,
- eLOC_Z0 = eLOC_2,
- ePHI = 2, ///< phi direction of momentum in global frame
- eTHETA = 3, ///< theta direction of momentum in global frame
- eQOP = 4, ///< charge/momentum for charged tracks, for neutral tracks it is 1/momentum
- NGlobalPars
- };
+namespace Acts {
+enum ParDef : unsigned int {
+ eLOC_1 = 0, ///< first coordinate in local surface frame
+ eLOC_2 = 1, ///< second coordinate in local surface frame
+ eLOC_R = eLOC_1,
+ eLOC_PHI = eLOC_2,
+ eLOC_RPHI = eLOC_1,
+ eLOC_Z = eLOC_2,
+ eLOC_X = eLOC_1,
+ eLOC_Y = eLOC_2,
+ eLOC_D0 = eLOC_1,
+ eLOC_Z0 = eLOC_2,
+ ePHI = 2, ///< phi direction of momentum in global frame
+ eTHETA = 3, ///< theta direction of momentum in global frame
+ eQOP = 4, ///< charge/momentum for charged tracks, for neutral tracks it is
+ ///1/momentum
+ NGlobalPars
+};
- typedef ParDef ParID_t;
- typedef double ParValue_t;
+typedef ParDef ParID_t;
+typedef double ParValue_t;
- template<ParID_t>
- struct par_type;
+template <ParID_t>
+struct par_type;
- template<ParID_t par>
- using par_type_t = typename par_type<par>::type;
+template <ParID_t par>
+using par_type_t = typename par_type<par>::type;
- template<>
- struct par_type<ParDef::eLOC_1>
- {
- typedef local_parameter type;
- };
+template <>
+struct par_type<ParDef::eLOC_1>
+{
+ typedef local_parameter type;
+};
- template<>
- struct par_type<ParDef::eLOC_2>
- {
- typedef local_parameter type;
- };
+template <>
+struct par_type<ParDef::eLOC_2>
+{
+ typedef local_parameter type;
+};
- template<>
- struct par_type<ParDef::ePHI>
+template <>
+struct par_type<ParDef::ePHI>
+{
+ static constexpr double
+ pMin()
{
- static constexpr double pMin(){return -M_PI;}
- static constexpr double pMax(){return M_PI;}
- typedef cyclic_parameter<double,pMin,pMax> type;
- };
-
- template<>
- struct par_type<ParDef::eTHETA>
+ return -M_PI;
+ }
+ static constexpr double
+ pMax()
{
- static constexpr double pMin(){return 0;}
- static constexpr double pMax(){return M_PI;}
- typedef bound_parameter<double,pMin,pMax> type;
- };
+ return M_PI;
+ }
+ typedef cyclic_parameter<double, pMin, pMax> type;
+};
- template<>
- struct par_type<ParDef::eQOP>
+template <>
+struct par_type<ParDef::eTHETA>
+{
+ static constexpr double
+ pMin()
{
- typedef unbound_parameter type;
- };
+ return 0;
+ }
+ static constexpr double
+ pMax()
+ {
+ return M_PI;
+ }
+ typedef bound_parameter<double, pMin, pMax> type;
+};
+
+template <>
+struct par_type<ParDef::eQOP>
+{
+ typedef unbound_parameter type;
+};
} // end of namespace Acts
-#endif // ACTS_DEFAULTPARAMETERDEFINITIONS_H
+#endif // ACTS_DEFAULTPARAMETERDEFINITIONS_H
diff --git a/Core/include/ACTS/Utilities/detail/MatrixBasePlugin.hpp b/Core/include/ACTS/Utilities/detail/MatrixBasePlugin.hpp
index 9b9fe05fe..8cea1358f 100644
--- a/Core/include/ACTS/Utilities/detail/MatrixBasePlugin.hpp
+++ b/Core/include/ACTS/Utilities/detail/MatrixBasePlugin.hpp
@@ -15,111 +15,139 @@
//#include <cmath>
-/** This is a plugin that makes Eigen look like CLHEP
+/** This is a plugin that makes Eigen look like CLHEP
& defines some convenience methods */
-
- // ------- Methods for 3D vector type objects ---------------------- //
-
- /** unit method - forward normalized() */
- inline const PlainObject unit() const {
- return (*this).normalized();
- }
-
- /** mag method - forward to norm() */
- inline Scalar mag() const {
- return (*this).norm();
- }
-
- /** mag2 method - forward to norm() */
- inline Scalar mag2() const {
- return (*this).squaredNorm();
- }
-
- /** perp method - perpenticular length */
- inline Scalar perp() const {
- if (this->rows() < 2) return 0.;
- return std::sqrt( (*this)[0]*(*this)[0]+(*this)[1]*(*this)[1] );
- }
-
- /** perp2 method - perpendicular length squared */
- inline Scalar perp2() const {
- if (this->rows() < 2) return 0.;
- return ( (*this)[0]*(*this)[0]+(*this)[1]*(*this)[1] );
- }
-
- inline Scalar perp2(const MatrixBase<Derived>& vec){
- if (this->rows() < 2) return 0.;
- Scalar tot = vec.mag2();
- if(tot>0){
- Scalar s = this->dot(vec);
- return this->mag2()-s*s/tot;
- }
- return this->mag2();
- }
- inline Scalar perp(const MatrixBase<Derived>& vec){
- return std::sqrt(this->perp2(vec));
- }
-
- /** phi method */
- inline Scalar phi() const {
- if (this->rows() < 2) return 0.;
- return std::atan2((*this)[1],(*this)[0]);
- }
-
- /** theta method */
- inline Scalar theta() const {
- if (this->rows() < 3) return 0.;
- return std::atan2(std::sqrt((*this)[0]*(*this)[0]+(*this)[1]*(*this)[1]),(*this)[2]);
- }
-
- /** pseudorapidity method */
- inline Scalar eta() const {
- return -std::log(std::tan(this->theta()*.5)); //TODO: slow
- }
-
- inline Scalar deltaR(const MatrixBase<Derived>& vec){
- if (this->rows() < 2) return 0.;
- double a = this->eta() - vec.eta();
- double b = this->deltaPhi(vec);
- return std::sqrt ( a*a + b*b );
- }
-
- inline Scalar deltaPhi(const MatrixBase<Derived>& vec){
- if (this->rows() < 2) return 0.;
- double dphi = vec.phi() - this->phi();
- if ( dphi > M_PI ) {
- dphi -= M_PI*2;
- } else if ( dphi <= -M_PI ) {
- dphi += M_PI*2;
- }
- return dphi;
- }
-
- // ------- Methods for symmetric matrix objects ---------------------- //
-
- /** method to fill symmetrically elments */
- void fillSymmetric(size_t i, size_t j, Scalar value) {
- (*this)(i,j) = value;
- (*this)(j,i) = value;
- }
-
-
- // /** similarity method : yields ms = m*s*m^T */
- template<typename OtherDerived>
- inline Matrix<Scalar, OtherDerived::RowsAtCompileTime, OtherDerived::RowsAtCompileTime>
- similarity(const MatrixBase<OtherDerived>& m) const
- {
- return m * ( this->derived() * m.transpose() );
- }
-
- /** similarityT method : yields ms = m^T*s*m */
- template<typename OtherDerived>
- inline Matrix<Scalar, OtherDerived::RowsAtCompileTime, OtherDerived::RowsAtCompileTime>
- similarityT(const MatrixBase<OtherDerived>& m) const
- {
- return m.transpose() * ( this->derived() * m );
- }
-
+// ------- Methods for 3D vector type objects ---------------------- //
+
+/** unit method - forward normalized() */
+inline const PlainObject
+unit() const
+{
+ return (*this).normalized();
+}
+
+/** mag method - forward to norm() */
+inline Scalar
+mag() const
+{
+ return (*this).norm();
+}
+
+/** mag2 method - forward to norm() */
+inline Scalar
+mag2() const
+{
+ return (*this).squaredNorm();
+}
+
+/** perp method - perpenticular length */
+inline Scalar
+perp() const
+{
+ if (this->rows() < 2) return 0.;
+ return std::sqrt((*this)[0] * (*this)[0] + (*this)[1] * (*this)[1]);
+}
+
+/** perp2 method - perpendicular length squared */
+inline Scalar
+perp2() const
+{
+ if (this->rows() < 2) return 0.;
+ return ((*this)[0] * (*this)[0] + (*this)[1] * (*this)[1]);
+}
+
+inline Scalar
+perp2(const MatrixBase<Derived>& vec)
+{
+ if (this->rows() < 2) return 0.;
+ Scalar tot = vec.mag2();
+ if (tot > 0) {
+ Scalar s = this->dot(vec);
+ return this->mag2() - s * s / tot;
+ }
+ return this->mag2();
+}
+inline Scalar
+perp(const MatrixBase<Derived>& vec)
+{
+ return std::sqrt(this->perp2(vec));
+}
+
+/** phi method */
+inline Scalar
+phi() const
+{
+ if (this->rows() < 2) return 0.;
+ return std::atan2((*this)[1], (*this)[0]);
+}
+
+/** theta method */
+inline Scalar
+theta() const
+{
+ if (this->rows() < 3) return 0.;
+ return std::atan2(
+ std::sqrt((*this)[0] * (*this)[0] + (*this)[1] * (*this)[1]), (*this)[2]);
+}
+
+/** pseudorapidity method */
+inline Scalar
+eta() const
+{
+ return -std::log(std::tan(this->theta() * .5)); // TODO: slow
+}
+
+inline Scalar
+deltaR(const MatrixBase<Derived>& vec)
+{
+ if (this->rows() < 2) return 0.;
+ double a = this->eta() - vec.eta();
+ double b = this->deltaPhi(vec);
+ return std::sqrt(a * a + b * b);
+}
+
+inline Scalar
+deltaPhi(const MatrixBase<Derived>& vec)
+{
+ if (this->rows() < 2) return 0.;
+ double dphi = vec.phi() - this->phi();
+ if (dphi > M_PI) {
+ dphi -= M_PI * 2;
+ } else if (dphi <= -M_PI) {
+ dphi += M_PI * 2;
+ }
+ return dphi;
+}
+
+// ------- Methods for symmetric matrix objects ---------------------- //
+
+/** method to fill symmetrically elments */
+void
+fillSymmetric(size_t i, size_t j, Scalar value)
+{
+ (*this)(i, j) = value;
+ (*this)(j, i) = value;
+}
+
+// /** similarity method : yields ms = m*s*m^T */
+template <typename OtherDerived>
+inline Matrix<Scalar,
+ OtherDerived::RowsAtCompileTime,
+ OtherDerived::RowsAtCompileTime>
+similarity(const MatrixBase<OtherDerived>& m) const
+{
+ return m * (this->derived() * m.transpose());
+}
+
+/** similarityT method : yields ms = m^T*s*m */
+template <typename OtherDerived>
+inline Matrix<Scalar,
+ OtherDerived::RowsAtCompileTime,
+ OtherDerived::RowsAtCompileTime>
+similarityT(const MatrixBase<OtherDerived>& m) const
+{
+ return m.transpose() * (this->derived() * m);
+}
#endif
diff --git a/Core/include/ACTS/Utilities/detail/MatrixPlugin.hpp b/Core/include/ACTS/Utilities/detail/MatrixPlugin.hpp
index cf2be477b..0de7ebeda 100644
--- a/Core/include/ACTS/Utilities/detail/MatrixPlugin.hpp
+++ b/Core/include/ACTS/Utilities/detail/MatrixPlugin.hpp
@@ -11,228 +11,261 @@
#include <cmath>
- //////////////////////////////////////////////////////////////////////
- // Inverse calculation for symmetric matrix (5x5) with Gauss-Jordan
- //
- // Input parameters : V(0/24) - only the elements of the lower
- // triangle of the matrix are accessed
- // 0
- // 1 6
- // 2 7 12
- // 3 8 13 18
- // 4 9 14 19 24
- //
- // Output parameters : Vn(0/24) symmetric ////////////////////////////
-
-
- bool inverseSym5(Matrix<Scalar, 5,5>& out) const {
-
- if(this == &out || this->cols() != 5 || this->rows() != 5){
- return false;
- }
- const double * a = this->data();
-
-
- double* b = out.data();
- if (a[ 0] == 0. ) {
- return false;
- }
- double x1 = 1./a[ 0],
- x2 =-a[ 1]*x1,
- x3 =-a[ 2]*x1,
- x4 =-a[ 3]*x1,
- x5 =-a[ 4]*x1;
- if ((b[ 0] = a[ 6]+a[ 1]*x2)==0.){
- return false;
- }
- b[ 1] = a[ 7]+a[ 2]*x2;
- b[ 6] = a[12]+a[ 2]*x3;
- b[ 2] = a[ 8]+a[ 3]*x2;
- b[ 7] = a[13]+a[ 3]*x3;
- b[12] = a[18]+a[ 3]*x4;
- b[ 3] = a[ 9]+a[ 4]*x2;
- b[ 8] = a[14]+a[ 4]*x3;
- b[13] = a[19]+a[ 4]*x4;
- b[18] = a[24]+a[ 4]*x5;
- double y1 = 1./b[ 0],
- y2 =-b[ 1]*y1,
- y3 =-b[ 2]*y1,
- y4 =-b[ 3]*y1,
- y5 = x2 *y1;
- if ((b[ 0] = b[ 6]+b[ 1]*y2)==0.) {
- return false;
- }
- b[ 1] = b[ 7]+b[ 2]*y2;
- b[ 6] = b[12]+b[ 2]*y3;
- b[ 2] = b[ 8]+b[ 3]*y2;
- b[ 7] = b[13]+b[ 3]*y3;
- b[12] = b[18]+b[ 3]*y4;
- b[ 3] = x3 +x2 *y2;
- b[ 8] = x4 +x2 *y3;
- b[13] = x5 +x2 *y4;
- b[18] = x1 +x2 *y5;
- x2 =-b[ 1]*(x1 = 1./b[ 0]);
- x3 =-b[ 2]* x1;
- x4 = b[ 3]* x1;
- x5 = y2 * x1;
- if ((b[ 0] = b[ 6]+b[ 1]*x2)==0.) {
- return false;
- }
- b[ 1] = b[ 7]+b[ 2]*x2;
- b[ 6] = b[12]+b[ 2]*x3;
- b[ 2] = b[ 8]+b[ 3]*x2;
- b[ 7] = b[13]+b[ 3]*x3;
- b[12] = b[18]+b[ 3]*x4;
- b[ 3] = y3 +y2 *x2;
- b[ 8] = y4 +y2 *x3;
- b[13] = y5 +y2 *x4;
- b[18] = y1 +y2 *x5;
- y2 =-b[ 1]*(y1 = 1./b[ 0]);
- y3 = b[ 2]* y1;
- y4 = b[ 3]* y1;
- y5 = x2 * y1;
- if ((b[ 0] = b[ 6]+b[ 1]*y2)==0.) {
- return false;
- }
- b[ 1] = b[ 7]+b[ 2]*y2;
- b[ 6] = b[12]+b[ 2]*y3;
- b[ 2] = b[ 8]+b[ 3]*y2;
- b[ 7] = b[13]+b[ 3]*y3;
- b[12] = b[18]+b[ 3]*y4;
- b[ 3] = x3 +x2 *y2;
- b[ 8] = x4 +x2 *y3;
- b[13] = x5 +x2 *y4;
- b[18] = x1 +x2 *y5;
- b[ 4] = b[ 1]*(b[24] = 1./b[ 0]);
- b[ 9] = b[ 2]* b[24];
- b[14] = b[ 3]* b[24];
- b[19] = y2 * b[24];
- b[ 0] = b[ 6]+b[ 1]*b[ 4];
- b[ 1] = b[ 7]+b[ 2]*b[ 4];
- b[ 6] = b[12]+b[ 2]*b[ 9];
- b[ 2] = b[ 8]+b[ 3]*b[ 4];
- b[ 7] = b[13]+b[ 3]*b[ 9];
- b[12] = b[18]+b[ 3]*b[14];
- b[ 3] = y3 +y2 *b[ 4];
- b[ 8] = y4 +y2 *b[ 9];
- b[13] = y5 +y2 *b[14];
- b[18] = y1 +y2 *b[19];
-
- b[ 5] = b[ 1];
- b[10] = b[ 2];
- b[15] = b[ 3];
- b[20] = b[ 4];
-
- b[11] = b[ 7];
- b[16] = b[ 8];
- b[21] = b[ 9];
-
- b[17] = b[13];
- b[22] = b[14];
-
- b[23] = b[19];
-
- return true;
-
- }
-
- ////////////////////////////////////////////////////////////////////////////////////////////
- // Similarity calculation for symmetric matrix (5x5)
- //
- // Input parameters : V(0/24) - only the elements of the lower
- // triangle of the matrix are accessed
- // 0
- // 1 6
- // 2 7 12
- // 3 8 13 18
- // 4 9 14 19 24
- // Jac(0/24) -jacobiam of transformation
- // 0 5 10 15 20
- // 1 6 11 16 21
- // 2 7 12 17 22
- // 3 8 13 18 23
- // 4 9 14 19 24
- //
- // Output parameters : Vn(0/24) = Jac*Vn*Jact symmetric /////////
-
- Matrix<Scalar,RowsAtCompileTime,ColsAtCompileTime> similaritySym5(Matrix<Scalar,RowsAtCompileTime,ColsAtCompileTime>& JacMat) const {
-
-
- if(this->rows() != 5 || this->cols() != 5 || JacMat.rows() != 5 || JacMat.cols() !=5){
- return (*this).similarity(JacMat);
- }
-
- const double * V = this->data();
- const double * Jac = JacMat.data();
- double * Vn;
- Matrix<Scalar, 5, 5> out;
- Vn = out.data();
-
- double a11 = (Jac[ 0]*V[ 0]+Jac[ 5]*V[ 1]+Jac[10]*V[ 2])+(Jac[15]*V[ 3]+Jac[20]*V[ 4]);
- double a12 = (Jac[ 0]*V[ 1]+Jac[ 5]*V[ 6]+Jac[10]*V[ 7])+(Jac[15]*V[ 8]+Jac[20]*V[ 9]);
- double a13 = (Jac[ 0]*V[ 2]+Jac[ 5]*V[ 7]+Jac[10]*V[12])+(Jac[15]*V[13]+Jac[20]*V[14]);
- double a14 = (Jac[ 0]*V[ 3]+Jac[ 5]*V[ 8]+Jac[10]*V[13])+(Jac[15]*V[18]+Jac[20]*V[19]);
- double a15 = (Jac[ 0]*V[ 4]+Jac[ 5]*V[ 9]+Jac[10]*V[14])+(Jac[15]*V[19]+Jac[20]*V[24]);
-
- Vn[ 0] = (a11*Jac[ 0]+a12*Jac[ 5]+a13*Jac[10])+(a14*Jac[15]+a15*Jac[20]);
-
- double a21 = (Jac[ 1]*V[ 0]+Jac[ 6]*V[ 1]+Jac[11]*V[ 2])+(Jac[16]*V[ 3]+Jac[21]*V[ 4]);
- double a22 = (Jac[ 1]*V[ 1]+Jac[ 6]*V[ 6]+Jac[11]*V[ 7])+(Jac[16]*V[ 8]+Jac[21]*V[ 9]);
- double a23 = (Jac[ 1]*V[ 2]+Jac[ 6]*V[ 7]+Jac[11]*V[12])+(Jac[16]*V[13]+Jac[21]*V[14]);
- double a24 = (Jac[ 1]*V[ 3]+Jac[ 6]*V[ 8]+Jac[11]*V[13])+(Jac[16]*V[18]+Jac[21]*V[19]);
- double a25 = (Jac[ 1]*V[ 4]+Jac[ 6]*V[ 9]+Jac[11]*V[14])+(Jac[16]*V[19]+Jac[21]*V[24]);
-
- Vn[ 1] = (a21*Jac[ 0]+a22*Jac[ 5]+a23*Jac[10])+(a24*Jac[15]+a25*Jac[20]);
- Vn[ 6] = (a21*Jac[ 1]+a22*Jac[ 6]+a23*Jac[11])+(a24*Jac[16]+a25*Jac[21]);
-
- double a31 = (Jac[ 2]*V[ 0]+Jac[ 7]*V[ 1]+Jac[12]*V[ 2])+(Jac[17]*V[ 3]+Jac[22]*V[ 4]);
- double a32 = (Jac[ 2]*V[ 1]+Jac[ 7]*V[ 6]+Jac[12]*V[ 7])+(Jac[17]*V[ 8]+Jac[22]*V[ 9]);
- double a33 = (Jac[ 2]*V[ 2]+Jac[ 7]*V[ 7]+Jac[12]*V[12])+(Jac[17]*V[13]+Jac[22]*V[14]);
- double a34 = (Jac[ 2]*V[ 3]+Jac[ 7]*V[ 8]+Jac[12]*V[13])+(Jac[17]*V[18]+Jac[22]*V[19]);
- double a35 = (Jac[ 2]*V[ 4]+Jac[ 7]*V[ 9]+Jac[12]*V[14])+(Jac[17]*V[19]+Jac[22]*V[24]);
-
- Vn[ 2] = (a31*Jac[ 0]+a32*Jac[ 5]+a33*Jac[10])+(a34*Jac[15]+a35*Jac[20]);
- Vn[ 7] = (a31*Jac[ 1]+a32*Jac[ 6]+a33*Jac[11])+(a34*Jac[16]+a35*Jac[21]);
- Vn[12] = (a31*Jac[ 2]+a32*Jac[ 7]+a33*Jac[12])+(a34*Jac[17]+a35*Jac[22]);
-
- double a41 = (Jac[ 3]*V[ 0]+Jac[ 8]*V[ 1]+Jac[13]*V[ 2])+(Jac[18]*V[ 3]+Jac[23]*V[ 4]);
- double a42 = (Jac[ 3]*V[ 1]+Jac[ 8]*V[ 6]+Jac[13]*V[ 7])+(Jac[18]*V[ 8]+Jac[23]*V[ 9]);
- double a43 = (Jac[ 3]*V[ 2]+Jac[ 8]*V[ 7]+Jac[13]*V[12])+(Jac[18]*V[13]+Jac[23]*V[14]);
- double a44 = (Jac[ 3]*V[ 3]+Jac[ 8]*V[ 8]+Jac[13]*V[13])+(Jac[18]*V[18]+Jac[23]*V[19]);
- double a45 = (Jac[ 3]*V[ 4]+Jac[ 8]*V[ 9]+Jac[13]*V[14])+(Jac[18]*V[19]+Jac[23]*V[24]);
-
- Vn[ 3] = (a41*Jac[ 0]+a42*Jac[ 5]+a43*Jac[10])+(a44*Jac[15]+a45*Jac[20]);
- Vn[ 8] = (a41*Jac[ 1]+a42*Jac[ 6]+a43*Jac[11])+(a44*Jac[16]+a45*Jac[21]);
- Vn[13] = (a41*Jac[ 2]+a42*Jac[ 7]+a43*Jac[12])+(a44*Jac[17]+a45*Jac[22]);
- Vn[18] = (a41*Jac[ 3]+a42*Jac[ 8]+a43*Jac[13])+(a44*Jac[18]+a45*Jac[23]);
-
- double a51 = (Jac[ 4]*V[ 0]+Jac[ 9]*V[ 1]+Jac[14]*V[ 2])+(Jac[19]*V[ 3]+Jac[24]*V[ 4]);
- double a52 = (Jac[ 4]*V[ 1]+Jac[ 9]*V[ 6]+Jac[14]*V[ 7])+(Jac[19]*V[ 8]+Jac[24]*V[ 9]);
- double a53 = (Jac[ 4]*V[ 2]+Jac[ 9]*V[ 7]+Jac[14]*V[12])+(Jac[19]*V[13]+Jac[24]*V[14]);
- double a54 = (Jac[ 4]*V[ 3]+Jac[ 9]*V[ 8]+Jac[14]*V[13])+(Jac[19]*V[18]+Jac[24]*V[19]);
- double a55 = (Jac[ 4]*V[ 4]+Jac[ 9]*V[ 9]+Jac[14]*V[14])+(Jac[19]*V[19]+Jac[24]*V[24]);
-
- Vn[ 4] = (a51*Jac[ 0]+a52*Jac[ 5]+a53*Jac[10])+(a54*Jac[15]+a55*Jac[20]);
- Vn[ 9] = (a51*Jac[ 1]+a52*Jac[ 6]+a53*Jac[11])+(a54*Jac[16]+a55*Jac[21]);
- Vn[14] = (a51*Jac[ 2]+a52*Jac[ 7]+a53*Jac[12])+(a54*Jac[17]+a55*Jac[22]);
- Vn[19] = (a51*Jac[ 3]+a52*Jac[ 8]+a53*Jac[13])+(a54*Jac[18]+a55*Jac[23]);
- Vn[24] = (a51*Jac[ 4]+a52*Jac[ 9]+a53*Jac[14])+(a54*Jac[19]+a55*Jac[24]);
-
- Vn[ 5] = Vn[ 1];
- Vn[10] = Vn[ 2];
- Vn[15] = Vn[ 3];
- Vn[20] = Vn[ 4];
-
- Vn[11] = Vn[ 7];
- Vn[16] = Vn[ 8];
- Vn[21] = Vn[ 9];
-
- Vn[17] = Vn[13];
- Vn[22] = Vn[14];
-
- Vn[23] = Vn[19];
-
- return out;
- }
+//////////////////////////////////////////////////////////////////////
+// Inverse calculation for symmetric matrix (5x5) with Gauss-Jordan
+//
+// Input parameters : V(0/24) - only the elements of the lower
+// triangle of the matrix are accessed
+// 0
+// 1 6
+// 2 7 12
+// 3 8 13 18
+// 4 9 14 19 24
+//
+// Output parameters : Vn(0/24) symmetric ////////////////////////////
+
+bool inverseSym5(Matrix<Scalar, 5, 5>& out) const
+{
+ if (this == &out || this->cols() != 5 || this->rows() != 5) {
+ return false;
+ }
+ const double* a = this->data();
+
+ double* b = out.data();
+ if (a[0] == 0.) {
+ return false;
+ }
+ double x1 = 1. / a[0], x2 = -a[1] * x1, x3 = -a[2] * x1, x4 = -a[3] * x1,
+ x5 = -a[4] * x1;
+ if ((b[0] = a[6] + a[1] * x2) == 0.) {
+ return false;
+ }
+ b[1] = a[7] + a[2] * x2;
+ b[6] = a[12] + a[2] * x3;
+ b[2] = a[8] + a[3] * x2;
+ b[7] = a[13] + a[3] * x3;
+ b[12] = a[18] + a[3] * x4;
+ b[3] = a[9] + a[4] * x2;
+ b[8] = a[14] + a[4] * x3;
+ b[13] = a[19] + a[4] * x4;
+ b[18] = a[24] + a[4] * x5;
+ double y1 = 1. / b[0], y2 = -b[1] * y1, y3 = -b[2] * y1, y4 = -b[3] * y1,
+ y5 = x2 * y1;
+ if ((b[0] = b[6] + b[1] * y2) == 0.) {
+ return false;
+ }
+ b[1] = b[7] + b[2] * y2;
+ b[6] = b[12] + b[2] * y3;
+ b[2] = b[8] + b[3] * y2;
+ b[7] = b[13] + b[3] * y3;
+ b[12] = b[18] + b[3] * y4;
+ b[3] = x3 + x2 * y2;
+ b[8] = x4 + x2 * y3;
+ b[13] = x5 + x2 * y4;
+ b[18] = x1 + x2 * y5;
+ x2 = -b[1] * (x1 = 1. / b[0]);
+ x3 = -b[2] * x1;
+ x4 = b[3] * x1;
+ x5 = y2 * x1;
+ if ((b[0] = b[6] + b[1] * x2) == 0.) {
+ return false;
+ }
+ b[1] = b[7] + b[2] * x2;
+ b[6] = b[12] + b[2] * x3;
+ b[2] = b[8] + b[3] * x2;
+ b[7] = b[13] + b[3] * x3;
+ b[12] = b[18] + b[3] * x4;
+ b[3] = y3 + y2 * x2;
+ b[8] = y4 + y2 * x3;
+ b[13] = y5 + y2 * x4;
+ b[18] = y1 + y2 * x5;
+ y2 = -b[1] * (y1 = 1. / b[0]);
+ y3 = b[2] * y1;
+ y4 = b[3] * y1;
+ y5 = x2 * y1;
+ if ((b[0] = b[6] + b[1] * y2) == 0.) {
+ return false;
+ }
+ b[1] = b[7] + b[2] * y2;
+ b[6] = b[12] + b[2] * y3;
+ b[2] = b[8] + b[3] * y2;
+ b[7] = b[13] + b[3] * y3;
+ b[12] = b[18] + b[3] * y4;
+ b[3] = x3 + x2 * y2;
+ b[8] = x4 + x2 * y3;
+ b[13] = x5 + x2 * y4;
+ b[18] = x1 + x2 * y5;
+ b[4] = b[1] * (b[24] = 1. / b[0]);
+ b[9] = b[2] * b[24];
+ b[14] = b[3] * b[24];
+ b[19] = y2 * b[24];
+ b[0] = b[6] + b[1] * b[4];
+ b[1] = b[7] + b[2] * b[4];
+ b[6] = b[12] + b[2] * b[9];
+ b[2] = b[8] + b[3] * b[4];
+ b[7] = b[13] + b[3] * b[9];
+ b[12] = b[18] + b[3] * b[14];
+ b[3] = y3 + y2 * b[4];
+ b[8] = y4 + y2 * b[9];
+ b[13] = y5 + y2 * b[14];
+ b[18] = y1 + y2 * b[19];
+
+ b[5] = b[1];
+ b[10] = b[2];
+ b[15] = b[3];
+ b[20] = b[4];
+
+ b[11] = b[7];
+ b[16] = b[8];
+ b[21] = b[9];
+
+ b[17] = b[13];
+ b[22] = b[14];
+
+ b[23] = b[19];
+
+ return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////
+// Similarity calculation for symmetric matrix (5x5)
+//
+// Input parameters : V(0/24) - only the elements of the lower
+// triangle of the matrix are accessed
+// 0
+// 1 6
+// 2 7 12
+// 3 8 13 18
+// 4 9 14 19 24
+// Jac(0/24) -jacobiam of transformation
+// 0 5 10 15 20
+// 1 6 11 16 21
+// 2 7 12 17 22
+// 3 8 13 18 23
+// 4 9 14 19 24
+//
+// Output parameters : Vn(0/24) = Jac*Vn*Jact symmetric /////////
+
+Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime>
+similaritySym5(
+ Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime>& JacMat) const
+{
+ if (this->rows() != 5 || this->cols() != 5 || JacMat.rows() != 5
+ || JacMat.cols() != 5) {
+ return (*this).similarity(JacMat);
+ }
+
+ const double* V = this->data();
+ const double* Jac = JacMat.data();
+ double* Vn;
+ Matrix<Scalar, 5, 5> out;
+ Vn = out.data();
+
+ double a11 = (Jac[0] * V[0] + Jac[5] * V[1] + Jac[10] * V[2])
+ + (Jac[15] * V[3] + Jac[20] * V[4]);
+ double a12 = (Jac[0] * V[1] + Jac[5] * V[6] + Jac[10] * V[7])
+ + (Jac[15] * V[8] + Jac[20] * V[9]);
+ double a13 = (Jac[0] * V[2] + Jac[5] * V[7] + Jac[10] * V[12])
+ + (Jac[15] * V[13] + Jac[20] * V[14]);
+ double a14 = (Jac[0] * V[3] + Jac[5] * V[8] + Jac[10] * V[13])
+ + (Jac[15] * V[18] + Jac[20] * V[19]);
+ double a15 = (Jac[0] * V[4] + Jac[5] * V[9] + Jac[10] * V[14])
+ + (Jac[15] * V[19] + Jac[20] * V[24]);
+
+ Vn[0] = (a11 * Jac[0] + a12 * Jac[5] + a13 * Jac[10])
+ + (a14 * Jac[15] + a15 * Jac[20]);
+
+ double a21 = (Jac[1] * V[0] + Jac[6] * V[1] + Jac[11] * V[2])
+ + (Jac[16] * V[3] + Jac[21] * V[4]);
+ double a22 = (Jac[1] * V[1] + Jac[6] * V[6] + Jac[11] * V[7])
+ + (Jac[16] * V[8] + Jac[21] * V[9]);
+ double a23 = (Jac[1] * V[2] + Jac[6] * V[7] + Jac[11] * V[12])
+ + (Jac[16] * V[13] + Jac[21] * V[14]);
+ double a24 = (Jac[1] * V[3] + Jac[6] * V[8] + Jac[11] * V[13])
+ + (Jac[16] * V[18] + Jac[21] * V[19]);
+ double a25 = (Jac[1] * V[4] + Jac[6] * V[9] + Jac[11] * V[14])
+ + (Jac[16] * V[19] + Jac[21] * V[24]);
+
+ Vn[1] = (a21 * Jac[0] + a22 * Jac[5] + a23 * Jac[10])
+ + (a24 * Jac[15] + a25 * Jac[20]);
+ Vn[6] = (a21 * Jac[1] + a22 * Jac[6] + a23 * Jac[11])
+ + (a24 * Jac[16] + a25 * Jac[21]);
+
+ double a31 = (Jac[2] * V[0] + Jac[7] * V[1] + Jac[12] * V[2])
+ + (Jac[17] * V[3] + Jac[22] * V[4]);
+ double a32 = (Jac[2] * V[1] + Jac[7] * V[6] + Jac[12] * V[7])
+ + (Jac[17] * V[8] + Jac[22] * V[9]);
+ double a33 = (Jac[2] * V[2] + Jac[7] * V[7] + Jac[12] * V[12])
+ + (Jac[17] * V[13] + Jac[22] * V[14]);
+ double a34 = (Jac[2] * V[3] + Jac[7] * V[8] + Jac[12] * V[13])
+ + (Jac[17] * V[18] + Jac[22] * V[19]);
+ double a35 = (Jac[2] * V[4] + Jac[7] * V[9] + Jac[12] * V[14])
+ + (Jac[17] * V[19] + Jac[22] * V[24]);
+
+ Vn[2] = (a31 * Jac[0] + a32 * Jac[5] + a33 * Jac[10])
+ + (a34 * Jac[15] + a35 * Jac[20]);
+ Vn[7] = (a31 * Jac[1] + a32 * Jac[6] + a33 * Jac[11])
+ + (a34 * Jac[16] + a35 * Jac[21]);
+ Vn[12] = (a31 * Jac[2] + a32 * Jac[7] + a33 * Jac[12])
+ + (a34 * Jac[17] + a35 * Jac[22]);
+
+ double a41 = (Jac[3] * V[0] + Jac[8] * V[1] + Jac[13] * V[2])
+ + (Jac[18] * V[3] + Jac[23] * V[4]);
+ double a42 = (Jac[3] * V[1] + Jac[8] * V[6] + Jac[13] * V[7])
+ + (Jac[18] * V[8] + Jac[23] * V[9]);
+ double a43 = (Jac[3] * V[2] + Jac[8] * V[7] + Jac[13] * V[12])
+ + (Jac[18] * V[13] + Jac[23] * V[14]);
+ double a44 = (Jac[3] * V[3] + Jac[8] * V[8] + Jac[13] * V[13])
+ + (Jac[18] * V[18] + Jac[23] * V[19]);
+ double a45 = (Jac[3] * V[4] + Jac[8] * V[9] + Jac[13] * V[14])
+ + (Jac[18] * V[19] + Jac[23] * V[24]);
+
+ Vn[3] = (a41 * Jac[0] + a42 * Jac[5] + a43 * Jac[10])
+ + (a44 * Jac[15] + a45 * Jac[20]);
+ Vn[8] = (a41 * Jac[1] + a42 * Jac[6] + a43 * Jac[11])
+ + (a44 * Jac[16] + a45 * Jac[21]);
+ Vn[13] = (a41 * Jac[2] + a42 * Jac[7] + a43 * Jac[12])
+ + (a44 * Jac[17] + a45 * Jac[22]);
+ Vn[18] = (a41 * Jac[3] + a42 * Jac[8] + a43 * Jac[13])
+ + (a44 * Jac[18] + a45 * Jac[23]);
+
+ double a51 = (Jac[4] * V[0] + Jac[9] * V[1] + Jac[14] * V[2])
+ + (Jac[19] * V[3] + Jac[24] * V[4]);
+ double a52 = (Jac[4] * V[1] + Jac[9] * V[6] + Jac[14] * V[7])
+ + (Jac[19] * V[8] + Jac[24] * V[9]);
+ double a53 = (Jac[4] * V[2] + Jac[9] * V[7] + Jac[14] * V[12])
+ + (Jac[19] * V[13] + Jac[24] * V[14]);
+ double a54 = (Jac[4] * V[3] + Jac[9] * V[8] + Jac[14] * V[13])
+ + (Jac[19] * V[18] + Jac[24] * V[19]);
+ double a55 = (Jac[4] * V[4] + Jac[9] * V[9] + Jac[14] * V[14])
+ + (Jac[19] * V[19] + Jac[24] * V[24]);
+
+ Vn[4] = (a51 * Jac[0] + a52 * Jac[5] + a53 * Jac[10])
+ + (a54 * Jac[15] + a55 * Jac[20]);
+ Vn[9] = (a51 * Jac[1] + a52 * Jac[6] + a53 * Jac[11])
+ + (a54 * Jac[16] + a55 * Jac[21]);
+ Vn[14] = (a51 * Jac[2] + a52 * Jac[7] + a53 * Jac[12])
+ + (a54 * Jac[17] + a55 * Jac[22]);
+ Vn[19] = (a51 * Jac[3] + a52 * Jac[8] + a53 * Jac[13])
+ + (a54 * Jac[18] + a55 * Jac[23]);
+ Vn[24] = (a51 * Jac[4] + a52 * Jac[9] + a53 * Jac[14])
+ + (a54 * Jac[19] + a55 * Jac[24]);
+
+ Vn[5] = Vn[1];
+ Vn[10] = Vn[2];
+ Vn[15] = Vn[3];
+ Vn[20] = Vn[4];
+
+ Vn[11] = Vn[7];
+ Vn[16] = Vn[8];
+ Vn[21] = Vn[9];
+
+ Vn[17] = Vn[13];
+ Vn[22] = Vn[14];
+
+ Vn[23] = Vn[19];
+
+ return out;
+}
#endif
diff --git a/Core/include/ACTS/Utilities/detail/TransformPlugin.hpp b/Core/include/ACTS/Utilities/detail/TransformPlugin.hpp
index e7d405a10..d46bcadc1 100644
--- a/Core/include/ACTS/Utilities/detail/TransformPlugin.hpp
+++ b/Core/include/ACTS/Utilities/detail/TransformPlugin.hpp
@@ -13,47 +13,53 @@
#ifndef EVENTPRIMITIVES_AMGTRANSFORMPLUGIN_H
#define EVENTPRIMITIVES_AMGTRANSFORMPLUGIN_H
+inline explicit Transform(const Vector3d& rotationMatrixCol0,
+ const Vector3d& rotationMatrixCol1,
+ const Vector3d& rotationMatrixCol2)
+{
+ check_template_params();
+ m_matrix.block(0, 0, 3, 1) = rotationMatrixCol0;
+ m_matrix.block(0, 1, 3, 1) = rotationMatrixCol1;
+ m_matrix.block(0, 2, 3, 1) = rotationMatrixCol2;
+ if (int(Mode) == Affine) makeAffine();
+}
- inline explicit Transform(const Vector3d& rotationMatrixCol0, const Vector3d& rotationMatrixCol1, const Vector3d& rotationMatrixCol2){
- check_template_params();
- m_matrix.block(0,0,3,1) = rotationMatrixCol0;
- m_matrix.block(0,1,3,1) = rotationMatrixCol1;
- m_matrix.block(0,2,3,1) = rotationMatrixCol2;
- if (int(Mode)==Affine)
- makeAffine();
- }
+inline explicit Transform(const Vector3d& translation)
+{
+ check_template_params();
+ m_matrix.block(0, 3, 3, 1) = translation;
+ m_matrix.block(0, 0, 3, 3).setIdentity();
+ if (int(Mode) == Affine) makeAffine();
+}
- inline explicit Transform(const Vector3d& translation){
- check_template_params();
- m_matrix.block(0,3,3,1) = translation;
- m_matrix.block(0,0,3,3).setIdentity();
- if (int(Mode)==Affine)
- makeAffine();
- }
+inline explicit Transform(const Matrix<double, 3, 3>& rotation,
+ const Vector3d& translation)
+{
+ check_template_params();
+ m_matrix.block(0, 0, 3, 3) = rotation;
+ m_matrix.block(0, 3, 3, 1) = translation;
+ if (int(Mode) == Affine) makeAffine();
+}
+inline explicit Transform(const Matrix<double, 3, 3>& rotation,
+ const TranslationType& translation)
+{
+ check_template_params();
+ m_matrix.block(0, 0, 3, 3) = rotation;
+ m_matrix.block(0, 3, 3, 1) = translation.vector();
+ if (int(Mode) == Affine) makeAffine();
+}
- inline explicit Transform(const Matrix<double, 3,3>& rotation, const Vector3d& translation){
- check_template_params();
- m_matrix.block(0,0,3,3) = rotation;
- m_matrix.block(0,3,3,1) = translation;
- if (int(Mode)==Affine)
- makeAffine();
- }
- inline explicit Transform(const Matrix<double, 3,3>& rotation, const TranslationType& translation){
- check_template_params();
- m_matrix.block(0,0,3,3) = rotation;
- m_matrix.block(0,3,3,1) = translation.vector();
- if (int(Mode)==Affine)
- makeAffine();
- }
-
- inline explicit Transform(const Vector3d& rotationMatrixCol0, const Vector3d& rotationMatrixCol1, const Vector3d& rotationMatrixCol2, const Vector3d& translation){
- check_template_params();
- m_matrix.block(0,0,3,1) = rotationMatrixCol0;
- m_matrix.block(0,1,3,1) = rotationMatrixCol1;
- m_matrix.block(0,2,3,1) = rotationMatrixCol2;
- m_matrix.block(0,3,3,1) = translation;
- if (int(Mode)==Affine)
- makeAffine();
- }
+inline explicit Transform(const Vector3d& rotationMatrixCol0,
+ const Vector3d& rotationMatrixCol1,
+ const Vector3d& rotationMatrixCol2,
+ const Vector3d& translation)
+{
+ check_template_params();
+ m_matrix.block(0, 0, 3, 1) = rotationMatrixCol0;
+ m_matrix.block(0, 1, 3, 1) = rotationMatrixCol1;
+ m_matrix.block(0, 2, 3, 1) = rotationMatrixCol2;
+ m_matrix.block(0, 3, 3, 1) = translation;
+ if (int(Mode) == Affine) makeAffine();
+}
#endif
diff --git a/Core/include/ACTS/Volumes/AbstractVolume.hpp b/Core/include/ACTS/Volumes/AbstractVolume.hpp
index 562262eb3..7d69d380a 100644
--- a/Core/include/ACTS/Volumes/AbstractVolume.hpp
+++ b/Core/include/ACTS/Volumes/AbstractVolume.hpp
@@ -14,71 +14,78 @@
#define ACTS_VOLUMES_ABSTRACTVOLUME_H
// Geometry module
-#include "ACTS/Volumes/Volume.hpp"
#include "ACTS/Volumes/BoundarySurface.hpp"
+#include "ACTS/Volumes/Volume.hpp"
// Core module
#include <vector>
#include "ACTS/Utilities/Definitions.hpp"
namespace Acts {
- class VolumeBounds;
- typedef std::shared_ptr<const VolumeBounds> VolumeBoundsPtr;
-
- /**
- @class AbstractVolume
-
- AbstractVolume description inside the tracking realm. This is the purely geometrical object volume.
-
- The Acts::AbstractVolume is constructed by giving a pointer to a Transform3D
- and a pointer to Acts::VolumeBounds, this implies that the ownership of the
- objects pointed to is passed as well. For memory optimisation, the AbstractVolume can also be
- constructed with shared_ptr objects.
+class VolumeBounds;
+typedef std::shared_ptr<const VolumeBounds> VolumeBoundsPtr;
- A Acts::AbstractVolume is at first a collection class of Acts::BoundarySurface,
- the vector of Acts::BoundarySurface is returned by the Acts::VolumeBounds that
- carry a decompose method.
+/**
+ @class AbstractVolume
- Boundary surfaces can be shared between AbstractVolumes to enhance automatic navigation
- between AbstractVolumes, therefor they are reference counted by a std::shared_ptr holder class.
+ AbstractVolume description inside the tracking realm. This is the purely
+ geometrical object volume.
- @image html VolumeShapes.gif
+ The Acts::AbstractVolume is constructed by giving a pointer to a Transform3D
+ and a pointer to Acts::VolumeBounds, this implies that the ownership of the
+ objects pointed to is passed as well. For memory optimisation, the
+ AbstractVolume can also be
+ constructed with shared_ptr objects.
- */
+ A Acts::AbstractVolume is at first a collection class of Acts::BoundarySurface,
+ the vector of Acts::BoundarySurface is returned by the Acts::VolumeBounds that
+ carry a decompose method.
- class AbstractVolume : public Volume {
+ Boundary surfaces can be shared between AbstractVolumes to enhance automatic
+ navigation
+ between AbstractVolumes, therefor they are reference counted by a
+ std::shared_ptr holder class.
- public:
- /**Constructor with Transform3D*, VolumeBounds*, passing ownership */
- AbstractVolume(Transform3D* htrans, const VolumeBounds* volbounds);
+ @image html VolumeShapes.gif
- /**Constructor with shared Transform3D*, VolumeBounds* */
- AbstractVolume(std::shared_ptr<Transform3D> htrans, VolumeBoundsPtr volbounds);
+ */
- /**Copy constructor - deleted */
- AbstractVolume(const AbstractVolume& vol) = delete;
+class AbstractVolume : public Volume
+{
+public:
+ /**Constructor with Transform3D*, VolumeBounds*, passing ownership */
+ AbstractVolume(Transform3D* htrans, const VolumeBounds* volbounds);
- /**Virtual Destructor*/
- virtual ~AbstractVolume();
+ /**Constructor with shared Transform3D*, VolumeBounds* */
+ AbstractVolume(std::shared_ptr<Transform3D> htrans,
+ VolumeBoundsPtr volbounds);
- /**Assignment operator*/
- AbstractVolume& operator=(const AbstractVolume& vol);
+ /**Copy constructor - deleted */
+ AbstractVolume(const AbstractVolume& vol) = delete;
- /** Method to return the BoundarySurfaces */
- const std::vector< std::shared_ptr<const BoundarySurface<AbstractVolume> > >& boundarySurfaces() const;
+ /**Virtual Destructor*/
+ virtual ~AbstractVolume();
- private:
- /**Default Constructor - needed for pool and inherited classes */
- AbstractVolume();
+ /**Assignment operator*/
+ AbstractVolume&
+ operator=(const AbstractVolume& vol);
- /**Private method to create BoundarySurfaces */
- void createBoundarySurfaces();
+ /** Method to return the BoundarySurfaces */
+ const std::vector<std::shared_ptr<const BoundarySurface<AbstractVolume>>>&
+ boundarySurfaces() const;
- std::vector< std::shared_ptr<const BoundarySurface<AbstractVolume> > >* m_boundarySurfaces; //!< boundary Surfaces
+private:
+ /**Default Constructor - needed for pool and inherited classes */
+ AbstractVolume();
- };
+ /**Private method to create BoundarySurfaces */
+ void
+ createBoundarySurfaces();
-} // end of namespace
+ std::vector<std::shared_ptr<const BoundarySurface<AbstractVolume>>>*
+ m_boundarySurfaces; //!< boundary Surfaces
+};
-#endif // ACTS_VOLUMES_ABSTRACTVOLUME_H
+} // end of namespace
+#endif // ACTS_VOLUMES_ABSTRACTVOLUME_H
diff --git a/Core/include/ACTS/Volumes/BevelledCylinderVolumeBounds.hpp b/Core/include/ACTS/Volumes/BevelledCylinderVolumeBounds.hpp
index af7752bbe..66d386da1 100644
--- a/Core/include/ACTS/Volumes/BevelledCylinderVolumeBounds.hpp
+++ b/Core/include/ACTS/Volumes/BevelledCylinderVolumeBounds.hpp
@@ -13,233 +13,361 @@
#ifndef ACTS_VOLUMES_BEVELLEDCYLINDERVOLUMESBOUNDS_H
#define ACTS_VOLUMES_BEVELLEDCYLINDERVOLUMESBOUNDS_H
-#include "ACTS/Volumes/VolumeBounds.hpp"
#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Volumes/VolumeBounds.hpp"
namespace Acts {
- /** @struct BevelledBoundaryIntersector
- - identical code to ExtrapolationUtils/RealLinearEquation (but forbidden dependency!)
- */
- struct BevelledBoundaryIntersector {
-
- double yOfX; //!< the result of x
- double segLength; //!< length of the line segment
-
- BevelledBoundaryIntersector(double px, double py, double k, double xprime) {
- double deltax = xprime-px;
- yOfX = py + k*(deltax);
- double deltay = yOfX-py;
- segLength = sqrt(deltax*deltax+deltay*deltay);
- }
-
- };
-
- class Surface;
- class EllipseBounds;
- class TrapezoidBounds;
- class RectangleBounds;
- class CylinderBounds;
- class RadialBounds;
-
- /**
- @class BevelledCylinderVolumeBounds
-
- Bounds for a cylindrical Volume, the decomposeToSurfaces method creates a
- vector of up to 6 surfaces:
-
- case A) 3 Surfaces (full cylindrical tube):
- BoundarySurfaceFace [index]:
- - negativeFaceXY [0] : Acts::DiscSurface with \f$ r_{inner}=0 \f$,
- parallel to \f$ xy \f$ plane at negative \f$ z \f$
- - positiveFaceXY [1] : Acts::DiscSurface with \f$ r_{inner}=0 \f$,
- parallel to \f$ xy \f$ plane at positive \f$ z \f$
- - cylinderCover [2] : Acts::CylinderSurface confining the Acts::Volume
-
- case B) 4 Surfaces (tube with inner and outer radius):
- BoundarySurfaceFace [index]:
- - negativeFaceXY [0] : Acts::DiscSurface with \f$ r_{inner}>0 \f$,
- parallel to \f$ xy \f$ plane at negative \f$ z \f$
- - positiveFaceXY [1] : Acts::DiscSurface with \f$ r_{inner}>0 \f$,
- parallel to \f$ xy \f$ plane at positive \f$ z \f$
- - tubeOuterCover [2] : Acts::CylinderSurface with \f$ r = r_{outer} \f$
- - tubeInnerCover [3] : Acts::CylinderSurface with \f$ r = r_{inner} \f$
-
- case C) 6 Surfaces (sectoral tube with inner and outer radius):
- BoundarySurfaceFace [index]:
- - negativeFaceXY [0] : Acts::DiscSurface with \f$ r_{inner}>0 \f$ and \f$ \phi < \pi \f$,
- parallel to \f$ xy \f$ plane at negative \f$ z \f$
- - positiveFaceXY [1] : Acts::DiscSurface with \f$ r_{inner}>0 \f$ and \f$ \phi < \pi \f$,
- parallel to \f$ xy \f$ plane at positive \f$ z \f$
- - tubeSectorOuterCover [2] : Acts::CylinderSurface with \f$ r = r_{outer} \f$
- - tubeSectorInnerCover [3] : Acts::CylinderSurface with \f$ r = r_{inner} \f$
- - tubeSectorNegativePhi [4] : Rectangular Acts::PlaneSurface attached to [0] and [1] at negative \f$ \phi \f$
- - tubeSectorNegativePhi [5] : Rectangular Acts::PlaneSurface attached to [0] and [1] at positive \f$ \phi \f$
-
- case D) 6 Surfaces (sectoral bevelled tube with inner and/or outer radius replaced by plane surface):
- BoundarySurfaceFace [index]:
- - negativeFaceXY [0] : Acts::DiscSurface with \f$ r_{inner}>0 \f$ and \f$ \phi < \pi \f$,
- parallel to \f$ xy \f$ plane at negative \f$ z \f$
- - positiveFaceXY [1] : Acts::DiscSurface with \f$ r_{inner}>0 \f$ and \f$ \phi < \pi \f$,
- parallel to \f$ xy \f$ plane at positive \f$ z \f$
- - tubeSectorOuterCover [2] : Acts::CylinderSurface with \f$ r = r_{outer} \f$
- OR rectangular plane surface
- - tubeSectorInnerCover [3] : Acts::CylinderSurface with \f$ r = r_{inner} \f$
- OR rectangular plane surface
- - tubeSectorNegativePhi [4] : Rectangular Acts::PlaneSurface attached to [0] and [1] at negative \f$ \phi \f$
- - tubeSectorNegativePhi [5] : Rectangular Acts::PlaneSurface attached to [0] and [1] at positive \f$ \phi \f$
-
- @image html CylinderVolumeBounds_decomp.gif
-
- */
-
- class BevelledCylinderVolumeBounds : public VolumeBounds {
-
- public:
-
- /** @enum BoundValues for readibility */
- enum BoundValues {
- bv_innerRadius = 0,
- bv_outerRadius = 1,
- bv_halfPhiSector = 2,
- bv_halfZ = 3,
- bv_thetaMinus = 4,
- bv_thetaPlus = 5,
- bv_length = 6
- };
-
- /**Default Constructor*/
- BevelledCylinderVolumeBounds();
-
- /**Constructor - cylinder segment bevelled in R */
- BevelledCylinderVolumeBounds(double rinner, double router, double halfPhiSector, double halez, int type);
-
- /**Copy Constructor */
- BevelledCylinderVolumeBounds(const BevelledCylinderVolumeBounds& cylbo);
-
- /**Destructor */
- virtual ~BevelledCylinderVolumeBounds();
-
- /**Assignment operator*/
- BevelledCylinderVolumeBounds& operator=(const BevelledCylinderVolumeBounds& cylbo);
-
- /**Virtual constructor */
- BevelledCylinderVolumeBounds* clone() const override;
-
- /**This method checks if position in the 3D volume frame is inside the cylinder*/
- bool inside(const Vector3D& , double tol=0.) const override;
-
- /** Method to decompose the Bounds into boundarySurfaces */
- const std::vector<const Acts::Surface*>* decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
-
- /**This method returns the inner radius*/
- double innerRadius() const;
-
- /**This method returns the outer radius*/
- double outerRadius() const;
-
- /**This method returns the medium radius*/
- double mediumRadius() const;
-
- /**This method returns the delta radius*/
- double deltaRadius() const;
-
- /**This method returns the halfPhiSector angle*/
- double halfPhiSector() const;
-
- /**This method returns the halflengthZ*/
- double halflengthZ() const;
-
- /**This method returns the thetaMinus*/
- double thetaMinus() const;
-
- /**This method returns the thetaPlus*/
- double thetaPlus() const;
-
- /**This method returns the type*/
- int type() const;
-
- /** Output Method for std::ostream */
- std::ostream& dump(std::ostream& sl) const override;
-
- private:
- template <class T> T& dumpT(T& tstream) const;
-
- /** This method returns the associated BevelledCylinderBounds of the inner BevelledCylinderSurfaces. */
- CylinderBounds* innerBevelledCylinderBounds() const;
- /** This method returns the associated BevelledCylinderBounds of the outer BevelledCylinderSurfaces. */
- CylinderBounds* outerBevelledCylinderBounds() const;
- /** This method returns the associated plane surface bounds of the inner bevelled surface*/
- RectangleBounds* innerBevelledPlaneBounds() const;
- /** This method returns the associated BevelledCylinderBounds of the outer BevelledCylinderSurfaces. */
- RectangleBounds* outerBevelledPlaneBounds() const;
- /** This method returns the associated EllipseBounds for the bottom/top EllipseSurface. */
- EllipseBounds* bottomEllipseBounds() const;
- /** This method returns the associated EllipseBounds for the bottom/top EllipseSurface. */
- EllipseBounds* topEllipseBounds() const;
- /** This method returns the associated CylinderBounds of the inner CylinderSurfaces. */
- CylinderBounds* innerCylinderBounds() const;
- /** This method returns the associated CylinderBounds of the outer CylinderSurfaces. */
- CylinderBounds* outerCylinderBounds() const;
- /** This method returns the associated RadialBounds for the bottom/top DiscSurface. */
- RadialBounds* discBounds() const;
- /** This method returns the bevelled area volume. */
- Volume* subtractedVolume() const;
- /** This method returns the associated PlaneBounds limiting a sectoral BevelledCylinderVolume. */
- TrapezoidBounds* sectorTrdBounds() const;
- RectangleBounds* sectorPlaneBounds() const;
-
- std::vector<TDD_real_t> m_boundValues;
- int m_type;
-
- /** numerical stability */
- static double s_numericalStable;
-
- mutable Acts::Volume* m_subtractedVolume;
- };
-
- inline BevelledCylinderVolumeBounds* BevelledCylinderVolumeBounds::clone() const
- { return new BevelledCylinderVolumeBounds(*this); }
-
- inline bool BevelledCylinderVolumeBounds::inside(const Vector3D &pos, double tol) const
- {
- double ros = pos.perp();
- bool insidePhi = fabs(pos.phi()) <= m_boundValues.at(bv_halfPhiSector) + tol;
- double cphi = cos(pos.phi());
- bool insideR = insidePhi;
- if (m_type < 1) insideR = insidePhi ? ((ros >= m_boundValues.at(bv_innerRadius) - tol ) && (ros <= m_boundValues.at(bv_outerRadius) + tol)) : false;
- else if (m_type == 1 ) insideR = insidePhi ? ((ros>= m_boundValues.at(bv_innerRadius)/cphi-tol)&&(ros<=m_boundValues.at(bv_outerRadius)+tol)):false;
- else if (m_type == 2 ) insideR = insidePhi ? ((ros>= m_boundValues.at(bv_innerRadius)-tol)&&(ros<=m_boundValues.at(bv_outerRadius)/cphi+tol)):false;
- else if (m_type == 3 ) insideR = insidePhi ? ((ros>= m_boundValues.at(bv_innerRadius)/cphi-tol)&&(ros<=m_boundValues.at(bv_outerRadius)/cphi+tol)):false;
-// bool insideZ = insideR ? (fabs(pos.z()) <= m_boundValues[bv_halfZ] + tol ) : false ;
- bool insideZ = insideR ? ((pos.z()<=m_boundValues.at(bv_halfZ)-(pos.x()+m_boundValues.at(bv_outerRadius))*tan(m_boundValues.at(bv_thetaPlus)) + tol)
- && ( pos.z()>=-m_boundValues.at(bv_halfZ)+(pos.x()+m_boundValues.at(bv_outerRadius))*tan(m_boundValues.at(bv_thetaMinus)) - tol)) : false ;
-
- return insideZ;
- }
-
- inline double BevelledCylinderVolumeBounds::innerRadius() const { return m_boundValues.at(bv_innerRadius); }
- inline double BevelledCylinderVolumeBounds::outerRadius() const { return m_boundValues.at(bv_outerRadius); }
- inline double BevelledCylinderVolumeBounds::mediumRadius() const { return 0.5*(m_boundValues.at(bv_innerRadius)+m_boundValues.at(bv_outerRadius)); }
- inline double BevelledCylinderVolumeBounds::deltaRadius() const { return (m_boundValues.at(bv_outerRadius)-m_boundValues.at(bv_innerRadius)); }
- inline double BevelledCylinderVolumeBounds::halfPhiSector() const { return m_boundValues.at(bv_halfPhiSector); }
- inline double BevelledCylinderVolumeBounds::halflengthZ() const { return m_boundValues.at(bv_halfZ); }
- inline double BevelledCylinderVolumeBounds::thetaMinus() const { return m_boundValues.at(bv_thetaMinus); }
- inline double BevelledCylinderVolumeBounds::thetaPlus() const { return m_boundValues.at(bv_thetaPlus); }
- inline int BevelledCylinderVolumeBounds::type() const { return m_type; }
-
- template <class T> T& BevelledCylinderVolumeBounds::dumpT(T& tstream) const
- {
- tstream << std::setiosflags(std::ios::fixed);
- tstream << std::setprecision(7);
- tstream << "Acts::BevelledCylinderVolumeBounds: (innerR, outerR, halfPhiSector, halflengthInZ, thetaMinus, thetaPlus) = ";
- tstream << "(" << m_boundValues.at(bv_innerRadius) << ", " << m_boundValues.at(bv_outerRadius) << ", " << m_boundValues.at(bv_halfPhiSector) << ", " << m_boundValues.at(bv_halfZ) << m_boundValues.at(bv_thetaMinus)<< ", " << m_boundValues.at(bv_thetaPlus) << ")";
- return tstream;
- }
-
+/** @struct BevelledBoundaryIntersector
+ - identical code to ExtrapolationUtils/RealLinearEquation (but forbidden
+ dependency!)
+ */
+struct BevelledBoundaryIntersector
+{
+ double yOfX; //!< the result of x
+ double segLength; //!< length of the line segment
+
+ BevelledBoundaryIntersector(double px, double py, double k, double xprime)
+ {
+ double deltax = xprime - px;
+ yOfX = py + k * (deltax);
+ double deltay = yOfX - py;
+ segLength = sqrt(deltax * deltax + deltay * deltay);
+ }
+};
+
+class Surface;
+class EllipseBounds;
+class TrapezoidBounds;
+class RectangleBounds;
+class CylinderBounds;
+class RadialBounds;
+
+/**
+ @class BevelledCylinderVolumeBounds
+
+ Bounds for a cylindrical Volume, the decomposeToSurfaces method creates a
+ vector of up to 6 surfaces:
+
+ case A) 3 Surfaces (full cylindrical tube):
+ BoundarySurfaceFace [index]:
+ - negativeFaceXY [0] : Acts::DiscSurface with \f$ r_{inner}=0 \f$,
+ parallel to \f$ xy \f$ plane at negative \f$ z \f$
+ - positiveFaceXY [1] : Acts::DiscSurface with \f$ r_{inner}=0 \f$,
+ parallel to \f$ xy \f$ plane at positive \f$ z \f$
+ - cylinderCover [2] : Acts::CylinderSurface confining the Acts::Volume
+
+ case B) 4 Surfaces (tube with inner and outer radius):
+ BoundarySurfaceFace [index]:
+ - negativeFaceXY [0] : Acts::DiscSurface with \f$ r_{inner}>0 \f$,
+ parallel to \f$ xy \f$ plane at negative \f$ z \f$
+ - positiveFaceXY [1] : Acts::DiscSurface with \f$ r_{inner}>0 \f$,
+ parallel to \f$ xy \f$ plane at positive \f$ z \f$
+ - tubeOuterCover [2] : Acts::CylinderSurface with \f$ r = r_{outer} \f$
+ - tubeInnerCover [3] : Acts::CylinderSurface with \f$ r = r_{inner} \f$
+
+ case C) 6 Surfaces (sectoral tube with inner and outer radius):
+ BoundarySurfaceFace [index]:
+ - negativeFaceXY [0] : Acts::DiscSurface with \f$ r_{inner}>0 \f$
+ and \f$ \phi < \pi \f$,
+ parallel to \f$ xy \f$ plane at negative \f$
+ z \f$
+ - positiveFaceXY [1] : Acts::DiscSurface with \f$ r_{inner}>0 \f$
+ and \f$ \phi < \pi \f$,
+ parallel to \f$ xy \f$ plane at positive \f$
+ z \f$
+ - tubeSectorOuterCover [2] : Acts::CylinderSurface with \f$ r = r_{outer}
+ \f$
+ - tubeSectorInnerCover [3] : Acts::CylinderSurface with \f$ r = r_{inner}
+ \f$
+ - tubeSectorNegativePhi [4] : Rectangular Acts::PlaneSurface attached to
+ [0] and [1] at negative \f$ \phi \f$
+ - tubeSectorNegativePhi [5] : Rectangular Acts::PlaneSurface attached to
+ [0] and [1] at positive \f$ \phi \f$
+
+ case D) 6 Surfaces (sectoral bevelled tube with inner and/or outer radius
+ replaced by plane surface):
+ BoundarySurfaceFace [index]:
+ - negativeFaceXY [0] : Acts::DiscSurface with \f$ r_{inner}>0 \f$
+ and \f$ \phi < \pi \f$,
+ parallel to \f$ xy \f$ plane at negative \f$
+ z \f$
+ - positiveFaceXY [1] : Acts::DiscSurface with \f$ r_{inner}>0 \f$
+ and \f$ \phi < \pi \f$,
+ parallel to \f$ xy \f$ plane at positive \f$
+ z \f$
+ - tubeSectorOuterCover [2] : Acts::CylinderSurface with \f$ r = r_{outer}
+ \f$
+ OR rectangular plane surface
+ - tubeSectorInnerCover [3] : Acts::CylinderSurface with \f$ r = r_{inner}
+ \f$
+ OR rectangular plane surface
+ - tubeSectorNegativePhi [4] : Rectangular Acts::PlaneSurface attached to
+ [0] and [1] at negative \f$ \phi \f$
+ - tubeSectorNegativePhi [5] : Rectangular Acts::PlaneSurface attached to
+ [0] and [1] at positive \f$ \phi \f$
+
+ @image html CylinderVolumeBounds_decomp.gif
+
+ */
+
+class BevelledCylinderVolumeBounds : public VolumeBounds
+{
+public:
+ /** @enum BoundValues for readibility */
+ enum BoundValues {
+ bv_innerRadius = 0,
+ bv_outerRadius = 1,
+ bv_halfPhiSector = 2,
+ bv_halfZ = 3,
+ bv_thetaMinus = 4,
+ bv_thetaPlus = 5,
+ bv_length = 6
+ };
+
+ /**Default Constructor*/
+ BevelledCylinderVolumeBounds();
+
+ /**Constructor - cylinder segment bevelled in R */
+ BevelledCylinderVolumeBounds(double rinner,
+ double router,
+ double halfPhiSector,
+ double halez,
+ int type);
+
+ /**Copy Constructor */
+ BevelledCylinderVolumeBounds(const BevelledCylinderVolumeBounds& cylbo);
+
+ /**Destructor */
+ virtual ~BevelledCylinderVolumeBounds();
+
+ /**Assignment operator*/
+ BevelledCylinderVolumeBounds&
+ operator=(const BevelledCylinderVolumeBounds& cylbo);
+
+ /**Virtual constructor */
+ BevelledCylinderVolumeBounds*
+ clone() const override;
+
+ /**This method checks if position in the 3D volume frame is inside the
+ * cylinder*/
+ bool
+ inside(const Vector3D&, double tol = 0.) const override;
+
+ /** Method to decompose the Bounds into boundarySurfaces */
+ const std::vector<const Acts::Surface*>*
+ decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
+
+ /**This method returns the inner radius*/
+ double
+ innerRadius() const;
+
+ /**This method returns the outer radius*/
+ double
+ outerRadius() const;
+
+ /**This method returns the medium radius*/
+ double
+ mediumRadius() const;
+
+ /**This method returns the delta radius*/
+ double
+ deltaRadius() const;
+
+ /**This method returns the halfPhiSector angle*/
+ double
+ halfPhiSector() const;
+
+ /**This method returns the halflengthZ*/
+ double
+ halflengthZ() const;
+
+ /**This method returns the thetaMinus*/
+ double
+ thetaMinus() const;
+
+ /**This method returns the thetaPlus*/
+ double
+ thetaPlus() const;
+
+ /**This method returns the type*/
+ int
+ type() const;
+
+ /** Output Method for std::ostream */
+ std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ template <class T>
+ T&
+ dumpT(T& tstream) const;
+
+ /** This method returns the associated BevelledCylinderBounds of the inner
+ * BevelledCylinderSurfaces. */
+ CylinderBounds*
+ innerBevelledCylinderBounds() const;
+ /** This method returns the associated BevelledCylinderBounds of the outer
+ * BevelledCylinderSurfaces. */
+ CylinderBounds*
+ outerBevelledCylinderBounds() const;
+ /** This method returns the associated plane surface bounds of the inner
+ * bevelled surface*/
+ RectangleBounds*
+ innerBevelledPlaneBounds() const;
+ /** This method returns the associated BevelledCylinderBounds of the outer
+ * BevelledCylinderSurfaces. */
+ RectangleBounds*
+ outerBevelledPlaneBounds() const;
+ /** This method returns the associated EllipseBounds for the bottom/top
+ * EllipseSurface. */
+ EllipseBounds*
+ bottomEllipseBounds() const;
+ /** This method returns the associated EllipseBounds for the bottom/top
+ * EllipseSurface. */
+ EllipseBounds*
+ topEllipseBounds() const;
+ /** This method returns the associated CylinderBounds of the inner
+ * CylinderSurfaces. */
+ CylinderBounds*
+ innerCylinderBounds() const;
+ /** This method returns the associated CylinderBounds of the outer
+ * CylinderSurfaces. */
+ CylinderBounds*
+ outerCylinderBounds() const;
+ /** This method returns the associated RadialBounds for the bottom/top
+ * DiscSurface. */
+ RadialBounds*
+ discBounds() const;
+ /** This method returns the bevelled area volume. */
+ Volume*
+ subtractedVolume() const;
+ /** This method returns the associated PlaneBounds limiting a sectoral
+ * BevelledCylinderVolume. */
+ TrapezoidBounds*
+ sectorTrdBounds() const;
+ RectangleBounds*
+ sectorPlaneBounds() const;
+
+ std::vector<TDD_real_t> m_boundValues;
+ int m_type;
+
+ /** numerical stability */
+ static double s_numericalStable;
+
+ mutable Acts::Volume* m_subtractedVolume;
+};
+
+inline BevelledCylinderVolumeBounds*
+BevelledCylinderVolumeBounds::clone() const
+{
+ return new BevelledCylinderVolumeBounds(*this);
}
-#endif // ACTS_VOLUMES_BEVELLEDCYLINDERVOLUMESBOUNDS_H
+inline bool
+BevelledCylinderVolumeBounds::inside(const Vector3D& pos, double tol) const
+{
+ double ros = pos.perp();
+ bool insidePhi = fabs(pos.phi()) <= m_boundValues.at(bv_halfPhiSector) + tol;
+ double cphi = cos(pos.phi());
+ bool insideR = insidePhi;
+ if (m_type < 1)
+ insideR = insidePhi ? ((ros >= m_boundValues.at(bv_innerRadius) - tol)
+ && (ros <= m_boundValues.at(bv_outerRadius) + tol))
+ : false;
+ else if (m_type == 1)
+ insideR = insidePhi
+ ? ((ros >= m_boundValues.at(bv_innerRadius) / cphi - tol)
+ && (ros <= m_boundValues.at(bv_outerRadius) + tol))
+ : false;
+ else if (m_type == 2)
+ insideR = insidePhi
+ ? ((ros >= m_boundValues.at(bv_innerRadius) - tol)
+ && (ros <= m_boundValues.at(bv_outerRadius) / cphi + tol))
+ : false;
+ else if (m_type == 3)
+ insideR = insidePhi
+ ? ((ros >= m_boundValues.at(bv_innerRadius) / cphi - tol)
+ && (ros <= m_boundValues.at(bv_outerRadius) / cphi + tol))
+ : false;
+ // bool insideZ = insideR ? (fabs(pos.z()) <= m_boundValues[bv_halfZ] + tol
+ // ) : false ;
+ bool insideZ = insideR
+ ? ((pos.z() <= m_boundValues.at(bv_halfZ)
+ - (pos.x() + m_boundValues.at(bv_outerRadius))
+ * tan(m_boundValues.at(bv_thetaPlus))
+ + tol)
+ && (pos.z() >= -m_boundValues.at(bv_halfZ)
+ + (pos.x() + m_boundValues.at(bv_outerRadius))
+ * tan(m_boundValues.at(bv_thetaMinus))
+ - tol))
+ : false;
+
+ return insideZ;
+}
+inline double
+BevelledCylinderVolumeBounds::innerRadius() const
+{
+ return m_boundValues.at(bv_innerRadius);
+}
+inline double
+BevelledCylinderVolumeBounds::outerRadius() const
+{
+ return m_boundValues.at(bv_outerRadius);
+}
+inline double
+BevelledCylinderVolumeBounds::mediumRadius() const
+{
+ return 0.5
+ * (m_boundValues.at(bv_innerRadius) + m_boundValues.at(bv_outerRadius));
+}
+inline double
+BevelledCylinderVolumeBounds::deltaRadius() const
+{
+ return (m_boundValues.at(bv_outerRadius) - m_boundValues.at(bv_innerRadius));
+}
+inline double
+BevelledCylinderVolumeBounds::halfPhiSector() const
+{
+ return m_boundValues.at(bv_halfPhiSector);
+}
+inline double
+BevelledCylinderVolumeBounds::halflengthZ() const
+{
+ return m_boundValues.at(bv_halfZ);
+}
+inline double
+BevelledCylinderVolumeBounds::thetaMinus() const
+{
+ return m_boundValues.at(bv_thetaMinus);
+}
+inline double
+BevelledCylinderVolumeBounds::thetaPlus() const
+{
+ return m_boundValues.at(bv_thetaPlus);
+}
+inline int
+BevelledCylinderVolumeBounds::type() const
+{
+ return m_type;
+}
+template <class T>
+T&
+BevelledCylinderVolumeBounds::dumpT(T& tstream) const
+{
+ tstream << std::setiosflags(std::ios::fixed);
+ tstream << std::setprecision(7);
+ tstream << "Acts::BevelledCylinderVolumeBounds: (innerR, outerR, "
+ "halfPhiSector, halflengthInZ, thetaMinus, thetaPlus) = ";
+ tstream << "(" << m_boundValues.at(bv_innerRadius) << ", "
+ << m_boundValues.at(bv_outerRadius) << ", "
+ << m_boundValues.at(bv_halfPhiSector) << ", "
+ << m_boundValues.at(bv_halfZ) << m_boundValues.at(bv_thetaMinus)
+ << ", " << m_boundValues.at(bv_thetaPlus) << ")";
+ return tstream;
+}
+}
+#endif // ACTS_VOLUMES_BEVELLEDCYLINDERVOLUMESBOUNDS_H
diff --git a/Core/include/ACTS/Volumes/BoundaryCylinderSurface.hpp b/Core/include/ACTS/Volumes/BoundaryCylinderSurface.hpp
index 4bd32ff60..2d4f104ee 100644
--- a/Core/include/ACTS/Volumes/BoundaryCylinderSurface.hpp
+++ b/Core/include/ACTS/Volumes/BoundaryCylinderSurface.hpp
@@ -21,99 +21,115 @@
namespace Acts {
- class Volume;
-
- /**
- @class BoundaryCylinderSurface
-
- BoundaryCylinderSurface description inside the tracking realm,
- it extends the Surface description to make a surface being a boundary of a
- Acts::Volume
-
- */
-
- template <class T> class BoundaryCylinderSurface :
- virtual public BoundarySurface<T>, public CylinderSurface {
-
- typedef std::shared_ptr<const T> VolumePtr;
- typedef BinnedArray< VolumePtr > VolumeArray;
-
- public:
- /** Default Constructor - needed for pool and inherited classes */
- BoundaryCylinderSurface():
- BoundarySurface<T>(),
- CylinderSurface()
- {}
-
- /** Copy constructor */
- BoundaryCylinderSurface(const BoundaryCylinderSurface<T>& bcs) :
- BoundarySurface<T>(bcs),
- CylinderSurface(bcs)
- {}
-
- /** Constructor for a Boundary with exact two Volumes attached to it*/
- BoundaryCylinderSurface(const T* inside, const T* outside, const CylinderSurface& csf) :
- BoundarySurface<T>(inside, outside),
- CylinderSurface(csf)
- {}
-
- /** Constructor for a Boundary with two VolumeArrays attached to it*/
- BoundaryCylinderSurface(std::shared_ptr<const VolumeArray> insideArray, std::shared_ptr<const VolumeArray> outsideArray, const CylinderSurface& csf) :
- BoundarySurface<T>(insideArray, outsideArray),
- CylinderSurface(csf)
- {}
-
- /** Copy constructor with a shift */
- BoundaryCylinderSurface(const T* inside, const T* outside, const CylinderSurface& csf, const Transform3D& tr) :
- BoundarySurface<T>(inside,outside),
- CylinderSurface(csf,tr)
- {}
-
- /**Virtual Destructor*/
- virtual ~BoundaryCylinderSurface(){}
-
- /** Get the next Volume depending on position, momentum, dir
- of the TrackParameters and the requested direction */
- const T* attachedVolume(const Vector3D& pos, const Vector3D& mom, PropDirection dir) const override;
-
- /** The Surface Representation of this */
- const Surface& surfaceRepresentation() const override;
-
- /**Assignment operator - assignment of boundary surfaces is forbidden */
- BoundaryCylinderSurface& operator=(const BoundaryCylinderSurface& vol) = delete;
-
- protected:
+class Volume;
+
+/**
+ @class BoundaryCylinderSurface
+
+ BoundaryCylinderSurface description inside the tracking realm,
+ it extends the Surface description to make a surface being a boundary of a
+ Acts::Volume
+
+ */
+
+template <class T>
+class BoundaryCylinderSurface : virtual public BoundarySurface<T>,
+ public CylinderSurface
+{
+ typedef std::shared_ptr<const T> VolumePtr;
+ typedef BinnedArray<VolumePtr> VolumeArray;
+
+public:
+ /** Default Constructor - needed for pool and inherited classes */
+ BoundaryCylinderSurface() : BoundarySurface<T>(), CylinderSurface() {}
+ /** Copy constructor */
+ BoundaryCylinderSurface(const BoundaryCylinderSurface<T>& bcs)
+ : BoundarySurface<T>(bcs), CylinderSurface(bcs)
+ {
+ }
- };
+ /** Constructor for a Boundary with exact two Volumes attached to it*/
+ BoundaryCylinderSurface(const T* inside,
+ const T* outside,
+ const CylinderSurface& csf)
+ : BoundarySurface<T>(inside, outside), CylinderSurface(csf)
+ {
+ }
- template <class T> inline const Surface& BoundaryCylinderSurface<T>::surfaceRepresentation() const { return *this; }
+ /** Constructor for a Boundary with two VolumeArrays attached to it*/
+ BoundaryCylinderSurface(std::shared_ptr<const VolumeArray> insideArray,
+ std::shared_ptr<const VolumeArray> outsideArray,
+ const CylinderSurface& csf)
+ : BoundarySurface<T>(insideArray, outsideArray), CylinderSurface(csf)
+ {
+ }
- template <class T> inline const T* BoundaryCylinderSurface<T>::attachedVolume(const Vector3D& pos,
- const Vector3D& mom,
- PropDirection dir) const
+ /** Copy constructor with a shift */
+ BoundaryCylinderSurface(const T* inside,
+ const T* outside,
+ const CylinderSurface& csf,
+ const Transform3D& tr)
+ : BoundarySurface<T>(inside, outside), CylinderSurface(csf, tr)
{
- const T* attVolume = nullptr;
- // it's a cylinder surface, we need to get the local normal vector
- // -> bring the position vector into the cylinder frame (if needed)
- Vector3D normalSf = Surface::m_transform ? Surface::m_transform->inverse()*pos : pos;
- normalSf[2] = 0.;
- // ->bring the momentum vector into the cylinder frame (if needed)
- Vector3D momentumSf = Surface::m_transform ? Surface::m_transform->inverse()*mom : mom;
- // dot product to decide between inside and outside)
- if ( normalSf.unit().dot(dir*momentumSf) > 0. ){
- attVolume = BoundarySurface<T>::m_outsideVolume;
- if (BoundarySurface<T>::m_outsideVolumeArray.get())
- attVolume = BoundarySurface<T>::m_outsideVolumeArray->object(pos).get();
- } else {
- attVolume = BoundarySurface<T>::m_insideVolume;
- if (BoundarySurface<T>::m_insideVolumeArray.get())
- attVolume = BoundarySurface<T>::m_insideVolumeArray->object(pos).get();
- }
- // return what you have
- return attVolume;
}
-} // end of namespace Acts
+ /**Virtual Destructor*/
+ virtual ~BoundaryCylinderSurface() {}
+ /** Get the next Volume depending on position, momentum, dir
+ of the TrackParameters and the requested direction */
+ const T*
+ attachedVolume(const Vector3D& pos,
+ const Vector3D& mom,
+ PropDirection dir) const override;
+
+ /** The Surface Representation of this */
+ const Surface&
+ surfaceRepresentation() const override;
+
+ /**Assignment operator - assignment of boundary surfaces is forbidden */
+ BoundaryCylinderSurface&
+ operator=(const BoundaryCylinderSurface& vol)
+ = delete;
+
+protected:
+};
+
+template <class T>
+inline const Surface&
+BoundaryCylinderSurface<T>::surfaceRepresentation() const
+{
+ return *this;
+}
+
+template <class T>
+inline const T*
+BoundaryCylinderSurface<T>::attachedVolume(const Vector3D& pos,
+ const Vector3D& mom,
+ PropDirection dir) const
+{
+ const T* attVolume = nullptr;
+ // it's a cylinder surface, we need to get the local normal vector
+ // -> bring the position vector into the cylinder frame (if needed)
+ Vector3D normalSf
+ = Surface::m_transform ? Surface::m_transform->inverse() * pos : pos;
+ normalSf[2] = 0.;
+ // ->bring the momentum vector into the cylinder frame (if needed)
+ Vector3D momentumSf
+ = Surface::m_transform ? Surface::m_transform->inverse() * mom : mom;
+ // dot product to decide between inside and outside)
+ if (normalSf.unit().dot(dir * momentumSf) > 0.) {
+ attVolume = BoundarySurface<T>::m_outsideVolume;
+ if (BoundarySurface<T>::m_outsideVolumeArray.get())
+ attVolume = BoundarySurface<T>::m_outsideVolumeArray->object(pos).get();
+ } else {
+ attVolume = BoundarySurface<T>::m_insideVolume;
+ if (BoundarySurface<T>::m_insideVolumeArray.get())
+ attVolume = BoundarySurface<T>::m_insideVolumeArray->object(pos).get();
+ }
+ // return what you have
+ return attVolume;
+}
-#endif // ACTS_VOLUMES_BOUNDARYCYLIMDERSURFACE_H
+} // end of namespace Acts
+#endif // ACTS_VOLUMES_BOUNDARYCYLIMDERSURFACE_H
diff --git a/Core/include/ACTS/Volumes/BoundaryDiscSurface.hpp b/Core/include/ACTS/Volumes/BoundaryDiscSurface.hpp
index fa95a3f7b..7c90cee2e 100644
--- a/Core/include/ACTS/Volumes/BoundaryDiscSurface.hpp
+++ b/Core/include/ACTS/Volumes/BoundaryDiscSurface.hpp
@@ -13,77 +13,84 @@
#ifndef ACTS_VOLUMES_BOUNDARYDISCSURFACE_H
#define ACTS_VOLUMES_BOUNDARYDISCSURFACE_H 1
-#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Surfaces/DiscSurface.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Volumes/BoundarySurface.hpp"
namespace Acts {
- class Volume;
-
- /**
- @class BoundaryDiscSurface
-
- BoundaryDiscSurface description inside the tracking realm,
- it extends the DiscSurface description to make a surface being a boundary of a
- Acts::Volume (used for cylindrical shape).
- It inherits from BoundarySurface to get the interface of boundaries.
-
- */
-
- template <class T> class BoundaryDiscSurface :
- virtual public BoundarySurface<T>, public DiscSurface {
-
- typedef std::shared_ptr<const T> VolumePtr;
- typedef BinnedArray< VolumePtr > VolumeArray;
-
- public:
- /** Default Constructor - needed for pool and inherited classes */
- BoundaryDiscSurface():
- BoundarySurface<T>(),
- DiscSurface()
- {}
-
- /** Copy constructor */
- BoundaryDiscSurface(const BoundaryDiscSurface<T>& bds) :
- BoundarySurface<T>(bds),
- DiscSurface(bds)
- {}
-
- /** Constructor for a Boundary with exact two Volumes attached to it*/
- BoundaryDiscSurface(const T* inside, const T* outside, const DiscSurface& dsf) :
- BoundarySurface<T>(inside, outside),
- DiscSurface(dsf)
- {}
-
- /** Constructor for a Boundary with two VolumeArrays attached to it*/
- BoundaryDiscSurface(std::shared_ptr<const VolumeArray> insideArray, std::shared_ptr<const VolumeArray> outsideArray, const DiscSurface& dsf) :
- BoundarySurface<T>(insideArray, outsideArray),
- DiscSurface(dsf)
- {}
-
- /** Copy constructor with a shift */
- BoundaryDiscSurface(const T* inside, const T* outside, const DiscSurface& dsf, const Transform3D& tr) :
- BoundarySurface<T>(inside,outside),
- DiscSurface(dsf,tr)
- {}
-
- /** The Surface Representation of this */
- const Surface& surfaceRepresentation() const override;
-
- /**Virtual Destructor*/
- virtual ~BoundaryDiscSurface(){}
-
- /**Assignment operator - assignment of boundary surfaces is forbidden */
- BoundaryDiscSurface& operator=(const BoundaryDiscSurface& vol) = delete;
-
- protected:
-
- };
-
-template <class T> inline const Surface& BoundaryDiscSurface<T>::surfaceRepresentation() const { return *this; }
-
-} // end of namespace Acts
-
-#endif // ACTS_VOLUMES_BOUNDARYDISCSURFACE_H
-
+class Volume;
+
+/**
+ @class BoundaryDiscSurface
+
+ BoundaryDiscSurface description inside the tracking realm,
+ it extends the DiscSurface description to make a surface being a boundary of a
+ Acts::Volume (used for cylindrical shape).
+ It inherits from BoundarySurface to get the interface of boundaries.
+
+ */
+
+template <class T>
+class BoundaryDiscSurface : virtual public BoundarySurface<T>,
+ public DiscSurface
+{
+ typedef std::shared_ptr<const T> VolumePtr;
+ typedef BinnedArray<VolumePtr> VolumeArray;
+
+public:
+ /** Default Constructor - needed for pool and inherited classes */
+ BoundaryDiscSurface() : BoundarySurface<T>(), DiscSurface() {}
+ /** Copy constructor */
+ BoundaryDiscSurface(const BoundaryDiscSurface<T>& bds)
+ : BoundarySurface<T>(bds), DiscSurface(bds)
+ {
+ }
+
+ /** Constructor for a Boundary with exact two Volumes attached to it*/
+ BoundaryDiscSurface(const T* inside, const T* outside, const DiscSurface& dsf)
+ : BoundarySurface<T>(inside, outside), DiscSurface(dsf)
+ {
+ }
+
+ /** Constructor for a Boundary with two VolumeArrays attached to it*/
+ BoundaryDiscSurface(std::shared_ptr<const VolumeArray> insideArray,
+ std::shared_ptr<const VolumeArray> outsideArray,
+ const DiscSurface& dsf)
+ : BoundarySurface<T>(insideArray, outsideArray), DiscSurface(dsf)
+ {
+ }
+
+ /** Copy constructor with a shift */
+ BoundaryDiscSurface(const T* inside,
+ const T* outside,
+ const DiscSurface& dsf,
+ const Transform3D& tr)
+ : BoundarySurface<T>(inside, outside), DiscSurface(dsf, tr)
+ {
+ }
+
+ /** The Surface Representation of this */
+ const Surface&
+ surfaceRepresentation() const override;
+
+ /**Virtual Destructor*/
+ virtual ~BoundaryDiscSurface() {}
+ /**Assignment operator - assignment of boundary surfaces is forbidden */
+ BoundaryDiscSurface&
+ operator=(const BoundaryDiscSurface& vol)
+ = delete;
+
+protected:
+};
+
+template <class T>
+inline const Surface&
+BoundaryDiscSurface<T>::surfaceRepresentation() const
+{
+ return *this;
+}
+
+} // end of namespace Acts
+
+#endif // ACTS_VOLUMES_BOUNDARYDISCSURFACE_H
diff --git a/Core/include/ACTS/Volumes/BoundaryPlaneSurface.hpp b/Core/include/ACTS/Volumes/BoundaryPlaneSurface.hpp
index 77350abf2..0b09ba39c 100644
--- a/Core/include/ACTS/Volumes/BoundaryPlaneSurface.hpp
+++ b/Core/include/ACTS/Volumes/BoundaryPlaneSurface.hpp
@@ -14,74 +14,82 @@
#define ACTS_VOLUMES_BOUNDARYPLANESURFACE_H 1
#include "ACTS/Surfaces/PlaneSurface.hpp"
-#include "ACTS/Volumes/BoundarySurface.hpp"
#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Volumes/BoundarySurface.hpp"
namespace Acts {
- class Volume;
-
- /**
- @class BoundaryPlaneSurface
-
- BoundaryPlaneSurface description inside the tracking realm,
- it extends the PlaneSurface description to make a surface being a boundary of a
- Acts::Volume (used for all volume shapes).
- It inherits from BoundarySurface to get the interface of boundaries.
-
- */
-
- template <class T> class BoundaryPlaneSurface :
- virtual public BoundarySurface<T>, public PlaneSurface {
-
- typedef std::shared_ptr<const T> VolumePtr;
- typedef BinnedArray< VolumePtr > VolumeArray;
-
- public:
- /** Default Constructor - needed for pool and inherited classes */
- BoundaryPlaneSurface() :
- BoundarySurface<T>(),
- PlaneSurface()
- {}
-
- /** Copy constructor */
- BoundaryPlaneSurface(const BoundaryPlaneSurface<T>& bps) :
- BoundarySurface<T>(bps),
- PlaneSurface(bps)
- {}
-
- /** Constructor for a Boundary with exact two Volumes attached to it*/
- BoundaryPlaneSurface(const T* inside, const T* outside, const PlaneSurface& psf) :
- BoundarySurface<T>(inside, outside),
- PlaneSurface(psf)
- {}
-
- /** Constructor for a Boundary with two VolumeArrays attached to it*/
- BoundaryPlaneSurface(std::shared_ptr<const VolumeArray> insideArray, std::shared_ptr<const VolumeArray> outsideArray, const PlaneSurface& psf) :
- BoundarySurface<T>(insideArray, outsideArray),
- PlaneSurface(psf)
- {}
-
- /** Copy constructor with a shift */
- BoundaryPlaneSurface(const T* inside, const T* outside, const PlaneSurface& psf, const Transform3D& tr) :
- BoundarySurface<T>(inside,outside),
- PlaneSurface(psf,tr)
- {}
-
- /** The Surface Representation of this */
- const Surface& surfaceRepresentation() const override;
-
- /**Virtual Destructor*/
- virtual ~BoundaryPlaneSurface(){}
-
- /**Assignment operator - addignment of boundary surfaces are forbidden*/
- BoundaryPlaneSurface& operator=(const BoundaryPlaneSurface& vol);
-
- };
-
-template <class T> inline const Surface& BoundaryPlaneSurface<T>::surfaceRepresentation() const { return *this; }
-
-} // end of namespace Acts
-
-#endif // ACTS_VOLUMES_BOUNDARYPLANESURFACE_H
-
+class Volume;
+
+/**
+ @class BoundaryPlaneSurface
+
+ BoundaryPlaneSurface description inside the tracking realm,
+ it extends the PlaneSurface description to make a surface being a boundary of a
+ Acts::Volume (used for all volume shapes).
+ It inherits from BoundarySurface to get the interface of boundaries.
+
+*/
+
+template <class T>
+class BoundaryPlaneSurface : virtual public BoundarySurface<T>,
+ public PlaneSurface
+{
+ typedef std::shared_ptr<const T> VolumePtr;
+ typedef BinnedArray<VolumePtr> VolumeArray;
+
+public:
+ /** Default Constructor - needed for pool and inherited classes */
+ BoundaryPlaneSurface() : BoundarySurface<T>(), PlaneSurface() {}
+ /** Copy constructor */
+ BoundaryPlaneSurface(const BoundaryPlaneSurface<T>& bps)
+ : BoundarySurface<T>(bps), PlaneSurface(bps)
+ {
+ }
+
+ /** Constructor for a Boundary with exact two Volumes attached to it*/
+ BoundaryPlaneSurface(const T* inside,
+ const T* outside,
+ const PlaneSurface& psf)
+ : BoundarySurface<T>(inside, outside), PlaneSurface(psf)
+ {
+ }
+
+ /** Constructor for a Boundary with two VolumeArrays attached to it*/
+ BoundaryPlaneSurface(std::shared_ptr<const VolumeArray> insideArray,
+ std::shared_ptr<const VolumeArray> outsideArray,
+ const PlaneSurface& psf)
+ : BoundarySurface<T>(insideArray, outsideArray), PlaneSurface(psf)
+ {
+ }
+
+ /** Copy constructor with a shift */
+ BoundaryPlaneSurface(const T* inside,
+ const T* outside,
+ const PlaneSurface& psf,
+ const Transform3D& tr)
+ : BoundarySurface<T>(inside, outside), PlaneSurface(psf, tr)
+ {
+ }
+
+ /** The Surface Representation of this */
+ const Surface&
+ surfaceRepresentation() const override;
+
+ /**Virtual Destructor*/
+ virtual ~BoundaryPlaneSurface() {}
+ /**Assignment operator - addignment of boundary surfaces are forbidden*/
+ BoundaryPlaneSurface&
+ operator=(const BoundaryPlaneSurface& vol);
+};
+
+template <class T>
+inline const Surface&
+BoundaryPlaneSurface<T>::surfaceRepresentation() const
+{
+ return *this;
+}
+
+} // end of namespace Acts
+
+#endif // ACTS_VOLUMES_BOUNDARYPLANESURFACE_H
diff --git a/Core/include/ACTS/Volumes/BoundarySubtractedCylinderSurface.hpp b/Core/include/ACTS/Volumes/BoundarySubtractedCylinderSurface.hpp
index 4203a11b7..0b2f41165 100644
--- a/Core/include/ACTS/Volumes/BoundarySubtractedCylinderSurface.hpp
+++ b/Core/include/ACTS/Volumes/BoundarySubtractedCylinderSurface.hpp
@@ -13,102 +13,125 @@
#ifndef ACTS_VOLUMES_BOUNDARYSUBTRACTEDCYLIMDERSURFACE_H
#define ACTS_VOLUMES_BOUNDARYSUBTRACTEDCYLIMDERSURFACE_H 1
-#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Surfaces/SubtractedCylinderSurface.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Volumes/BoundarySurface.hpp"
namespace Acts {
- class Volume;
-
- /**
- @class BoundarySubtractedCylinderSurface
-
- BoundarySubtractedCylinderSurface description inside the tracking realm,
- it extends the Surface description to make a surface being a boundary of a
- Acts::Volume
-
- */
-
- template <class T> class BoundarySubtractedCylinderSurface :
- virtual public BoundarySurface<T>, public SubtractedCylinderSurface {
-
- /** typedef the BinnedArray */
- typedef BinnedArray<T> VolumeArray;
-
- public:
- /** Default Constructor - needed for pool and inherited classes */
- BoundarySubtractedCylinderSurface():
- BoundarySurface<T>(),
- SubtractedCylinderSurface()
- {}
-
- /** Copy constructor */
- BoundarySubtractedCylinderSurface(const BoundarySubtractedCylinderSurface<T>& bcs) :
- BoundarySurface<T>(bcs),
- SubtractedCylinderSurface(bcs)
- {}
-
- /** Constructor for a Boundary with exact two Volumes attached to it*/
- BoundarySubtractedCylinderSurface(const T* inside, const T* outside, const SubtractedCylinderSurface& csf) :
- BoundarySurface<T>(inside, outside),
- SubtractedCylinderSurface(csf)
- {}
+class Volume;
- /** Constructor for a Boundary with two VolumeArrays attached to it*/
- BoundarySubtractedCylinderSurface(std::shared_ptr<VolumeArray> insideArray, std::shared_ptr<VolumeArray> outsideArray, const SubtractedCylinderSurface& csf) :
- BoundarySurface<T>(insideArray, outsideArray),
- SubtractedCylinderSurface(csf)
- {}
+/**
+ @class BoundarySubtractedCylinderSurface
- /** Copy constructor with a shift */
- BoundarySubtractedCylinderSurface(const T* inside, const T* outside, const SubtractedCylinderSurface& csf, const Transform3D& tr) :
- BoundarySurface<T>(inside,outside),
- SubtractedCylinderSurface(csf,tr)
- {}
+ BoundarySubtractedCylinderSurface description inside the tracking realm,
+ it extends the Surface description to make a surface being a boundary of a
+ Acts::Volume
- /**Virtual Destructor*/
- virtual ~BoundarySubtractedCylinderSurface()
- {}
+ */
- /** Get the next Volume depending on GlobalPosition, GlobalMomentum, dir on the TrackParameters and the requested direction */
- const T* attachedVolume(const Vector3D& pos, const Vector3D& mom, PropDirection dir) const override;
+template <class T>
+class BoundarySubtractedCylinderSurface : virtual public BoundarySurface<T>,
+ public SubtractedCylinderSurface
+{
+ /** typedef the BinnedArray */
+ typedef BinnedArray<T> VolumeArray;
- /** The Surface Representation of this */
- const Surface& surfaceRepresentation() const override;
+public:
+ /** Default Constructor - needed for pool and inherited classes */
+ BoundarySubtractedCylinderSurface()
+ : BoundarySurface<T>(), SubtractedCylinderSurface()
+ {
+ }
- /**Assignment operator - forbidden */
- BoundarySubtractedCylinderSurface& operator=(const BoundarySubtractedCylinderSurface& vol) = delete ;
+ /** Copy constructor */
+ BoundarySubtractedCylinderSurface(
+ const BoundarySubtractedCylinderSurface<T>& bcs)
+ : BoundarySurface<T>(bcs), SubtractedCylinderSurface(bcs)
+ {
+ }
- };
+ /** Constructor for a Boundary with exact two Volumes attached to it*/
+ BoundarySubtractedCylinderSurface(const T* inside,
+ const T* outside,
+ const SubtractedCylinderSurface& csf)
+ : BoundarySurface<T>(inside, outside), SubtractedCylinderSurface(csf)
+ {
+ }
- template <class T> inline const Surface& BoundarySubtractedCylinderSurface<T>::surfaceRepresentation() const { return *this; }
+ /** Constructor for a Boundary with two VolumeArrays attached to it*/
+ BoundarySubtractedCylinderSurface(std::shared_ptr<VolumeArray> insideArray,
+ std::shared_ptr<VolumeArray> outsideArray,
+ const SubtractedCylinderSurface& csf)
+ : BoundarySurface<T>(insideArray, outsideArray)
+ , SubtractedCylinderSurface(csf)
+ {
+ }
- template <class T> inline const T* BoundarySubtractedCylinderSurface<T>::attachedVolume(const Vector3D& pos,
- const Vector3D& mom,
- PropDirection dir) const
+ /** Copy constructor with a shift */
+ BoundarySubtractedCylinderSurface(const T* inside,
+ const T* outside,
+ const SubtractedCylinderSurface& csf,
+ const Transform3D& tr)
+ : BoundarySurface<T>(inside, outside), SubtractedCylinderSurface(csf, tr)
{
- const T* attVolume = 0;
- // it's a cylinder surface, we need to get the local normal vector
- // -> bring the position vector into the cylinder frame (if needed)
- Vector3D normalSf = Surface::m_transform ? Surface::m_transform->inverse()*pos : pos;
- normalSf[2] = 0.;
- // ->bring the momentum vector into the cylinder frame (if needed)
- Vector3D momentumSf = Surface::m_transform ? Surface::m_transform->inverse()*mom : mom;
- // dot product to decide between inside and outside)
- if ( normalSf.unit().dot(dir*momentumSf) > 0. ){
- attVolume = BoundarySurface<T>::m_outsideVolume;
- if (BoundarySurface<T>::m_outsideVolumeArray.get())
- attVolume = BoundarySurface<T>::m_outsideVolumeArray->object(pos).get();
- } else {
- attVolume = BoundarySurface<T>::m_insideVolume;
- if (BoundarySurface<T>::m_insideVolumeArray.get())
- attVolume = BoundarySurface<T>::m_insideVolumeArray->object(pos).get();
- }
- // return what you have
- return attVolume;
}
-} // end of namespace Acts
+ /**Virtual Destructor*/
+ virtual ~BoundarySubtractedCylinderSurface() {}
+ /** Get the next Volume depending on GlobalPosition, GlobalMomentum, dir on
+ * the TrackParameters and the requested direction */
+ const T*
+ attachedVolume(const Vector3D& pos,
+ const Vector3D& mom,
+ PropDirection dir) const override;
+
+ /** The Surface Representation of this */
+ const Surface&
+ surfaceRepresentation() const override;
+
+ /**Assignment operator - forbidden */
+ BoundarySubtractedCylinderSurface&
+ operator=(const BoundarySubtractedCylinderSurface& vol)
+ = delete;
+};
+
+template <class T>
+inline const Surface&
+BoundarySubtractedCylinderSurface<T>::surfaceRepresentation() const
+{
+ return *this;
+}
+
+template <class T>
+inline const T*
+BoundarySubtractedCylinderSurface<T>::attachedVolume(const Vector3D& pos,
+ const Vector3D& mom,
+ PropDirection dir) const
+{
+ const T* attVolume = 0;
+ // it's a cylinder surface, we need to get the local normal vector
+ // -> bring the position vector into the cylinder frame (if needed)
+ Vector3D normalSf
+ = Surface::m_transform ? Surface::m_transform->inverse() * pos : pos;
+ normalSf[2] = 0.;
+ // ->bring the momentum vector into the cylinder frame (if needed)
+ Vector3D momentumSf
+ = Surface::m_transform ? Surface::m_transform->inverse() * mom : mom;
+ // dot product to decide between inside and outside)
+ if (normalSf.unit().dot(dir * momentumSf) > 0.) {
+ attVolume = BoundarySurface<T>::m_outsideVolume;
+ if (BoundarySurface<T>::m_outsideVolumeArray.get())
+ attVolume = BoundarySurface<T>::m_outsideVolumeArray->object(pos).get();
+ } else {
+ attVolume = BoundarySurface<T>::m_insideVolume;
+ if (BoundarySurface<T>::m_insideVolumeArray.get())
+ attVolume = BoundarySurface<T>::m_insideVolumeArray->object(pos).get();
+ }
+ // return what you have
+ return attVolume;
+}
+
+} // end of namespace Acts
-#endif // ACTS_VOLUMES_BOUNDARYSUBTRACTEDCYLINDERSURFACE_H
+#endif // ACTS_VOLUMES_BOUNDARYSUBTRACTEDCYLINDERSURFACE_H
diff --git a/Core/include/ACTS/Volumes/BoundarySubtractedPlaneSurface.hpp b/Core/include/ACTS/Volumes/BoundarySubtractedPlaneSurface.hpp
index 43e20a220..42f8a6b74 100644
--- a/Core/include/ACTS/Volumes/BoundarySubtractedPlaneSurface.hpp
+++ b/Core/include/ACTS/Volumes/BoundarySubtractedPlaneSurface.hpp
@@ -14,73 +14,88 @@
#define ACTS_VOLUMES_BOUNDARYSUBTRACTEDPLANESURFACE_H 1
#include "ACTS/Surfaces/SubtractedPlaneSurface.hpp"
-#include "ACTS/Volumes/BoundarySurface.hpp"
#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Volumes/BoundarySurface.hpp"
namespace Acts {
- class Volume;
-
- /**
- @class BoundarySubtractedPlaneSurface
-
- BoundarySubtractedPlaneSurface description inside the tracking realm,
- it extends the SubtractedPlaneSurface description to make a surface being a boundary of a
- Acts::Volume (used for all volume shapes).
- It inherits from BoundarySurface to get the interface of boundaries.
-
- */
-
- template <class T> class BoundarySubtractedPlaneSurface :
- virtual public BoundarySurface<T>, public SubtractedPlaneSurface {
-
- /** typedef the BinnedArray */
- typedef BinnedArray<T> VolumeArray;
-
- public:
- /** Default Constructor - needed for pool and inherited classes */
- BoundarySubtractedPlaneSurface() :
- BoundarySurface<T>(),
- SubtractedPlaneSurface()
- {}
-
- /** Copy constructor */
- BoundarySubtractedPlaneSurface(const BoundarySubtractedPlaneSurface<T>& bps) :
- BoundarySurface<T>(bps),
- SubtractedPlaneSurface(bps)
- {}
-
- /** Constructor for a Boundary with exact two Volumes attached to it*/
- BoundarySubtractedPlaneSurface(const T* inside, const T* outside, const SubtractedPlaneSurface& psf) :
- BoundarySurface<T>(inside, outside),
- SubtractedPlaneSurface(psf)
- {}
-
- /** Constructor for a Boundary with two VolumeArrays attached to it*/
- BoundarySubtractedPlaneSurface(std::shared_ptr<VolumeArray> insideArray, std::shared_ptr<VolumeArray> outsideArray, const SubtractedPlaneSurface& psf) :
- BoundarySurface<T>(insideArray, outsideArray),
- SubtractedPlaneSurface(psf)
- {}
-
- /** Copy constructor with a shift */
- BoundarySubtractedPlaneSurface(const T* inside, const T* outside, const SubtractedPlaneSurface& psf, const Transform3D& tr) :
- BoundarySurface<T>(inside,outside),
- SubtractedPlaneSurface(psf,tr)
- {}
-
- /** The Surface Representation of this */
- const Surface& surfaceRepresentation() const override;
-
- /**Virtual Destructor*/
- virtual ~BoundarySubtractedPlaneSurface(){}
-
- /**Assignment operator - assignment is forbidden */
- BoundarySubtractedPlaneSurface& operator=(const BoundarySubtractedPlaneSurface& vol) = delete ;
-
- };
-
- template <class T> inline const Surface& BoundarySubtractedPlaneSurface<T>::surfaceRepresentation() const { return *this; }
-
-} // end of namespace Acts
-
-#endif // ACTS_VOLUMES_BOUNDARYSUBTRACTEDPLANESURFACE_H
+class Volume;
+
+/**
+ @class BoundarySubtractedPlaneSurface
+
+ BoundarySubtractedPlaneSurface description inside the tracking realm,
+ it extends the SubtractedPlaneSurface description to make a surface being a
+ boundary of a
+ Acts::Volume (used for all volume shapes).
+ It inherits from BoundarySurface to get the interface of boundaries.
+
+*/
+
+template <class T>
+class BoundarySubtractedPlaneSurface : virtual public BoundarySurface<T>,
+ public SubtractedPlaneSurface
+{
+ /** typedef the BinnedArray */
+ typedef BinnedArray<T> VolumeArray;
+
+public:
+ /** Default Constructor - needed for pool and inherited classes */
+ BoundarySubtractedPlaneSurface()
+ : BoundarySurface<T>(), SubtractedPlaneSurface()
+ {
+ }
+
+ /** Copy constructor */
+ BoundarySubtractedPlaneSurface(const BoundarySubtractedPlaneSurface<T>& bps)
+ : BoundarySurface<T>(bps), SubtractedPlaneSurface(bps)
+ {
+ }
+
+ /** Constructor for a Boundary with exact two Volumes attached to it*/
+ BoundarySubtractedPlaneSurface(const T* inside,
+ const T* outside,
+ const SubtractedPlaneSurface& psf)
+ : BoundarySurface<T>(inside, outside), SubtractedPlaneSurface(psf)
+ {
+ }
+
+ /** Constructor for a Boundary with two VolumeArrays attached to it*/
+ BoundarySubtractedPlaneSurface(std::shared_ptr<VolumeArray> insideArray,
+ std::shared_ptr<VolumeArray> outsideArray,
+ const SubtractedPlaneSurface& psf)
+ : BoundarySurface<T>(insideArray, outsideArray), SubtractedPlaneSurface(psf)
+ {
+ }
+
+ /** Copy constructor with a shift */
+ BoundarySubtractedPlaneSurface(const T* inside,
+ const T* outside,
+ const SubtractedPlaneSurface& psf,
+ const Transform3D& tr)
+ : BoundarySurface<T>(inside, outside), SubtractedPlaneSurface(psf, tr)
+ {
+ }
+
+ /** The Surface Representation of this */
+ const Surface&
+ surfaceRepresentation() const override;
+
+ /**Virtual Destructor*/
+ virtual ~BoundarySubtractedPlaneSurface() {}
+ /**Assignment operator - assignment is forbidden */
+ BoundarySubtractedPlaneSurface&
+ operator=(const BoundarySubtractedPlaneSurface& vol)
+ = delete;
+};
+
+template <class T>
+inline const Surface&
+BoundarySubtractedPlaneSurface<T>::surfaceRepresentation() const
+{
+ return *this;
+}
+
+} // end of namespace Acts
+
+#endif // ACTS_VOLUMES_BOUNDARYSUBTRACTEDPLANESURFACE_H
diff --git a/Core/include/ACTS/Volumes/BoundarySurface.hpp b/Core/include/ACTS/Volumes/BoundarySurface.hpp
index 0393f1f5d..43249ceec 100644
--- a/Core/include/ACTS/Volumes/BoundarySurface.hpp
+++ b/Core/include/ACTS/Volumes/BoundarySurface.hpp
@@ -13,131 +13,171 @@
#ifndef ACTS_VOLUMES_BOUNDARYSURFACE_H
#define ACTS_VOLUMES_BOUNDARYSURFACE_H
-#include "ACTS/Volumes/Volume.hpp"
-#include "ACTS/Volumes/BoundarySurfaceFace.hpp"
#include "ACTS/Utilities/BinnedArray.hpp"
#include "ACTS/Utilities/BinnedArray0D.hpp"
#include "ACTS/Utilities/Definitions.hpp"
-
+#include "ACTS/Volumes/BoundarySurfaceFace.hpp"
+#include "ACTS/Volumes/Volume.hpp"
namespace Acts {
- class Surface;
-
- /**
- @class BoundarySurface
-
- Description of a BoundarySurface for volumes in the Tracking geometry.
- It extends the Surface description to make a surface being a boundary of a
- Acts::AbstractVolume & Acts::TrackingVolume.
-
- To avoid dynamic_cast operations the BoundarySurface class is realized as a templated class,
- with the Volume type as the template argument.
-
- A Acts::BoundarySurface can have an inside Volume and an outside Volume, resp.
- a Acts::BinnedArray for inside or outside direction.
-
- Inside and outside are by this referring to the normal vector definition of the Surface,
- and not necessarily corresponding to the Volume inside/outside definition.
-
- The GeometryBuilder as defined in the GeometryTools Package is declared
- to be friend, so that it can glue Volumes together by sharing the same
- Boundary Surface.
-
- */
+class Surface;
- template <class T> class BoundarySurface {
+/**
+ @class BoundarySurface
- /** delcare the TrackingVolume as friend */
- friend T;
+ Description of a BoundarySurface for volumes in the Tracking geometry.
+ It extends the Surface description to make a surface being a boundary of a
+ Acts::AbstractVolume & Acts::TrackingVolume.
- typedef std::shared_ptr<const T> VolumePtr;
- typedef BinnedArray< VolumePtr > VolumeArray;
+ To avoid dynamic_cast operations the BoundarySurface class is realized as a
+ templated class,
+ with the Volume type as the template argument.
- public:
- /** Default Constructor - needed for pool and inherited classes */
- BoundarySurface() :
- m_insideVolume(nullptr),
- m_outsideVolume(nullptr),
- m_insideVolumeArray(nullptr),
- m_outsideVolumeArray(nullptr)
- {}
+ A Acts::BoundarySurface can have an inside Volume and an outside Volume, resp.
+ a Acts::BinnedArray for inside or outside direction.
- /** Constructor for a Boundary with exact two Volumes attached to it - usually used in a volume constructor*/
- BoundarySurface(const T* inside, const T* outside) :
- m_insideVolume(inside),
- m_outsideVolume(outside),
- m_insideVolumeArray(nullptr),
- m_outsideVolumeArray(nullptr)
- {}
+ Inside and outside are by this referring to the normal vector definition of the
+ Surface,
+ and not necessarily corresponding to the Volume inside/outside definition.
- /** Constructor for a Boundary with exact two Volumes attached to it - for already constructed volumes */
- BoundarySurface(VolumePtr inside, VolumePtr outside) :
- m_insideVolume(nullptr),
- m_outsideVolume(nullptr),
- m_insideVolumeArray(new BinnedArray0D<VolumePtr>(inside)),
- m_outsideVolumeArray(new BinnedArray0D<VolumePtr>(outside))
- {}
+ The GeometryBuilder as defined in the GeometryTools Package is declared
+ to be friend, so that it can glue Volumes together by sharing the same
+ Boundary Surface.
- /** Constructor for a Boundary with exact two Volumes attached to it*/
- BoundarySurface(std::shared_ptr<const VolumeArray> insideArray, std::shared_ptr<const VolumeArray> outsideArray) :
- m_insideVolume(nullptr),
- m_outsideVolume(nullptr),
- m_insideVolumeArray(insideArray),
- m_outsideVolumeArray(outsideArray)
- {}
+*/
- /** Get the next Volume depending on GlobalPosition, GlobalMomentum, dir on the TrackParameters and the requested direction
- - the position, momentum are assumed to be on surface */
- virtual const T* attachedVolume(const Vector3D& pos, const Vector3D& mom, PropDirection dir) const;
+template <class T>
+class BoundarySurface
+{
+ /** delcare the TrackingVolume as friend */
+ friend T;
- /** templated onBoundary method */
- template <class P> bool onBoundary(const P& pars) const
- { return surfaceRepresentation().onSurface(pars); }
+ typedef std::shared_ptr<const T> VolumePtr;
+ typedef BinnedArray<VolumePtr> VolumeArray;
- /** The Surface Representation of this */
- virtual const Surface& surfaceRepresentation() const = 0;
-
- /**Virtual Destructor*/
- virtual ~BoundarySurface(){}
-
- protected:
- /** attach a Volume to this BoundarySurface - will always be done as an 0D array
- - the owning volume can call this as it is fiend */
- void attachVolume(VolumePtr volume, BoundaryOrientation inout) const;
-
- /** attach a VolumeArray to this BoundarySurface
- - the owing volume can call this as it is friend */
- void attachVolumeArray(std::shared_ptr<const VolumeArray> volumes, BoundaryOrientation inout) const;
-
- mutable const T* m_insideVolume;
- mutable const T* m_outsideVolume;
- mutable std::shared_ptr<const VolumeArray> m_insideVolumeArray;
- mutable std::shared_ptr<const VolumeArray> m_outsideVolumeArray;
-
- };
+public:
+ /** Default Constructor - needed for pool and inherited classes */
+ BoundarySurface()
+ : m_insideVolume(nullptr)
+ , m_outsideVolume(nullptr)
+ , m_insideVolumeArray(nullptr)
+ , m_outsideVolumeArray(nullptr)
+ {
+ }
- template <class T> void BoundarySurface<T>::attachVolume(VolumePtr volume, BoundaryOrientation inout) const {
- if (inout == insideVolume) m_insideVolumeArray = std::shared_ptr<const VolumeArray>(new BinnedArray0D<VolumePtr>(volume));
- else m_outsideVolumeArray = std::shared_ptr<const VolumeArray>(new BinnedArray0D<VolumePtr>(volume));
+ /** Constructor for a Boundary with exact two Volumes attached to it - usually
+ * used in a volume constructor*/
+ BoundarySurface(const T* inside, const T* outside)
+ : m_insideVolume(inside)
+ , m_outsideVolume(outside)
+ , m_insideVolumeArray(nullptr)
+ , m_outsideVolumeArray(nullptr)
+ {
}
- template <class T> void BoundarySurface<T>::attachVolumeArray(const std::shared_ptr<const VolumeArray> volumes, BoundaryOrientation inout) const {
- if (inout == insideVolume) m_insideVolumeArray = volumes;
- else m_outsideVolumeArray = volumes;
+ /** Constructor for a Boundary with exact two Volumes attached to it - for
+ * already constructed volumes */
+ BoundarySurface(VolumePtr inside, VolumePtr outside)
+ : m_insideVolume(nullptr)
+ , m_outsideVolume(nullptr)
+ , m_insideVolumeArray(new BinnedArray0D<VolumePtr>(inside))
+ , m_outsideVolumeArray(new BinnedArray0D<VolumePtr>(outside))
+ {
}
- template <class T> const T* BoundarySurface<T>::attachedVolume(const Vector3D& pos, const Vector3D& mom, PropDirection dir) const
+ /** Constructor for a Boundary with exact two Volumes attached to it*/
+ BoundarySurface(std::shared_ptr<const VolumeArray> insideArray,
+ std::shared_ptr<const VolumeArray> outsideArray)
+ : m_insideVolume(nullptr)
+ , m_outsideVolume(nullptr)
+ , m_insideVolumeArray(insideArray)
+ , m_outsideVolumeArray(outsideArray)
{
+ }
- const T* attVolume = nullptr;
- // dot product with normal vector to distinguish inside/outside
- if ( (surfaceRepresentation().normal(pos)).dot(dir*mom) > 0.)
- attVolume = m_outsideVolumeArray ? m_outsideVolumeArray->object(pos).get() : m_outsideVolume;
- else
- attVolume = m_insideVolumeArray ? m_insideVolumeArray->object(pos).get() : m_insideVolume;
- return attVolume;
+ /** Get the next Volume depending on GlobalPosition, GlobalMomentum, dir on
+ the TrackParameters and the requested direction
+ - the position, momentum are assumed to be on surface */
+ virtual const T*
+ attachedVolume(const Vector3D& pos,
+ const Vector3D& mom,
+ PropDirection dir) const;
+
+ /** templated onBoundary method */
+ template <class P>
+ bool
+ onBoundary(const P& pars) const
+ {
+ return surfaceRepresentation().onSurface(pars);
}
-} // end of namespace Acts
-#endif // ACTS_VOLUMES_BOUNDARYSURFACE_H
+ /** The Surface Representation of this */
+ virtual const Surface&
+ surfaceRepresentation() const = 0;
+
+ /**Virtual Destructor*/
+ virtual ~BoundarySurface() {}
+protected:
+ /** attach a Volume to this BoundarySurface - will always be done as an 0D
+ array
+ - the owning volume can call this as it is fiend */
+ void
+ attachVolume(VolumePtr volume, BoundaryOrientation inout) const;
+
+ /** attach a VolumeArray to this BoundarySurface
+ - the owing volume can call this as it is friend */
+ void
+ attachVolumeArray(std::shared_ptr<const VolumeArray> volumes,
+ BoundaryOrientation inout) const;
+
+ mutable const T* m_insideVolume;
+ mutable const T* m_outsideVolume;
+ mutable std::shared_ptr<const VolumeArray> m_insideVolumeArray;
+ mutable std::shared_ptr<const VolumeArray> m_outsideVolumeArray;
+};
+
+template <class T>
+void
+BoundarySurface<T>::attachVolume(VolumePtr volume,
+ BoundaryOrientation inout) const
+{
+ if (inout == insideVolume)
+ m_insideVolumeArray = std::shared_ptr<const VolumeArray>(
+ new BinnedArray0D<VolumePtr>(volume));
+ else
+ m_outsideVolumeArray = std::shared_ptr<const VolumeArray>(
+ new BinnedArray0D<VolumePtr>(volume));
+}
+
+template <class T>
+void
+BoundarySurface<T>::attachVolumeArray(
+ const std::shared_ptr<const VolumeArray> volumes,
+ BoundaryOrientation inout) const
+{
+ if (inout == insideVolume)
+ m_insideVolumeArray = volumes;
+ else
+ m_outsideVolumeArray = volumes;
+}
+
+template <class T>
+const T*
+BoundarySurface<T>::attachedVolume(const Vector3D& pos,
+ const Vector3D& mom,
+ PropDirection dir) const
+{
+ const T* attVolume = nullptr;
+ // dot product with normal vector to distinguish inside/outside
+ if ((surfaceRepresentation().normal(pos)).dot(dir * mom) > 0.)
+ attVolume = m_outsideVolumeArray ? m_outsideVolumeArray->object(pos).get()
+ : m_outsideVolume;
+ else
+ attVolume = m_insideVolumeArray ? m_insideVolumeArray->object(pos).get()
+ : m_insideVolume;
+ return attVolume;
+}
+} // end of namespace Acts
+
+#endif // ACTS_VOLUMES_BOUNDARYSURFACE_H
diff --git a/Core/include/ACTS/Volumes/BoundarySurfaceFace.hpp b/Core/include/ACTS/Volumes/BoundarySurfaceFace.hpp
index 36c9f1962..8cf3ed59b 100644
--- a/Core/include/ACTS/Volumes/BoundarySurfaceFace.hpp
+++ b/Core/include/ACTS/Volumes/BoundarySurfaceFace.hpp
@@ -12,65 +12,61 @@
#ifndef ACTS_VOLUMES_BOUNDARYSURFACEFACE_H
#define ACTS_VOLUMES_BOUNDARYSURFACEFACE_H 1
-
-namespace Acts {
-
- /**
- @enum BoundarySurfaceFace
-
- Enum to describe the position of the BoundarySurface
- respectively to the frame orientatin of the volume,
- this is mainly ment for code readability.
-
- The different numeration sequences can be found in the
- documentation of the actual VolumeBounds implementations.
-
- The order of faces is chosen to follow - as much as
- possible - a cycular structure.
-
-
- */
- enum BoundarySurfaceFace { negativeFaceXY = 0,
- positiveFaceXY = 1,
- negativeFaceYZ = 2,
- positiveFaceYZ = 3,
- negativeFaceZX = 4,
- positiveFaceZX = 5,
- cylinderCover = 2,
- tubeInnerCover = 3,
- tubeOuterCover = 2,
- tubeSectorNegativePhi = 4,
- tubeSectorPositivePhi = 5,
- tubeSectorInnerCover = 3,
- tubeSectorOuterCover = 2,
- trapezoidFaceAlpha = 2,
- trapezoidFaceBeta = 3,
- index0 = 0,
- index1 = 1,
- index2 = 2,
- index3 = 3,
- index4 = 4,
- index5 = 5,
- index6 = 6,
- index7 = 7,
- index8 = 8,
- index9 = 9,
- index10 = 10,
- index11 = 11,
- undefinedFace = 99
+namespace Acts {
+
+/**
+ @enum BoundarySurfaceFace
+
+ Enum to describe the position of the BoundarySurface
+ respectively to the frame orientatin of the volume,
+ this is mainly ment for code readability.
+
+ The different numeration sequences can be found in the
+ documentation of the actual VolumeBounds implementations.
+
+ The order of faces is chosen to follow - as much as
+ possible - a cycular structure.
- };
-
- /** @enum to specify the inside/outside
- this is with respect to the normal vector
- */
- enum BoundaryOrientation {
- insideVolume = -1,
- outsideVolume = 1
- };
-
-}
-#endif // ACTS_VOLUMES_BOUNDARYSURFACEFACE_H
+ */
+
+enum BoundarySurfaceFace {
+ negativeFaceXY = 0,
+ positiveFaceXY = 1,
+ negativeFaceYZ = 2,
+ positiveFaceYZ = 3,
+ negativeFaceZX = 4,
+ positiveFaceZX = 5,
+ cylinderCover = 2,
+ tubeInnerCover = 3,
+ tubeOuterCover = 2,
+ tubeSectorNegativePhi = 4,
+ tubeSectorPositivePhi = 5,
+ tubeSectorInnerCover = 3,
+ tubeSectorOuterCover = 2,
+ trapezoidFaceAlpha = 2,
+ trapezoidFaceBeta = 3,
+ index0 = 0,
+ index1 = 1,
+ index2 = 2,
+ index3 = 3,
+ index4 = 4,
+ index5 = 5,
+ index6 = 6,
+ index7 = 7,
+ index8 = 8,
+ index9 = 9,
+ index10 = 10,
+ index11 = 11,
+ undefinedFace = 99
+
+};
+
+/** @enum to specify the inside/outside
+ this is with respect to the normal vector
+ */
+enum BoundaryOrientation { insideVolume = -1, outsideVolume = 1 };
+}
+#endif // ACTS_VOLUMES_BOUNDARYSURFACEFACE_H
diff --git a/Core/include/ACTS/Volumes/CombinedVolumeBounds.hpp b/Core/include/ACTS/Volumes/CombinedVolumeBounds.hpp
index 31b03a027..ddd5a4bc4 100644
--- a/Core/include/ACTS/Volumes/CombinedVolumeBounds.hpp
+++ b/Core/include/ACTS/Volumes/CombinedVolumeBounds.hpp
@@ -15,99 +15,128 @@
// Geometry module
#include "ACTS/Utilities/Definitions.hpp"
-#include "ACTS/Volumes/VolumeBounds.hpp"
#include "ACTS/Volumes/Volume.hpp"
+#include "ACTS/Volumes/VolumeBounds.hpp"
// Core module
namespace Acts {
- class SurfaceBounds;
- class Volume;
- class Surface;
-
- /**
- @class CombinedVolumeBounds
-
- Bounds for a generic combined volume, the decomposeToSurfaces method creates a
- vector of n surfaces (n1+n2-nshared):
-
- BoundarySurfaceFace [index]: [n1+n2-nshared] combined surfaces
-
- designed to allow transcript of GeoShapeUnion and GeoShapeIntersection
+class SurfaceBounds;
+class Volume;
+class Surface;
- */
+/**
+ @class CombinedVolumeBounds
- class CombinedVolumeBounds : public VolumeBounds {
+ Bounds for a generic combined volume, the decomposeToSurfaces method creates a
+ vector of n surfaces (n1+n2-nshared):
- public:
- /**Default Constructor*/
- CombinedVolumeBounds();
+ BoundarySurfaceFace [index]: [n1+n2-nshared] combined surfaces
- /**Constructor - the box boundaries */
- CombinedVolumeBounds( Volume* first,Volume* second, bool intersection);
+ designed to allow transcript of GeoShapeUnion and GeoShapeIntersection
- /**Copy Constructor */
- CombinedVolumeBounds(const CombinedVolumeBounds& bobo);
+*/
- /**Destructor */
- virtual ~CombinedVolumeBounds();
+class CombinedVolumeBounds : public VolumeBounds
+{
+public:
+ /**Default Constructor*/
+ CombinedVolumeBounds();
- /**Assignment operator*/
- CombinedVolumeBounds& operator=(const CombinedVolumeBounds& bobo);
+ /**Constructor - the box boundaries */
+ CombinedVolumeBounds(Volume* first, Volume* second, bool intersection);
- /**Virtual constructor */
- CombinedVolumeBounds* clone() const override;
+ /**Copy Constructor */
+ CombinedVolumeBounds(const CombinedVolumeBounds& bobo);
- /**This method checks if position in the 3D volume frame is inside the volume*/
- bool inside(const Vector3D&, double tol=0.) const override;
+ /**Destructor */
+ virtual ~CombinedVolumeBounds();
- /** Method to decompose the Bounds into boundarySurfaces */
- const std::vector<const Acts::Surface*>* decomposeToSurfaces(std::shared_ptr<Transform3D>transformPtr) const override;
+ /**Assignment operator*/
+ CombinedVolumeBounds&
+ operator=(const CombinedVolumeBounds& bobo);
- /**This method returns the first VolumeBounds*/
- Volume* first() const;
+ /**Virtual constructor */
+ CombinedVolumeBounds*
+ clone() const override;
- /**This method returns the second VolumeBounds*/
- Volume* second() const;
+ /**This method checks if position in the 3D volume frame is inside the
+ * volume*/
+ bool
+ inside(const Vector3D&, double tol = 0.) const override;
- /**This method distinguishes between Union(0) and Intersection(1)*/
- bool intersection() const;
+ /** Method to decompose the Bounds into boundarySurfaces */
+ const std::vector<const Acts::Surface*>*
+ decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
- /**This method returns bounds orientation*/
- const std::vector<bool> boundsOrientation() const;
+ /**This method returns the first VolumeBounds*/
+ Volume*
+ first() const;
- /** Output Method for std::ostream */
- std::ostream& dump(std::ostream& sl) const override;
+ /**This method returns the second VolumeBounds*/
+ Volume*
+ second() const;
- private:
+ /**This method distinguishes between Union(0) and Intersection(1)*/
+ bool
+ intersection() const;
- Acts::Volume* createSubtractedVolume(const Transform3D& transf, Acts::Volume* subtrVol) const;
+ /**This method returns bounds orientation*/
+ const std::vector<bool>
+ boundsOrientation() const;
- Volume* m_first; //!< first volume of the combination
- Volume* m_second; //!< second volume of the combination
- bool m_intersection; //!< boolean if intersection is needed or not
- mutable std::vector<bool> m_boundsOrientation; //!< orientation of the bounds
+ /** Output Method for std::ostream */
+ std::ostream&
+ dump(std::ostream& sl) const override;
- };
+private:
+ Acts::Volume*
+ createSubtractedVolume(const Transform3D& transf,
+ Acts::Volume* subtrVol) const;
- inline CombinedVolumeBounds* CombinedVolumeBounds::clone() const
- { return new CombinedVolumeBounds(*this); }
+ Volume* m_first; //!< first volume of the combination
+ Volume* m_second; //!< second volume of the combination
+ bool m_intersection; //!< boolean if intersection is needed or not
+ mutable std::vector<bool> m_boundsOrientation; //!< orientation of the bounds
+};
- inline bool CombinedVolumeBounds::inside(const Vector3D &pos, double tol) const
- {
- if (m_intersection) return (m_first->inside(pos,tol) && m_second->inside(pos,tol) );
- return (m_first->inside(pos,tol) || m_second->inside(pos,tol) );
- }
+inline CombinedVolumeBounds*
+CombinedVolumeBounds::clone() const
+{
+ return new CombinedVolumeBounds(*this);
+}
- inline Volume* CombinedVolumeBounds::first() const { return m_first; }
+inline bool
+CombinedVolumeBounds::inside(const Vector3D& pos, double tol) const
+{
+ if (m_intersection)
+ return (m_first->inside(pos, tol) && m_second->inside(pos, tol));
+ return (m_first->inside(pos, tol) || m_second->inside(pos, tol));
+}
- inline Volume* CombinedVolumeBounds::second() const { return m_second; }
+inline Volume*
+CombinedVolumeBounds::first() const
+{
+ return m_first;
+}
- inline bool CombinedVolumeBounds::intersection() const { return m_intersection; }
+inline Volume*
+CombinedVolumeBounds::second() const
+{
+ return m_second;
+}
- inline const std::vector<bool> CombinedVolumeBounds::boundsOrientation() const
- { return(m_boundsOrientation); }
+inline bool
+CombinedVolumeBounds::intersection() const
+{
+ return m_intersection;
+}
+inline const std::vector<bool>
+CombinedVolumeBounds::boundsOrientation() const
+{
+ return (m_boundsOrientation);
+}
}
-#endif // ACTS_VOLUMES_COMBINEDVOLUMEBOUNDS_H
+#endif // ACTS_VOLUMES_COMBINEDVOLUMEBOUNDS_H
diff --git a/Core/include/ACTS/Volumes/CuboidVolumeBounds.hpp b/Core/include/ACTS/Volumes/CuboidVolumeBounds.hpp
index ac2e0c24d..e3d46714b 100644
--- a/Core/include/ACTS/Volumes/CuboidVolumeBounds.hpp
+++ b/Core/include/ACTS/Volumes/CuboidVolumeBounds.hpp
@@ -13,122 +13,159 @@
#ifndef ACTS_VOLUMES_BOXVOLUMESBOUNDS_H
#define ACTS_VOLUMES_BOXVOLUMESBOUNDS_H 1
-#include "ACTS/Volumes/VolumeBounds.hpp"
#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Volumes/VolumeBounds.hpp"
namespace Acts {
- class RectangleBounds;
- class Volume;
- class Surface;
-
- /**
- @class CuboidVolumeBounds
-
- Bounds for a cubical Volume, the decomposeToSurfaces method creates a
- vector of 6 surfaces:
-
- BoundarySurfaceFace [index]:
-
- - negativeFaceXY [0] : Rectangular Acts::PlaneSurface, parallel to \f$ xy \f$ plane at negative \f$ z \f$
- - positiveFaceXY [1] : Rectangular Acts::PlaneSurface, parallel to \f$ xy \f$ plane at positive \f$ z \f$
- - negativeFaceXY [2] : Rectangular Acts::PlaneSurface, attached to \f$ yz \f$ plane at negative \f$ x \f$
- - positiveFaceXY [3] : Rectangular Acts::PlaneSurface, attached to \f$ yz \f$ plane at negative \f$ x \f$
- - negativeFaceXY [4] : Rectangular Acts::PlaneSurface, parallel to \f$ zx \f$ plane at negative \f$ y \f$
- - positiveFaceXY [5] : Rectangular Acts::PlaneSurface, parallel to \f$ zx \f$ plane at positive \f$ y \f$
-
- @image html CuboidVolumeBounds_decomp.gif
-
- */
-
- class CuboidVolumeBounds : public VolumeBounds {
-
- public:
- /** @enum BoundValues for readability */
- enum BoundValues {
- bv_halfX = 0,
- bv_halfY = 1,
- bv_halfZ = 2,
- bv_length = 3
- };
-
- /**Default Constructor*/
- CuboidVolumeBounds();
-
- /**Constructor - the box boundaries */
- CuboidVolumeBounds(double hlenghtx, double hlenghty, double hlengthz);
-
- /**Copy Constructor */
- CuboidVolumeBounds(const CuboidVolumeBounds& bobo);
-
- /**Destructor */
- virtual ~CuboidVolumeBounds();
-
- /**Assignment operator*/
- CuboidVolumeBounds& operator=(const CuboidVolumeBounds& bobo);
-
- /**Virtual constructor */
- CuboidVolumeBounds* clone() const override;
-
- /**This method checks if position in the 3D volume frame is inside the cylinder*/
- bool inside(const Vector3D& , double tol=0.) const override;
-
- /** Method to decompose the Bounds into boundarySurfaces */
- const std::vector<const Acts::Surface*>* decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
-
- /**This method returns the halflength in local x*/
- double halflengthX() const;
-
- /**This method returns the halflength in local y*/
- double halflengthY() const;
-
- /**This method returns the halflength in local z*/
- double halflengthZ() const;
-
- /** Output Method for std::ostream */
- std::ostream& dump(std::ostream& sl) const override;
-
- private:
- /** Templated dumpT method */
- template <class T> T& dumpT(T& dt) const;
-
- /** This method returns the associated RecantleBounds of the face PlaneSurface parallel to local xy plane */
- RectangleBounds* faceXYRectangleBounds() const;
-
- /** This method returns the associated RecantleBounds of the face PlaneSurface parallel to local yz plane */
- RectangleBounds* faceYZRectangleBounds() const;
-
- /** This method returns the associated RecantleBounds of the face PlaneSurface parallel to local zx plane */
- RectangleBounds* faceZXRectangleBounds() const;
-
- /** The bound values */
- std::vector<TDD_real_t> m_boundValues;
-
- };
-
- inline CuboidVolumeBounds* CuboidVolumeBounds::clone() const
- { return new CuboidVolumeBounds(*this); }
-
- inline bool CuboidVolumeBounds::inside(const Vector3D &pos, double tol) const
- {
- return (fabs(pos.x())<=m_boundValues.at(bv_halfX)+tol && fabs(pos.y())<=m_boundValues.at(bv_halfY)+tol && fabs(pos.z())<=m_boundValues.at(bv_halfZ)+tol);
- }
+class RectangleBounds;
+class Volume;
+class Surface;
+
+/**
+ @class CuboidVolumeBounds
+
+ Bounds for a cubical Volume, the decomposeToSurfaces method creates a
+ vector of 6 surfaces:
+
+ BoundarySurfaceFace [index]:
+
+ - negativeFaceXY [0] : Rectangular Acts::PlaneSurface, parallel to \f$ xy
+ \f$ plane at negative \f$ z \f$
+ - positiveFaceXY [1] : Rectangular Acts::PlaneSurface, parallel to \f$ xy
+ \f$ plane at positive \f$ z \f$
+ - negativeFaceXY [2] : Rectangular Acts::PlaneSurface, attached to \f$ yz
+ \f$ plane at negative \f$ x \f$
+ - positiveFaceXY [3] : Rectangular Acts::PlaneSurface, attached to \f$ yz
+ \f$ plane at negative \f$ x \f$
+ - negativeFaceXY [4] : Rectangular Acts::PlaneSurface, parallel to \f$ zx
+ \f$ plane at negative \f$ y \f$
+ - positiveFaceXY [5] : Rectangular Acts::PlaneSurface, parallel to \f$ zx
+ \f$ plane at positive \f$ y \f$
+
+ @image html CuboidVolumeBounds_decomp.gif
+
+ */
+
+class CuboidVolumeBounds : public VolumeBounds
+{
+public:
+ /** @enum BoundValues for readability */
+ enum BoundValues { bv_halfX = 0, bv_halfY = 1, bv_halfZ = 2, bv_length = 3 };
+
+ /**Default Constructor*/
+ CuboidVolumeBounds();
+
+ /**Constructor - the box boundaries */
+ CuboidVolumeBounds(double hlenghtx, double hlenghty, double hlengthz);
+
+ /**Copy Constructor */
+ CuboidVolumeBounds(const CuboidVolumeBounds& bobo);
+
+ /**Destructor */
+ virtual ~CuboidVolumeBounds();
+
+ /**Assignment operator*/
+ CuboidVolumeBounds&
+ operator=(const CuboidVolumeBounds& bobo);
+
+ /**Virtual constructor */
+ CuboidVolumeBounds*
+ clone() const override;
+
+ /**This method checks if position in the 3D volume frame is inside the
+ * cylinder*/
+ bool
+ inside(const Vector3D&, double tol = 0.) const override;
+
+ /** Method to decompose the Bounds into boundarySurfaces */
+ const std::vector<const Acts::Surface*>*
+ decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
+
+ /**This method returns the halflength in local x*/
+ double
+ halflengthX() const;
+
+ /**This method returns the halflength in local y*/
+ double
+ halflengthY() const;
+
+ /**This method returns the halflength in local z*/
+ double
+ halflengthZ() const;
+
+ /** Output Method for std::ostream */
+ std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ /** Templated dumpT method */
+ template <class T>
+ T&
+ dumpT(T& dt) const;
+
+ /** This method returns the associated RecantleBounds of the face PlaneSurface
+ * parallel to local xy plane */
+ RectangleBounds*
+ faceXYRectangleBounds() const;
+
+ /** This method returns the associated RecantleBounds of the face PlaneSurface
+ * parallel to local yz plane */
+ RectangleBounds*
+ faceYZRectangleBounds() const;
+
+ /** This method returns the associated RecantleBounds of the face PlaneSurface
+ * parallel to local zx plane */
+ RectangleBounds*
+ faceZXRectangleBounds() const;
+
+ /** The bound values */
+ std::vector<TDD_real_t> m_boundValues;
+};
+
+inline CuboidVolumeBounds*
+CuboidVolumeBounds::clone() const
+{
+ return new CuboidVolumeBounds(*this);
+}
- inline double CuboidVolumeBounds::halflengthX() const { return m_boundValues.at(bv_halfX); }
+inline bool
+CuboidVolumeBounds::inside(const Vector3D& pos, double tol) const
+{
+ return (fabs(pos.x()) <= m_boundValues.at(bv_halfX) + tol
+ && fabs(pos.y()) <= m_boundValues.at(bv_halfY) + tol
+ && fabs(pos.z()) <= m_boundValues.at(bv_halfZ) + tol);
+}
- inline double CuboidVolumeBounds::halflengthY() const { return m_boundValues.at(bv_halfY); }
+inline double
+CuboidVolumeBounds::halflengthX() const
+{
+ return m_boundValues.at(bv_halfX);
+}
- inline double CuboidVolumeBounds::halflengthZ() const { return m_boundValues.at(bv_halfZ); }
+inline double
+CuboidVolumeBounds::halflengthY() const
+{
+ return m_boundValues.at(bv_halfY);
+}
- template <class T> T& CuboidVolumeBounds::dumpT(T& dt) const
- {
- dt << std::setiosflags(std::ios::fixed);
- dt << std::setprecision(7);
- dt << "Acts::CuboidVolumeBounds: (halfX, halfY, halfZ) = ";
- dt << "(" << m_boundValues.at(bv_halfX) << ", " << m_boundValues.at(bv_halfY) << ", " << m_boundValues.at(bv_halfZ) << ")";
- return dt;
- }
+inline double
+CuboidVolumeBounds::halflengthZ() const
+{
+ return m_boundValues.at(bv_halfZ);
+}
+template <class T>
+T&
+CuboidVolumeBounds::dumpT(T& dt) const
+{
+ dt << std::setiosflags(std::ios::fixed);
+ dt << std::setprecision(7);
+ dt << "Acts::CuboidVolumeBounds: (halfX, halfY, halfZ) = ";
+ dt << "(" << m_boundValues.at(bv_halfX) << ", " << m_boundValues.at(bv_halfY)
+ << ", " << m_boundValues.at(bv_halfZ) << ")";
+ return dt;
+}
}
-#endif // ACTS_VOLUMES_BOXVOLUMESBOUNDS_H
+#endif // ACTS_VOLUMES_BOXVOLUMESBOUNDS_H
diff --git a/Core/include/ACTS/Volumes/CylinderVolumeBounds.hpp b/Core/include/ACTS/Volumes/CylinderVolumeBounds.hpp
index 4c25bdbc3..3c394acf9 100644
--- a/Core/include/ACTS/Volumes/CylinderVolumeBounds.hpp
+++ b/Core/include/ACTS/Volumes/CylinderVolumeBounds.hpp
@@ -18,193 +18,261 @@
namespace Acts {
- class Surface;
- class RadialBounds;
- class CylinderBounds;
- class RectangleBounds;
-
- /**
- @class CylinderVolumeBounds
-
- Bounds for a cylindrical Volume, the decomposeToSurfaces method creates a
- vector of up to 6 surfaces:
-
- case A) 3 Surfaces (full cylindrical tube):
- BoundarySurfaceFace [index]:
- - negativeFaceXY [0] : Acts::DiscSurface with \f$ r_{inner}=0 \f$,
- parallel to \f$ xy \f$ plane at negative \f$ z \f$
- - positiveFaceXY [1] : Acts::DiscSurface with \f$ r_{inner}=0 \f$,
- parallel to \f$ xy \f$ plane at positive \f$ z \f$
- - cylinderCover [2] : Acts::CylinderSurface confining the Acts::Volume
-
- case B) 4 Surfaces (tube with inner and outer radius):
- BoundarySurfaceFace [index]:
- - negativeFaceXY [0] : Acts::DiscSurface with \f$ r_{inner}>0 \f$,
- parallel to \f$ xy \f$ plane at negative \f$ z \f$
- - positiveFaceXY [1] : Acts::DiscSurface with \f$ r_{inner}>0 \f$,
- parallel to \f$ xy \f$ plane at positive \f$ z \f$
- - tubeOuterCover [2] : Acts::CylinderSurface with \f$ r = r_{outer} \f$
- - tubeInnerCover [3] : Acts::CylinderSurface with \f$ r = r_{inner} \f$
-
- case C) 6 Surfaces (sectoral tube with inner and outer radius):
- BoundarySurfaceFace [index]:
- - negativeFaceXY [0] : Acts::DiscSurface with \f$ r_{inner}>0 \f$ and \f$ \phi < \pi \f$,
- parallel to \f$ xy \f$ plane at negative \f$ z \f$
- - positiveFaceXY [1] : Acts::DiscSurface with \f$ r_{inner}>0 \f$ and \f$ \phi < \pi \f$,
- parallel to \f$ xy \f$ plane at positive \f$ z \f$
- - tubeSectorOuterCover [2] : Acts::CylinderSurface with \f$ r = r_{outer} \f$
- - tubeSectorInnerCover [3] : Acts::CylinderSurface with \f$ r = r_{inner} \f$
- - tubeSectorNegativePhi [4] : Rectangular Acts::PlaneSurface attached to [0] and [1] at negative \f$ \phi \f$
- - tubeSectorNegativePhi [5] : Rectangular Acts::PlaneSurface attached to [0] and [1] at positive \f$ \phi \f$
-
- @image html CylinderVolumeBounds_decomp.gif
-
- */
-
- class CylinderVolumeBounds : public VolumeBounds {
-
- public:
-
- /** @enum BoundValues for readability */
- enum BoundValues {
- bv_innerRadius = 0,
- bv_outerRadius = 1,
- bv_halfPhiSector = 2,
- bv_halfZ = 3,
- bv_length = 4
- };
-
- /**Default Constructor*/
- CylinderVolumeBounds();
-
- /**Constructor - full cylinder */
- CylinderVolumeBounds(double radius, double halez);
-
- /**Constructor - extruded cylinder */
- CylinderVolumeBounds(double rinner, double router, double halez);
-
- /**Constructor - extruded cylinder segment */
- CylinderVolumeBounds(double rinner, double router, double halfPhiSector, double halez);
-
- /**Copy Constructor */
- CylinderVolumeBounds(const CylinderVolumeBounds& cylbo);
-
- /**Destructor */
- virtual ~CylinderVolumeBounds();
-
- /**Assignment operator*/
- CylinderVolumeBounds& operator=(const CylinderVolumeBounds& cylbo);
-
- /**Virtual constructor */
- CylinderVolumeBounds* clone() const override;
-
- /**This method checks if position in the 3D volume frame is inside the cylinder*/
- bool inside(const Vector3D& , double tol=0.) const override;
-
- /** Method to decompose the Bounds into boundarySurfaces */
- const std::vector<const Acts::Surface*>* decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
-
- /** Binning offset - overloaded for some R-binning types */
- virtual Vector3D binningOffset(BinningValue bValue) const override;
-
- /** Binning borders in double */
- virtual double binningBorder(BinningValue bValue) const override;
-
-
- /**This method returns the inner radius*/
- double innerRadius() const;
-
- /**This method returns the outer radius*/
- double outerRadius() const;
-
- /**This method returns the medium radius*/
- double mediumRadius() const;
-
- /**This method returns the delta radius*/
- double deltaRadius() const;
-
- /**This method returns the halfPhiSector angle*/
- double halfPhiSector() const;
-
- /**This method returns the halflengthZ*/
- double halflengthZ() const;
-
- /** Output Method for std::ostream */
- std::ostream& dump(std::ostream& sl) const override;
-
- private:
- /** templated dumpT method */
- template <class T> T& dumpT(T& t) const;
-
- /** This method returns the associated CylinderBounds of the inner CylinderSurfaces. */
- CylinderBounds* innerCylinderBounds() const;
-
- /** This method returns the associated CylinderBounds of the outer CylinderSurfaces. */
- CylinderBounds* outerCylinderBounds() const;
-
- /** This method returns the associated RadialBounds for the bottom/top DiscSurface. */
- RadialBounds* discBounds() const;
-
- /** This method returns the associated PlaneBounds limiting a sectoral CylinderVolume. */
- RectangleBounds* sectorPlaneBounds() const;
-
- /** The internal version of the bounds can be float/double*/
- std::vector<TDD_real_t> m_boundValues;
-
- /** numerical stability */
- static double s_numericalStable;
-
- };
-
- inline CylinderVolumeBounds* CylinderVolumeBounds::clone() const
- { return new CylinderVolumeBounds(*this); }
-
- inline bool CylinderVolumeBounds::inside(const Vector3D &pos, double tol) const
- {
- double ros = pos.perp();
- bool insidePhi = cos(pos.phi()) >= cos(m_boundValues[bv_halfPhiSector]) - tol;
- bool insideR = insidePhi ? ((ros >= m_boundValues[bv_innerRadius] - tol ) && (ros <= m_boundValues[bv_outerRadius] + tol)) : false;
- bool insideZ = insideR ? (fabs(pos.z()) <= m_boundValues[bv_halfZ] + tol ) : false ;
- return (insideZ && insideR && insidePhi);
- }
+class Surface;
+class RadialBounds;
+class CylinderBounds;
+class RectangleBounds;
+
+/**
+ @class CylinderVolumeBounds
+
+ Bounds for a cylindrical Volume, the decomposeToSurfaces method creates a
+ vector of up to 6 surfaces:
+
+ case A) 3 Surfaces (full cylindrical tube):
+ BoundarySurfaceFace [index]:
+ - negativeFaceXY [0] : Acts::DiscSurface with \f$ r_{inner}=0 \f$,
+ parallel to \f$ xy \f$ plane at negative \f$ z \f$
+ - positiveFaceXY [1] : Acts::DiscSurface with \f$ r_{inner}=0 \f$,
+ parallel to \f$ xy \f$ plane at positive \f$ z \f$
+ - cylinderCover [2] : Acts::CylinderSurface confining the Acts::Volume
+
+ case B) 4 Surfaces (tube with inner and outer radius):
+ BoundarySurfaceFace [index]:
+ - negativeFaceXY [0] : Acts::DiscSurface with \f$ r_{inner}>0 \f$,
+ parallel to \f$ xy \f$ plane at negative \f$ z \f$
+ - positiveFaceXY [1] : Acts::DiscSurface with \f$ r_{inner}>0 \f$,
+ parallel to \f$ xy \f$ plane at positive \f$ z \f$
+ - tubeOuterCover [2] : Acts::CylinderSurface with \f$ r = r_{outer} \f$
+ - tubeInnerCover [3] : Acts::CylinderSurface with \f$ r = r_{inner} \f$
+
+ case C) 6 Surfaces (sectoral tube with inner and outer radius):
+ BoundarySurfaceFace [index]:
+ - negativeFaceXY [0] : Acts::DiscSurface with \f$ r_{inner}>0 \f$
+ and \f$ \phi < \pi \f$,
+ parallel to \f$ xy \f$ plane at negative \f$
+ z \f$
+ - positiveFaceXY [1] : Acts::DiscSurface with \f$ r_{inner}>0 \f$
+ and \f$ \phi < \pi \f$,
+ parallel to \f$ xy \f$ plane at positive \f$
+ z \f$
+ - tubeSectorOuterCover [2] : Acts::CylinderSurface with \f$ r = r_{outer}
+ \f$
+ - tubeSectorInnerCover [3] : Acts::CylinderSurface with \f$ r = r_{inner}
+ \f$
+ - tubeSectorNegativePhi [4] : Rectangular Acts::PlaneSurface attached to
+ [0] and [1] at negative \f$ \phi \f$
+ - tubeSectorNegativePhi [5] : Rectangular Acts::PlaneSurface attached to
+ [0] and [1] at positive \f$ \phi \f$
+
+ @image html CylinderVolumeBounds_decomp.gif
+
+ */
+
+class CylinderVolumeBounds : public VolumeBounds
+{
+public:
+ /** @enum BoundValues for readability */
+ enum BoundValues {
+ bv_innerRadius = 0,
+ bv_outerRadius = 1,
+ bv_halfPhiSector = 2,
+ bv_halfZ = 3,
+ bv_length = 4
+ };
+
+ /**Default Constructor*/
+ CylinderVolumeBounds();
+
+ /**Constructor - full cylinder */
+ CylinderVolumeBounds(double radius, double halez);
+
+ /**Constructor - extruded cylinder */
+ CylinderVolumeBounds(double rinner, double router, double halez);
+
+ /**Constructor - extruded cylinder segment */
+ CylinderVolumeBounds(double rinner,
+ double router,
+ double halfPhiSector,
+ double halez);
+
+ /**Copy Constructor */
+ CylinderVolumeBounds(const CylinderVolumeBounds& cylbo);
+
+ /**Destructor */
+ virtual ~CylinderVolumeBounds();
+
+ /**Assignment operator*/
+ CylinderVolumeBounds&
+ operator=(const CylinderVolumeBounds& cylbo);
+
+ /**Virtual constructor */
+ CylinderVolumeBounds*
+ clone() const override;
+
+ /**This method checks if position in the 3D volume frame is inside the
+ * cylinder*/
+ bool
+ inside(const Vector3D&, double tol = 0.) const override;
+
+ /** Method to decompose the Bounds into boundarySurfaces */
+ const std::vector<const Acts::Surface*>*
+ decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
+
+ /** Binning offset - overloaded for some R-binning types */
+ virtual Vector3D
+ binningOffset(BinningValue bValue) const override;
+
+ /** Binning borders in double */
+ virtual double
+ binningBorder(BinningValue bValue) const override;
+
+ /**This method returns the inner radius*/
+ double
+ innerRadius() const;
+
+ /**This method returns the outer radius*/
+ double
+ outerRadius() const;
+
+ /**This method returns the medium radius*/
+ double
+ mediumRadius() const;
+
+ /**This method returns the delta radius*/
+ double
+ deltaRadius() const;
+
+ /**This method returns the halfPhiSector angle*/
+ double
+ halfPhiSector() const;
+
+ /**This method returns the halflengthZ*/
+ double
+ halflengthZ() const;
+
+ /** Output Method for std::ostream */
+ std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ /** templated dumpT method */
+ template <class T>
+ T&
+ dumpT(T& t) const;
+
+ /** This method returns the associated CylinderBounds of the inner
+ * CylinderSurfaces. */
+ CylinderBounds*
+ innerCylinderBounds() const;
+
+ /** This method returns the associated CylinderBounds of the outer
+ * CylinderSurfaces. */
+ CylinderBounds*
+ outerCylinderBounds() const;
+
+ /** This method returns the associated RadialBounds for the bottom/top
+ * DiscSurface. */
+ RadialBounds*
+ discBounds() const;
+
+ /** This method returns the associated PlaneBounds limiting a sectoral
+ * CylinderVolume. */
+ RectangleBounds*
+ sectorPlaneBounds() const;
+
+ /** The internal version of the bounds can be float/double*/
+ std::vector<TDD_real_t> m_boundValues;
+
+ /** numerical stability */
+ static double s_numericalStable;
+};
+
+inline CylinderVolumeBounds*
+CylinderVolumeBounds::clone() const
+{
+ return new CylinderVolumeBounds(*this);
+}
- inline Vector3D CylinderVolumeBounds::binningOffset(BinningValue bValue) const
- { // the medium radius is taken for r-type binning
- if (bValue == Acts::binR || bValue == Acts::binRPhi)
- return Vector3D(mediumRadius(),0.,0.);
- return VolumeBounds::binningOffset(bValue);
- }
+inline bool
+CylinderVolumeBounds::inside(const Vector3D& pos, double tol) const
+{
+ double ros = pos.perp();
+ bool insidePhi = cos(pos.phi()) >= cos(m_boundValues[bv_halfPhiSector]) - tol;
+ bool insideR = insidePhi ? ((ros >= m_boundValues[bv_innerRadius] - tol)
+ && (ros <= m_boundValues[bv_outerRadius] + tol))
+ : false;
+ bool insideZ
+ = insideR ? (fabs(pos.z()) <= m_boundValues[bv_halfZ] + tol) : false;
+ return (insideZ && insideR && insidePhi);
+}
- inline double CylinderVolumeBounds::binningBorder(BinningValue bValue) const
- { // the medium radius is taken for r-type binning
- if (bValue == Acts::binR)
- return 0.5*deltaRadius();
- if (bValue == Acts::binZ)
- return halflengthZ();
- return VolumeBounds::binningBorder(bValue);
- }
+inline Vector3D
+CylinderVolumeBounds::binningOffset(BinningValue bValue) const
+{ // the medium radius is taken for r-type binning
+ if (bValue == Acts::binR || bValue == Acts::binRPhi)
+ return Vector3D(mediumRadius(), 0., 0.);
+ return VolumeBounds::binningOffset(bValue);
+}
- inline double CylinderVolumeBounds::innerRadius() const { return m_boundValues.at(bv_innerRadius); }
+inline double
+CylinderVolumeBounds::binningBorder(BinningValue bValue) const
+{ // the medium radius is taken for r-type binning
+ if (bValue == Acts::binR) return 0.5 * deltaRadius();
+ if (bValue == Acts::binZ) return halflengthZ();
+ return VolumeBounds::binningBorder(bValue);
+}
- inline double CylinderVolumeBounds::outerRadius() const { return m_boundValues.at(bv_outerRadius); }
+inline double
+CylinderVolumeBounds::innerRadius() const
+{
+ return m_boundValues.at(bv_innerRadius);
+}
- inline double CylinderVolumeBounds::mediumRadius() const { return 0.5*(m_boundValues.at(bv_innerRadius)+m_boundValues.at(bv_outerRadius)); }
+inline double
+CylinderVolumeBounds::outerRadius() const
+{
+ return m_boundValues.at(bv_outerRadius);
+}
- inline double CylinderVolumeBounds::deltaRadius() const { return (m_boundValues.at(bv_outerRadius)-m_boundValues.at(bv_innerRadius)); }
+inline double
+CylinderVolumeBounds::mediumRadius() const
+{
+ return 0.5
+ * (m_boundValues.at(bv_innerRadius) + m_boundValues.at(bv_outerRadius));
+}
- inline double CylinderVolumeBounds::halfPhiSector() const { return m_boundValues.at(bv_halfPhiSector); }
+inline double
+CylinderVolumeBounds::deltaRadius() const
+{
+ return (m_boundValues.at(bv_outerRadius) - m_boundValues.at(bv_innerRadius));
+}
- inline double CylinderVolumeBounds::halflengthZ() const { return m_boundValues.at(bv_halfZ); }
+inline double
+CylinderVolumeBounds::halfPhiSector() const
+{
+ return m_boundValues.at(bv_halfPhiSector);
+}
- template <class T> T& CylinderVolumeBounds::dumpT(T& tstream) const
- {
- tstream << std::setiosflags(std::ios::fixed);
- tstream << std::setprecision(2);
- tstream << "Acts::CylinderVolumeBounds: (rMin, rMax, halfPhi, halfZ) = ";
- tstream << m_boundValues.at(bv_innerRadius) << ", " << m_boundValues.at(bv_outerRadius) << ", " << m_boundValues.at(bv_halfPhiSector) << ", " << m_boundValues.at(bv_halfZ);
- return tstream;
- }
+inline double
+CylinderVolumeBounds::halflengthZ() const
+{
+ return m_boundValues.at(bv_halfZ);
+}
+template <class T>
+T&
+CylinderVolumeBounds::dumpT(T& tstream) const
+{
+ tstream << std::setiosflags(std::ios::fixed);
+ tstream << std::setprecision(2);
+ tstream << "Acts::CylinderVolumeBounds: (rMin, rMax, halfPhi, halfZ) = ";
+ tstream << m_boundValues.at(bv_innerRadius) << ", "
+ << m_boundValues.at(bv_outerRadius) << ", "
+ << m_boundValues.at(bv_halfPhiSector) << ", "
+ << m_boundValues.at(bv_halfZ);
+ return tstream;
+}
}
-#endif // ACTS_VOLUMES_CYLINDERVOLUMESBOUNDS_H
+#endif // ACTS_VOLUMES_CYLINDERVOLUMESBOUNDS_H
diff --git a/Core/include/ACTS/Volumes/DoubleTrapezoidVolumeBounds.hpp b/Core/include/ACTS/Volumes/DoubleTrapezoidVolumeBounds.hpp
index 27b9f4a03..2db85fccf 100644
--- a/Core/include/ACTS/Volumes/DoubleTrapezoidVolumeBounds.hpp
+++ b/Core/include/ACTS/Volumes/DoubleTrapezoidVolumeBounds.hpp
@@ -18,161 +18,242 @@
namespace Acts {
- class Surface;
- class RectangleBounds;
- class TrapezoidBounds;
- class DiamondBounds;
-
- /**
- @class DoubleTrapezoidVolumeBounds
-
- Bounds for a double trapezoidal shaped Volume, the decomposeToSurfaces method creates a
- vector of 8 surfaces:
-
- BoundarySurfaceFace [index]:
-
- - negativeFaceXY [0] : Diamond Acts::PlaneSurface,
- parallel to \f$ xy \f$ plane at negative \f$ z \f$
- - positiveFaceXY [1] : Diamond Acts::PlaneSurface,
- parallel to \f$ xy \f$ plane at positive \f$ z \f$
- - trapezoidFaceAlpha1 [2] : Rectangular Acts::PlaneSurface,
- attached to [0] and [1] at negative \f$ x \f$ (associated to alpha1)
- - trapezoidFaceBeta1 [3] : Rectangular Acts::PlaneSurface,
- attached to [0] and [1] at positive \f$ x \f$ (associated to beta1)
- - trapezoidFaceAlpha2 [5] : Rectangular Acts::PlaneSurface,
- attached to [0] and [1] at negative \f$ x \f$ (associated to alpha2)
- - trapezoidFaceBeta2 [6] : Rectangular Acts::PlaneSurface,
- attached to [0] and [1] at positive \f$ x \f$ (associated to beta2)
- - negativeFaceZX [4] : Rectangular Acts::PlaneSurface,
- parallel to \f$ zx \f$ plane at negative \f$ y \f$
- - positiveFaceZX [5] : Rectangular Acts::PlaneSurface,
- parallel to \f$ zx \f$ plane at positive \f$ y \f$
-
- @image html DoubleTrapezoidVolumeBounds_decomp.gif
-
- */
-
- class DoubleTrapezoidVolumeBounds : public VolumeBounds {
-
- public:
- /** @enum BoundValues for readability */
- enum BoundValues {
- bv_minHalfX = 0,
- bv_medHalfX = 1,
- bv_maxHalfX = 2,
- bv_halfY1 = 3,
- bv_halfY2 = 4,
- bv_halfZ = 5,
- bv_alpha1 = 6,
- bv_alpha2 = 7,
- bv_length = 8
- };
-
- /**Default Constructor*/
- DoubleTrapezoidVolumeBounds();
-
- /**Constructor - the double trapezoid boundaries (symmetric trapezoid/diamond) */
- DoubleTrapezoidVolumeBounds(double minhlenghtx, double medhlengthx, double maxhlengthx, double hlenghty1, double hlenghty2, double hlengthz);
-
- /**Copy Constructor */
- DoubleTrapezoidVolumeBounds(const DoubleTrapezoidVolumeBounds& bobo);
-
- /**Destructor */
- virtual ~DoubleTrapezoidVolumeBounds();
-
- /**Assignment operator*/
- DoubleTrapezoidVolumeBounds& operator=(const DoubleTrapezoidVolumeBounds& bobo);
-
- /**Virtual constructor */
- DoubleTrapezoidVolumeBounds* clone() const override;
-
- /**This method checks if position in the 3D volume frame is inside the cylinder*/
- bool inside(const Vector3D& , double tol=0.) const override;
-
- /** Method to decompose the Bounds into Surfaces */
- const std::vector<const Acts::Surface*>* decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
-
- /**This method returns the X halflength at minimal Y*/
- double minHalflengthX() const;
-
- /**This method returns the (maximal) halflength in local x*/
- double medHalflengthX() const;
-
- /**This method returns the X halflength at maximal Y (local coordinates)*/
- double maxHalflengthX() const;
-
- /**This method returns the halflength1 in local y*/
- double halflengthY1() const;
-
- /**This method returns the halflength2 in local y*/
- double halflengthY2() const;
-
- /**This method returns the halflength in local z*/
- double halflengthZ() const;
-
- /**This method returns the opening angle in point A (negative local x)*/
- double alpha1() const;
-
- /**This method returns the opening angle in point A' (negative local x)*/
- double alpha2() const;
-
- /** Output Method for std::ostream */
- std::ostream& dump(std::ostream& sl) const override;
-
- private:
- template <class T> T& dumpT(T& dT) const;
-
-
- /** This method returns the associated DoubleTrapezoidBounds of the face PlaneSurface parallel to local xy plane */
- DiamondBounds* faceXYDiamondBounds() const;
-
- /** This method returns the associated RecantleBounds of the face PlaneSurface attached to alpha (negative local x)*/
- RectangleBounds* faceAlpha1RectangleBounds() const;
- RectangleBounds* faceAlpha2RectangleBounds() const;
-
- /** This method returns the associated RecantleBounds of the face PlaneSurface attached to beta (positive local x)*/
- RectangleBounds* faceBeta1RectangleBounds() const;
- RectangleBounds* faceBeta2RectangleBounds() const;
-
- /** This method returns the associated RecantleBounds of the face PlaneSurface parallel to local zx plane, negative local y */
- RectangleBounds* faceZXRectangleBoundsBottom() const;
-
- /** This method returns the associated RecantleBounds of the face PlaneSurface parallel to local zx plane, positive local y */
- RectangleBounds* faceZXRectangleBoundsTop() const;
-
- std::vector<TDD_real_t> m_boundValues;
-
- };
-
- inline DoubleTrapezoidVolumeBounds* DoubleTrapezoidVolumeBounds::clone() const
- { return new DoubleTrapezoidVolumeBounds(*this); }
-
- inline double DoubleTrapezoidVolumeBounds::minHalflengthX() const { return m_boundValues.at(bv_minHalfX); }
+class Surface;
+class RectangleBounds;
+class TrapezoidBounds;
+class DiamondBounds;
+
+/**
+ @class DoubleTrapezoidVolumeBounds
+
+ Bounds for a double trapezoidal shaped Volume, the decomposeToSurfaces method
+ creates a
+ vector of 8 surfaces:
+
+ BoundarySurfaceFace [index]:
+
+ - negativeFaceXY [0] : Diamond Acts::PlaneSurface,
+ parallel to \f$ xy \f$ plane at negative \f$ z
+ \f$
+ - positiveFaceXY [1] : Diamond Acts::PlaneSurface,
+ parallel to \f$ xy \f$ plane at positive \f$ z
+ \f$
+ - trapezoidFaceAlpha1 [2] : Rectangular Acts::PlaneSurface,
+ attached to [0] and [1] at negative \f$ x \f$
+ (associated to alpha1)
+ - trapezoidFaceBeta1 [3] : Rectangular Acts::PlaneSurface,
+ attached to [0] and [1] at positive \f$ x \f$
+ (associated to beta1)
+ - trapezoidFaceAlpha2 [5] : Rectangular Acts::PlaneSurface,
+ attached to [0] and [1] at negative \f$ x \f$
+ (associated to alpha2)
+ - trapezoidFaceBeta2 [6] : Rectangular Acts::PlaneSurface,
+ attached to [0] and [1] at positive \f$ x \f$
+ (associated to beta2)
+ - negativeFaceZX [4] : Rectangular Acts::PlaneSurface,
+ parallel to \f$ zx \f$ plane at negative \f$ y
+ \f$
+ - positiveFaceZX [5] : Rectangular Acts::PlaneSurface,
+ parallel to \f$ zx \f$ plane at positive \f$ y
+ \f$
+
+ @image html DoubleTrapezoidVolumeBounds_decomp.gif
+
+ */
+
+class DoubleTrapezoidVolumeBounds : public VolumeBounds
+{
+public:
+ /** @enum BoundValues for readability */
+ enum BoundValues {
+ bv_minHalfX = 0,
+ bv_medHalfX = 1,
+ bv_maxHalfX = 2,
+ bv_halfY1 = 3,
+ bv_halfY2 = 4,
+ bv_halfZ = 5,
+ bv_alpha1 = 6,
+ bv_alpha2 = 7,
+ bv_length = 8
+ };
+
+ /**Default Constructor*/
+ DoubleTrapezoidVolumeBounds();
+
+ /**Constructor - the double trapezoid boundaries (symmetric trapezoid/diamond)
+ */
+ DoubleTrapezoidVolumeBounds(double minhlenghtx,
+ double medhlengthx,
+ double maxhlengthx,
+ double hlenghty1,
+ double hlenghty2,
+ double hlengthz);
+
+ /**Copy Constructor */
+ DoubleTrapezoidVolumeBounds(const DoubleTrapezoidVolumeBounds& bobo);
+
+ /**Destructor */
+ virtual ~DoubleTrapezoidVolumeBounds();
+
+ /**Assignment operator*/
+ DoubleTrapezoidVolumeBounds&
+ operator=(const DoubleTrapezoidVolumeBounds& bobo);
+
+ /**Virtual constructor */
+ DoubleTrapezoidVolumeBounds*
+ clone() const override;
+
+ /**This method checks if position in the 3D volume frame is inside the
+ * cylinder*/
+ bool
+ inside(const Vector3D&, double tol = 0.) const override;
+
+ /** Method to decompose the Bounds into Surfaces */
+ const std::vector<const Acts::Surface*>*
+ decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
+
+ /**This method returns the X halflength at minimal Y*/
+ double
+ minHalflengthX() const;
+
+ /**This method returns the (maximal) halflength in local x*/
+ double
+ medHalflengthX() const;
+
+ /**This method returns the X halflength at maximal Y (local coordinates)*/
+ double
+ maxHalflengthX() const;
+
+ /**This method returns the halflength1 in local y*/
+ double
+ halflengthY1() const;
+
+ /**This method returns the halflength2 in local y*/
+ double
+ halflengthY2() const;
+
+ /**This method returns the halflength in local z*/
+ double
+ halflengthZ() const;
+
+ /**This method returns the opening angle in point A (negative local x)*/
+ double
+ alpha1() const;
+
+ /**This method returns the opening angle in point A' (negative local x)*/
+ double
+ alpha2() const;
+
+ /** Output Method for std::ostream */
+ std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ template <class T>
+ T&
+ dumpT(T& dT) const;
+
+ /** This method returns the associated DoubleTrapezoidBounds of the face
+ * PlaneSurface parallel to local xy plane */
+ DiamondBounds*
+ faceXYDiamondBounds() const;
+
+ /** This method returns the associated RecantleBounds of the face PlaneSurface
+ * attached to alpha (negative local x)*/
+ RectangleBounds*
+ faceAlpha1RectangleBounds() const;
+ RectangleBounds*
+ faceAlpha2RectangleBounds() const;
+
+ /** This method returns the associated RecantleBounds of the face PlaneSurface
+ * attached to beta (positive local x)*/
+ RectangleBounds*
+ faceBeta1RectangleBounds() const;
+ RectangleBounds*
+ faceBeta2RectangleBounds() const;
+
+ /** This method returns the associated RecantleBounds of the face PlaneSurface
+ * parallel to local zx plane, negative local y */
+ RectangleBounds*
+ faceZXRectangleBoundsBottom() const;
+
+ /** This method returns the associated RecantleBounds of the face PlaneSurface
+ * parallel to local zx plane, positive local y */
+ RectangleBounds*
+ faceZXRectangleBoundsTop() const;
+
+ std::vector<TDD_real_t> m_boundValues;
+};
+
+inline DoubleTrapezoidVolumeBounds*
+DoubleTrapezoidVolumeBounds::clone() const
+{
+ return new DoubleTrapezoidVolumeBounds(*this);
+}
- inline double DoubleTrapezoidVolumeBounds::medHalflengthX() const { return m_boundValues.at(bv_medHalfX); }
+inline double
+DoubleTrapezoidVolumeBounds::minHalflengthX() const
+{
+ return m_boundValues.at(bv_minHalfX);
+}
- inline double DoubleTrapezoidVolumeBounds::maxHalflengthX() const { return m_boundValues.at(bv_maxHalfX ); }
+inline double
+DoubleTrapezoidVolumeBounds::medHalflengthX() const
+{
+ return m_boundValues.at(bv_medHalfX);
+}
- inline double DoubleTrapezoidVolumeBounds::halflengthY1() const { return m_boundValues.at(bv_halfY1); }
+inline double
+DoubleTrapezoidVolumeBounds::maxHalflengthX() const
+{
+ return m_boundValues.at(bv_maxHalfX);
+}
- inline double DoubleTrapezoidVolumeBounds::halflengthY2() const { return m_boundValues.at(bv_halfY2); }
+inline double
+DoubleTrapezoidVolumeBounds::halflengthY1() const
+{
+ return m_boundValues.at(bv_halfY1);
+}
- inline double DoubleTrapezoidVolumeBounds::halflengthZ() const { return m_boundValues.at(bv_halfZ); }
+inline double
+DoubleTrapezoidVolumeBounds::halflengthY2() const
+{
+ return m_boundValues.at(bv_halfY2);
+}
- inline double DoubleTrapezoidVolumeBounds::alpha1() const { return m_boundValues.at(bv_alpha1); }
+inline double
+DoubleTrapezoidVolumeBounds::halflengthZ() const
+{
+ return m_boundValues.at(bv_halfZ);
+}
- inline double DoubleTrapezoidVolumeBounds::alpha2() const { return m_boundValues.at(bv_alpha2); }
+inline double
+DoubleTrapezoidVolumeBounds::alpha1() const
+{
+ return m_boundValues.at(bv_alpha1);
+}
- template <class T> T& DoubleTrapezoidVolumeBounds::dumpT(T& dT) const
- {
- dT << std::setiosflags(std::ios::fixed);
- dT << std::setprecision(7);
- dT << "Acts::DoubleTrapezoidVolumeBounds: (minhalfX, medhalfX, maxhalfX, halfY1, halfY2, halfZ) = ";
- dT << "(" << m_boundValues.at(bv_minHalfX) << ", " << m_boundValues.at(bv_medHalfX) << ", " << m_boundValues.at(bv_maxHalfX);
- dT << ", " << m_boundValues.at(bv_halfY1) <<", " << m_boundValues.at(bv_halfY2) << ", " << m_boundValues.at(bv_halfZ) << ")";
- return dT;
- }
+inline double
+DoubleTrapezoidVolumeBounds::alpha2() const
+{
+ return m_boundValues.at(bv_alpha2);
+}
+template <class T>
+T&
+DoubleTrapezoidVolumeBounds::dumpT(T& dT) const
+{
+ dT << std::setiosflags(std::ios::fixed);
+ dT << std::setprecision(7);
+ dT << "Acts::DoubleTrapezoidVolumeBounds: (minhalfX, medhalfX, maxhalfX, "
+ "halfY1, halfY2, halfZ) = ";
+ dT << "(" << m_boundValues.at(bv_minHalfX) << ", "
+ << m_boundValues.at(bv_medHalfX) << ", " << m_boundValues.at(bv_maxHalfX);
+ dT << ", " << m_boundValues.at(bv_halfY1) << ", "
+ << m_boundValues.at(bv_halfY2) << ", " << m_boundValues.at(bv_halfZ)
+ << ")";
+ return dT;
+}
}
-#endif // ACTS_VOLUMES_DOUBLETRAPEZOIDVOLUMESBOUNDS_H
+#endif // ACTS_VOLUMES_DOUBLETRAPEZOIDVOLUMESBOUNDS_H
diff --git a/Core/include/ACTS/Volumes/PrismVolumeBounds.hpp b/Core/include/ACTS/Volumes/PrismVolumeBounds.hpp
index c485da8eb..8458ba789 100644
--- a/Core/include/ACTS/Volumes/PrismVolumeBounds.hpp
+++ b/Core/include/ACTS/Volumes/PrismVolumeBounds.hpp
@@ -13,111 +13,137 @@
#ifndef ACTS_VOLUMES_PRISMVOLUMEBOUNDS_H
#define ACTS_VOLUMES_PRISMVOLUMEBOUNDS_H 1
-#include "ACTS/Volumes/VolumeBounds.hpp"
#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Volumes/VolumeBounds.hpp"
namespace Acts {
- class Surface;
- class PlaneSurface;
- class TriangleBounds;
-
- /**
- @class PrismVolumeBounds
-
- Bounds for the transcript of triangular prism
-
- BoundarySurfaceFace [index]:
-
- - negativeFaceXY [0] : Triangular Acts::PlaneSurface,
- parallel to \f$ xy \f$ plane at negative \f$ z \f$
- - positiveFaceXY [1] : Triangular Acts::PlaneSurface,
- parallel to \f$ xy \f$ plane at positive \f$ z \f$
- - face [2... n+1] : Rectangular Acts::PlaneSurface
+class Surface;
+class PlaneSurface;
+class TriangleBounds;
- */
+/**
+ @class PrismVolumeBounds
- class PrismVolumeBounds : public VolumeBounds {
+ Bounds for the transcript of triangular prism
- public:
- /**Default Constructor*/
- PrismVolumeBounds();
+ BoundarySurfaceFace [index]:
- /**Constructor - generic case (from float)*/
- PrismVolumeBounds(std::vector<std::pair<float,float> > xyvtx, float hlengthz);
+ - negativeFaceXY [0] : Triangular Acts::PlaneSurface,
+ parallel to \f$ xy \f$ plane at negative \f$ z
+ \f$
+ - positiveFaceXY [1] : Triangular Acts::PlaneSurface,
+ parallel to \f$ xy \f$ plane at positive \f$ z
+ \f$
+ - face [2... n+1] : Rectangular Acts::PlaneSurface
- /**Constructor - generic case from (double)*/
- PrismVolumeBounds(std::vector<std::pair<double,double> > xyvtx, double hlengthz);
+ */
- /**Copy Constructor */
- PrismVolumeBounds(const PrismVolumeBounds& bobo);
+class PrismVolumeBounds : public VolumeBounds
+{
+public:
+ /**Default Constructor*/
+ PrismVolumeBounds();
- /**Destructor */
- virtual ~PrismVolumeBounds();
+ /**Constructor - generic case (from float)*/
+ PrismVolumeBounds(std::vector<std::pair<float, float>> xyvtx, float hlengthz);
- /**Assignment operator*/
- PrismVolumeBounds& operator=(const PrismVolumeBounds& bobo);
+ /**Constructor - generic case from (double)*/
+ PrismVolumeBounds(std::vector<std::pair<double, double>> xyvtx,
+ double hlengthz);
- /**Virtual constructor */
- PrismVolumeBounds* clone() const override;
+ /**Copy Constructor */
+ PrismVolumeBounds(const PrismVolumeBounds& bobo);
- /**This method checks if position in the 3D volume frame is inside the volume*/
- bool inside(const Vector3D& , double tol=0.) const override;
+ /**Destructor */
+ virtual ~PrismVolumeBounds();
- /** Method to decompose the Bounds into Surfaces */
- const std::vector<const Surface*>* decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
+ /**Assignment operator*/
+ PrismVolumeBounds&
+ operator=(const PrismVolumeBounds& bobo);
- /**This method returns the set of xy generating vertices*/
- const std::vector<std::pair<TDD_real_t, TDD_real_t> > xyVertices() const;
+ /**Virtual constructor */
+ PrismVolumeBounds*
+ clone() const override;
- /**This method returns the halflength in local z*/
- double halflengthZ() const;
+ /**This method checks if position in the 3D volume frame is inside the
+ * volume*/
+ bool
+ inside(const Vector3D&, double tol = 0.) const override;
- /** Output Method for std::ostream */
- std::ostream& dump(std::ostream& sl) const override;
+ /** Method to decompose the Bounds into Surfaces */
+ const std::vector<const Surface*>*
+ decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
- private:
- /** templated dump method */
- template <class T> T& dumpT(T& dt) const;
+ /**This method returns the set of xy generating vertices*/
+ const std::vector<std::pair<TDD_real_t, TDD_real_t>>
+ xyVertices() const;
- /** method to construct side boundary planes */
- Acts::PlaneSurface* sideSurf(Transform3D,unsigned int,unsigned int) const;
+ /**This method returns the halflength in local z*/
+ double
+ halflengthZ() const;
- /** mirror the input vertices for down-side boundary */
- std::vector<std::pair<double,double> > mirror_xyVtx() const;
+ /** Output Method for std::ostream */
+ std::ostream&
+ dump(std::ostream& sl) const override;
- /** assess ordering of vertices */
- int ordering() const;
+private:
+ /** templated dump method */
+ template <class T>
+ T&
+ dumpT(T& dt) const;
- mutable std::vector<std::pair<TDD_real_t,TDD_real_t> > m_xyVtx; //!< generating xy vertices
- TDD_real_t m_halfZ; //!< halflength in z
+ /** method to construct side boundary planes */
+ Acts::PlaneSurface*
+ sideSurf(Transform3D, unsigned int, unsigned int) const;
- mutable Acts::TriangleBounds* m_baseBounds; //!< base xy bounds
- mutable int m_ordering; //!< cache vertex ordering
+ /** mirror the input vertices for down-side boundary */
+ std::vector<std::pair<double, double>>
+ mirror_xyVtx() const;
- };
+ /** assess ordering of vertices */
+ int
+ ordering() const;
- inline PrismVolumeBounds* PrismVolumeBounds::clone() const
- { return new PrismVolumeBounds(*this); }
+ mutable std::vector<std::pair<TDD_real_t, TDD_real_t>>
+ m_xyVtx; //!< generating xy vertices
+ TDD_real_t m_halfZ; //!< halflength in z
- inline const std::vector<std::pair<TDD_real_t,TDD_real_t> > PrismVolumeBounds::xyVertices() const { return m_xyVtx; }
+ mutable Acts::TriangleBounds* m_baseBounds; //!< base xy bounds
+ mutable int m_ordering; //!< cache vertex ordering
+};
- inline double PrismVolumeBounds::halflengthZ() const { return m_halfZ; }
-
- template <class T> T& PrismVolumeBounds::dumpT(T& dt) const
- {
+inline PrismVolumeBounds*
+PrismVolumeBounds::clone() const
+{
+ return new PrismVolumeBounds(*this);
+}
- dt << std::setiosflags(std::ios::fixed);
- dt << std::setprecision(7);
- dt << "Acts::PrismVolumeBounds: (halfZ, generating vtx) = ";
- dt << "( " << m_halfZ << ")";
- for (unsigned int i=0;i<m_xyVtx.size();i++)
- dt << "(" << m_xyVtx.at(i).first << ","<<m_xyVtx.at(i).second <<")";
- // return the modified stream
- return dt;
- }
+inline const std::vector<std::pair<TDD_real_t, TDD_real_t>>
+PrismVolumeBounds::xyVertices() const
+{
+ return m_xyVtx;
+}
+inline double
+PrismVolumeBounds::halflengthZ() const
+{
+ return m_halfZ;
}
-#endif // ACTS_VOLUMES_PRISMVOLUMEBOUNDS_H
+template <class T>
+T&
+PrismVolumeBounds::dumpT(T& dt) const
+{
+ dt << std::setiosflags(std::ios::fixed);
+ dt << std::setprecision(7);
+ dt << "Acts::PrismVolumeBounds: (halfZ, generating vtx) = ";
+ dt << "( " << m_halfZ << ")";
+ for (unsigned int i = 0; i < m_xyVtx.size(); i++)
+ dt << "(" << m_xyVtx.at(i).first << "," << m_xyVtx.at(i).second << ")";
+ // return the modified stream
+ return dt;
+}
+}
+#endif // ACTS_VOLUMES_PRISMVOLUMEBOUNDS_H
diff --git a/Core/include/ACTS/Volumes/SimplePolygonBrepVolumeBounds.hpp b/Core/include/ACTS/Volumes/SimplePolygonBrepVolumeBounds.hpp
index c4b7d1703..f584aca05 100644
--- a/Core/include/ACTS/Volumes/SimplePolygonBrepVolumeBounds.hpp
+++ b/Core/include/ACTS/Volumes/SimplePolygonBrepVolumeBounds.hpp
@@ -18,129 +18,185 @@
namespace Acts {
- class Surface;
- class PlaneSurface;
- class RectangleBounds;
-
-
- /**
- @class SimplePolygonBrepVolumeBounds
-
- Bounds for the exact transcript of the GeoSimplePolygonBrep; volume defined by combination of symm.trapezoids
-
- BoundarySurfaceFace [index]:
-
- - negativeFaceXY [0] : Acts::SubtractedPlaneSurface,
- parallel to \f$ xy \f$ plane at negative \f$ z \f$
- - positiveFaceXY [1] : Acts::SubtractedPlaneSurface,
- parallel to \f$ xy \f$ plane at positive \f$ z \f$
- - face [2... n+1] : Rectangular Acts::PlaneSurface
-
- */
-
- class SimplePolygonBrepVolumeBounds : public VolumeBounds {
-
- public:
- /**Default Constructor*/
- SimplePolygonBrepVolumeBounds();
-
- /**Constructor - generic case (from float)*/
- SimplePolygonBrepVolumeBounds(std::vector<std::pair<float,float> > xyvtx, float hlengthz);
-
- /**Constructor - generic case (from double)*/
- SimplePolygonBrepVolumeBounds(std::vector<std::pair<double,double> > xyvtx, double hlengthz);
-
- /**Copy Constructor */
- SimplePolygonBrepVolumeBounds(const SimplePolygonBrepVolumeBounds& bobo);
-
- /**Destructor */
- virtual ~SimplePolygonBrepVolumeBounds();
-
- /**Assignment operator*/
- SimplePolygonBrepVolumeBounds& operator=(const SimplePolygonBrepVolumeBounds& bobo);
-
- /**Virtual constructor */
- SimplePolygonBrepVolumeBounds* clone() const override;
-
- /**This method checks if position in the 3D volume frame is inside the volume*/
- bool inside(const Vector3D& , double tol=0.) const override;
-
- /** Method to decompose the Bounds into Surfaces */
- const std::vector<const Acts::Surface*>* decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
-
- /**This method returns the set of xy generating vertices*/
- const std::vector<std::pair<TDD_real_t, TDD_real_t> > xyVertices() const;
-
- /**This method returns the halflength in local z*/
- double halflengthZ() const;
-
- /**This method returns the transcript into combined volume*/
- const Acts::Volume* combinedVolume() const;
-
- /**This method returns the volume envelope*/
- const Acts::Volume* envelope() const;
-
- /** Output Method for std::ostream */
- std::ostream& dump(std::ostream& sl) const override;
-
- private:
- template <class T> T& dumpT(T& dt) const;
-
-
- void processSubVols() const;
- Acts::PlaneSurface* sideSurf(Transform3D,unsigned int,unsigned int) const;
- bool Xor(bool x, bool y) const;
-
- bool Left(std::pair<TDD_real_t,TDD_real_t> a, std::pair<TDD_real_t,TDD_real_t> b, std::pair<TDD_real_t,TDD_real_t> c) const;
-
- bool Intersect(std::pair<TDD_real_t,TDD_real_t> a, std::pair<TDD_real_t,TDD_real_t> b,
- std::pair<TDD_real_t,TDD_real_t> c, std::pair<TDD_real_t,TDD_real_t> d) const;
-
- bool InCone(int i, int j, std::vector<std::pair<TDD_real_t,TDD_real_t> > inputVertices) const;
-
- bool Diagonalie(int i , int j ,std::vector<std::pair<TDD_real_t,TDD_real_t> > inputVertices) const;
-
- bool Diagonal(int i, int j, std::vector<std::pair<TDD_real_t,TDD_real_t> > inputVertices) const;
-
-
- std::vector<std::pair<TDD_real_t,TDD_real_t> > TriangulatePolygon(const std::vector<std::pair<TDD_real_t,TDD_real_t> >& Vertices ) const;
-
- std::vector<std::pair<TDD_real_t,TDD_real_t> > TriangulatePolygonCheck(const std::vector<std::pair<TDD_real_t,TDD_real_t> >& Vertices ) const;
-
- mutable std::vector<std::pair<double,double> > m_xyVtx; //!< generating xy vertices
- double m_halfX; //!< halflength in x - to define enclosing rectangle
- double m_halfY; //!< halflength in y - to define enclosing rectangle
- double m_halfZ; //!< halflength in z
-
- mutable int m_ordering; //!< -1 not set/ 1 anticlockwise / 0 clockwise
- mutable const Acts::Volume* m_combinedVolume; //!< triangulated polygon
- mutable const Acts::Volume* m_envelope; //!< simplified envelope
-
- };
-
- inline SimplePolygonBrepVolumeBounds* SimplePolygonBrepVolumeBounds::clone() const
- { return new SimplePolygonBrepVolumeBounds(*this); }
-
- inline const std::vector<std::pair<TDD_real_t,TDD_real_t> > SimplePolygonBrepVolumeBounds::xyVertices() const { return m_xyVtx; }
-
- inline double SimplePolygonBrepVolumeBounds::halflengthZ() const { return m_halfZ; }
+class Surface;
+class PlaneSurface;
+class RectangleBounds;
+
+/**
+ @class SimplePolygonBrepVolumeBounds
+
+ Bounds for the exact transcript of the GeoSimplePolygonBrep; volume defined by
+ combination of symm.trapezoids
+
+ BoundarySurfaceFace [index]:
+
+ - negativeFaceXY [0] : Acts::SubtractedPlaneSurface,
+ parallel to \f$ xy \f$ plane at negative \f$ z
+ \f$
+ - positiveFaceXY [1] : Acts::SubtractedPlaneSurface,
+ parallel to \f$ xy \f$ plane at positive \f$ z
+ \f$
+ - face [2... n+1] : Rectangular Acts::PlaneSurface
+
+ */
+
+class SimplePolygonBrepVolumeBounds : public VolumeBounds
+{
+public:
+ /**Default Constructor*/
+ SimplePolygonBrepVolumeBounds();
+
+ /**Constructor - generic case (from float)*/
+ SimplePolygonBrepVolumeBounds(std::vector<std::pair<float, float>> xyvtx,
+ float hlengthz);
+
+ /**Constructor - generic case (from double)*/
+ SimplePolygonBrepVolumeBounds(std::vector<std::pair<double, double>> xyvtx,
+ double hlengthz);
+
+ /**Copy Constructor */
+ SimplePolygonBrepVolumeBounds(const SimplePolygonBrepVolumeBounds& bobo);
+
+ /**Destructor */
+ virtual ~SimplePolygonBrepVolumeBounds();
+
+ /**Assignment operator*/
+ SimplePolygonBrepVolumeBounds&
+ operator=(const SimplePolygonBrepVolumeBounds& bobo);
+
+ /**Virtual constructor */
+ SimplePolygonBrepVolumeBounds*
+ clone() const override;
+
+ /**This method checks if position in the 3D volume frame is inside the
+ * volume*/
+ bool
+ inside(const Vector3D&, double tol = 0.) const override;
+
+ /** Method to decompose the Bounds into Surfaces */
+ const std::vector<const Acts::Surface*>*
+ decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
+
+ /**This method returns the set of xy generating vertices*/
+ const std::vector<std::pair<TDD_real_t, TDD_real_t>>
+ xyVertices() const;
+
+ /**This method returns the halflength in local z*/
+ double
+ halflengthZ() const;
+
+ /**This method returns the transcript into combined volume*/
+ const Acts::Volume*
+ combinedVolume() const;
+
+ /**This method returns the volume envelope*/
+ const Acts::Volume*
+ envelope() const;
+
+ /** Output Method for std::ostream */
+ std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ template <class T>
+ T&
+ dumpT(T& dt) const;
+
+ void
+ processSubVols() const;
+ Acts::PlaneSurface*
+ sideSurf(Transform3D, unsigned int, unsigned int) const;
+ bool
+ Xor(bool x, bool y) const;
+
+ bool
+ Left(std::pair<TDD_real_t, TDD_real_t> a,
+ std::pair<TDD_real_t, TDD_real_t> b,
+ std::pair<TDD_real_t, TDD_real_t> c) const;
+
+ bool
+ Intersect(std::pair<TDD_real_t, TDD_real_t> a,
+ std::pair<TDD_real_t, TDD_real_t> b,
+ std::pair<TDD_real_t, TDD_real_t> c,
+ std::pair<TDD_real_t, TDD_real_t> d) const;
+
+ bool
+ InCone(int i,
+ int j,
+ std::vector<std::pair<TDD_real_t, TDD_real_t>> inputVertices) const;
+
+ bool
+ Diagonalie(
+ int i,
+ int j,
+ std::vector<std::pair<TDD_real_t, TDD_real_t>> inputVertices) const;
+
+ bool
+ Diagonal(int i,
+ int j,
+ std::vector<std::pair<TDD_real_t, TDD_real_t>> inputVertices) const;
+
+ std::vector<std::pair<TDD_real_t, TDD_real_t>>
+ TriangulatePolygon(
+ const std::vector<std::pair<TDD_real_t, TDD_real_t>>& Vertices) const;
+
+ std::vector<std::pair<TDD_real_t, TDD_real_t>>
+ TriangulatePolygonCheck(
+ const std::vector<std::pair<TDD_real_t, TDD_real_t>>& Vertices) const;
+
+ mutable std::vector<std::pair<double, double>>
+ m_xyVtx; //!< generating xy vertices
+ double m_halfX; //!< halflength in x - to define enclosing rectangle
+ double m_halfY; //!< halflength in y - to define enclosing rectangle
+ double m_halfZ; //!< halflength in z
+
+ mutable int m_ordering; //!< -1 not set/ 1 anticlockwise / 0 clockwise
+ mutable const Acts::Volume* m_combinedVolume; //!< triangulated polygon
+ mutable const Acts::Volume* m_envelope; //!< simplified envelope
+};
+
+inline SimplePolygonBrepVolumeBounds*
+SimplePolygonBrepVolumeBounds::clone() const
+{
+ return new SimplePolygonBrepVolumeBounds(*this);
+}
- inline const Acts::Volume* SimplePolygonBrepVolumeBounds::combinedVolume() const { return m_combinedVolume; }
+inline const std::vector<std::pair<TDD_real_t, TDD_real_t>>
+SimplePolygonBrepVolumeBounds::xyVertices() const
+{
+ return m_xyVtx;
+}
- inline const Acts::Volume* SimplePolygonBrepVolumeBounds::envelope() const { return m_envelope; }
+inline double
+SimplePolygonBrepVolumeBounds::halflengthZ() const
+{
+ return m_halfZ;
+}
- template <class T> T& SimplePolygonBrepVolumeBounds::dumpT(T& dt) const
- {
- dt << std::setiosflags(std::ios::fixed);
- dt << std::setprecision(7);
- dt << "Acts::SimplePolygonBrepVolumeBounds: (halfZ, xy vertices) = ";
- dt << "( " << m_halfZ << ")";
- for (unsigned int i=0;i<m_xyVtx.size();i++)
- dt << "(" << m_xyVtx.at(i).first << ","<<m_xyVtx.at(i).second <<")";
- return dt;
- }
+inline const Acts::Volume*
+SimplePolygonBrepVolumeBounds::combinedVolume() const
+{
+ return m_combinedVolume;
+}
+inline const Acts::Volume*
+SimplePolygonBrepVolumeBounds::envelope() const
+{
+ return m_envelope;
+}
+template <class T>
+T&
+SimplePolygonBrepVolumeBounds::dumpT(T& dt) const
+{
+ dt << std::setiosflags(std::ios::fixed);
+ dt << std::setprecision(7);
+ dt << "Acts::SimplePolygonBrepVolumeBounds: (halfZ, xy vertices) = ";
+ dt << "( " << m_halfZ << ")";
+ for (unsigned int i = 0; i < m_xyVtx.size(); i++)
+ dt << "(" << m_xyVtx.at(i).first << "," << m_xyVtx.at(i).second << ")";
+ return dt;
+}
}
-#endif // ACTS_VOLUMES_SIMPLEPOLYGONBREPVOLUMEBOUNDS_H
+#endif // ACTS_VOLUMES_SIMPLEPOLYGONBREPVOLUMEBOUNDS_H
diff --git a/Core/include/ACTS/Volumes/SubtractedVolumeBounds.hpp b/Core/include/ACTS/Volumes/SubtractedVolumeBounds.hpp
index 30eadc1e1..5a34e57d0 100644
--- a/Core/include/ACTS/Volumes/SubtractedVolumeBounds.hpp
+++ b/Core/include/ACTS/Volumes/SubtractedVolumeBounds.hpp
@@ -15,95 +15,117 @@
// Geometry module
#include "ACTS/Utilities/Definitions.hpp"
-#include "ACTS/Volumes/VolumeBounds.hpp"
#include "ACTS/Volumes/Volume.hpp"
+#include "ACTS/Volumes/VolumeBounds.hpp"
// Core module
namespace Acts {
- class SurfaceBounds;
- class Volume;
- class Surface;
-
- /**
- @class SubtractedVolumeBounds
-
- Bounds for a generic subtracted volume, the decomposeToSurfaces method creates a
- vector of n surfaces (n1+n2-n_subtracted):
-
- BoundarySurfaceFace [index]: [n1] surfaces from 'outer' volume
- [n1+n2-n_subtr] remaining surfaces (after subtraction) from 'inner' volume
-
- */
-
- class SubtractedVolumeBounds : public VolumeBounds {
+class SurfaceBounds;
+class Volume;
+class Surface;
- public:
- /**Default Constructor*/
- SubtractedVolumeBounds();
+/**
+ @class SubtractedVolumeBounds
- /**Constructor - the box boundaries */
- SubtractedVolumeBounds(Volume* outerVol, Volume* innerVol);
+ Bounds for a generic subtracted volume, the decomposeToSurfaces method creates
+ a
+ vector of n surfaces (n1+n2-n_subtracted):
- /**Copy Constructor */
- SubtractedVolumeBounds(const SubtractedVolumeBounds& bobo);
+ BoundarySurfaceFace [index]: [n1] surfaces from 'outer' volume
+ [n1+n2-n_subtr] remaining surfaces (after
+ subtraction) from 'inner' volume
- /**Destructor */
- virtual ~SubtractedVolumeBounds();
+ */
- /**Assignment operator*/
- SubtractedVolumeBounds& operator=(const SubtractedVolumeBounds& bobo);
+class SubtractedVolumeBounds : public VolumeBounds
+{
+public:
+ /**Default Constructor*/
+ SubtractedVolumeBounds();
- /**Virtual constructor */
- SubtractedVolumeBounds* clone() const override;
+ /**Constructor - the box boundaries */
+ SubtractedVolumeBounds(Volume* outerVol, Volume* innerVol);
- /**This method checks if position in the 3D volume frame is inside the cylinder*/
- bool inside(const Vector3D& , double tol=0.) const override;
+ /**Copy Constructor */
+ SubtractedVolumeBounds(const SubtractedVolumeBounds& bobo);
- /** Method to decompose the Bounds into boundarySurfaces */
- const std::vector<const Acts::Surface*>* decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
+ /**Destructor */
+ virtual ~SubtractedVolumeBounds();
- /**This method returns the outer Volume*/
- Volume* outer() const;
+ /**Assignment operator*/
+ SubtractedVolumeBounds&
+ operator=(const SubtractedVolumeBounds& bobo);
- /**This method returns the inner Volume*/
- Volume* inner() const;
+ /**Virtual constructor */
+ SubtractedVolumeBounds*
+ clone() const override;
- /**This method returns bounds orientation*/
- const std::vector<bool> boundsOrientation() const;
+ /**This method checks if position in the 3D volume frame is inside the
+ * cylinder*/
+ bool
+ inside(const Vector3D&, double tol = 0.) const override;
- /** Output Method for std::ostream */
- std::ostream& dump(std::ostream& sl) const override;
+ /** Method to decompose the Bounds into boundarySurfaces */
+ const std::vector<const Acts::Surface*>*
+ decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
- private:
+ /**This method returns the outer Volume*/
+ Volume*
+ outer() const;
- Acts::Volume* createSubtractedVolume(const Transform3D& transf, Acts::Volume* subtrVol) const;
+ /**This method returns the inner Volume*/
+ Volume*
+ inner() const;
- Volume* m_outer;
- Volume* m_inner;
+ /**This method returns bounds orientation*/
+ const std::vector<bool>
+ boundsOrientation() const;
- mutable std::vector<bool> m_boundsOrientation;
+ /** Output Method for std::ostream */
+ std::ostream&
+ dump(std::ostream& sl) const override;
- };
+private:
+ Acts::Volume*
+ createSubtractedVolume(const Transform3D& transf,
+ Acts::Volume* subtrVol) const;
- inline SubtractedVolumeBounds* SubtractedVolumeBounds::clone() const
- { return new SubtractedVolumeBounds(*this); }
+ Volume* m_outer;
+ Volume* m_inner;
- inline bool SubtractedVolumeBounds::inside(const Vector3D &pos, double tol) const
- {
- return (m_outer->inside(pos,tol) && !m_inner->inside(pos,-tol) );
- }
+ mutable std::vector<bool> m_boundsOrientation;
+};
- inline Volume* SubtractedVolumeBounds::outer() const { return m_outer; }
-
- inline Volume* SubtractedVolumeBounds::inner() const { return m_inner; }
-
- inline const std::vector<bool> SubtractedVolumeBounds::boundsOrientation() const
- { return(m_boundsOrientation); }
+inline SubtractedVolumeBounds*
+SubtractedVolumeBounds::clone() const
+{
+ return new SubtractedVolumeBounds(*this);
+}
+inline bool
+SubtractedVolumeBounds::inside(const Vector3D& pos, double tol) const
+{
+ return (m_outer->inside(pos, tol) && !m_inner->inside(pos, -tol));
}
-#endif // ACTS_VOLUMES_SUBTRACTEDVOLUMEBOUNDS_H
+inline Volume*
+SubtractedVolumeBounds::outer() const
+{
+ return m_outer;
+}
+inline Volume*
+SubtractedVolumeBounds::inner() const
+{
+ return m_inner;
+}
+inline const std::vector<bool>
+SubtractedVolumeBounds::boundsOrientation() const
+{
+ return (m_boundsOrientation);
+}
+}
+#endif // ACTS_VOLUMES_SUBTRACTEDVOLUMEBOUNDS_H
diff --git a/Core/include/ACTS/Volumes/TrapezoidVolumeBounds.hpp b/Core/include/ACTS/Volumes/TrapezoidVolumeBounds.hpp
index d219a090c..1b3a4e421 100644
--- a/Core/include/ACTS/Volumes/TrapezoidVolumeBounds.hpp
+++ b/Core/include/ACTS/Volumes/TrapezoidVolumeBounds.hpp
@@ -13,151 +13,214 @@
#ifndef ACTS_VOLUMES_TRAPEZOIDVOLUMESBOUNDS_H
#define ACTS_VOLUMES_TRAPEZOIDVOLUMESBOUNDS_H 1
-#include "ACTS/Volumes/VolumeBounds.hpp"
#include "ACTS/Utilities/Definitions.hpp"
+#include "ACTS/Volumes/VolumeBounds.hpp"
namespace Acts {
- class Surface;
- class RectangleBounds;
- class TrapezoidBounds;
-
- /**
- @class TrapezoidVolumeBounds
-
- Bounds for a trapezoidal shaped Volume, the decomposeToSurfaces method creates a
- vector of 6 surfaces:
-
- BoundarySurfaceFace [index]:
-
- - negativeFaceXY [0] : Trazpezoidal Acts::PlaneSurface,
- parallel to \f$ xy \f$ plane at negative \f$ z \f$
- - positiveFaceXY [1] : Trazpezoidal Acts::PlaneSurface,
- parallel to \f$ xy \f$ plane at positive \f$ z \f$
- - trapezoidFaceAlpha [2] : Rectangular Acts::PlaneSurface,
- attached to [0] and [1] at negative \f$ x \f$ (associated to alpha)
- - trapezoidFaceBeta [3] : Rectangular Acts::PlaneSurface,
- attached to [0] and [1] at positive \f$ x \f$ (associated to beta)
- - negativeFaceZX [4] : Rectangular Acts::PlaneSurface,
- parallel to \f$ zx \f$ plane at negative \f$ y \f$
- - positiveFaceZX [5] : Rectangular Acts::PlaneSurface,
- parallel to \f$ zx \f$ plane at positive \f$ y \f$
-
- @image html TrapezoidVolumeBounds_decomp.gif
-
- */
-
- class TrapezoidVolumeBounds : public VolumeBounds {
-
- public:
- /** @enum BoundValues for readability */
- enum BoundValues {
- bv_minHalfX = 0, //!< minimal halflength in x
- bv_maxHalfX = 1, //!< maximal halflength in x
- bv_halfY = 2, //!< halflength in y
- bv_halfZ = 3, //!< halflength in z
- bv_alpha = 4, //!< opening angle alpha (in point A)
- bv_beta = 5, //!< opening angle beta (in point B)
- bv_length = 6 // length of the bounds vector
-
- };
-
- /**Default Constructor*/
- TrapezoidVolumeBounds();
-
- /**Constructor - the trapezoid boundaries (symmetric trapezoid) */
- TrapezoidVolumeBounds(double minhlenghtx, double maxhlengthx, double hlenghty, double hlengthz);
-
- /**Constructor - the trapezoid boundaries (arbitrary trapezoid) */
- TrapezoidVolumeBounds(double minhlenghtx, double hlenghty, double hlengthz, double alpha, double beta);
-
- /**Copy Constructor */
- TrapezoidVolumeBounds(const TrapezoidVolumeBounds& bobo);
-
- /**Destructor */
- virtual ~TrapezoidVolumeBounds();
-
- /**Assignment operator*/
- TrapezoidVolumeBounds& operator=(const TrapezoidVolumeBounds& bobo);
-
- /**Virtual constructor */
- TrapezoidVolumeBounds* clone() const override;
-
- /**This method checks if position in the 3D volume frame is inside the cylinder*/
- bool inside(const Vector3D& , double tol=0.) const override;
-
- /** Method to decompose the Bounds into Surfaces */
- const std::vector<const Acts::Surface*>* decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
-
- /**This method returns the minimal halflength in local x*/
- double minHalflengthX() const;
-
- /**This method returns the maximal halflength in local x*/
- double maxHalflengthX() const;
-
- /**This method returns the halflength in local y*/
- double halflengthY() const;
-
- /**This method returns the halflength in local z*/
- double halflengthZ() const;
-
- /**This method returns the opening angle in point A (negative local x)*/
- double alpha() const;
-
- /**This method returns the opening angle in point B (negative local x)*/
- double beta() const;
-
- /** Output Method for std::ostream */
- std::ostream& dump(std::ostream& sl) const override;
-
- private:
- /** Templated dump methos */
- template <class T> T& dumpT(T& dt) const;
-
- /** This method returns the associated TrapezoidBounds of the face PlaneSurface parallel to local xy plane */
- TrapezoidBounds* faceXYTrapezoidBounds() const;
-
- /** This method returns the associated RecantleBounds of the face PlaneSurface attached to alpha (negative local x)*/
- RectangleBounds* faceAlphaRectangleBounds() const;
-
- /** This method returns the associated RecantleBounds of the face PlaneSurface attached to beta (positive local x)*/
- RectangleBounds* faceBetaRectangleBounds() const;
-
- /** This method returns the associated RecantleBounds of the face PlaneSurface parallel to local zx plane, negative local y */
- RectangleBounds* faceZXRectangleBoundsBottom() const;
-
- /** This method returns the associated RecantleBounds of the face PlaneSurface parallel to local zx plane, positive local y */
- RectangleBounds* faceZXRectangleBoundsTop() const;
-
- /** the bounds values */
- std::vector<TDD_real_t> m_boundValues;
-
- };
-
- inline TrapezoidVolumeBounds* TrapezoidVolumeBounds::clone() const
- { return new TrapezoidVolumeBounds(*this); }
-
- inline double TrapezoidVolumeBounds::minHalflengthX() const { return m_boundValues.at(bv_minHalfX); }
- inline double TrapezoidVolumeBounds::maxHalflengthX() const { return m_boundValues.at(bv_maxHalfX); }
- inline double TrapezoidVolumeBounds::halflengthY() const { return m_boundValues.at(bv_halfY); }
- inline double TrapezoidVolumeBounds::halflengthZ() const { return m_boundValues.at(bv_halfZ); }
- inline double TrapezoidVolumeBounds::alpha() const { return m_boundValues.at(bv_alpha); }
- inline double TrapezoidVolumeBounds::beta() const { return m_boundValues.at(bv_beta); }
-
- template <class T> T& TrapezoidVolumeBounds::dumpT(T& dt) const
- {
- dt << std::setiosflags(std::ios::fixed);
- dt << std::setprecision(7);
- dt << "Acts::TrapezoidVolumeBounds: (minhalfX, halfY, halfZ, alpha, beta) = ";
- dt << "(" << m_boundValues.at(bv_minHalfX) << ", " << m_boundValues.at(bv_halfY) << ", " << m_boundValues.at(bv_halfZ);
- dt << ", " << m_boundValues.at(bv_alpha) << ", " << m_boundValues.at(bv_beta) << ")";
- return dt;
- }
-
+class Surface;
+class RectangleBounds;
+class TrapezoidBounds;
+
+/**
+ @class TrapezoidVolumeBounds
+
+ Bounds for a trapezoidal shaped Volume, the decomposeToSurfaces method creates
+ a
+ vector of 6 surfaces:
+
+ BoundarySurfaceFace [index]:
+
+ - negativeFaceXY [0] : Trazpezoidal Acts::PlaneSurface,
+ parallel to \f$ xy \f$ plane at negative \f$ z
+ \f$
+ - positiveFaceXY [1] : Trazpezoidal Acts::PlaneSurface,
+ parallel to \f$ xy \f$ plane at positive \f$ z
+ \f$
+ - trapezoidFaceAlpha [2] : Rectangular Acts::PlaneSurface,
+ attached to [0] and [1] at negative \f$ x \f$
+ (associated to alpha)
+ - trapezoidFaceBeta [3] : Rectangular Acts::PlaneSurface,
+ attached to [0] and [1] at positive \f$ x \f$
+ (associated to beta)
+ - negativeFaceZX [4] : Rectangular Acts::PlaneSurface,
+ parallel to \f$ zx \f$ plane at negative \f$ y
+ \f$
+ - positiveFaceZX [5] : Rectangular Acts::PlaneSurface,
+ parallel to \f$ zx \f$ plane at positive \f$ y
+ \f$
+
+ @image html TrapezoidVolumeBounds_decomp.gif
+
+ */
+
+class TrapezoidVolumeBounds : public VolumeBounds
+{
+public:
+ /** @enum BoundValues for readability */
+ enum BoundValues {
+ bv_minHalfX = 0, //!< minimal halflength in x
+ bv_maxHalfX = 1, //!< maximal halflength in x
+ bv_halfY = 2, //!< halflength in y
+ bv_halfZ = 3, //!< halflength in z
+ bv_alpha = 4, //!< opening angle alpha (in point A)
+ bv_beta = 5, //!< opening angle beta (in point B)
+ bv_length = 6 // length of the bounds vector
+
+ };
+
+ /**Default Constructor*/
+ TrapezoidVolumeBounds();
+
+ /**Constructor - the trapezoid boundaries (symmetric trapezoid) */
+ TrapezoidVolumeBounds(double minhlenghtx,
+ double maxhlengthx,
+ double hlenghty,
+ double hlengthz);
+
+ /**Constructor - the trapezoid boundaries (arbitrary trapezoid) */
+ TrapezoidVolumeBounds(double minhlenghtx,
+ double hlenghty,
+ double hlengthz,
+ double alpha,
+ double beta);
+
+ /**Copy Constructor */
+ TrapezoidVolumeBounds(const TrapezoidVolumeBounds& bobo);
+
+ /**Destructor */
+ virtual ~TrapezoidVolumeBounds();
+
+ /**Assignment operator*/
+ TrapezoidVolumeBounds&
+ operator=(const TrapezoidVolumeBounds& bobo);
+
+ /**Virtual constructor */
+ TrapezoidVolumeBounds*
+ clone() const override;
+
+ /**This method checks if position in the 3D volume frame is inside the
+ * cylinder*/
+ bool
+ inside(const Vector3D&, double tol = 0.) const override;
+
+ /** Method to decompose the Bounds into Surfaces */
+ const std::vector<const Acts::Surface*>*
+ decomposeToSurfaces(std::shared_ptr<Transform3D> transformPtr) const override;
+
+ /**This method returns the minimal halflength in local x*/
+ double
+ minHalflengthX() const;
+
+ /**This method returns the maximal halflength in local x*/
+ double
+ maxHalflengthX() const;
+
+ /**This method returns the halflength in local y*/
+ double
+ halflengthY() const;
+
+ /**This method returns the halflength in local z*/
+ double
+ halflengthZ() const;
+
+ /**This method returns the opening angle in point A (negative local x)*/
+ double
+ alpha() const;
+
+ /**This method returns the opening angle in point B (negative local x)*/
+ double
+ beta() const;
+
+ /** Output Method for std::ostream */
+ std::ostream&
+ dump(std::ostream& sl) const override;
+
+private:
+ /** Templated dump methos */
+ template <class T>
+ T&
+ dumpT(T& dt) const;
+
+ /** This method returns the associated TrapezoidBounds of the face
+ * PlaneSurface parallel to local xy plane */
+ TrapezoidBounds*
+ faceXYTrapezoidBounds() const;
+
+ /** This method returns the associated RecantleBounds of the face PlaneSurface
+ * attached to alpha (negative local x)*/
+ RectangleBounds*
+ faceAlphaRectangleBounds() const;
+
+ /** This method returns the associated RecantleBounds of the face PlaneSurface
+ * attached to beta (positive local x)*/
+ RectangleBounds*
+ faceBetaRectangleBounds() const;
+
+ /** This method returns the associated RecantleBounds of the face PlaneSurface
+ * parallel to local zx plane, negative local y */
+ RectangleBounds*
+ faceZXRectangleBoundsBottom() const;
+
+ /** This method returns the associated RecantleBounds of the face PlaneSurface
+ * parallel to local zx plane, positive local y */
+ RectangleBounds*
+ faceZXRectangleBoundsTop() const;
+
+ /** the bounds values */
+ std::vector<TDD_real_t> m_boundValues;
+};
+
+inline TrapezoidVolumeBounds*
+TrapezoidVolumeBounds::clone() const
+{
+ return new TrapezoidVolumeBounds(*this);
}
+inline double
+TrapezoidVolumeBounds::minHalflengthX() const
+{
+ return m_boundValues.at(bv_minHalfX);
+}
+inline double
+TrapezoidVolumeBounds::maxHalflengthX() const
+{
+ return m_boundValues.at(bv_maxHalfX);
+}
+inline double
+TrapezoidVolumeBounds::halflengthY() const
+{
+ return m_boundValues.at(bv_halfY);
+}
+inline double
+TrapezoidVolumeBounds::halflengthZ() const
+{
+ return m_boundValues.at(bv_halfZ);
+}
+inline double
+TrapezoidVolumeBounds::alpha() const
+{
+ return m_boundValues.at(bv_alpha);
+}
+inline double
+TrapezoidVolumeBounds::beta() const
+{
+ return m_boundValues.at(bv_beta);
+}
-#endif // ACTS_VOLUMES_TRAPEZOIDVOLUMESBOUNDS_H
-
-
+template <class T>
+T&
+TrapezoidVolumeBounds::dumpT(T& dt) const
+{
+ dt << std::setiosflags(std::ios::fixed);
+ dt << std::setprecision(7);
+ dt << "Acts::TrapezoidVolumeBounds: (minhalfX, halfY, halfZ, alpha, beta) = ";
+ dt << "(" << m_boundValues.at(bv_minHalfX) << ", "
+ << m_boundValues.at(bv_halfY) << ", " << m_boundValues.at(bv_halfZ);
+ dt << ", " << m_boundValues.at(bv_alpha) << ", " << m_boundValues.at(bv_beta)
+ << ")";
+ return dt;
+}
+}
+#endif // ACTS_VOLUMES_TRAPEZOIDVOLUMESBOUNDS_H
diff --git a/Core/include/ACTS/Volumes/Volume.hpp b/Core/include/ACTS/Volumes/Volume.hpp
index 651c8c982..0398514ee 100644
--- a/Core/include/ACTS/Volumes/Volume.hpp
+++ b/Core/include/ACTS/Volumes/Volume.hpp
@@ -17,96 +17,109 @@
#include "ACTS/Utilities/Definitions.hpp"
// Geometry module
-#include "ACTS/Utilities/GeometryStatics.hpp"
#include "ACTS/Utilities/GeometryObject.hpp"
+#include "ACTS/Utilities/GeometryStatics.hpp"
// Core module
namespace Acts {
- class VolumeBounds;
- typedef std::shared_ptr<const VolumeBounds> VolumeBoundsPtr;
-
- /** @class Volume
+class VolumeBounds;
+typedef std::shared_ptr<const VolumeBounds> VolumeBoundsPtr;
- It inhertis of GeometryObject for TDD identification
+/** @class Volume
- Base class for all volumes inside the tracking realm, it defines
- the interface for inherited Volume classes
- regarding the geometrical information.
+ It inhertis of GeometryObject for TDD identification
- */
+ Base class for all volumes inside the tracking realm, it defines
+ the interface for inherited Volume classes
+ regarding the geometrical information.
- class Volume : public virtual GeometryObject {
+ */
- public:
- /** Default constructor */
- Volume();
+class Volume : public virtual GeometryObject
+{
+public:
+ /** Default constructor */
+ Volume();
- /** Expizit constructor with arguments */
- Volume(Transform3D* htrans, const VolumeBounds* volBounds);
+ /** Expizit constructor with arguments */
+ Volume(Transform3D* htrans, const VolumeBounds* volBounds);
- /** Expizit constructor with shared arguments */
- Volume(std::shared_ptr<Transform3D> htrans, VolumeBoundsPtr volBounds);
+ /** Expizit constructor with shared arguments */
+ Volume(std::shared_ptr<Transform3D> htrans, VolumeBoundsPtr volBounds);
- /** Copy Constructor */
- Volume(const Volume& vol);
+ /** Copy Constructor */
+ Volume(const Volume& vol);
- /** Copy Constructor */
- Volume(const Volume& vol, const Transform3D& shift);
+ /** Copy Constructor */
+ Volume(const Volume& vol, const Transform3D& shift);
- /** Destructor */
- virtual ~Volume();
+ /** Destructor */
+ virtual ~Volume();
- /** Assignment operator */
- Volume& operator=(const Volume& vol);
+ /** Assignment operator */
+ Volume&
+ operator=(const Volume& vol);
- /** Pseudo-constructor */
- virtual Volume* clone() const;
+ /** Pseudo-constructor */
+ virtual Volume*
+ clone() const;
- /** Return methods for geometry transform */
- const Transform3D& transform() const;
+ /** Return methods for geometry transform */
+ const Transform3D&
+ transform() const;
- /** returns the center of the volume */
- const Vector3D& center() const;
+ /** returns the center of the volume */
+ const Vector3D&
+ center() const;
- /** returns the volumeBounds() */
- const VolumeBounds& volumeBounds() const;
+ /** returns the volumeBounds() */
+ const VolumeBounds&
+ volumeBounds() const;
- /** Inside() method for checks */
- bool inside(const Vector3D& gp, double tol=0.) const;
+ /** Inside() method for checks */
+ bool
+ inside(const Vector3D& gp, double tol = 0.) const;
- /** The binning position method - as default the center is given, but may be overloaded */
- virtual Vector3D binningPosition(BinningValue bValue) const override;
+ /** The binning position method - as default the center is given, but may be
+ * overloaded */
+ virtual Vector3D
+ binningPosition(BinningValue bValue) const override;
- protected:
- std::shared_ptr<Transform3D> m_transform; //!< Transform3D
- mutable Vector3D* m_center; //!< center position of the surface
- VolumeBoundsPtr m_volumeBounds; //!< the volumeBounds
- };
+protected:
+ std::shared_ptr<Transform3D> m_transform; //!< Transform3D
+ mutable Vector3D* m_center; //!< center position of the surface
+ VolumeBoundsPtr m_volumeBounds; //!< the volumeBounds
+};
- inline const Transform3D& Volume::transform() const
- { if (m_transform.get()) return(*(m_transform.get()));
- return Acts::s_idTransform;
- }
+inline const Transform3D&
+Volume::transform() const
+{
+ if (m_transform.get()) return (*(m_transform.get()));
+ return Acts::s_idTransform;
+}
- inline const Vector3D& Volume::center() const
- {
- if (m_center) return (*m_center);
- if (!m_center && m_transform.get()){
- m_center = new Vector3D(m_transform->translation());
- return(*m_center);
- }
- return Acts::s_origin;
- }
-
- inline const VolumeBounds& Volume::volumeBounds() const
- { return (*(m_volumeBounds.get())); }
+inline const Vector3D&
+Volume::center() const
+{
+ if (m_center) return (*m_center);
+ if (!m_center && m_transform.get()) {
+ m_center = new Vector3D(m_transform->translation());
+ return (*m_center);
+ }
+ return Acts::s_origin;
+}
+inline const VolumeBounds&
+Volume::volumeBounds() const
+{
+ return (*(m_volumeBounds.get()));
+}
/**Overload of << operator for std::ostream for debug output*/
-std::ostream& operator << ( std::ostream& sl, const Volume& vol);
-
+std::ostream&
+operator<<(std::ostream& sl, const Volume& vol);
-} // end of namespace Acts
+} // end of namespace Acts
-#endif // ACTS_VOLUMES_VOLUME_H
+#endif // ACTS_VOLUMES_VOLUME_H
diff --git a/Core/include/ACTS/Volumes/VolumeBounds.hpp b/Core/include/ACTS/Volumes/VolumeBounds.hpp
index 954ce16bb..34bd137a0 100644
--- a/Core/include/ACTS/Volumes/VolumeBounds.hpp
+++ b/Core/include/ACTS/Volumes/VolumeBounds.hpp
@@ -14,8 +14,8 @@
#define ACTS_VOLUMES_VOLUMEBOUNDS_H 1
// STD/STL
-#include <iostream>
#include <iomanip>
+#include <iostream>
#include <memory>
#include "ACTS/Utilities/Definitions.hpp"
@@ -25,72 +25,81 @@
namespace Acts {
+class Surface;
+class Volume;
- class Surface;
- class Volume;
-
- // master typedef
- class VolumeBounds;
- typedef std::shared_ptr<const VolumeBounds> VolumeBoundsPtr;
-
- /**
- @class VolumeBounds
-
- Pure Absract Base Class for Volume bounds.
+// master typedef
+class VolumeBounds;
+typedef std::shared_ptr<const VolumeBounds> VolumeBoundsPtr;
- Acts::VolumeBounds are a set of up to six confining Surfaces that are stored in a std::vector.
- Each type of Acts::VolumeBounds has to implement a decomposeToSurfaces() and a inside() method.
+/**
+ @class VolumeBounds
- The orientation of the Surfaces are in a way that the normal vector points to the oustide world.
+ Pure Absract Base Class for Volume bounds.
- The Volume, retrieving a set of Surfaces from the VolumeBounds, can turn the Surfaces into BoundarySurfaces.
+ Acts::VolumeBounds are a set of up to six confining Surfaces that are stored in
+ a std::vector.
+ Each type of Acts::VolumeBounds has to implement a decomposeToSurfaces() and a
+ inside() method.
- */
+ The orientation of the Surfaces are in a way that the normal vector points to
+ the oustide world.
- class VolumeBounds {
+ The Volume, retrieving a set of Surfaces from the VolumeBounds, can turn the
+ Surfaces into BoundarySurfaces.
- public:
- /**Default Constructor*/
- VolumeBounds(){}
+ */
- /**Destructor*/
- virtual ~VolumeBounds(){}
+class VolumeBounds
+{
+public:
+ /**Default Constructor*/
+ VolumeBounds() {}
+ /**Destructor*/
+ virtual ~VolumeBounds() {}
+ /** clone() method to make deep copy in Volume copy constructor and for
+ assigment operator
+ of the Surface class.*/
+ virtual VolumeBounds*
+ clone() const = 0;
- /** clone() method to make deep copy in Volume copy constructor and for assigment operator
- of the Surface class.*/
- virtual VolumeBounds* clone() const = 0;
+ /** Checking if position given in volume frame is inside*/
+ virtual bool
+ inside(const Vector3D& pos, double tol = 0.) const = 0;
- /** Checking if position given in volume frame is inside*/
- virtual bool inside(const Vector3D& pos, double tol=0.) const = 0;
+ /** Method to decompose the Bounds into Surfaces, the Volume can turn them
+ * into BoundarySurfaces */
+ virtual const std::vector<const Acts::Surface*>*
+ decomposeToSurfaces(std::shared_ptr<Transform3D> transform) const = 0;
- /** Method to decompose the Bounds into Surfaces, the Volume can turn them into BoundarySurfaces */
- virtual const std::vector<const Acts::Surface*>* decomposeToSurfaces(std::shared_ptr<Transform3D> transform) const = 0;
-
- /** Binning offset - overloaded for some R-binning types */
- virtual Vector3D binningOffset(BinningValue bValue) const;
-
- /** Binning borders in double */
- virtual double binningBorder(BinningValue bValue) const;
+ /** Binning offset - overloaded for some R-binning types */
+ virtual Vector3D
+ binningOffset(BinningValue bValue) const;
- /** Output Method for std::ostream, to be overloaded by child classes */
- virtual std::ostream& dump(std::ostream& sl) const = 0;
+ /** Binning borders in double */
+ virtual double
+ binningBorder(BinningValue bValue) const;
- };
+ /** Output Method for std::ostream, to be overloaded by child classes */
+ virtual std::ostream&
+ dump(std::ostream& sl) const = 0;
+};
- /** Binning offset - overloaded for some R-binning types */
- inline Vector3D VolumeBounds::binningOffset(BinningValue) const
- { // standard offset is 0.,0.,0.
- return Vector3D(0.,0.,0.);
- }
+/** Binning offset - overloaded for some R-binning types */
+inline Vector3D VolumeBounds::binningOffset(BinningValue) const
+{ // standard offset is 0.,0.,0.
+ return Vector3D(0., 0., 0.);
+}
- inline double VolumeBounds::binningBorder(BinningValue) const
- {
- return 0.;
- }
+inline double VolumeBounds::binningBorder(BinningValue) const
+{
+ return 0.;
+}
- /**Overload of << operator for std::ostream for debug output*/
- std::ostream& operator << ( std::ostream& sl, const VolumeBounds& vb);
+/**Overload of << operator for std::ostream for debug output*/
+std::ostream&
+operator<<(std::ostream& sl, const VolumeBounds& vb);
-} // end of namespace
+} // end of namespace
-#endif // ACTS_VOLUMES_VOLUMEBOUNDS_H
+#endif // ACTS_VOLUMES_VOLUMEBOUNDS_H
diff --git a/Core/include/ACTS/Volumes/VolumeExcluder.hpp b/Core/include/ACTS/Volumes/VolumeExcluder.hpp
index aaed67133..21977291a 100644
--- a/Core/include/ACTS/Volumes/VolumeExcluder.hpp
+++ b/Core/include/ACTS/Volumes/VolumeExcluder.hpp
@@ -14,62 +14,71 @@
#define ACTS_VOLUMES_VOLUMEEXCLUDER_H 1
// Geometry module
-#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Utilities/AreaExcluder.hpp"
+#include "ACTS/Utilities/Definitions.hpp"
#include "ACTS/Volumes/Volume.hpp"
// Core module
namespace Acts {
- class AreaExcluder;
+class AreaExcluder;
/** @class VolumeExcluder
removes explicit dependence of Subtracted*Surface on Volumes
*/
- class VolumeExcluder: public AreaExcluder {
-
- public:
- /** Default constructor */
- VolumeExcluder();
-
- /** Explicit constructor with volume */
- VolumeExcluder(Volume* vol);
-
- /** copy constructor */
- VolumeExcluder(const VolumeExcluder& ex);
+class VolumeExcluder : public AreaExcluder
+{
+public:
+ /** Default constructor */
+ VolumeExcluder();
- /** Destructor */
- virtual ~VolumeExcluder();
+ /** Explicit constructor with volume */
+ VolumeExcluder(Volume* vol);
- /** Assignment operator */
- VolumeExcluder& operator=(const VolumeExcluder &vol);
+ /** copy constructor */
+ VolumeExcluder(const VolumeExcluder& ex);
- /** Pseudo-constructor */
- VolumeExcluder* clone() const;
+ /** Destructor */
+ virtual ~VolumeExcluder();
- /** First bin from global position */
- bool inside(const Vector3D& gp, double tol=0.) const;
+ /** Assignment operator */
+ VolumeExcluder&
+ operator=(const VolumeExcluder& vol);
- /** Acces the subtracted volume */
- Volume* volume() const;
+ /** Pseudo-constructor */
+ VolumeExcluder*
+ clone() const;
- /** Output Method for std::ostream, to be overloaded by child classes */
- std::ostream& dump(std::ostream& sl) const;
+ /** First bin from global position */
+ bool
+ inside(const Vector3D& gp, double tol = 0.) const;
- private:
- Volume* m_vol;
+ /** Acces the subtracted volume */
+ Volume*
+ volume() const;
- };
+ /** Output Method for std::ostream, to be overloaded by child classes */
+ std::ostream&
+ dump(std::ostream& sl) const;
- inline bool VolumeExcluder::inside(const Vector3D& gp, double tol) const
- { return ( m_vol->inside(gp,tol) ); }
+private:
+ Volume* m_vol;
+};
- inline Volume* VolumeExcluder::volume() const
- { return ( m_vol ); }
+inline bool
+VolumeExcluder::inside(const Vector3D& gp, double tol) const
+{
+ return (m_vol->inside(gp, tol));
+}
-} // end of namespace Acts
+inline Volume*
+VolumeExcluder::volume() const
+{
+ return (m_vol);
+}
-#endif // ACTS_VOLUMES_VOLUMEEXCLUDER
+} // end of namespace Acts
+#endif // ACTS_VOLUMES_VOLUMEEXCLUDER
--
GitLab