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

Adds DD4hep plugin layer (dd4hepplugins/) and a raindrop example geometry to run optical photon simulation through the DD4hep framework, both on CPU  (Geant4) and GPU (simphony).

Author: ggalgoczi

.gitignore

@@ -1 +1,4 @@
 *~
+dd4hepplugins/examples/drich-dev/
+dd4hepplugins/examples/calibrations/
+dd4hepplugins/examples/fieldmaps/

CMakeLists.txt

@@ -39,6 +39,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(dd4hepplugins/examples)
+else()
+    message(STATUS "DD4hep not found -- skipping dd4hepplugins")
+endif()
+
 # Export configs
 include(CMakePackageConfigHelpers)
 

dd4hepplugins/CMakeLists.txt

@@ -0,0 +1,63 @@
+#------------------------------- -*- 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}
+)
+# STANDALONE changes class export macros in eic-opticks headers;
+# only needed when building outside the main eic-opticks tree.
+if(NOT TARGET G4CX)
+    target_compile_definitions(ddeicopticks PRIVATE STANDALONE)
+endif()
+
+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,93 @@
+#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 <iostream>
+#include <vector>
+
+#include "G4PVPlacement.hh"
+#include "G4VSensitiveDetector.hh"
+
+#include "U4SensorIdentifier.h"
+
+struct DD4hepSensorIdentifier : public U4SensorIdentifier
+{
+    int level = 0;
+    int counter = 0; // auto-increment sensor ID (1-based; 0 means "not a sensor" in opticks)
+
+    void setLevel(int _level) override
+    {
+        level = _level;
+    }
+
+    /**
+    getGlobalIdentity
+    -------------------
+    Checks if the physical volume has a G4VSensitiveDetector attached.
+    Returns a unique 1-based sensor_id, or -1 if not sensitive.
+
+    Note: opticks treats sensor_id == 0 as "not a sensor", so IDs must be >= 1.
+    PV copy numbers are not reliable (e.g. dRICH SiPMs all have copyNo=0).
+    **/
+    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;
+
+        int sensor_id = ++counter; // 1-based unique ID
+
+        if (level > 0)
+            std::cout << "DD4hepSensorIdentifier::getGlobalIdentity" << " sensor_id " << sensor_id << " sd "
+                      << sd->GetName() << " pv " << pv->GetName() << std::endl;
+
+        return sensor_id;
+    }
+
+    /**
+    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);
+    }
+};