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
+    OpticsRun.cc
+    OpticsEvent.cc
+    OpticsSteppingAction.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/DD4hepSensorIdentifier.hh

@@ -0,0 +1,85 @@
+#pragma once
+/**
+DD4hepSensorIdentifier.hh
+===========================
+
+Custom sensor identifier for DD4hep geometries.
+
+Unlike the default U4SensorIdentifierDefault which relies on
+GLOBAL_SENSOR_BOUNDARY_LIST env var for non-instanced geometries,
+this implementation directly checks G4VSensitiveDetector on volumes.
+
+This works for DD4hep geometries where sensitive detectors are
+explicitly set via DetElement::setSensitiveDetector().
+**/
+
+#include "G4PVPlacement.hh"
+#include "G4VSensitiveDetector.hh"
+
+#include "U4SensorIdentifier.h"
+
+struct DD4hepSensorIdentifier : public U4SensorIdentifier
+{
+    int level = 0 ;
+
+    void setLevel(int _level) override { level = _level ; }
+
+    /**
+    getGlobalIdentity
+    -------------------
+    Checks if the physical volume has a G4VSensitiveDetector attached.
+    Returns the copy number as sensor_id, or -1 if not sensitive.
+    **/
+    int getGlobalIdentity(const G4VPhysicalVolume* pv,
+                          const G4VPhysicalVolume* /*ppv*/) override
+    {
+        if (!pv) return -1 ;
+
+        const G4LogicalVolume* lv = pv->GetLogicalVolume() ;
+        G4VSensitiveDetector* sd = lv->GetSensitiveDetector() ;
+
+        if (!sd) return -1 ;
+
+        const G4PVPlacement* pvp = dynamic_cast<const G4PVPlacement*>(pv) ;
+        int copyno = pvp ? pvp->GetCopyNo() : 0 ;
+
+        if (level > 0)
+            std::cout << "DD4hepSensorIdentifier::getGlobalIdentity"
+                      << " copyno " << copyno
+                      << " sd " << sd->GetName()
+                      << " pv " << pv->GetName()
+                      << std::endl ;
+
+        return copyno ;
+    }
+
+    /**
+    getInstanceIdentity
+    ---------------------
+    Same as default: recursively search for G4VSensitiveDetector
+    within the instance subtree.
+    **/
+    int getInstanceIdentity(const G4VPhysicalVolume* instance_outer_pv) const override
+    {
+        if (!instance_outer_pv) return -1 ;
+
+        std::vector<const G4VPhysicalVolume*> sdpv ;
+        FindSD_r(sdpv, instance_outer_pv, 0) ;
+
+        if (sdpv.empty()) return -1 ;
+
+        const G4PVPlacement* pvp =
+            dynamic_cast<const G4PVPlacement*>(instance_outer_pv) ;
+        return pvp ? pvp->GetCopyNo() : 0 ;
+    }
+
+    static void FindSD_r(std::vector<const G4VPhysicalVolume*>& sdpv,
+                         const G4VPhysicalVolume* pv, int depth)
+    {
+        const G4LogicalVolume* lv = pv->GetLogicalVolume() ;
+        G4VSensitiveDetector* sd = lv->GetSensitiveDetector() ;
+        if (sd) sdpv.push_back(pv) ;
+        for (size_t i = 0; i < size_t(lv->GetNoDaughters()); i++)
+            FindSD_r(sdpv, lv->GetDaughter(i), depth + 1) ;
+    }
+};

dd4hepplugins/OpticsEvent.cc

@@ -0,0 +1,197 @@
+#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 <chrono>
+
+#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_);
+    declareProperty("PhotonThreshold", photon_threshold_);
+}
+
+//---------------------------------------------------------------------------//
+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);
+
+    // In batch mode, only start a new SEvt at the beginning of each batch.
+    // Skipping beginOfEvent between events lets gensteps accumulate
+    // (SEvt::clear_output preserves gensteps by design).
+    if (!batch_begun_)
+    {
+        SEvt::CreateOrReuse_EGPU();
+        SEvt* sev = SEvt::Get_EGPU();
+        if (sev)
+            sev->beginOfEvent(eventID);
+        batch_begun_ = true;
+    }
+}
+
+//---------------------------------------------------------------------------//
+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 accumulated",
+             eventID,
+             static_cast<long long>(num_genstep),
+             static_cast<long long>(num_photon));
+    }
+
+    // Batch mode: keep accumulating until threshold reached
+    if (photon_threshold_ > 0 && num_photon < photon_threshold_)
+        return;
+
+    if (num_genstep > 0)
+    {
+        auto sim_t0 = std::chrono::high_resolution_clock::now();
+        gx->simulate(eventID, /*reset=*/false);
+        auto sim_t1 = std::chrono::high_resolution_clock::now();
+        double simulate_ms =
+            std::chrono::duration<double, std::milli>(sim_t1 - sim_t0).count();
+
+        unsigned num_hit = sev->getNumHit();
+        info("OPTICKS_GPU_TIME event=%d ms=%.3f photons=%lld hits=%u",
+             eventID, simulate_ms,
+             static_cast<long long>(num_photon), num_hit);
+
+        // Inject hits only in per-event mode; batch mode cannot map
+        // hits back to individual events.
+        if (photon_threshold_ == 0 && 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);
+        if (photon_threshold_ == 0)
+            sev->endOfEvent(eventID);
+    }
+
+    batch_begun_ = false;
+}
+
+//---------------------------------------------------------------------------//
+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)