started run data collection

Author: maureeungaro

actions/event/gEventAction.cc

@@ -28,17 +28,20 @@ void GEventAction::BeginOfEventAction([[maybe_unused]] const G4Event* event) {
 
 void GEventAction::EndOfEventAction([[maybe_unused]] const G4Event* event) {
 	// End-of-event hook: collect hit collections, digitize hits, and publish the event to streamers.
-	auto* const hcs_this_event = event->GetHCofThisEvent();
-	if (hcs_this_event == nullptr) {
-		return;
-	}
-
 	if (run_action == nullptr) {
 		log->error(ERR_GRUNACTION_NOT_EXISTING, FUNCTION_NAME,
 				   " run_action is null - cannot access digitization routines or streamers.");
 		return;
 	}
 
+	// Count every processed event once, independently of whether it produces any payload.
+	run_action->increment_run_events_processed();
+
+	auto* const hcs_this_event = event->GetHCofThisEvent();
+	if (hcs_this_event == nullptr) {
+		return;
+	}
+
 	const auto thread_id = G4Threading::G4GetThreadId();
 	const auto event_id  = event->GetEventID();
 
@@ -53,6 +56,7 @@ void GEventAction::EndOfEventAction([[maybe_unused]] const G4Event* event) {
 	}
 
 	bool has_event_mode_payload = false;
+	bool has_run_mode_payload   = false;
 
 	// Loop over all hit collections produced by sensitive detectors in this event.
 	for (G4int hci = 0; hci < hcs_this_event->GetNumberOfCollections(); ++hci) {
@@ -103,13 +107,22 @@ void GEventAction::EndOfEventAction([[maybe_unused]] const G4Event* event) {
 				has_event_mode_payload = true;
 			}
 			else if (collection_mode == CollectionMode::run) {
-				run_action->collect_event_data_collections(
-					hcSDName,
-					std::move(digi_data));
+				if (digi_data != nullptr) {
+					run_action->collect_event_data_collections(
+						hcSDName,
+						std::move(digi_data));
+					has_run_mode_payload = true;
+				}
 			}
 		}
 	}
 
+	// Count this event once for run-level accumulation if any run-mode payload was produced.
+	if (has_run_mode_payload) {
+		run_action->increment_run_events_with_payload();
+	}
+
+
 	// Publish once per event, after all event-mode collections have been processed.
 	if (has_event_mode_payload) {
 		publish_event_data(eventDataCollection);
@@ -137,4 +150,4 @@ void GEventAction::publish_event_data(const std::shared_ptr<GEventDataCollection
 
 		gstreamer->publishEventData(event_data);
 	}
-}
+}

actions/run/gRunAction.h

@@ -125,6 +125,40 @@ class GRunAction : public GBase<GRunAction>, public G4UserRunAction
 			std::move(digi_data));
 	}
 
+	void increment_run_events_processed() {
+		if (run_data == nullptr) {
+			log->error(ERR_GRUNACTION_NOT_EXISTING, FUNCTION_NAME,
+					   " run_data is null - cannot increment processed events.");
+			return;
+		}
+
+		auto& header = run_data->getHeader();
+		if (header == nullptr) {
+			log->error(ERR_GRUNACTION_NOT_EXISTING, FUNCTION_NAME,
+					   " run_data header is null - cannot increment processed events.");
+			return;
+		}
+
+		header->increment_events_processed();
+	}
+
+	void increment_run_events_with_payload() {
+		if (run_data == nullptr) {
+			log->error(ERR_GRUNACTION_NOT_EXISTING, FUNCTION_NAME,
+					   " run_data is null - cannot increment payload events.");
+			return;
+		}
+
+		auto& header = run_data->getHeader();
+		if (header == nullptr) {
+			log->error(ERR_GRUNACTION_NOT_EXISTING, FUNCTION_NAME,
+					   " run_data header is null - cannot increment payload events.");
+			return;
+		}
+
+		header->increment_events_with_payload();
+	}
+
 private:
 	using CompletedRunData = std::vector<std::unique_ptr<GRunDataCollection>>;
 
