added generated and generated_tracked to the various streamers

Author: maureeungaro

actions/event/gEventAction.cc

@@ -7,6 +7,31 @@
 
 // gemc
 #include "event/gEventDataCollection.h"
+#include "../generator/gPrimaryGeneratorAction.h"
+
+namespace {
+GGeneratedParticleBank make_generated_particle_bank(const GParticleRecordEvent& particles) {
+	GGeneratedParticleBank bank;
+	bank.reserve(particles.size());
+
+	for (const auto& particle : particles) {
+		bank.push_back({
+			particle.name,
+			particle.pid,
+			particle.type,
+			particle.multiplicity,
+			particle.p,
+			particle.theta,
+			particle.phi,
+			particle.vx,
+			particle.vy,
+			particle.vz
+		});
+	}
+
+	return bank;
+}
+}
 
 
 // Construct the event action and keep access to shared configuration plus the
@@ -39,16 +64,24 @@ void GEventAction::EndOfEventAction([[maybe_unused]] const G4Event* event) {
 	// Count each processed event once, even when it produces no 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();
 
 	auto gevent_header       = std::make_unique<GEventHeader>(goptions, event_id, thread_id);
 	auto eventDataCollection = std::make_shared<GEventDataCollection>(goptions, std::move(gevent_header));
+	eventDataCollection->setGeneratedParticles(
+		make_generated_particle_bank(GPrimaryGeneratorAction::currentGeneratedParticleRecords()));
+	eventDataCollection->setGeneratedTrackedParticles(
+		make_generated_particle_bank(GPrimaryGeneratorAction::currentGeneratedTrackedParticleRecords()));
+
+	auto* const hcs_this_event = event->GetHCofThisEvent();
+	if (hcs_this_event == nullptr) {
+		if (!eventDataCollection->getGeneratedParticles().empty() ||
+		    !eventDataCollection->getGeneratedTrackedParticles().empty()) {
+			publish_event_data(eventDataCollection);
+		}
+		return;
+	}
 
 	const auto digi_map = run_action->get_digitization_routines_map();
 	if (digi_map == nullptr) {
@@ -128,7 +161,9 @@ void GEventAction::EndOfEventAction([[maybe_unused]] const G4Event* event) {
 	}
 
 	// Publish event-mode output once, after all collections have been processed.
-	if (has_event_mode_payload) {
+	if (has_event_mode_payload ||
+	    !eventDataCollection->getGeneratedParticles().empty() ||
+	    !eventDataCollection->getGeneratedTrackedParticles().empty()) {
 		publish_event_data(eventDataCollection);
 	}
 }
@@ -139,6 +174,10 @@ void GEventAction::publish_event_data(const std::shared_ptr<GEventDataCollection
 		return;
 	}
 
+	if (!run_action->has_streamer_threads_map()) {
+		return;
+	}
+
 	const auto gstreamers_threads_map = run_action->get_streamer_threads_map();
 	if (gstreamers_threads_map == nullptr) {
 		log->error(ERR_STREAMERMAP_NOT_EXISTING, FUNCTION_NAME,
@@ -155,4 +194,4 @@ void GEventAction::publish_event_data(const std::shared_ptr<GEventDataCollection
 
 		gstreamer->publishEventData(event_data);
 	}
-}
+}

actions/generator/gPrimaryGeneratorAction.cc

@@ -6,6 +6,29 @@
 // geant4
 #include "G4Event.hh"
 
+thread_local GParticleEvent GPrimaryGeneratorAction::current_generated_particles;
+thread_local GParticleEvent GPrimaryGeneratorAction::current_generated_tracked_particles;
+thread_local GParticleRecordEvent GPrimaryGeneratorAction::current_generated_particle_records;
+thread_local GParticleRecordEvent GPrimaryGeneratorAction::current_generated_tracked_particle_records;
+
+namespace {
+GParticleRecord make_particle_record(const GparticlePtr& particle) {
+	if (particle == nullptr) { return {}; }
+	const auto& vertex = particle->getVertex();
+	return {
+		particle->getName(),
+		particle->getPid(),
+		particle->getGeneratorType(),
+		particle->getMultiplicity(),
+		particle->getMomentum(),
+		particle->getTheta(),
+		particle->getPhi(),
+		vertex.x(),
+		vertex.y(),
+		vertex.z()
+	};
+}
+}
 
 // Build the primary-generator action, load the configured particle definitions,
 // and guarantee a valid fallback particle when no explicit configuration is present.
@@ -16,8 +39,9 @@ GPrimaryGeneratorAction::GPrimaryGeneratorAction(std::shared_ptr<GOptions> gopts
 	// definitions are event records and are selected by Geant4 event id.
 	gparticles           = gparticle::getGParticlesFromOption(gopts, log);
 	gparticleFileEvents  = gparticle::getGParticleEventsFromSources(gopts, log);
+	allGparticleFileRecordEvents = gparticle::getGParticleRecordEventsFromSources(gopts, log);
 
-	if (gparticles.empty() && gparticleFileEvents.empty()) {
+	if (gparticles.empty() && allGparticleFileRecordEvents.empty()) {
 		// Fall back to a default particle definition so the generator remains usable
 		// even when no explicit particle configuration was provided.
 		auto default_particle = Gparticle::create_default_gparticle(log);
@@ -30,14 +54,44 @@ GPrimaryGeneratorAction::GPrimaryGeneratorAction(std::shared_ptr<GOptions> gopts
 // For each configured particle definition, configure the shared particle gun and
 // inject the corresponding primary information into the current event.
 void GPrimaryGeneratorAction::GeneratePrimaries(G4Event* anEvent) {
+	current_generated_particles.clear();
+	current_generated_tracked_particles.clear();
+	current_generated_particle_records.clear();
+	current_generated_tracked_particle_records.clear();
+
+	current_generated_particles.insert(current_generated_particles.end(), gparticles.begin(), gparticles.end());
+	current_generated_tracked_particles.insert(current_generated_tracked_particles.end(), gparticles.begin(), gparticles.end());
+	current_generated_particle_records.reserve(gparticles.size());
+	current_generated_tracked_particle_records.reserve(gparticles.size());
+	for (const auto& gparticle : gparticles) {
+		current_generated_particle_records.emplace_back(make_particle_record(gparticle));
+		current_generated_tracked_particle_records.emplace_back(make_particle_record(gparticle));
+	}
+
+	const auto event_id = anEvent->GetEventID();
+	if (event_id >= 0 && static_cast<size_t>(event_id) < allGparticleFileRecordEvents.size()) {
+		const auto& event_particles = allGparticleFileRecordEvents[static_cast<size_t>(event_id)];
+		current_generated_particle_records.insert(current_generated_particle_records.end(),
+		                                          event_particles.begin(),
+		                                          event_particles.end());
+	}
+	if (event_id >= 0 && static_cast<size_t>(event_id) < gparticleFileEvents.size()) {
+		const auto& event_particles = gparticleFileEvents[static_cast<size_t>(event_id)];
+		current_generated_tracked_particles.insert(current_generated_tracked_particles.end(),
+		                                           event_particles.begin(),
+		                                           event_particles.end());
+		for (const auto& gparticle : event_particles) {
+			current_generated_tracked_particle_records.emplace_back(make_particle_record(gparticle));
+		}
+	}
+
 	for (const auto& gparticle : gparticles) {
 
 		if (gparticle != nullptr) {
 			gparticle->shootParticle(gparticleGun.get(), anEvent);
 		}
 	}
 
-	const auto event_id = anEvent->GetEventID();
 	if (event_id >= 0 && static_cast<size_t>(event_id) < gparticleFileEvents.size()) {
 		log->info(2, "Generating gparticlefile event ", event_id,
 		          " with ", gparticleFileEvents[static_cast<size_t>(event_id)].size(),
@@ -50,3 +104,19 @@ void GPrimaryGeneratorAction::GeneratePrimaries(G4Event* anEvent) {
 		}
 	}
 }
+
+const GParticleEvent& GPrimaryGeneratorAction::currentGeneratedParticles() {
+	return current_generated_particles;
+}
+
+const GParticleEvent& GPrimaryGeneratorAction::currentGeneratedTrackedParticles() {
+	return current_generated_tracked_particles;
+}
+
+const GParticleRecordEvent& GPrimaryGeneratorAction::currentGeneratedParticleRecords() {
+	return current_generated_particle_records;
+}
+
+const GParticleRecordEvent& GPrimaryGeneratorAction::currentGeneratedTrackedParticleRecords() {
+	return current_generated_tracked_particle_records;
+}

actions/generator/gPrimaryGeneratorAction.h

@@ -52,6 +52,8 @@ inline GOptions defineOptions() {
  *
  * This class is the GEMC implementation of the Geant4 primary-generator action.
  * It owns a \c G4ParticleGun and a list of configured Gparticle objects.
+ * Inline particles from \c -gparticle are generated for every event, while
+ * \c -gparticlefile sources are indexed by Geant4 event id.
  *
  * For every event, \ref GPrimaryGeneratorAction::GeneratePrimaries "GeneratePrimaries()"
  * iterates over the configured particle definitions and delegates the actual shooting
@@ -61,6 +63,11 @@ inline GOptions defineOptions() {
  * If no particle definitions are found in the configuration, the constructor creates
  * a default particle so the simulation still has a valid primary source.
  *
+ * The class also exposes thread-local generated-particle snapshots for event
+ * output. The \c generated snapshot includes inline particles and all parsed
+ * file rows. The \c generated_tracked snapshot includes inline particles and
+ * only the file rows propagated in Geant4.
+ *
  * @ingroup gactions_module
  */
 class GPrimaryGeneratorAction : public GBase<GPrimaryGeneratorAction>, public G4VUserPrimaryGeneratorAction {
@@ -98,6 +105,43 @@ class GPrimaryGeneratorAction : public GBase<GPrimaryGeneratorAction>, public G4
 	 */
 	void GeneratePrimaries(G4Event* event) override;
 
+	/**
+	 * \brief Returns the current event's Geant4-propagated generated particles.
+	 *
+	 * \return Thread-local generated particles for the active event.
+	 */
+	static const GParticleEvent& currentGeneratedParticles();
+
+	/**
+	 * \brief Returns the current event's Geant4-tracked generated particles.
+	 *
+	 * This view contains inline particles and file-backed particles propagated
+	 * in Geant4.
+	 *
+	 * \return Thread-local tracked generated particles for the active event.
+	 */
+	static const GParticleEvent& currentGeneratedTrackedParticles();
+
+	/**
+	 * \brief Returns the current event's full generated-particle records.
+	 *
+	 * This is the source for the \c generated output bank. It includes inline
+	 * particles and every parsed file-backed particle row.
+	 *
+	 * \return Thread-local generated-particle records for the active event.
+	 */
+	static const GParticleRecordEvent& currentGeneratedParticleRecords();
+
+	/**
+	 * \brief Returns the current event's Geant4-tracked generated-particle records.
+	 *
+	 * This is the source for the \c generated_tracked output bank. It includes
+	 * inline particles and only file-backed particles propagated in Geant4.
+	 *
+	 * \return Thread-local tracked generated-particle records for the active event.
+	 */
+	static const GParticleRecordEvent& currentGeneratedTrackedParticleRecords();
+
 private:
 	/**
 	 * \brief Particle-gun instance used to materialize configured primaries into the event.
@@ -124,4 +168,24 @@ class GPrimaryGeneratorAction : public GBase<GPrimaryGeneratorAction>, public G4
 	 * matching file event record.
 	 */
 	GParticleEvents gparticleFileEvents;
+
+	/**
+	 * \brief File-backed generated-particle records, indexed by Geant4 event id.
+	 *
+	 * This record view preserves all parsed file particles for the
+	 * \c generated output bank, including rows that are not propagated in Geant4.
+	 */
+	GParticleRecordEvents allGparticleFileRecordEvents;
+
+	/// \brief Thread-local \ref GParticleEvent snapshot for the current event.
+	static thread_local GParticleEvent current_generated_particles;
+
+	/// \brief Thread-local tracked \ref GParticleEvent snapshot for the current event.
+	static thread_local GParticleEvent current_generated_tracked_particles;
+
+	/// \brief Thread-local full generated-particle record snapshot for the current event.
+	static thread_local GParticleRecordEvent current_generated_particle_records;
+
+	/// \brief Thread-local tracked generated-particle record snapshot for the current event.
+	static thread_local GParticleRecordEvent current_generated_tracked_particle_records;
 };

actions/run/gRunAction.cc

@@ -73,6 +73,13 @@ void GRunAction::BeginOfRunAction(const G4Run *aRun) {
 		           " digitization_routines_map is null - streamer mode detection skipped.");
 	}
 
+	for (const auto& streamer_definition : gstreamer::getGStreamerDefinition(goptions)) {
+		if (streamer_definition.type == "event") {
+			need_a_thread_streamer = true;
+			break;
+		}
+	}
+
 
 	// Worker threads own event-mode publication, so they lazily build and open
 	// thread-local streamers only when at least one event-mode digitizer exists.

actions/run/gRunAction.h

@@ -114,6 +114,10 @@ class GRunAction : public GBase<GRunAction>, public G4UserRunAction
 		return gstreamer_threads_map;
 	}
 
+	[[nodiscard]] bool has_streamer_threads_map() const {
+		return gstreamer_threads_map != nullptr;
+	}
+
 	/**
 	 * \brief Adds one run-mode digitized payload to the current thread run-data collection.
 	 *

ci/env.sh

@@ -113,11 +113,11 @@ cores=$(getconf _NPROCESSORS_ONLN 2>/dev/null || nproc)
 jobs=$((cores < 16 ? cores : 16))
 
 mkdir -p $log_dir
-setup_log=$log_dir/setup.log
-compile_log=$log_dir/build.log
-install_log=$log_dir/install.log
-test_log=$log_dir/test.log
-gemc_install_show=$log_dir/gemc.log
+setup_log=$log_dir/01_setup.log
+compile_log=$log_dir/02_build.log
+install_log=$log_dir/03_install.log
+gemc_install_show=$log_dir/04_show_install.log
+test_log=$log_dir/05_tests.log
 
 touch $setup_log $compile_log $install_log $test_log
 echo

examples/basic/simple_flux/simple_flux.py

@@ -15,7 +15,7 @@
 
 target_dz = 20
 target_radius = 5
-gvolume = GVolume("Target")
+gvolume = GVolume("target")
 gvolume.mother = "root"
 gvolume.description = "Simple Carbon Target"
 gvolume.make_tube(0, target_radius, target_dz, 0, 360)