refactor: Reduce WARNING verbosity in 2 cases

Core/include/Acts/TrackFitting/GaussianSumFitter.hpp

@@ -317,6 +317,8 @@ struct GaussianSumFitter {
     ACTS_VERBOSE("- processed states: " << fwdGsfResult.processedStates);
     ACTS_VERBOSE("- measuerement states: " << fwdGsfResult.measurementStates);
 
+    std::size_t nInvalidBetheHeitler = fwdGsfResult.nInvalidBetheHeitler;
+
     //////////////////
     // Backward pass
     //////////////////
@@ -400,6 +402,16 @@ struct GaussianSumFitter {
           GsfError::NoMeasurementStatesCreatedBackward);
     }
 
+    nInvalidBetheHeitler += bwdGsfResult.nInvalidBetheHeitler;
+
+    if (nInvalidBetheHeitler > 0) {
+      ACTS_WARNING("Encountered "
+                   << nInvalidBetheHeitler
+                   << " cases where the material thickness exceeds the range "
+                      "of the Bethe-Heitler-Approximation. Enable DEBUG output "
+                      "for more information.");
+    }
+
     ////////////////////////////////////
     // Create Kalman Result
     ////////////////////////////////////

Core/include/Acts/TrackFitting/detail/GsfActor.hpp

@@ -56,6 +56,8 @@ struct GsfResult {
   std::vector<const Acts::Surface*> visitedSurfaces;
   std::vector<const Acts::Surface*> surfacesVisitedBwdAgain;
 
+  std::size_t nInvalidBetheHeitler = 0;
+
   // Propagate potential errors to the outside
   Result<void> result{Result<void>::success()};
 
@@ -308,7 +310,8 @@ struct GsfActor {
       std::vector<ComponentCache>& componentCache = result.componentCache;
       componentCache.clear();
 
-      convoluteComponents(state, stepper, navigator, tmpStates, componentCache);
+      convoluteComponents(state, stepper, navigator, tmpStates, componentCache,
+                          result.nInvalidBetheHeitler);
 
       if (componentCache.empty()) {
         ACTS_WARNING(
@@ -344,7 +347,8 @@ struct GsfActor {
   void convoluteComponents(propagator_state_t& state, const stepper_t& stepper,
                            const navigator_t& navigator,
                            const TemporaryStates& tmpStates,
-                           std::vector<ComponentCache>& componentCache) const {
+                           std::vector<ComponentCache>& componentCache,
+                           std::size_t& nInvalidBetheHeitler) const {
     auto cmps = stepper.componentIterable(state.stepping);
     for (auto [idx, cmp] : zip(tmpStates.tips, cmps)) {
       auto proxy = tmpStates.traj.getTrackState(idx);
@@ -361,7 +365,7 @@ struct GsfActor {
                                  proxy.filtered(), proxy.filteredCovariance());
 
       applyBetheHeitler(state, navigator, bound, tmpStates.weights.at(idx),
-                        mcache, componentCache);
+                        mcache, componentCache, nInvalidBetheHeitler);
     }
   }
 
@@ -370,7 +374,8 @@ struct GsfActor {
                          const navigator_t& navigator,
                          const BoundTrackParameters& old_bound,
                          const double old_weight, const MetaCache& metaCache,
-                         std::vector<ComponentCache>& componentCaches) const {
+                         std::vector<ComponentCache>& componentCaches,
+                         std::size_t& nInvalidBetheHeitler) const {
     const auto& surface = *navigator.currentSurface(state.navigation);
     const auto p_prev = old_bound.absoluteMomentum();
 
@@ -386,7 +391,8 @@ struct GsfActor {
 
     // Emit a warning if the approximation is not valid for this x/x0
     if (not m_cfg.bethe_heitler_approx->validXOverX0(slab.thicknessInX0())) {
-      ACTS_WARNING(
+      ++nInvalidBetheHeitler;
+      ACTS_DEBUG(
           "Bethe-Heitler approximation encountered invalid value for x/x0="
           << slab.thicknessInX0() << " at surface " << surface.geometryId());
     }

Examples/Algorithms/Digitization/src/DigitizationAlgorithm.cpp

@@ -150,6 +150,9 @@ ActsExamples::ProcessCode ActsExamples::DigitizationAlgorithm::execute(
   // Setup random number generator
   auto rng = m_cfg.randomNumbers->spawnGenerator(ctx);
 
+  // Some statistics
+  std::size_t skippedHits = 0;
+
   ACTS_DEBUG("Starting loop over modules ...");
   for (const auto& simHitsGroup : groupByModule(simHits)) {
     // Manual pair unpacking instead of using
@@ -222,8 +225,9 @@ ActsExamples::ProcessCode ActsExamples::DigitizationAlgorithm::execute(
               auto res =
                   digitizer.smearing(rng, simHit, *surfacePtr, ctx.geoContext);
               if (not res.ok()) {
-                ACTS_WARNING("Problem in hit smearing, skip hit ("
-                             << res.error().message() << ")");
+                ++skippedHits;
+                ACTS_DEBUG("Problem in hit smearing, skip hit ("
+                           << res.error().message() << ")");
                 continue;
               }
               const auto& [par, cov] = res.value();
@@ -274,6 +278,12 @@ ActsExamples::ProcessCode ActsExamples::DigitizationAlgorithm::execute(
         *digitizerItr);
   }
 
+  if (skippedHits > 0) {
+    ACTS_WARNING(
+        skippedHits
+        << " skipped in Digitization. Enable DEBUG mode to see more details.");
+  }
+
   m_sourceLinkWriteHandle(ctx, std::move(sourceLinks));
   m_measurementWriteHandle(ctx, std::move(measurements));
   m_clusterWriteHandle(ctx, std::move(clusters));