@@ -231,7 +265,6 @@ class GRunAction : public GBase<GRunAction>, public G4UserRunAction
 	static CompletedRunData completed_worker_run_data;
 
 	void publish_run_data(const std::shared_ptr<GRunDataCollection>& run_data) const;
-
 };
 
 
@@ -263,4 +296,4 @@ class GRunAction : public GBase<GRunAction>, public G4UserRunAction
 // frameDuration = 64000;
 // eventDuration = gutilities::getG4Number(goptions->getScalarString("eventTimeSize"));
 
-// stream = gopt->getSwitch("stream");
+// stream = gopt->getSwitch("stream");

examples/basic/b1/b1.yaml

@@ -7,8 +7,8 @@ gparticle:
   - name: gamma
     p: 6
     vz: -17
-    delta_vx: 8
-    delta_vy: 8
+    delta_vx: 3
+    delta_vy: 3
     multiplicity: 1
 
 verbosity:

gdata/run/gRunDataCollection.cc

@@ -42,7 +42,7 @@ void GRunDataCollection::collect_event_data_collection(const std::shared_ptr<GEv
 
 void GRunDataCollection::collect_event_data_collections(const std::string&              sdName,
 														std::unique_ptr<GDigitizedData> ddata) {
-	
+
 	collectDetectorDigitizedData(sdName, ddata);
 
 	log->info(2, *gdataCollectionMap[sdName]);
@@ -52,6 +52,7 @@ void GRunDataCollection::collect_event_data_collections(const std::string&
 void GRunDataCollection::merge(const GRunDataCollection& other) {
 
 	grun_header->add_events_processed(other.get_events_processed());
+	grun_header->add_events_with_payload(other.get_events_with_payload());
 
 	const auto& other_map = other.getDataCollectionMap();
 
@@ -68,4 +69,4 @@ void GRunDataCollection::merge(const GRunDataCollection& other) {
 			}
 		}
 	}
-}
+}

gdata/run/gRunDataCollection.h

@@ -8,7 +8,7 @@
  * A run collection integrates event-level data into a run summary.
  *
  * It owns:
- * - a \ref GRunHeader describing run ID and integrated event count
+ * - a \ref GRunHeader describing run ID and event counters
  * - a map from sensitive detector name to \ref GDataCollection (the per-detector accumulator)
  *
  * Integration is performed by consuming \ref GEventDataCollection objects and:
@@ -20,10 +20,10 @@
  * - one integrated \ref GDigitizedData entry per detector
  *   (vector size 1), depending on how \ref GDataCollection integration is used.
  *
- * \note Event counter
- * This class currently does not increment \c GRunHeader::events_processed.
- * If you want that counter to reflect integrated events, the caller (or this class)
- * must call \ref GRunHeader::increment_events_processed "increment_events_processed()" once per integrated event.
+ * \note Event counters
+ * This class stores event counters in \ref GRunHeader:
+ * - \c events_processed tracks total processed events
+ * - \c events_with_payload tracks events that contributed at least one run-mode payload
  */
 
 #include "gRunHeader.h"
@@ -83,7 +83,7 @@ class GRunDataCollection : public GBase<GRunDataCollection>
 	 * \brief Construct a run data collection.
 	 *
 	 * \details
-	 * The header stores metadata such as run ID and (optionally) number of integrated events.
+	 * The header stores metadata such as run ID and event counters.
 	 *
 	 * Ownership:
 	 * - \p header is moved into this object and owned exclusively.
@@ -107,6 +107,8 @@ class GRunDataCollection : public GBase<GRunDataCollection>
 	 * - first hit creates the integrated entry
 	 * - subsequent hits contribute by summation of scalars
 	 *
+	 * This method increments \c events_processed once for the integrated event.
+	 *
 	 * \param edc Event-level container to integrate.
 	 */
 	void collect_event_data_collection(const std::shared_ptr<GEventDataCollection> edc);
