new options -digitization_variation in gdynamicdigitization overwrites gsystem variation if present. passed to digitization routines

Author: maureeungaro

.github/workflows/binary_tarballs.yml

@@ -24,7 +24,7 @@ jobs:
     if: >-
       ${{
         github.event.workflow_run.conclusion == 'success' &&
-        github.event.workflow_run.event == 'push'
+        github.event.workflow_run.head_repository.full_name == github.repository
       }}
     name: Attach GEMC tarballs to dev release
     runs-on: ubuntu-latest
@@ -66,7 +66,7 @@ jobs:
     if: >-
       ${{
         github.event.workflow_run.conclusion == 'success' &&
-        github.event.workflow_run.event == 'push'
+        github.event.workflow_run.head_repository.full_name == github.repository
       }}
     name: Create Job Matrix
     runs-on: ubuntu-latest

.github/workflows/trigger_clas12_systems_tests.yml

@@ -24,13 +24,16 @@ on:
 jobs:
   dispatch:
     name: Dispatch clas12-systems Test
-    # Security: only dispatch for a successful push to the base repo. workflow_run
-    # runs privileged (here it consumes CLAS12_SYSTEMS_PAT), so guard against
-    # fork-PR events the same way deploy.yml and binary_tarballs.yml do.
+    # Security: only dispatch when the upstream chain originated in the base repo
+    # (not a fork). This is a 2nd-hop workflow_run (Deploy is itself workflow_run-
+    # triggered), so workflow_run.event is always 'workflow_run' here, not 'push' --
+    # head_repository is what carries the original source through the chain. This
+    # workflow_run runs privileged (it consumes CLAS12_SYSTEMS_PAT), so the guard
+    # keeps fork PRs from reaching the dispatch step.
     if: >-
       ${{
         github.event.workflow_run.conclusion == 'success' &&
-        github.event.workflow_run.event == 'push'
+        github.event.workflow_run.head_repository.full_name == github.repository
       }}
     runs-on: ubuntu-latest
     steps:

gemc/eventDispenser/eventDispenser.cc

