refactor: Reworked HitSelector in Examples

Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/HitSelector.cpp

@@ -0,0 +1,84 @@
+// This file is part of the ACTS project.
+//
+// Copyright (C) 2016 CERN for the benefit of the ACTS project
+//
+// 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 https://mozilla.org/MPL/2.0/.
+
+#include "ActsExamples/TruthTracking/HitSelector.hpp"
+
+#include "Acts/Utilities/MathHelpers.hpp"
+#include "ActsExamples/EventData/SimHit.hpp"
+#include "ActsExamples/EventData/SimParticle.hpp"
+
+ActsExamples::HitSelector::HitSelector(const Config& config,
+                                       Acts::Logging::Level level)
+    : IAlgorithm("HitSelector", level), m_cfg(config) {
+  m_inputHits.initialize(m_cfg.inputHits);
+  m_inputParticlesSelected.maybeInitialize(m_cfg.inputParticlesSelected);
+  m_outputHits.initialize(m_cfg.outputHits);
+
+  ACTS_DEBUG("selection particles " << m_cfg.inputParticlesSelected);
+  ACTS_DEBUG("selection hit x [" << m_cfg.minX << "," << m_cfg.maxX << ")");
+  ACTS_DEBUG("selection hit y [" << m_cfg.minY << "," << m_cfg.maxY << ")");
+  ACTS_DEBUG("selection hit z [" << m_cfg.minZ << "," << m_cfg.maxZ << ")");
+  ACTS_DEBUG("selection hit r [" << m_cfg.minR << "," << m_cfg.maxR << ")");
+  ACTS_DEBUG("selection hit time [" << m_cfg.minTime << "," << m_cfg.maxTime
+                                    << ")");
+  ACTS_DEBUG("selection hit energy loss [" << m_cfg.minEnergyLoss << ","
+                                           << m_cfg.maxEnergyLoss << ")");
+  ACTS_DEBUG("selection primary vertex ID [" << m_cfg.minPrimaryVertexId << ","
+                                             << m_cfg.maxPrimaryVertexId
+                                             << ")");
+}
+
+ActsExamples::ProcessCode ActsExamples::HitSelector::execute(
+    const ActsExamples::AlgorithmContext& ctx) const {
+  const SimHitContainer& hits = m_inputHits(ctx);
+  const SimParticleContainer* particlesSelected =
+      m_inputParticlesSelected.isInitialized() ? &m_inputParticlesSelected(ctx)
+                                               : nullptr;
+
+  std::vector<SimHit> unorderedHits;
+  unorderedHits.reserve(hits.size());
+
+  for (const auto& hit : hits) {
+    const double r = Acts::fastHypot(hit.position().x(), hit.position().y());
+    const std::uint64_t primaryVertexId = hit.particleId().vertexPrimary();
+
+    const bool validParticle = (particlesSelected == nullptr) ||
+                               particlesSelected->contains(hit.particleId());
+    const bool validX =
+        (m_cfg.minX <= hit.position().x()) && (hit.position().x() < m_cfg.maxX);
+    const bool validY =
+        (m_cfg.minY <= hit.position().y()) && (hit.position().y() < m_cfg.maxY);
+    const bool validZ =
+        (m_cfg.minZ <= hit.position().z()) && (hit.position().z() < m_cfg.maxZ);
+    const bool validR = (m_cfg.minR <= r) && (r < m_cfg.maxR);
+    const bool validTime =
+        (m_cfg.minTime <= hit.time()) && (hit.time() < m_cfg.maxTime);
+    const bool validEnergyLoss =
+        (m_cfg.minEnergyLoss <= hit.depositedEnergy()) &&
+        (hit.depositedEnergy() < m_cfg.maxEnergyLoss);
+    const bool validPrimaryVertexId =
+        (m_cfg.minPrimaryVertexId <= primaryVertexId) &&
+        (primaryVertexId < m_cfg.maxPrimaryVertexId);
+
+    const bool validHit = validParticle && validX && validY && validZ &&
+                          validR && validTime && validEnergyLoss &&
+                          validPrimaryVertexId;
+    if (validHit) {
+      unorderedHits.push_back(hit);
+    }
+  }
+
+  SimHitContainer selectedHits(unorderedHits.begin(), unorderedHits.end());
+
+  ACTS_DEBUG("selected " << selectedHits.size() << " from " << hits.size()
+                         << " hits");
+
+  m_outputHits(ctx, std::move(selectedHits));
+
+  return ProcessCode::SUCCESS;
+}

Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/HitSelector.hpp