@@ -139,7 +141,7 @@ class GRunDataCollection : public GBase<GRunDataCollection>
 	[[nodiscard]] auto getRunNumber() const -> int { return grun_header->getRunID(); }
 
 	/**
-	 * \brief Number of events integrated into this run summary.
+	 * \brief Total number of processed events associated with this run summary.
 	 *
 	 * \details
 	 * This value is stored in \ref GRunHeader and incremented by
@@ -149,6 +151,17 @@ class GRunDataCollection : public GBase<GRunDataCollection>
 	 */
 	[[nodiscard]] auto get_events_processed() const -> int { return grun_header->get_events_processed(); }
 
+	/**
+	 * \brief Number of processed events that contributed run-mode payload.
+	 *
+	 * \details
+	 * This value is stored in \ref GRunHeader and incremented by
+	 * \ref GRunHeader::increment_events_with_payload "increment_events_with_payload()".
+	 *
+	 * \return Count stored in the header.
+	 */
+	[[nodiscard]] auto get_events_with_payload() const -> int { return grun_header->get_events_with_payload(); }
+
 	/**
 	 * \brief Merge another run-level accumulator into this one.
 	 *
@@ -160,6 +173,10 @@ class GRunDataCollection : public GBase<GRunDataCollection>
 	 * Detector entries are merged by detector name. For each detector:
 	 * - digitized integrated data are accumulated into this object
 	 *
+	 * Event counters are also merged:
+	 * - total processed events
+	 * - events with payload
+	 *
 	 * \param other Source run accumulator to merge into this object.
 	 */
 	void merge(const GRunDataCollection& other);
@@ -181,4 +198,4 @@ class GRunDataCollection : public GBase<GRunDataCollection>
 	 * \param data   Digitized-hit object to integrate (not owned; deep-copied internally).
 	 */
 	void collectDetectorDigitizedData(const std::string& sdName, const std::unique_ptr<GDigitizedData>& data);
-};
+};

gdata/run/gRunHeader.h

@@ -14,8 +14,9 @@
  * A run header is a minimal metadata object associated with a \ref GRunDataCollection.
  *
  * It records:
- * - \c runID            : run identifier (application-defined)
- * - \c events_processed : number of events integrated into this run summary so far
+ * - \c runID               : run identifier (application-defined)
+ * - \c events_processed    : total number of events seen by the run action
+ * - \c events_with_payload : number of events that contributed at least one run-mode payload
  *
  * The constructor emits a brief log summary. In multi-threaded contexts, an optional
  * thread ID can be attached for diagnostics and provenance.
@@ -43,20 +44,25 @@ inline auto defineOptions() -> GOptions {
 } // namespace grun_header
 
 /**
- * \brief Minimal run metadata: run ID and integrated-event counter.
+ * \brief Minimal run metadata: run ID and run-level event counters.
  *
  * \details
  * This object is typically owned by \ref GRunDataCollection as a \c std::unique_ptr.
  * It provides:
  * - stable access to run identifier
- * - a simple counter tracking how many events were integrated
+ * - a simple counter tracking how many events were processed
+ * - a simple counter tracking how many events contributed run-mode payload
  *
- * The counter is incremented via \ref GRunHeader::increment_events_processed "increment_events_processed()".
+ * The counters are incremented via:
+ * - \ref GRunHeader::increment_events_processed "increment_events_processed()"
+ * - \ref GRunHeader::increment_events_with_payload "increment_events_with_payload()"
  *
  * \note
- * \ref GRunDataCollection does not automatically increment this counter in the current implementation.
- * If you want the value to reflect integrated events, ensure the caller (or the run collection)
- * invokes \ref GRunHeader::increment_events_processed "increment_events_processed()" once per event.
+ * \ref GRunDataCollection does not automatically decide which events contributed payload.
+ * The caller (or higher-level run/event action code) must invoke:
+ * - \ref GRunHeader::increment_events_processed "increment_events_processed()" once per processed event
+ * - \ref GRunHeader::increment_events_with_payload "increment_events_with_payload()" once per event
+ *   that produced at least one run-mode payload
  */
 class GRunHeader : public GBase<GRunHeader>
 {
@@ -67,7 +73,8 @@ class GRunHeader : public GBase<GRunHeader>
 	 * \details
 	 * The constructor logs:
 	 * - run ID
-	 * - initial event count (usually 0)
+	 * - initial total processed-event count (usually 0)
+	 * - initial payload-event count (usually 0)
 	 * - optional thread ID if provided
 	 *
 	 * \param gopts Shared options object used to configure logging and behavior.
@@ -80,13 +87,15 @@ class GRunHeader : public GBase<GRunHeader>
 		if (tid != -1) {
 			log->info(1, "\n",
 			          TPOINTITEM, " Run ID:  ", rid, "\n",
-			          TPOINTITEM, " Number of events collected:  ", events_processed,
+			          TPOINTITEM, " Number of events processed:  ", events_processed, "\n",
+			          TPOINTITEM, " Number of events with payload:  ", events_with_payload, "\n",
 			          TPOINTITEM, " Thread ID:  ", tid);
 		}
 		else {
 			log->info(1, "\n",
 			          TPOINTITEM, " Run ID:  ", rid, "\n",
-			          TPOINTITEM, " Number of events collected:  ", events_processed);
+			          TPOINTITEM, " Number of events processed:  ", events_processed, "\n",
+			          TPOINTITEM, " Number of events with payload:  ", events_with_payload);
 		}
 	}
 
