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(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,91 @@
+#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) ;
+    }
+};