@@ -0,0 +1,86 @@
+// This file is part of the ACTS project.
+//
+// Copyright (C) 2016 CERN for the benefit of the ACTS project
+//
+// 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 https://mozilla.org/MPL/2.0/.
+
+#pragma once
+
+#include "Acts/Utilities/Logger.hpp"
+#include "ActsExamples/EventData/SimHit.hpp"
+#include "ActsExamples/EventData/SimParticle.hpp"
+#include "ActsExamples/Framework/DataHandle.hpp"
+#include "ActsExamples/Framework/IAlgorithm.hpp"
+
+#include <limits>
+#include <string>
+
+namespace ActsExamples {
+
+/// Select hits by applying some selection cuts.
+class HitSelector final : public IAlgorithm {
+ public:
+  struct Config {
+    /// Input hit collection.
+    std::string inputHits;
+    /// Optional input particle collection.
+    std::string inputParticlesSelected;
+    /// Output hit collection
+    std::string outputHits;
+
+    /// Min x cut
+    double minX = -std::numeric_limits<double>::max();
+    /// Max x cut
+    double maxX = std::numeric_limits<double>::max();
+
+    /// Min y cut
+    double minY = -std::numeric_limits<double>::max();
+    /// Max y cut
+    double maxY = std::numeric_limits<double>::max();
+
+    /// Min z cut
+    double minZ = -std::numeric_limits<double>::max();
+    /// Max z cut
+    double maxZ = std::numeric_limits<double>::max();
+
+    /// Min r cut
+    double minR = -std::numeric_limits<double>::max();
+    /// Max r cut
+    double maxR = std::numeric_limits<double>::max();
+
+    /// Min time cut
+    double minTime = -std::numeric_limits<double>::max();
+    /// Max time cut
+    double maxTime = std::numeric_limits<double>::max();
+
+    /// Min energy loss cut
+    double minEnergyLoss = 0;
+    /// Max energy loss cut
+    double maxEnergyLoss = std::numeric_limits<double>::max();
+
+    /// Min primary vertex ID cut
+    std::uint64_t minPrimaryVertexId = 0;
+    /// Max primary vertex ID cut
+    std::uint64_t maxPrimaryVertexId =
+        std::numeric_limits<std::uint64_t>::max();
+  };
+
+  HitSelector(const Config& config, Acts::Logging::Level level);
+
+  ProcessCode execute(const AlgorithmContext& ctx) const final;
+
+  /// Get readonly access to the config parameters
+  const Config& config() const { return m_cfg; }
+
+ private:
+  Config m_cfg;
+
+  ReadDataHandle<SimHitContainer> m_inputHits{this, "InputHits"};
+  ReadDataHandle<SimParticleContainer> m_inputParticlesSelected{
+      this, "InputParticlesSelected"};
+  WriteDataHandle<SimHitContainer> m_outputHits{this, "OutputHits"};
+};
+
+}  // namespace ActsExamples

Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/ParticleSelector.cpp

@@ -46,9 +46,17 @@ ActsExamples::ParticleSelector::ParticleSelector(const Config& config,
                                        << ")");
   ACTS_DEBUG("selection particle m [" << m_cfg.mMin << "," << m_cfg.mMax
                                       << ")");
+  ACTS_DEBUG("selection particle measurements ["
+             << m_cfg.measurementsMin << "," << m_cfg.measurementsMax << ")");
   ACTS_DEBUG("remove charged particles " << m_cfg.removeCharged);
   ACTS_DEBUG("remove neutral particles " << m_cfg.removeNeutral);
   ACTS_DEBUG("remove secondary particles " << m_cfg.removeSecondaries);
