feat(dd4hep): add experimental DDG4 integration plugins and examples

CMakeLists.txt

@@ -41,6 +41,16 @@ add_subdirectory(g4cx)
 add_subdirectory(g4cx/tests)
 add_subdirectory(src)
 
+# Optional DD4hep integration plugins
+find_package(DD4hep QUIET COMPONENTS DDG4 DDCore)
+if(DD4hep_FOUND)
+    message(STATUS "DD4hep found -- building dd4hepplugins")
+    add_subdirectory(dd4hepplugins)
+    add_subdirectory(examples/dd4hep)
+else()
+    message(STATUS "DD4hep not found -- skipping dd4hepplugins")
+endif()
+
 # Export configs
 include(CMakePackageConfigHelpers)
 

dd4hepplugins/CMakeLists.txt

@@ -0,0 +1,59 @@
+#------------------------------- -*- cmake -*- -------------------------------#
+# eic-opticks DD4hep integration plugins
+#
+# Builds DD4hep action plugins that integrate eic-opticks GPU-accelerated
+# optical photon simulation into DD4hep/Geant4.
+#
+# Works both as part of the top-level eic-opticks build (in-tree) and as a
+# standalone project against an installed eic-opticks.
+#
+# Usage from a DD4hep steering file:
+#   OpticsRun      -- initializes/finalizes G4CXOpticks per run
+#   OpticsEvent    -- triggers GPU simulation per event
+#----------------------------------------------------------------------------#
+
+# Detect standalone vs in-tree build
+if(NOT TARGET G4CX)
+    cmake_minimum_required(VERSION 3.18 FATAL_ERROR)
+    project(ddeicopticks VERSION 0.1.0 LANGUAGES CXX)
+    find_package(DD4hep REQUIRED COMPONENTS DDG4 DDCore)
+    find_package(eic-opticks REQUIRED)
+    find_package(Geant4 REQUIRED)
+    set(_g4cx   eic-opticks::G4CX)
+    set(_u4     eic-opticks::U4)
+    set(_sysrap eic-opticks::SysRap)
+else()
+    # In-tree: DD4hep already found by parent, targets use local names
+    find_package(Geant4 REQUIRED)
+    set(_g4cx   G4CX)
+    set(_u4     U4)
+    set(_sysrap SysRap)
+endif()
+
+dd4hep_set_compiler_flags()
+
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
+set(LIBRARY_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}")
+
+dd4hep_add_plugin(ddeicopticks
+  SOURCES
+    OpticsPhysics.cc
+    OpticsRun.cc
+    OpticsEvent.cc
+  USES
+    DD4hep::DDG4
+    DD4hep::DDCore
+    ${_g4cx}
+    ${_u4}
+    ${_sysrap}
+)
+target_compile_definitions(ddeicopticks PRIVATE STANDALONE)
+
+install(TARGETS ddeicopticks
+  LIBRARY DESTINATION lib
+)
+
+install(FILES
+  ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_SHARED_MODULE_PREFIX}ddeicopticks.components
+  DESTINATION lib
+)

dd4hepplugins/OpticsEvent.cc