@@ -157,7 +157,12 @@ int EventDispenser::processEvents() {
 			// Iterate the (plugin name -> digitization routine) map.
 			// digiRoutine is a std::shared_ptr<GDynamicDigitization>.
 			for (const auto& [plugin, digiRoutine] : *gDigitizationMap) {
-				log->debug(NORMAL, FUNCTION_NAME, "Calling ", plugin, " loadConstants for run ", runNumber);
+				// The variation is resolved per routine at geometry load (gsystem variation,
+				// or the digitization_variation option override when set).
+				const std::string& variation = digiRoutine->getDigitizationVariation();
+
+				log->debug(NORMAL, FUNCTION_NAME, "Calling ", plugin, " loadConstants for run ", runNumber,
+				           " with variation ", variation);
 				if (digiRoutine->loadConstants(runNumber, variation) == false) {
 					log->error(ERR_LOADCONSTANTFAIL,
 					           "Failed to load constants for ", plugin, " for run ", runNumber, " with variation ",

gemc/eventDispenser/eventDispenser.h

@@ -6,7 +6,6 @@
 #include <map>
 #include <memory>
 #include <vector>
-#include <string>
 
 /**
  * \file eventDispenser.h
@@ -67,9 +66,6 @@ class EventDispenser : public GBase<EventDispenser>
 	/// Most recently processed run number. Used to detect run changes and reload run-dependent data.
 	int currentRunno = -1;
 
-	/// Variation string passed to digitization routines when loading constants/translation tables.
-	std::string variation;
-
 	/** @} */
 
 	/**

gemc/gdetector/gdetectorConstruction.cc

@@ -257,6 +257,23 @@ void GDetectorConstruction::loadDigitizationPlugins() {
 	// when the geometry is reloaded with the same SD names.
 	digitization_routines_map->clear();
 
+	// Resolve the variation each routine uses to load constants / translation tables.
+	// By default a routine follows the variation of the gsystem it belongs to; the
+	// digitization_variation option, when set, overrides that for every routine.
+	const std::string digiVariationOverride = gopt->getScalarString("digitization_variation");
+	const bool        overrideVariation     = (digiVariationOverride != UNINITIALIZEDSTRINGQUANTITY);
+
+	// Map each digitization (sensitive-detector) name to its system's variation.
+	std::map<std::string, std::string> systemVariationFor;
+	for (const auto& [systemName, gsystemPtr] : *gworld->getSystemsMap()) {
+		for (const auto& [volumeName, gvolumePtr] : gsystemPtr->getGVolumesMap()) {
+			const auto& digiName = gvolumePtr->getDigitization();
+			if (digiName != "" && digiName != UNINITIALIZEDSTRINGQUANTITY) {
+				systemVariationFor.emplace(digiName, gsystemPtr->getVariation());
+			}
+		}
+	}
+
 	const auto sdetectors = gworld->getSensitiveDetectorsList();
 
 	for (auto &sdname: sdetectors) {
@@ -281,6 +298,15 @@ void GDetectorConstruction::loadDigitizationPlugins() {
 		// Ensure each routine uses the correct logger and is configured for readout.
 		digitization_routines_map->at(sdname)->set_loggers(gopt);
 
+		// Resolve and store the variation used when loading this routine's constants/TT:
+		// the digitization_variation option when set, otherwise the routine's gsystem variation.
+		std::string variation = "default";
+		if (const auto it = systemVariationFor.find(sdname); it != systemVariationFor.end()) {
+			variation = it->second;
+		}
+		if (overrideVariation) { variation = digiVariationOverride; }
+		digitization_routines_map->at(sdname)->setDigitizationVariation(variation);
+
 		if (digitization_routines_map->at(sdname)->defineReadoutSpecs()) {
 			log->info(1, "Digitization routine <" + sdname + "> has been successfully defined.");
 		} else { log->error(ERR_DEFINESPECFAIL, "defineReadoutSpecs failure for <" + sdname + ">"); }

gemc/gdynamicDigitization/gdynamicdigitization.h

@@ -498,10 +498,31 @@ class GDynamicDigitization : public GBase<GDynamicDigitization> {
     // TODO: REMOVE THIS EVERYWHERE also remove check_if_log_defined
     void set_loggers(const std::shared_ptr<GOptions> &g) { gopts = g; }
 
+    /**
+     * \brief Sets the variation used when this routine loads constants / translation tables.
+     *
+     * Resolved once per geometry load: defaults to the variation of the gsystem the routine
+     * belongs to, and is overridden by the \c digitization_variation option when that is set.
+     *
+     * \param v Variation string to use.
+     */
+    void setDigitizationVariation(const std::string &v) { digitization_variation = v; }
+
+    /**
+     * \brief Returns the variation passed to loadConstants() / loadTT().
+     *
+     * \return The effective digitization variation for this routine.
+     */
+    [[nodiscard]] std::string getDigitizationVariation() const { return digitization_variation; }
+
 private:
     /// When false, hits with exactly zero deposited energy may be skipped.
     bool recordZeroEdep = false;
 
+    /// Variation used to load constants / translation tables. Defaults to the routine's
+    /// gsystem variation; overridden by the digitization_variation option when set.
+    std::string digitization_variation = "default";
+
 protected:
     /// Options used by the digitization plugin instance.
     std::shared_ptr<GOptions> gopts;

gemc/gdynamicDigitization/gdynamicdigitization_options.cc

@@ -21,6 +21,15 @@ GOptions defineOptions() {
 	// When enabled, hits with exactly zero deposited energy are still recorded.
 	goptions.defineSwitch("recordZeroEdep", "Record particle even if they do not deposit energy in the sensitive volumes");
 
+	// When set, overrides the per-system geometry variation used to load digitization
+	// constants and translation tables. The sentinel default means "not set": each routine
+	// then follows the variation of the gsystem it belongs to.
+	goptions.defineOption(
+		GVariable("digitization_variation", UNINITIALIZEDSTRINGQUANTITY, "digitization variation"),
+		"If set, overrides the gsystem variation when the digitization routines load their\n"
+		"constants and translation tables. Default: not set (each routine uses its system's\n"
+		"variation).\n \nExample: -digitization_variation=rga_fall2018");
+
 	// Aggregate options required by downstream types used in the digitization workflow.
 	goptions += gevent_data::defineOptions();
 	goptions += grun_data::defineOptions();

gemc_options.cc

@@ -40,7 +40,6 @@ namespace gemc {
         goptions.defineOption(GVariable("nthreads", 0, "sets number of threads."), "Default: 0 (use one thread for each available cores)");
         // goptions.defineOption(GVariable("event_module_log", 0, "Event Modulo log"), "Logs every <value> events. Default: 0 (log all events)");
         //
-        // goptions.defineOption(GVariable("digitization_variation", "default", "digitization variation"), "Default: default");
         // goptions.defineOption(GVariable("eventTimeSize", "0*ns", "event duration with unit"), "Default: 0*ns");
 
         // random engine name