+  ACTS_DEBUG("exclude pdgs: ");
+  for (auto pdg : m_cfg.excludeAbsPdgs) {
+    ACTS_DEBUG("  " << pdg);
+  }
+  ACTS_DEBUG("primary vertex ID [" << m_cfg.minPrimaryVertexId << ","
+                                   << m_cfg.maxPrimaryVertexId << ")");
 }
 
 ActsExamples::ProcessCode ActsExamples::ParticleSelector::execute(
@@ -73,6 +81,9 @@ ActsExamples::ProcessCode ActsExamples::ParticleSelector::execute(
     const bool validCharged = (p.charge() != 0) && !m_cfg.removeCharged;
     const bool validCharge = validNeutral || validCharged;
     const bool validSecondary = !m_cfg.removeSecondaries || !p.isSecondary();
+    const bool validPrimaryVertexId =
+        within(p.particleId().vertexPrimary(), m_cfg.minPrimaryVertexId,
+               m_cfg.maxPrimaryVertexId);
 
     nInvalidCharge += static_cast<std::size_t>(!validCharge);
 
@@ -91,7 +102,8 @@ ActsExamples::ProcessCode ActsExamples::ParticleSelector::execute(
       }
     }
 
-    return validPdg && validCharge && validSecondary && validMeasurementCount &&
+    return validPdg && validCharge && validSecondary && validPrimaryVertexId &&
+           validMeasurementCount &&
            within(p.transverseMomentum(), m_cfg.ptMin, m_cfg.ptMax) &&
            within(std::abs(eta), m_cfg.absEtaMin, m_cfg.absEtaMax) &&
            within(eta, m_cfg.etaMin, m_cfg.etaMax) &&

Examples/Algorithms/TruthTracking/ActsExamples/TruthTracking/ParticleSelector.hpp

@@ -62,6 +62,12 @@ class ParticleSelector final : public IAlgorithm {
     bool removeSecondaries = false;
     /// Exclude particles depending on absolute pdg value
     std::vector<int> excludeAbsPdgs;
+
+    /// Min primary vertex ID cut
+    std::uint64_t minPrimaryVertexId = 0;
+    /// Max primary vertex ID cut
+    std::uint64_t maxPrimaryVertexId =
+        std::numeric_limits<std::uint64_t>::max();
   };
 
   ParticleSelector(const Config& config, Acts::Logging::Level level);

Examples/Algorithms/TruthTracking/CMakeLists.txt

@@ -9,6 +9,7 @@ add_library(
     ActsExamples/TruthTracking/TruthTrackFinder.cpp
     ActsExamples/TruthTracking/TruthVertexFinder.cpp
     ActsExamples/TruthTracking/TruthSeedingAlgorithm.cpp
+    ActsExamples/TruthTracking/HitSelector.cpp
 )
 target_include_directories(
     ActsExamplesTruthTracking

Examples/Algorithms/Utilities/CMakeLists.txt

@@ -7,7 +7,6 @@ add_library(
     src/TrackSelectorAlgorithm.cpp
     src/TracksToTrajectories.cpp
     src/PrototracksToTracks.cpp
-    src/HitSelector.cpp
     src/TracksToParameters.cpp
 )
 target_include_directories(

Examples/Framework/include/ActsExamples/EventData/Measurement.hpp

@@ -10,25 +10,16 @@
 
 #include "Acts/Definitions/Algebra.hpp"
 #include "Acts/Definitions/TrackParametrization.hpp"
-#include "Acts/EventData/MeasurementHelpers.hpp"
 #include "Acts/EventData/SubspaceHelpers.hpp"
 #include "Acts/EventData/Types.hpp"
-#include "Acts/EventData/detail/ParameterTraits.hpp"
-#include "Acts/EventData/detail/PrintParameters.hpp"
 #include "Acts/Geometry/GeometryIdentifier.hpp"
 #include "Acts/Utilities/Iterator.hpp"
 #include "ActsExamples/EventData/GeometryContainers.hpp"
 #include "ActsExamples/EventData/IndexSourceLink.hpp"
 #include "ActsExamples/EventData/MeasurementConcept.hpp"
 
-#include <array>
-#include <compare>
-#include <concepts>
 #include <cstddef>
-#include <iosfwd>
-#include <iterator>
 #include <type_traits>
-#include <variant>
 #include <vector>
 
 #include <boost/container/static_vector.hpp>
@@ -138,6 +129,11 @@ class MeasurementContainer {
     return getMeasurement<Size>(addMeasurement(Size, geometryId));
   }
 
+  template <MeasurementConcept OtherDerived>
+  VariableProxy copyMeasurement(const OtherDerived& other);
+  template <MeasurementConcept OtherDerived, std::size_t Size>
+  FixedProxy<Size> copyMeasurement(const OtherDerived& other);
+
   template <typename... Args>
   VariableProxy emplaceMeasurement(std::uint8_t size,
                                    Acts::GeometryIdentifier geometryId,
@@ -494,6 +490,22 @@ class VariableMeasurementProxy
   }
 };
 
+template <MeasurementConcept OtherDerived>
+MeasurementContainer::VariableProxy MeasurementContainer::copyMeasurement(
+    const OtherDerived& other) {
+  VariableProxy meas = makeMeasurement(other.size(), other.geometryId());
+  meas.copyFrom(other);
+  return meas;
+}
+
+template <MeasurementConcept OtherDerived, std::size_t Size>
+MeasurementContainer::FixedProxy<Size> MeasurementContainer::copyMeasurement(
+    const OtherDerived& other) {
+  FixedProxy<Size> meas = makeMeasurement<Size>(other.geometryId());
+  meas.copyFrom(other);
+  return meas;
+}
+
 template <typename... Args>
 MeasurementContainer::VariableProxy MeasurementContainer::emplaceMeasurement(
     std::uint8_t size, Acts::GeometryIdentifier geometryId, Args&&... args) {

Examples/Framework/include/ActsExamples/EventData/MeasurementConcept.hpp

@@ -8,7 +8,6 @@
 
 #pragma once
 
-#include "Acts/EventData/SourceLink.hpp"
 #include "Acts/Geometry/GeometryIdentifier.hpp"
 
 #include <concepts>
@@ -23,4 +22,5 @@ concept MeasurementConcept = requires(const T& m) {
   { m.parameters() };
   { m.covariance() };
 };
+
 }  // namespace ActsExamples