@@ -0,0 +1,179 @@
+#include "OpticsEvent.hh"
+
+#include <DD4hep/InstanceCount.h>
+#include <DDG4/Factories.h>
+#include <DDG4/Geant4Data.h>
+#include <DDG4/Geant4HitCollection.h>
+#include <DDG4/Geant4SensDetAction.h>
+#include <DDG4/Geant4Context.h>
+
+#include <G4Event.hh>
+
+#include <G4CXOpticks.hh>
+#include <SEvt.hh>
+#include <SComp.h>
+#include <sphoton.h>
+#include <NP.hh>
+#include <NPFold.h>
+
+namespace ddeicopticks
+{
+//---------------------------------------------------------------------------//
+OpticsEvent::OpticsEvent(dd4hep::sim::Geant4Context* ctxt,
+                         std::string const& name)
+    : dd4hep::sim::Geant4EventAction(ctxt, name)
+{
+    dd4hep::InstanceCount::increment(this);
+    declareProperty("Verbose", verbose_);
+}
+
+//---------------------------------------------------------------------------//
+OpticsEvent::~OpticsEvent()
+{
+    dd4hep::InstanceCount::decrement(this);
+}
+
+//---------------------------------------------------------------------------//
+void OpticsEvent::begin(G4Event const* event)
+{
+    int eventID = event->GetEventID();
+
+    if (verbose_ > 0)
+    {
+        info("OpticsEvent::begin -- event #%d", eventID);
+    }
+
+    SEvt::CreateOrReuse_EGPU();
+    SEvt* sev = SEvt::Get_EGPU();
+    if (sev)
+    {
+        sev->beginOfEvent(eventID);
+    }
+}
+
+//---------------------------------------------------------------------------//
+void OpticsEvent::end(G4Event const* event)
+{
+    int eventID = event->GetEventID();
+
+    G4CXOpticks* gx = G4CXOpticks::Get();
+    if (!gx)
+    {
+        error("OpticsEvent::end -- G4CXOpticks not initialized");
+        return;
+    }
+
+    SEvt* sev = SEvt::Get_EGPU();
+    if (!sev)
+    {
+        error("OpticsEvent::end -- no EGPU SEvt instance");
+        return;
+    }
+
+    int64_t num_genstep = sev->getNumGenstepFromGenstep();
+    int64_t num_photon = sev->getNumPhotonFromGenstep();
+
+    if (verbose_ > 0 || num_genstep > 0)
+    {
+        info("Event #%d: %lld gensteps, %lld photons to simulate",
+             eventID,
+             static_cast<long long>(num_genstep),
+             static_cast<long long>(num_photon));
+    }
+
+    if (num_genstep > 0)
+    {
+        gx->simulate(eventID, /*reset=*/false);
+
+        unsigned num_hit = sev->getNumHit();
+        info("Event #%d: %u hits from GPU", eventID, num_hit);
+
+        // Inject GPU hits into DD4hep sensitive detector hit collections
+        if (num_hit > 0)
+        {
+            injectHits(event, sev, num_hit);
+        }
+
+        sev->endOfEvent(eventID);
+        gx->reset(eventID);
+    }
+    else
+    {
+        if (verbose_ > 0)
+            info("Event #%d: no gensteps, skipping GPU simulation", eventID);
+        sev->endOfEvent(eventID);
+    }
+}
+
+//---------------------------------------------------------------------------//
+void OpticsEvent::injectHits(G4Event const* event,
+                             SEvt* sev,
+                             unsigned num_hit)
+{
+    using dd4hep::sim::Geant4SensDetSequences;
+    using dd4hep::sim::Geant4HitCollection;
+    using dd4hep::sim::Geant4Tracker;
+
+    int eventID = event->GetEventID();
+
+    Geant4SensDetSequences& sens = context()->sensitiveActions();
+    auto const& seqs = sens.sequences();
+
+    if (seqs.empty())
+    {
+        warning("Event #%d: no sensitive detectors registered -- "
+                "call setupTracker() in steering script", eventID);
+        return;
+    }
+
+    for (auto const& [det_name, seq] : seqs)
+    {
+        Geant4HitCollection* coll = seq->collection(0);
+        if (!coll)
+            continue;
+
+        for (unsigned i = 0; i < num_hit; i++)
+        {
+            sphoton ph;
+            sev->getHit(ph, i);
+            coll->add(createTrackerHit(ph));
+        }
+
+        info("Event #%d: injected %u hits into '%s' collection",
+             eventID, num_hit, det_name.c_str());
+    }
+}
+
+//---------------------------------------------------------------------------//
+dd4hep::sim::Geant4Tracker::Hit*
+OpticsEvent::createTrackerHit(sphoton const& ph)
+{
+    using dd4hep::sim::Geant4Tracker;
+
+    auto* hit = new Geant4Tracker::Hit();
+
+    hit->position = {ph.pos.x, ph.pos.y, ph.pos.z};
+    hit->momentum = {ph.mom.x, ph.mom.y, ph.mom.z};
+    hit->length = ph.wavelength;
+    hit->energyDeposit = 0;
+    hit->cellID = ph.identity;
+
+    hit->truth.trackID = ph.index;
+    hit->truth.pdgID = 0;
+    hit->truth.deposit = 0;
+    hit->truth.time = ph.time;
+    hit->truth.length = ph.wavelength;
+    hit->truth.x = ph.pos.x;
+    hit->truth.y = ph.pos.y;
+    hit->truth.z = ph.pos.z;
+    hit->truth.px = ph.mom.x;
+    hit->truth.py = ph.mom.y;
+    hit->truth.pz = ph.mom.z;
+
+    return hit;
+}
+
+//---------------------------------------------------------------------------//
+}  // namespace ddeicopticks
+
+DECLARE_GEANT4ACTION_NS(ddeicopticks, OpticsEvent)

dd4hepplugins/OpticsEvent.hh

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <string>
+#include <DDG4/Geant4Action.h>
+#include <DDG4/Geant4EventAction.h>
+#include <DDG4/Geant4Data.h>
+
+class SEvt;
+struct sphoton;
+
+namespace ddeicopticks
+{
+//---------------------------------------------------------------------------//
+/*!
+ * DDG4 action plugin for eic-opticks event-level GPU simulation.
+ *
+ * At begin-of-event: prepares GPU event buffer (SEvt).
+ * At end-of-event: triggers GPU optical photon simulation via
+ * G4CXOpticks::simulate(), retrieves hits, injects them into DD4hep
+ * hit collections, and resets for next event.
+ *
+ * Requires setupTracker() to be called in the steering script so that
+ * DD4hep creates hit collections for the sensitive detectors.
+ *
+ * Properties:
+ *   - Verbose (default: 0) -- verbosity level
+ */
+class OpticsEvent final : public dd4hep::sim::Geant4EventAction
+{
+  public:
+    OpticsEvent(dd4hep::sim::Geant4Context* ctxt, std::string const& name);
+
+    void begin(G4Event const* event) final;
+    void end(G4Event const* event) final;
+
+  protected:
+    DDG4_DEFINE_ACTION_CONSTRUCTORS(OpticsEvent);
+    ~OpticsEvent() final;
+
+  private:
+    void injectHits(G4Event const* event, SEvt* sev, unsigned num_hit);
+    static dd4hep::sim::Geant4Tracker::Hit* createTrackerHit(sphoton const& ph);
+
+    int verbose_{0};
+};
+
+//---------------------------------------------------------------------------//
+}  // namespace ddeicopticks