Fix G4VExceptionHandler lifetime and improve exception wrapping

src/celeritas/CMakeLists.txt

@@ -120,8 +120,8 @@ if(CELERITAS_USE_Geant4)
     ext/GeantImporter.cc
     ext/GeantSetup.cc
     ext/GeantVolumeMapper.cc
+    ext/ScopedGeantExceptionHandler.cc
     ext/detail/GeantBremsstrahlungProcess.cc
-    ext/detail/GeantExceptionHandler.cc
     ext/detail/GeantLoggerAdapter.cc
     ext/detail/GeantMicroXsCalculator.cc
     ext/detail/GeantModelImporter.cc

src/celeritas/ext/GeantSetup.cc

@@ -31,7 +31,7 @@
 #include "corecel/sys/ScopedMem.hh"
 
 #include "GeantGeoUtils.hh"
-#include "detail/GeantExceptionHandler.hh"
+#include "ScopedGeantExceptionHandler.hh"
 #include "detail/GeantLoggerAdapter.hh"
 #include "detail/GeantPhysicsList.hh"
 
@@ -94,7 +94,7 @@ GeantSetup::GeantSetup(std::string const& gdml_filename, Options options)
     {
         // Run manager writes output that cannot be redirected...
         ScopedTimeAndRedirect scoped_time("G4RunManager");
-        detail::GeantExceptionHandler scoped_exception_handler;
+        ScopedGeantExceptionHandler scoped_exceptions;
         // Access the particle table before creating the run manager, so that
         // missing environment variables like G4ENSDFSTATEDATA get caught
         // cleanly rather than segfaulting
@@ -123,7 +123,7 @@ GeantSetup::GeantSetup(std::string const& gdml_filename, Options options)
     }
 
     detail::GeantLoggerAdapter scoped_logger;
