added lund format through factory mechanism. distributing events over threads.

Author: maureeungaro

actions/examples/generator_file_events_example.cc

@@ -0,0 +1,51 @@
+// actions
+#include "generator/gPrimaryGeneratorAction.h"
+
+// gparticle
+#include "gparticle_reader.h"
+
+// geant4
+#include "G4Event.hh"
+#include "G4RunManagerFactory.hh"
+#include "QBBC.hh"
+
+// c++
+#include <cstdlib>
+#include <iostream>
+#include <memory>
+
+int main(int argc, char* argv[]) {
+	auto option_definitions = gparticle::defineOptions();
+	option_definitions += gprimaryaction::defineOptions();
+
+	auto gopts = std::make_shared<GOptions>(argc, argv, option_definitions);
+	auto log   = std::make_shared<GLogger>(gopts, FUNCTION_NAME, GPRIMARYGENERATORACTION_LOGGER);
+
+	auto runManager = G4RunManagerFactory::CreateRunManager(G4RunManagerType::Default);
+	runManager->SetUserInitialization(new QBBC);
+
+	auto source_events = gparticle::getGParticleEventsFromSources(gopts, log);
+	if (source_events.size() != 11) {
+		std::cerr << "Expected 11 gparticlefile events, got " << source_events.size() << '\n';
+		delete runManager;
+		return EXIT_FAILURE;
+	}
+
+	GPrimaryGeneratorAction generator(gopts);
+	auto inline_particles = gparticle::getGParticlesFromOption(gopts, log);
+	for (size_t event_index = 0; event_index < source_events.size(); event_index++) {
+		G4Event event(static_cast<G4int>(event_index));
+		generator.GeneratePrimaries(&event);
+
+		const auto expected_vertices = static_cast<G4int>(inline_particles.size() + source_events[event_index].size());
+		if (event.GetNumberOfPrimaryVertex() != expected_vertices) {
+			std::cerr << "Event " << event_index << " expected " << expected_vertices
+			          << " primary vertices, got " << event.GetNumberOfPrimaryVertex() << '\n';
+			delete runManager;
+			return EXIT_FAILURE;
+		}
+	}
+
+	delete runManager;
+	return EXIT_SUCCESS;
+}

actions/generator/gPrimaryGeneratorAction.cc

@@ -1,17 +1,23 @@
 // gemc
 #include "gparticle_options.h"
+#include "gparticle_reader.h"
 #include "gPrimaryGeneratorAction.h"
 
+// geant4
+#include "G4Event.hh"
+
 
 // Build the primary-generator action, load the configured particle definitions,
 // and guarantee a valid fallback particle when no explicit configuration is present.
 GPrimaryGeneratorAction::GPrimaryGeneratorAction(std::shared_ptr<GOptions> gopts) :
 	GBase(gopts, GPRIMARYGENERATORACTION_LOGGER),
 	gparticleGun(std::make_unique<G4ParticleGun>()) {
-	// Load all configured particle descriptions from the shared options object.
-	gparticles = gparticle::getGParticles(gopts, log);
+	// Inline gparticle definitions are generated for every event. File-backed
+	// definitions are event records and are selected by Geant4 event id.
+	gparticles           = gparticle::getGParticlesFromOption(gopts, log);
+	gparticleFileEvents  = gparticle::getGParticleEventsFromSources(gopts, log);
 
-	if (gparticles.empty()) {
+	if (gparticles.empty() && gparticleFileEvents.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,4 +36,17 @@ void GPrimaryGeneratorAction::GeneratePrimaries(G4Event* anEvent) {
 			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(),
+		          " propagated particles");
+
+		for (const auto& gparticle : gparticleFileEvents[static_cast<size_t>(event_id)]) {
+			if (gparticle != nullptr) {
+				gparticle->shootParticle(gparticleGun.get(), anEvent);
+			}
+		}
+	}
+}

actions/generator/gPrimaryGeneratorAction.h

@@ -7,6 +7,7 @@
 #include "goptions.h"
 #include "gbase.h"
 #include "gparticle_options.h"
+#include "gparticle_reader.h"
 
 // geant4
 #include "G4VUserPrimaryGeneratorAction.hh"
@@ -114,4 +115,13 @@ class GPrimaryGeneratorAction : public GBase<GPrimaryGeneratorAction>, public G4
 	 * the opportunity to contribute primary content to the event.
 	 */
 	std::vector<GparticlePtr> gparticles;
-};
+
+	/**
+	 * \brief File-backed particle events, indexed by Geant4 event id.
+	 *
+	 * These records are kept separate from \ref gparticles so worker threads do not
+	 * replay the full file on every event. Each generated event consumes only the
+	 * matching file event record.
+	 */
+	GParticleEvents gparticleFileEvents;
+};

actions/meson.build

@@ -1,5 +1,12 @@
 sub_dir_name = meson.current_source_dir().split('/').get(-1)
-internal_deps = []
+internal_deps = ['goptions', 'guts', 'glogging', 'gbase', 'gfactory', 'gparticle']
+
+dis_file = meson.project_source_root() + '/gparticle/examples/test_dis.dat'
+generator_file_events = [
+    '-gparticlefile="[{format: lund, filename: ' + dis_file + '}]"',
+    '-gparticle="[{name: e-, p: 2300, theta: 23.0}]"',
+    '-verbosity.generator=2'
+]
 
 LD += {
     'name' : sub_dir_name,
@@ -20,4 +27,10 @@ LD += {
     ),
     'dependencies' : [yaml_cpp_dep, clhep_deps, qt6_deps, geant4_core_deps],
     'internal_dependencies' : internal_deps,
+    'examples' : {
+        'test_generator_lund_file_events' : [
+            files('examples/generator_file_events_example.cc'),
+            generator_file_events
+        ],
+    }
 }

gfactory/gfactory.h

@@ -276,6 +276,9 @@ std::shared_ptr<T> GManager::LoadAndRegisterObjectFromLibrary(std::string_view
 	if (pluginLib && pluginLib->handle) {
 		// The product type performs the symbol lookup and raw allocation.
 		T* raw = T::instantiate(pluginLib->handle, gopts);
+		if (raw == nullptr) {
+			log->error(ERR_FACTORYNOTFOUND, "Plugin ", name, " could not instantiate its factory object.");
+		}
 
 		// Standardize logger wiring on the instance.
 		raw->set_loggers(gopts);