temp commit, saving progress on using smart pointers on data

Author: maureeungaro

.github/workflows/build_gemc_fedora.yml

@@ -16,7 +16,7 @@ on:
 jobs:
   build-on-fedora:
     runs-on: ubuntu-latest
-    container:  jeffersonlab/geant4:g4v11.3.1-fedora36
+    container:  jeffersonlab/geant4:g4v11.3.1-fedora40
 
     steps:
       - name: Checkout

.github/workflows/doxygen.yaml

@@ -14,7 +14,7 @@ on:
 jobs:
   build-doxygen:
     runs-on: ubuntu-latest
-    container: jeffersonlab/base:fedora36
+    container: jeffersonlab/base:fedora40
     steps:
       - name: Checkout
         uses: actions/checkout@main

.github/workflows/sanitize.yaml

@@ -21,9 +21,9 @@ jobs:
         container:
           - name: ubuntu24
             image: jeffersonlab/geant4:g4v11.3.1-ubuntu24
-          - name: fedora36
-            image: jeffersonlab/geant4:g4v11.3.1-fedora36
-          - name: almalinux93
+          - name: fedora40
+            image: jeffersonlab/geant4:g4v11.3.1-fedora40
+          - name: almalinux94
             image: jeffersonlab/geant4:g4v11.3.1-almalinux94
         # NOTE: additional packages needed for the sanitizer: libasan libubsan libtsan
         # MacOS: address, thread, undefined

ci/doxygen.sh

@@ -3,7 +3,7 @@
 # Purpose: creates the doxygen documentation for the selected classes
 
 # Container run:
-# docker_run_image jeffersonlab/base:fedora36
+# docker_run_image jeffersonlab/base:fedora40
 #
 # local build:
 # git clone http://github.com/gemc/src /root/src && cd /root/src

ci/test.sh

@@ -3,7 +3,7 @@
 # Purpose: compiles, installs gemc, run tests
 
 # Container run:
-# docker_run_image jeffersonlab/geant4:g4v11.3.0-almalinux93
+# docker_run_image jeffersonlab/geant4:g4v11.3.0-almalinux94
 #
 # local build:
 # git clone http://github.com/gemc/src /root/src && cd /root/src

gdata/event/gDataCollection.h

@@ -10,66 +10,72 @@
 
 #include "gTrueInfoData.h"
 #include "gDigitizedData.h"
+
+// c++
+#include <memory>
 #include <vector>
 