-    detail::GeantExceptionHandler scoped_exception_handler;
+    ScopedGeantExceptionHandler scoped_exceptions;
 
     {
         CELER_LOG(status) << "Initializing Geant4 geometry and physics";

src/celeritas/ext/ScopedGeantExceptionHandler.cc

@@ -0,0 +1,112 @@
+//----------------------------------*-C++-*----------------------------------//
+// Copyright 2023 UT-Battelle, LLC, and other Celeritas developers.
+// See the top-level COPYRIGHT file for details.
+// SPDX-License-Identifier: (Apache-2.0 OR MIT)
+//---------------------------------------------------------------------------//
+//! \file celeritas/ext/ScopedGeantExceptionHandler.cc
+//---------------------------------------------------------------------------//
+#include "ScopedGeantExceptionHandler.hh"
+
+#include <G4ExceptionSeverity.hh>
+#include <G4StateManager.hh>
+#include <G4Types.hh>
+#include <G4VExceptionHandler.hh>
+
+#include "corecel/Assert.hh"
+#include "corecel/io/Logger.hh"
+
+namespace celeritas
+{
+namespace
+{
+//---------------------------------------------------------------------------//
+/*!
+ * Process Geant4 exceptions with Celeritas.
+ *
+ * The Geant exception handler base class changes global state in its
+ * constructor (assigning "this") so this class instance must stay in scope
+ * once created. There is no way to save or restore the previous handler.
+ * Furthermore, creating a G4RunManagerKernel also resets the exception
+ * handler, so errors thrown during setup *CANNOT* be caught by celeritas, and
+ * this class can only be used after creating the G4RunManager.
+ */
+class GeantExceptionHandler final : public G4VExceptionHandler
+{
+  public:
+    // Accept error codes from geant4
+    G4bool Notify(char const* originOfException,
+                  char const* exceptionCode,
+                  G4ExceptionSeverity severity,
+                  char const* description) final;
+};
+
+//---------------------------------------------------------------------------//
+/*!
+ * Propagate exceptions to Celeritas.
+ */
+G4bool GeantExceptionHandler::Notify(char const* origin_of_exception,
+                                     char const* exception_code,
+                                     G4ExceptionSeverity severity,
+                                     char const* description)
+{
+    CELER_EXPECT(origin_of_exception);
+    CELER_EXPECT(exception_code);
+
+    // Construct message
+    auto err = RuntimeError::from_geant_exception(
+        origin_of_exception, exception_code, description);
+
+    switch (severity)
+    {
+        case FatalException:
+        case FatalErrorInArgument:
+        case RunMustBeAborted:
+        case EventMustBeAborted:
+            // Severe or initialization error
+            throw err;
+        case JustWarning:
+            // Display a message
+            CELER_LOG_LOCAL(error) << err.what();
+            break;
+        default:
+            CELER_ASSERT_UNREACHABLE();
+    }
+
+    // Return "true" to cause Geant4 to crash the program, or "false" to let it
+    // know that we've handled the exception.
+    return false;
+}
+
+//---------------------------------------------------------------------------//
+}  // namespace
+
+//---------------------------------------------------------------------------//
+/*!
+ * Install the Celeritas Geant4 exception handler.
+ *
+ * The base class of the exception handler calls SetExceptionHandler...
+ */
+ScopedGeantExceptionHandler::ScopedGeantExceptionHandler()
+{
+    auto* state_mgr = G4StateManager::GetStateManager();
+    CELER_ASSERT(state_mgr);
+    previous_ = state_mgr->GetExceptionHandler();
+    current_ = std::make_unique<GeantExceptionHandler>();
+    CELER_ENSURE(state_mgr->GetExceptionHandler() == current_.get());
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Revert to the previous exception handler.
+ */
+ScopedGeantExceptionHandler::~ScopedGeantExceptionHandler()
+{
+    auto* state_mgr = G4StateManager::GetStateManager();
+    if (state_mgr->GetExceptionHandler() == current_.get())
+    {
+        state_mgr->SetExceptionHandler(previous_);
+    }
+}
+
+//---------------------------------------------------------------------------//
+}  // namespace celeritas

src/celeritas/ext/ScopedGeantExceptionHandler.hh

@@ -0,0 +1,51 @@
+//----------------------------------*-C++-*----------------------------------//
+// Copyright 2023 UT-Battelle, LLC, and other Celeritas developers.
+// See the top-level COPYRIGHT file for details.
+// SPDX-License-Identifier: (Apache-2.0 OR MIT)
+//---------------------------------------------------------------------------//
+//! \file celeritas/ext/ScopedGeantExceptionHandler.hh
+//---------------------------------------------------------------------------//
+#pragma once
+
+#include <memory>
+
+#include "celeritas_config.h"
+
+class G4VExceptionHandler;
+
+namespace celeritas
+{
+//---------------------------------------------------------------------------//
+/*!
+ * Install and clear a Geant exception handler during this class lifetime.
+ *
+ * Note that creating a \c G4RunManagerKernel resets the exception
+ * handler, so errors thrown during setup *CANNOT* be caught by Celeritas, and
+ * this class can only be used after creating the \c G4RunManager.
+ */
+class ScopedGeantExceptionHandler
+{
+  public:
+    // Construct exception handler
+    ScopedGeantExceptionHandler();
+
+    // Clear on destruction
+    ~ScopedGeantExceptionHandler();
+
+  private:
+#if CELERITAS_USE_GEANT4
+    G4VExceptionHandler* previous_{nullptr};
+    std::unique_ptr<G4VExceptionHandler> current_;
+#endif
+};
+
+#if !CELERITAS_USE_GEANT4
+//!@{
+//! Do nothing if Geant4 is disabled (source file will not be compiled)
+inline ScopedGeantExceptionHandler::ScopedGeantExceptionHandler() {}
+inline ScopedGeantExceptionHandler::~ScopedGeantExceptionHandler() {}
+//!@}
+#endif
+
+//---------------------------------------------------------------------------//
+}  // namespace celeritas

src/celeritas/ext/ScopedRootErrorHandler.cc

@@ -71,17 +71,22 @@ void RootErrorHandler(Int_t rootlevel,
 
 //---------------------------------------------------------------------------//
 /*!
- * Install the Celeritas ROOT error handler
+ * Clear ROOT's signal handlers that get installed on startup/activation.
+ */
+void ScopedRootErrorHandler::disable_signal_handler()
+{
+    gSystem->ResetSignals();
+}
+
+//---------------------------------------------------------------------------//
+/*!
+ * Install the Celeritas ROOT error handler.
  */
 ScopedRootErrorHandler::ScopedRootErrorHandler()
     : previous_(SetErrorHandler(RootErrorHandler))
     , prev_errored_{g_has_root_errored_}
 {
-    // Disable ROOT interception of system signals the first time we run
-    [[maybe_unused]] static bool const disabled_root_backtrace = [] {
-        gSystem->ResetSignals();
-        return true;
-    }();
+    ScopedRootErrorHandler::disable_signal_handler();
 }
 
 //---------------------------------------------------------------------------//
@@ -101,7 +106,7 @@ void ScopedRootErrorHandler::throw_if_errors() const
 
 //---------------------------------------------------------------------------//
 /*!
- * Revert to the previous ROOT error handler
+ * Revert to the previous ROOT error handler.
  */
 ScopedRootErrorHandler::~ScopedRootErrorHandler()
 {

src/celeritas/ext/ScopedRootErrorHandler.hh

@@ -19,6 +19,9 @@ namespace celeritas
 class ScopedRootErrorHandler
 {
   public:
+    // Clear ROOT's signal handlers that get installed on startup/activation
+    static void disable_signal_handler();
+
     // Install the error handler
     ScopedRootErrorHandler();
 
@@ -38,6 +41,7 @@ class ScopedRootErrorHandler
 #if !CELERITAS_USE_ROOT
 //!@{
 //! Do nothing if ROOT is disabled (source file will not be compiled)
+inline void ScopedRootErrorHandler::disable_signal_handler() {}
 inline ScopedRootErrorHandler::ScopedRootErrorHandler()
 {
     (void)sizeof(previous_);

test/CMakeLists.txt

@@ -251,6 +251,7 @@ celeritas_add_library(testcel_celeritas
   celeritas/user/ExampleMctruth.cc
   celeritas/user/CaloTestBase.cc
   celeritas/user/MctruthTestBase.cc
+  celeritas/user/StepCollectorTestBase.cc
 )
 
 celeritas_target_link_libraries(testcel_celeritas