gbase to gsfactory and g4sfactory

Author: maureeungaro

dbselect/dbselectView.cc

@@ -23,22 +23,23 @@ DBSelectView::DBSelectView(const std::shared_ptr<GOptions>& gopts, GDetectorCons
 	dbhost     = gopts->getScalarString("sql");
 	experiment = gopts->getScalarString("experiment");
 
-	if (sqlite3_open(dbhost.c_str(), &db) != SQLITE_OK || !isGeometryTableValid()) {
-		std::cerr << "Database Warning: Failed to open or validate database: " << dbhost << std::endl;
-		sqlite3_close(db);
-		db = nullptr;
+	// try local dir, gemc installation, then example dir
+	std::vector<std::string> dirs = {
+		".",
+		gutilities::gemc_root().string(),
+		(gutilities::gemc_root() / "examples").string()
+	};
 
-		std::filesystem::path gemcRoot = gutilities::gemc_root();
-		dbhost                         = gemcRoot.string() + "/examples/gemc.db";
 
-		if (sqlite3_open(dbhost.c_str(), &db) != SQLITE_OK || !isGeometryTableValid()) {
-			std::cerr << "Database Error: Failed to open or validate backup database: " << dbhost << std::endl;
-			sqlite3_close(db);
-			db = nullptr;
-			std::exit(1);
-		}
-		else { std::cerr << "Database Warning: Using backup database: " << dbhost << std::endl; }
+	auto dbPath = gutilities::searchForFileInLocations(dirs, dbhost);
+	if (!dbPath) { log->error(ERR_GSQLITEERROR, "Failed to find database file. Exiting."); }
+
+	if (sqlite3_open_v2(dbPath.value().c_str(), &db, SQLITE_OPEN_READONLY, nullptr) != SQLITE_OK || !isGeometryTableValid()) {
+		sqlite3_close(db);
+		db = nullptr;
+		log->error(ERR_GSQLITEERROR, " Failed to open or validate database", dbhost);
 	}
+	log->info(1, "Opened database: " + dbhost, " found at ", dbPath.value());
 
 	setupUI();
 
@@ -56,10 +57,7 @@ DBSelectView::DBSelectView(const std::shared_ptr<GOptions>& gopts, GDetectorCons
 			break;
 		}
 	}
-	if (!expFound) {
-		std::cerr << "Error: Experiment \"" << experiment << "\" not found in database. Exiting." << std::endl;
-		std::exit(1);
-	}
+	if (!expFound) { log->error(ERR_EXPERIMENTNOTFOUND, experiment, " not found in database.", dbhost); }
 
 	// Apply selections from GSystem objects.
 	applyGSystemSelections();
@@ -88,17 +86,15 @@ bool DBSelectView::isGeometryTableValid() const {
 	sqlite3_stmt* stmt      = nullptr;
 	const char*   sql_query = "SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='geometry'";
 	if (sqlite3_prepare_v2(db, sql_query, -1, &stmt, nullptr) != SQLITE_OK) {
-		std::cerr << "SQL Error: Failed to check geometry table existence: " << sqlite3_errmsg(db) << std::endl;
-		return false;
+		log->error(ERR_GSQLITEERROR, "SQL Error: Failed to check geometry table existence:", sqlite3_errmsg(db));
 	}
 	bool tableExists = false;
 	if (sqlite3_step(stmt) == SQLITE_ROW) { tableExists = sqlite3_column_int(stmt, 0) > 0; }
 	sqlite3_finalize(stmt);
 	if (!tableExists) return false;
 	sql_query = "SELECT COUNT(*) FROM geometry";
 	if (sqlite3_prepare_v2(db, sql_query, -1, &stmt, nullptr) != SQLITE_OK) {
-		std::cerr << "SQL Error: Failed to count rows in geometry table: " << sqlite3_errmsg(db) << std::endl;
-		return false;
+		log->error(ERR_GSQLITEERROR, "SQL Error: Failed to count rows in geometry table:", sqlite3_errmsg(db));
 	}
 	bool hasData = false;
 	if (sqlite3_step(stmt) == SQLITE_ROW) { hasData = sqlite3_column_int(stmt, 0) > 0; }
@@ -221,10 +217,7 @@ void DBSelectView::loadExperiments() {
 	sqlite3_stmt* stmt      = nullptr;
 	const char*   sql_query = "SELECT DISTINCT experiment FROM geometry";
 	int           rc        = sqlite3_prepare_v2(db, sql_query, -1, &stmt, nullptr);
-	if (rc != SQLITE_OK) {
-		std::cerr << "Failed to prepare experiment query: " << sqlite3_errmsg(db) << std::endl;
-		return;
-	}
+	if (rc != SQLITE_OK) { log->error(ERR_GSQLITEERROR, "Failed to prepare experiment query:", sqlite3_errmsg(db)); }
 	while (sqlite3_step(stmt) == SQLITE_ROW) {
 		const char* expText = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
 		if (expText) {
@@ -294,7 +287,7 @@ int DBSelectView::getGeometryCount(const std::string& system, const std::string&
 		sqlite3_bind_int(stmt, 4, run);
 		if (sqlite3_step(stmt) == SQLITE_ROW) { count = sqlite3_column_int(stmt, 0); }
 	}
-	else { std::cerr << "getGeometryCount: prepare failed: " << sqlite3_errmsg(db) << std::endl; }
+	else { log->error(ERR_GSQLITEERROR, "SQL Error: Failed togetGeometryCounte:", sqlite3_errmsg(db)); }
 	sqlite3_finalize(stmt);
 	return count;
 }
@@ -333,8 +326,7 @@ bool DBSelectView::systemAvailable(const std::string& system, const std::string&
 	std::string   query = "SELECT COUNT(*) FROM geometry WHERE system = ? AND variation = ? AND run = ?";
 	sqlite3_stmt* stmt  = nullptr;
 	if (sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
-		std::cerr << "systemAvailable: prepare failed: " << sqlite3_errmsg(db) << std::endl;
-		return false;
+		log->error(ERR_GSQLITEERROR, "SQL Error:systemAvailable: prepare failed:e:", sqlite3_errmsg(db));
 	}
 	sqlite3_bind_text(stmt, 1, system.c_str(), -1, SQLITE_TRANSIENT);
 	sqlite3_bind_text(stmt, 2, variation.c_str(), -1, SQLITE_TRANSIENT);
@@ -503,9 +495,7 @@ void DBSelectView::reload_geometry() {
 	log->info(0, SFUNCTION_NAME, ": Reloading geometry...");
 
 	auto reloaded_system = get_gsystems();
-	for (auto& gsys : reloaded_system) {
-		log->info(2, SFUNCTION_NAME, ": reloaded system: ", gsys->getName());
-	}
+	for (auto& gsys : reloaded_system) { log->info(2, SFUNCTION_NAME, ": reloaded system: ", gsys->getName()); }
 
 	// Reload the geometry using the updated GSystem objects.
 	gDetectorConstruction->reload_geometry(reloaded_system);

examples/meson.build

@@ -1,4 +1,6 @@
 examples_dir = get_option('prefix') + '/examples/'
+sql_db = get_option('prefix') + '/examples/gemc.db'
+
 python_exe = import('python').find_installation('python3')
 
 install_subdir(meson.current_source_dir(), install_dir : '.')
@@ -32,18 +34,18 @@ foreach branch : examples_map.keys()
                 root_output = '-gstreamer="[{format: root, filename: out' + branch + variation + '}]"'
                 test(geo_test_name,
                      python_exe,
-                     args : [example_dir + example + '.py', '-f', format, '-sql', '../../gemc.db', '-v', variation], # the sql flag is ignored for ascii format
+                     args : [example_dir + example + '.py', '-f', format, '-sql', sql_db, '-v', variation], # the sql flag is ignored for ascii format
                      workdir : example_dir,
                      env : { 'PYTHONDONTWRITEBYTECODE' : '1' },
                      priority : 10)
                 test(run_test_name_asci,
                      gemc,
-                     args : [yaml_file, '-gsystem="[{name: ' + example + ', factory: ' + format + ', variation: ' + variation + '}]"', ascii_output, '-sql=../../gemc.db'],
+                     args : [yaml_file, '-gsystem="[{name: ' + example + ', factory: ' + format + ', variation: ' + variation + '}]"', ascii_output, '-sql=' + sql_db],
                      workdir : example_dir,
                      priority : -10)
                 test(run_test_name_root,
                      gemc,
-                     args : [yaml_file, '-gsystem="[{name: ' + example + ', factory: ' + format + ', variation: ' + variation + '}]"', root_output, '-sql=../../gemc.db'],
+                     args : [yaml_file, '-gsystem="[{name: ' + example + ', factory: ' + format + ', variation: ' + variation + '}]"', root_output, '-sql=' + sql_db],
                      workdir : example_dir,
                      priority : -15)
             endforeach
@@ -57,20 +59,20 @@ foreach branch : examples_map.keys()
                 root_output = '-gstreamer="[{format: root, filename: out' + branch + run_value + '}]"'
                 test(geo_test_name,
                      python_exe,
-                     args : [example_dir + example + '.py', '-f', format, '-sql', '../../gemc.db', '-r', run_value], # the sql flag is ignored for ascii format
+                     args : [example_dir + example + '.py', '-f', format, '-sql', sql_db, '-r', run_value], # the sql flag is ignored for ascii format
                      workdir : example_dir,
                      env : { 'PYTHONDONTWRITEBYTECODE' : '1' },
                      priority : 5)
                 test(run_test_name_asci,
                      gemc,
-                     args : [yaml_file, '-gsystem="[{name: ' + example + ', factory: ' + format + ', runno:' + run_value + '}]"', ascii_output, '-sql=../../gemc.db'],
+                     args : [yaml_file, '-gsystem="[{name: ' + example + ', factory: ' + format + ', runno:' + run_value + '}]"', ascii_output, '-sql=' + sql_db],
                      workdir : example_dir,
-                     priority : -20)
+                     priority : -22)
                 test(run_test_name_root,
                      gemc,
-                     args : [yaml_file, '-gsystem="[{name: ' + example + ', factory: ' + format + ', runno:' + run_value + '}]"', root_output, '-sql=../../gemc.db'],
+                     args : [yaml_file, '-gsystem="[{name: ' + example + ', factory: ' + format + ', runno:' + run_value + '}]"', root_output, '-sql=' + sql_db],
                      workdir : example_dir,
-                     priority : -25)
+                     priority : -27)
             endforeach
 
         endforeach

g4system/g4objectsFactories/cad/cadSystemFactory.h

@@ -13,7 +13,6 @@
 
 #include <unordered_map>
 #include <string>
-#include <vector>
 
 #include "g4objectsFactory.h"
 
@@ -27,9 +26,8 @@
 class G4CadSystemFactory final : public G4ObjectsFactory
 {
 public:
-	/** Default constructor / destructor. */
-	G4CadSystemFactory()  = default;
-	~G4CadSystemFactory() override = default;
+	// inherit the base (const std::shared_ptr<GOptions>&) ctor
+	using G4ObjectsFactory::G4ObjectsFactory;
 
 	/**
 	 * @copydoc G4ObjectsFactory::className

g4system/g4objectsFactories/g4native/buildSolid.cc

@@ -4,11 +4,10 @@
  * @brief  Implementation of G4NativeSystemFactory::buildSolid()
  */
 
-#include "g4NativeObjectsFactory.h"
 
 // g4system
-#include "g4NativeObjectsFactory.h"      // self
-#include "g4system/g4systemConventions.h"
+#include "g4NativeObjectsFactory.h"
+#include "g4systemConventions.h"
 
 // geant4
 #include "G4Box.hh"

g4system/g4objectsFactories/g4native/checkAndReturnParameters.cc

@@ -10,11 +10,7 @@
 #include "g4system/g4systemConventions.h"
 
 
-
-// ────────────────────────────────────────────────────────────────
 // checkAndReturnParameters – validates & parses constructor inputs
-// ────────────────────────────────────────────────────────────────
-
 std::vector<double> G4NativeSystemFactory::checkAndReturnParameters(const GVolume* s)
 {
     // PRAGMA TODO: check non‑zero pars for various constructor

g4system/g4objectsFactories/g4native/g4NativeObjectsFactory.h

@@ -14,7 +14,7 @@
 #include <unordered_map>  // std::unordered_map
 
 // g4system
-#include "g4NativeObjectsFactory.h"      // self include‑guard pattern
+#include "g4NativeObjectsFactory.h"
 
 // gemc utility helpers
 #include "gutilities.h"
@@ -28,9 +28,8 @@
  */
 class G4NativeSystemFactory final : public G4ObjectsFactory {
 public:
-	/** Default constructor/destructor. */
-	G4NativeSystemFactory()           = default;
-	~G4NativeSystemFactory() override = default;
+	// inherit the base (const std::shared_ptr<GOptions>&) ctor
+	using G4ObjectsFactory::G4ObjectsFactory;
 
 	/**
 	 * @brief Human‑readable name used by the base class for logging.

g4system/g4objectsFactories/g4objectsFactory.cc

@@ -19,13 +19,10 @@
 // c++
 #include <string_view>
 
-void G4ObjectsFactory::initialize_context(const std::shared_ptr<GLogger>& logger,
-                                          int                             check_overlaps,
-                                          const std::string&              backup_mat) {
-	log             = logger;
-	checkOverlaps   = check_overlaps;
-	backupMaterial  = backup_mat;
-	log_is_assigned = true;
+void G4ObjectsFactory::initialize_context(int                check_overlaps,
+                                          const std::string& backup_mat) {
+	checkOverlaps  = check_overlaps;
+	backupMaterial = backup_mat;
 }
 
 

g4system/g4objectsFactories/g4objectsFactory.h

@@ -9,15 +9,21 @@
  * `buildPhysical()` if the defaults do not fit your detector geometry.
  */
 
+// c++
 #include <memory>
 #include <string>
 #include <string_view>
 #include <unordered_map>
 
-#include "glogger.h"
-#include "g4system/g4volume.h"
-#include "gsystem/gvolume.h"
+// gemc
+#include "gbase.h"
+#include "gvolume.h"
 
+// g4system
+#include "g4volume.h"
+#include "g4system_options.h"
+
+// geant4
 #include "G4LogicalVolume.hh"
 #include "G4PVPlacement.hh"
 #include "G4RotationMatrix.hh"
@@ -31,17 +37,20 @@
  *        *solid*, *logical*, and *physical* Geant4 representation.
  *
  * Call sequence inside `loadG4System()`
- * 1. `buildSolid()` ► *pure virtual* – derived class must implement.
+ * 1. `buildSolid()`► *pure virtual* –derived class must implement.
  * 2. `buildLogical()` – default uses material lookup, may be overridden.
  * 3. `buildPhysical()` – default places volume, may be overridden.
  *
  * The factory short circuits if dependencies are missing, so systems can be
  * built in any order.
  */
-class G4ObjectsFactory {
+class G4ObjectsFactory : public GBase<G4ObjectsFactory> {
 public:
-	/** Virtual destructor. */
-	virtual ~G4ObjectsFactory() = default;
+	~G4ObjectsFactory() override = default;
+
+	explicit G4ObjectsFactory(const std::shared_ptr<GOptions>& g) : GBase(g, G4SFACTORY_LOGGER) {
+	}
+
 
 	/**
 	 * @brief Provide the runtime logger, overlap‑check flag, and backup material.
@@ -52,11 +61,8 @@ class G4ObjectsFactory {
 	 *
 	 * Must be invoked before the first call to `loadG4System()`.
 	 */
-	void initialize_context(const std::shared_ptr<GLogger>& logger,
-	                        int                            checkOverlaps,
-	                        const std::string&                     backupMaterial);
-
-	bool has_log() const noexcept { return log_is_assigned; } ///< Check if logger is assigned
+	void initialize_context(int                checkOverlaps,
+	                        const std::string& backupMaterial);
 
 	/**
 	 * @brief Build—or retrieve—solid, logical, and physical volumes for @p s.
@@ -99,20 +105,17 @@ class G4ObjectsFactory {
 	                                         std::unordered_map<std::string, G4Volume*>* g4s);
 
 
-	// ──────── static convenience helpers ───────────────────────────
-	/// Lookup solid in `g4s` map.
-	static G4VSolid* getSolidFromMap(const std::string&                          volume_name,
-	                                 std::unordered_map<std::string, G4Volume*>* g4s);
-	/// Lookup logical volume in `g4s` map.
-	static G4LogicalVolume* getLogicalFromMap(const std::string&                          volume_name,
-	                                          std::unordered_map<std::string, G4Volume*>* g4s);
-	/// Lookup physical volume in `g4s` map.
-	static G4VPhysicalVolume* getPhysicalFromMap(const std::string&                          volume_name,
-	                                             std::unordered_map<std::string, G4Volume*>* g4s);
-
-	// get or create new GVolume in the map
-	G4Volume* getOrCreateG4Volume(const std::string&                          volume_name,
-	                              std::unordered_map<std::string, G4Volume*>* g4s) {
+	/// Lookup solid in the `g4s` map.
+	static G4VSolid* getSolidFromMap(const std::string& volume_name, std::unordered_map<std::string, G4Volume*>* g4s);
+
+	/// Lookup logical volume in the `g4s` map.
+	static G4LogicalVolume* getLogicalFromMap(const std::string& volume_name, std::unordered_map<std::string, G4Volume*>* g4s);
+
+	/// Lookup physical volume in the `g4s` map.
+	static G4VPhysicalVolume* getPhysicalFromMap(const std::string& volume_name, std::unordered_map<std::string, G4Volume*>* g4s);
+
+	// get or create a new GVolume in the map
+	G4Volume* getOrCreateG4Volume(const std::string& volume_name, std::unordered_map<std::string, G4Volume*>* g4s) {
 		if (auto it = g4s->find(volume_name); it != g4s->end()) { return it->second; }
 		else {
 			(*g4s)[volume_name] = new G4Volume();
@@ -163,13 +166,6 @@ class G4ObjectsFactory {
 	static G4RotationMatrix* getRotation(const GVolume* s); ///< Parse rotation string.
 	static G4ThreeVector     getPosition(const GVolume* s); ///< Parse position + shift.
 
-	// ──────── data members ─────────────────────────────────────────
-	/**
-	 * @brief Logger used for info/debug/error output.
-	 *
-	 * May remain `nullptr` until `assign_logger()` is called.
-	 */
-	std::shared_ptr<GLogger> log;
 
 	/** Forwarded to `G4PVPlacement` overlap‑check flag. */
 	int checkOverlaps{0};
@@ -181,7 +177,4 @@ class G4ObjectsFactory {
 	 */
 	std::string backupMaterial;
 
-private:
-	bool log_is_assigned{false}; ///< Flag to check if logger is assigned
-
 };

g4system/g4system_options.cc

@@ -8,7 +8,10 @@ namespace g4system {
 
 // returns array of options definitions
 GOptions defineOptions() {
+
 	GOptions goptions(G4SYSTEM_LOGGER);
+	goptions += GOptions(G4SFACTORY_LOGGER);
+
 	goptions += gsystem::defineOptions();
 
 	std::string help =

g4system/g4system_options.h

@@ -4,6 +4,7 @@
 #include "goptions.h"
 
 constexpr const char* G4SYSTEM_LOGGER = "g4system";
+constexpr const char* G4SFACTORY_LOGGER = "g4sfactory";
 
 namespace g4system {