+
 class GDataCollection {
 public:
 	/**
 	 * \brief Constructs a GDataCollection.
 	 * \param logger Pointer to a GLogger instance.
 	 */
-	explicit GDataCollection(std::shared_ptr<GLogger> logger) : log(logger) {
-		log->debug(CONSTRUCTOR, "GDataCollection");
-		trueInfosData = new std::vector<GTrueInfoData*>;
-		digitizedData = new std::vector<GDigitizedData*>;
-	}
+	explicit GDataCollection(std::shared_ptr<GLogger> logger)
+		: log(logger) { log->debug(CONSTRUCTOR, "GDataCollection"); }
 
 	/**
 	 * \brief Destructor for GDataCollection.
 	 *
-	 * Deletes all stored hit data and the associated containers.
+	 * Smart pointers clean up automatically.
 	 */
-	~GDataCollection() {
-		for (auto* hit : (*trueInfosData)) { delete hit; }
-		for (auto* hit : (*digitizedData)) { delete hit; }
-		log->debug(DESTRUCTOR, "GDataCollection");
-		delete trueInfosData;
-		delete digitizedData;
-	}
+	~GDataCollection() { if (log) log->debug(DESTRUCTOR, "GDataCollection"); }
 
 	/**
 	 * \brief Adds true hit information data.
-	 * \param data Pointer to GTrueInfoData.
+	 * \param data Unique pointer to GTrueInfoData.
 	 */
-	void addTrueInfoData(GTrueInfoData* data) const {
+	void addTrueInfoData(std::unique_ptr<GTrueInfoData> data) {
 		log->debug(NORMAL, " adding hit to trueInfosData with identity: ", data->getIdentityString());
-		trueInfosData->push_back(data);
+		trueInfosData.push_back(std::move(data)); // taking ownership of the unique_ptr
 	}
 
 	/**
 	 * \brief Adds digitized hit data.
-	 * \param data Pointer to GDigitizedData.
+	 * \param data Unique pointer to GDigitizedData.
 	 */
-	void addDigitizedData(GDigitizedData* data) const {
+	void addDigitizedData(std::unique_ptr<GDigitizedData> data) {
 		log->debug(NORMAL, " adding hit to digitizedData with identity: ", data->getIdentityString());
-		digitizedData->push_back(data);
+		digitizedData.push_back(std::move(data)); // taking ownership of the unique_ptr
 	}
 
 	/**
-	 * \brief Returns the vector of true hit information data.
-	 * \return Pointer to the vector of GTrueInfoData pointers.
+	 * \brief Provides read-only access to the stored true hit data.
+	 *
+	 * Returns a constant reference to the internal vector of unique pointers
+	 * to GTrueInfoData objects. Ownership of the data remains with this class.
+	 * Callers may inspect the data via the pointers but must not modify or
+	 * take ownership of them.
+	 *
+	 * \return Const reference to the vector of unique_ptr<GTrueInfoData>.
 	 */
-	[[nodiscard]] inline const std::vector<GTrueInfoData*>* getTrueInfoData() const { return trueInfosData; }
+	[[nodiscard]] inline const std::vector<std::unique_ptr<GTrueInfoData>>& getTrueInfoData() const { return trueInfosData; }
 
 	/**
-	 * \brief Returns the vector of digitized hit data.
-	 * \return Pointer to the vector of GDigitizedData pointers.
+	 * \brief Provides read-only access to the stored digitized hit data.
+	 *
+	 * Returns a constant reference to the internal vector of unique pointers
+	 * to GDigitizedData objects. Ownership of the data remains with this class.
+	 * Callers may read the data but must not modify or transfer ownership.
+	 *
+	 * \return Const reference to the vector of unique_ptr<GDigitizedData>.
 	 */
-	[[nodiscard]] inline const std::vector<GDigitizedData*>* getDigitizedData() const { return digitizedData; }
+	[[nodiscard]] inline const std::vector<std::unique_ptr<GDigitizedData>>& getDigitizedData() const { return digitizedData; }
 
 private:
-	std::vector<GTrueInfoData*>*  trueInfosData = nullptr; ///< Vector of true hit data.
-	std::vector<GDigitizedData*>* digitizedData = nullptr; ///< Vector of digitized hit data.
-	std::shared_ptr<GLogger>      log;                     ///< Logger instance
-};
+	std::vector<std::unique_ptr<GTrueInfoData>>  trueInfosData; ///< Vector of true hit data.
+	std::vector<std::unique_ptr<GDigitizedData>> digitizedData; ///< Vector of digitized hit data.
+	std::shared_ptr<GLogger>                     log;           ///< Logger instance
 
+};

gdata/event/gDigitizedData.cc

@@ -5,49 +5,38 @@
 
 #include "gDigitizedData.h"
 #include "gdataConventions.h"
+
+// c++
 #include <string>
 #include <map>
 #include <vector>
 
-GDigitizedData::GDigitizedData(GHit *ghit, const std::shared_ptr<GLogger>& logger) : log(logger) {
+std::atomic<int> GDigitizedData::globalDigitizedDataCounter{0};
+
+GDigitizedData::GDigitizedData(const std::unique_ptr<GHit>& ghit, const std::shared_ptr<GLogger>& logger) : log(logger) {
 	log->debug(CONSTRUCTOR, "GDigitizedData");
 	gidentity = ghit->getGID();
 }
 
 std::map<std::string, int> GDigitizedData::getIntObservablesMap(int which) const {
 	std::map<std::string, int> filteredIntObservablesMap;
-	for (const auto& [varName, value] : intObservablesMap) {
-		if (validVarName(varName, which)) {
-			filteredIntObservablesMap[varName] = value;
-		}
-	}
+	for (const auto& [varName, value] : intObservablesMap) { if (validVarName(varName, which)) { filteredIntObservablesMap[varName] = value; } }
 	log->debug(NORMAL, " getting ", which, " from intObservablesMap.");
 	return filteredIntObservablesMap;
 }
 
 std::map<std::string, double> GDigitizedData::getDblObservablesMap(int which) const {
 	std::map<std::string, double> filteredDblObservablesMap;
-	for (const auto& [varName, value] : doubleObservablesMap) {
-		if (validVarName(varName, which)) {
-			filteredDblObservablesMap[varName] = value;
-		}
-	}
+	for (const auto& [varName, value] : doubleObservablesMap) { if (validVarName(varName, which)) { filteredDblObservablesMap[varName] = value; } }
 	log->debug(NORMAL, " getting ", which, " from doubleObservablesMap.");
 	return filteredDblObservablesMap;
 }
 
 bool GDigitizedData::validVarName(const std::string& varName, int which) {
 	bool isSROVar = (varName == CRATESTRINGID || varName == SLOTSTRINGID || varName == CHANNELSTRINGID ||
-					 varName == CHARGEATELECTRONICS || varName == TIMEATELECTRONICS);
-	if (which == 0) {
-		if (isSROVar) {
-			return false;
-		}
-	} else if (which == 1) {
-		if (!isSROVar) {
-			return false;
-		}
-	}
+	                 varName == CHARGEATELECTRONICS || varName == TIMEATELECTRONICS);
+	if (which == 0) { if (isSROVar) { return false; } }
+	else if (which == 1) { if (!isSROVar) { return false; } }
 	return true;
 }
 
@@ -62,9 +51,7 @@ void GDigitizedData::includeVariable(const std::string& vname, double value) {
 }
 
 int GDigitizedData::getTimeAtElectronics() {
-	if (intObservablesMap.find(TIMEATELECTRONICS) == intObservablesMap.end()) {
-		return TIMEATELECTRONICSNOTDEFINED;
-	}
+	if (intObservablesMap.find(TIMEATELECTRONICS) == intObservablesMap.end()) { return TIMEATELECTRONICSNOTDEFINED; }
 	log->debug(NORMAL, "Getting TIMEATELECTRONICS from intObservablesMap.");
 	return intObservablesMap[TIMEATELECTRONICS];
 }
@@ -85,9 +72,7 @@ double GDigitizedData::getDblObservable(const std::string& varName) {
 
 std::string GDigitizedData::getIdentityString() {
 	std::string identifierString;
-	for (size_t i = 0; i < gidentity.size() - 1; i++) {
-		identifierString += gidentity[i].getName() + "->" + std::to_string(gidentity[i].getValue()) + ", ";
-	}
+	for (size_t i = 0; i < gidentity.size() - 1; i++) { identifierString += gidentity[i].getName() + "->" + std::to_string(gidentity[i].getValue()) + ", "; }
 	identifierString += gidentity.back().getName() + "->" + std::to_string(gidentity.back().getValue());
 	return identifierString;
 }

gdata/event/gDigitizedData.h

@@ -8,20 +8,25 @@
  * It maintains maps for single-value and array observables keyed by variable names.
  */
 
+// c++
 #include <string>
 #include <map>
 #include <vector>
+#include <atomic>
+
+// gemc
 #include "ghit.h"
 #include "glogger.h"
+#include "gdataConventions.h"
 
 class GDigitizedData {
 public:
 	/**
 	 * \brief Constructs a GDigitizedData object from a GHit.
-	 * \param ghit Pointer to the GHit from which identity information is extracted.
+	 * \param ghit unique_ptr GHit from which identity information is extracted.
 	 * \param logger Pointer to a GLogger instance.
 	 */
-	GDigitizedData(GHit* ghit, const std::shared_ptr<GLogger>& logger);
+	GDigitizedData(const std::unique_ptr<GHit>& ghit, const std::shared_ptr<GLogger>& logger);
 
 	/**
 	 * \brief Destructor for GDigitizedData.
@@ -77,6 +82,20 @@ class GDigitizedData {
 	 */
 	[[nodiscard]] inline std::map<std::string, std::vector<double>> getArrayDblObservablesMap() const { return arrayDoubleObservablesMap; }
 
+
+	static std::unique_ptr<GDigitizedData> create(std::shared_ptr<GLogger> logger) {
+		auto hit       = GHit::create(logger);
+		auto digi_data = std::make_unique<GDigitizedData>(hit, logger);
+		auto counter   = globalDigitizedDataCounter.fetch_add(1, std::memory_order_relaxed);
+
+		digi_data->includeVariable(CRATESTRINGID, counter % 10);
+		digi_data->includeVariable(SLOTSTRINGID, counter % 20);
+		digi_data->includeVariable(CHANNELSTRINGID, counter);
+		digi_data->includeVariable(TIMEATELECTRONICS, counter * 5);
+		digi_data->includeVariable("adc", counter * 0.1);
+		return digi_data;
+	}
+
 private:
 	std::map<std::string, int>                 intObservablesMap;                                   ///< Map of integer observables.
 	std::map<std::string, double>              doubleObservablesMap;                                ///< Map of double observables.
@@ -85,4 +104,7 @@ class GDigitizedData {
 	std::vector<GIdentifier>                   gidentity;                                           ///< Identity extracted from the hit.
 	[[nodiscard]] static bool                  validVarName(const std::string& varName, int which); ///< Validates variable names.
 	std::shared_ptr<GLogger>                   log;                                                 ///< Logger instance
+
+	/// Static thread-safe event counter - used for testing only
+	static std::atomic<int> globalDigitizedDataCounter;
 };

gdata/event/gEventDataCollection.cc

@@ -4,28 +4,20 @@
  */
 
 #include "gEventDataCollection.h"
+#include "gEventHeader.h"
 
-void GEventDataCollection::addDetectorTrueInfoData(std::string sdName, GTrueInfoData* data) {
+std::atomic<int> GEventDataCollection::globalEventDataCollectionCounter{1};
+std::atomic<int> GEventHeader::globalEventHeaderCounter{1};
+
+void GEventDataCollection::addDetectorTrueInfoData(std::string sdName, std::unique_ptr<GTrueInfoData> data) {
 	if (gdataCollectionMap.find(sdName) == gdataCollectionMap.end()) { gdataCollectionMap[sdName] = std::make_unique<GDataCollection>(log); }
-	gdataCollectionMap[sdName]->addTrueInfoData(data);
+	gdataCollectionMap[sdName]->addTrueInfoData(std::move(data));
 	log->info(2, "GEventDataCollection: added new detector TrueInfoData for ", sdName);
 }
 
-void GEventDataCollection::addDetectorDigitizedData(std::string sdName, GDigitizedData* data) {
+void GEventDataCollection::addDetectorDigitizedData(std::string sdName, std::unique_ptr<GDigitizedData> data) {
 	if (gdataCollectionMap.find(sdName) == gdataCollectionMap.end()) { gdataCollectionMap[sdName] = std::make_unique<GDataCollection>(log); }
-	gdataCollectionMap[sdName]->addDigitizedData(data);
+	gdataCollectionMap[sdName]->addDigitizedData(std::move(data));
 	log->info(2, "GEventDataCollection: added new detector DigitizedData for ", sdName);
 }
 
-
-const std::vector<GTrueInfoData*>* GEventDataCollection::getTrueInfoDataForDetector(std::string detector) const {
-	auto it = gdataCollectionMap.find(detector);
-	if (it != gdataCollectionMap.end()) { return it->second->getTrueInfoData(); }
-	return nullptr;
-}
-
-const std::vector<GDigitizedData*>* GEventDataCollection::getDigitizedDataForDetector(std::string detector) const {
-	auto it = gdataCollectionMap.find(detector);
-	if (it != gdataCollectionMap.end()) { return it->second->getDigitizedData(); }
-	return nullptr;
-}