@@ -97,32 +106,61 @@ class GRunHeader : public GBase<GRunHeader>
 	[[nodiscard]] auto getRunID() const -> int { return runID; }
 
 	/**
-	 * \brief Get the number of events integrated into this run summary so far.
+	 * \brief Get the total number of events processed in this run summary so far.
 	 *
 	 * \details
 	 * This value is incremented by \ref GRunHeader::increment_events_processed "increment_events_processed()".
-	 * Typical usage is "once per event integrated into the run accumulator".
+	 * Typical usage is "once per processed event reaching end-of-event handling".
 	 *
 	 * \return Number of processed events.
 	 */
 	[[nodiscard]] auto get_events_processed() const -> int { return events_processed; }
 
+	/**
+	 * \brief Get the number of events that contributed run-mode payload in this run summary so far.
+	 *
+	 * \details
+	 * This value is incremented by
+	 * \ref GRunHeader::increment_events_with_payload "increment_events_with_payload()".
+	 * Typical usage is "once per event that contributed at least one run-mode payload".
+	 *
+	 * \return Number of payload-producing events.
+	 */
+	[[nodiscard]] auto get_events_with_payload() const -> int { return events_with_payload; }
+
 	/**
 	 * \brief Increment the number of processed events.
 	 *
 	 * \details
-	 * Intended to be called once per event integrated into the run accumulator.
+	 * Intended to be called once per processed event.
 	 */
 	void increment_events_processed() { events_processed++; }
 
 	/**
- * \brief Add a number of processed events to the counter.
- *
- * \param count Number of processed events to add.
- */
+	 * \brief Increment the number of events that produced run-mode payload.
+	 *
+	 * \details
+	 * Intended to be called once per event that contributed at least one run-mode payload
+	 * to the run accumulator.
+	 */
+	void increment_events_with_payload() { events_with_payload++; }
+
+	/**
+	 * \brief Add a number of processed events to the counter.
+	 *
+	 * \param count Number of processed events to add.
+	 */
 	void add_events_processed(int count) { events_processed += count; }
 
+	/**
+	 * \brief Add a number of payload-producing events to the counter.
+	 *
+	 * \param count Number of payload-producing events to add.
+	 */
+	void add_events_with_payload(int count) { events_with_payload += count; }
+
 private:
-	int events_processed{0}; ///< Number of events integrated into the run summary.
-	int runID;               ///< Run identifier.
-};
+	int events_processed{0};    ///< Total number of processed events in the run summary.
+	int events_with_payload{0}; ///< Number of processed events that contributed run-mode payload.
+	int runID;                  ///< Run identifier.
+};