Performance studies

CSG/csg_intersect_leaf_newcone.h

@@ -119,5 +119,3 @@ void intersect_leaf_newcone( bool& valid_isect, float4& isect, const quad& q0, c
         isect.w = t_cand ; 
     }
 }
-
-

README.md

@@ -125,3 +125,66 @@ Process](https://geant4-userdoc.web.cern.ch/UsersGuides/ForApplicationDeveloper/
   ...
 </gdml>
 ```
+
+
+## User/developer defined inputs
+
+### Defining primary particles
+
+There are certain user defined inputs that the user/developer has to define. In
+the ```src/simg4oxmt``` example that imports ```src/g4appmt.h``` we provide
+a working example with a simple geometry. The User/developer has to change the
+following details: **Number of primary particles** to simulate in a macro file
+and the **number of G4 threads**. For example:
+
+```
+/run/numberOfThreads {threads}
+/run/verbose 1
+/process/optical/cerenkov/setStackPhotons {flag}
+/run/initialize
+/run/beamOn 500
+```
+
+Here setStackPhotons defines **whether G4 will propagate optical photons or
+not**. In production Opticks (GPU) takes care of the optical photon propagation.
+Additionally the user has to define the **starting position**, **momentum** etc
+of the primary particles define in the **GeneratePrimaries** function in
+``src/g4appmt.h```. The hits of the optical photons are returned in the
+**EndOfRunAction** function. If more photons are simulated than can fit in the
+GPU RAM the execution of a GPU call should be moved to **EndOfEventAction**
+together with retriving the hits.
+
+### Loading in geometry into EIC-Opticks
+
+EIC-Opticks can import geometries with GDML format automatically. There are
+about 10 primitives supported now, eg. G4Box. G4Trd or G4Trap are not supported
+yet, we are working on them. ```src/simg4oxmt``` takes GDML files through
+arguments, eg. ```src/simg4oxmt -g mygdml.gdml```.
+
+The GDML must define all optical properties of surfaces of materials including:
+- Efficiency (used by EIC-Opticks to specify detection efficiency and assign
+  sensitive surfaces)
+- Refractive index
+- Group velocity
+- Reflectivity
+- Etc.
+
+
+## Performance studies
+
+In order to quantify the speed-up achieved by EIC-Opticks compared to G4 we
+provide a python code that runs the same G4 simulation with and without tracking
+optical photons in G4. The difference of the runs will yield the time required
+to simulate photons. Meanwhile the same photons are simulated on GPU with
+EIC-Opticks and the simulation time is saved.
+
+```
+mkdir -p /tmp/out/dev
+mkdir -p /tmp/out/rel
+
+docker build -t eic-opticks:perf-dev --target=develop
+docker run --rm -t -v /tmp/out:/tmp/out eic-opticks:perf-dev run-performance -o /tmp/out/dev
+
+docker build -t eic-opticks:perf-rel --target=release
+docker run --rm -t -v /tmp/out:/tmp/out eic-opticks:perf-rel run-performance -o /tmp/out/rel
+```

optiphy/tools/run_performance.py

@@ -0,0 +1,114 @@
+import argparse
+import subprocess
+import re
+import os
+from pathlib import Path
+
+run_mac_template = """
+/run/numberOfThreads {threads}
+/run/verbose 1
+/process/optical/cerenkov/setStackPhotons {flag}
+/run/initialize
+/run/beamOn 500
+"""
+
+os.environ["OPTICKS_EVENT_MODE"] = "Minimal"
+
+def get_opticks_home():
+    """Get OPTICKS_HOME from environment, warn if not set."""
+    opticks_home = os.environ.get("OPTICKS_HOME")
+    if opticks_home is None:
+        print("Warning: $OPTICKS_HOME is not defined, so this script should be called from the eic-opticks directory.")
+        return Path(".")
+    return Path(opticks_home)
+
+def parse_real_time(time_str):
+    # Parses 'real\t0m41.149s' to seconds
+    match = re.search(r'real\s+(\d+)m([\d.]+)s', time_str)
+    if match:
+        minutes = int(match.group(1))
+        seconds = float(match.group(2))
+        return minutes * 60 + seconds
+    return None
+
+def parse_sim_time(output):
+    match = re.search(r"Simulation time:\s*([\d.]+)\s*seconds", output)
+    if match:
+        return float(match.group(1))
+    return None
+
+def main():
+    opticks_home = get_opticks_home()
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-g', '--gdml', type=Path, default=None, help="Path to a custom GDML geometry file (relative to current directory)")
+    parser.add_argument('-o', '--outpath', type=Path, default=Path('./'), help="Path where the output file will be saved")
+    args = parser.parse_args()
+
+    # If gdml not provided, use default path relative to OPTICKS_HOME
+    if args.gdml is None:
+        gdml_path = opticks_home / 'tests/geom/opticks_raindrop.gdml'
+    else:
+        # User-provided path is used as-is (relative to current directory or absolute)
+        gdml_path = args.gdml
+
+    # run.mac is created in OPTICKS_HOME
+    run_mac_path = opticks_home / "run.mac"
+
+    geant_file = args.outpath / "timing_geant.txt"
+    optix_file = args.outpath / "timing_optix.txt"
+    log_file = args.outpath / "g4logs.txt"
+
+    with open(geant_file, "w") as gfile, open(optix_file, "w") as ofile, open(log_file, "w") as logfile:
+        for threads in range(50, 0, -1):
+            times = {}
+            sim_time_true = None
+            for flag in ['true', 'false']:
+                # Write run.mac with current flag
+                with open(run_mac_path, "w") as rm:
+                    rm.write(run_mac_template.format(threads=threads, flag=flag))
+
+                # Run with time in bash to capture real/user/sys
+                cmd = f"time simg4oxmt -g {gdml_path} -m {run_mac_path}"
+                print(f"Running {threads} threads: {cmd}")
+                result = subprocess.run(
+                    ["bash", "-c", cmd],
+                    capture_output=True, text=True
+                )
+                stdout = result.stdout
+                stderr = result.stderr
+                # Save full output to log file
+                logfile.write(f"\n{'='*60}\n")
+                logfile.write(f"Threads: {threads}, StackPhotons: {flag}\n")
+                logfile.write(f"{'='*60}\n")
+                logfile.write(f"--- STDOUT ---\n{stdout}\n")
+                logfile.write(f"--- STDERR ---\n{stderr}\n")
+                logfile.flush()
+
+                # Save simulation time for true run only
+                if flag == 'true':
+                    sim_time_true = parse_sim_time(stdout + stderr)
+                    if sim_time_true is not None:
+                        ofile.write(f"{threads} {sim_time_true}\n")
+                        ofile.flush()
+
+                # Extract real time
+                real_match = re.search(r"real\s+\d+m[\d.]+s", stderr)
+                if real_match:
+                    real_sec = parse_real_time(real_match.group())
+                    times[flag] = real_sec
+                else:
+                    print(f"[!] Could not find 'real' time for threads={threads} flag={flag}")
+
+            # Write the difference to timing_geant.txt (true - false)
+            if 'true' in times and 'false' in times:
+                diff = times['true'] - times['false']
+                gfile.write(f"{threads} {diff}\n")
+                gfile.flush()
+            else:
+                print(f"[!] Missing times for threads={threads}")
+
+    print("Done.")
+
+if __name__ == '__main__':
+    main()

pyproject.toml

@@ -14,6 +14,7 @@ dependencies = [
 generate-input-photons = "optiphy.tools.generate_input_photons:main"
 plot-csg = "optiphy.tools.plot_csg:main"
 serve-path = "optiphy.tools.serve_path:main"
+run-performance = "optiphy.tools.run_performance:main"
 
 [build-system]
 requires = ["setuptools", "wheel"]

src/CMakeLists.txt

@@ -32,6 +32,14 @@ target_include_directories(simg4ox PRIVATE
     $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
 )
 
+# simg4ox runs Geant4 and OptiX simulations
+add_executable(simg4oxmt simg4oxmt.cpp g4appmt.h)
+target_link_libraries(simg4oxmt gphox)
+target_include_directories(simg4oxmt PRIVATE
+    $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>
+    $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
+)
+
 # simtox creates a numpy file with initial photons for simulation
 add_executable(simtox simtox.cpp)
 
@@ -42,7 +50,7 @@ target_include_directories(simtox PRIVATE
     $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
 )
 
-install(TARGETS consgeo simg4ox simtox gphox
+install(TARGETS consgeo simg4ox simg4oxmt simtox gphox
     EXPORT ${PROJECT_NAME}Targets
     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}