added true information vars

Author: maureeungaro

gemc/gdynamicDigitization/gdynamicdigitization.cc

@@ -36,9 +36,12 @@ std::unique_ptr<GTrueInfoData> GDynamicDigitization::collectTrueInformationImpl(
 	G4ThreeVector motherTrackVertex = ghit->getMotherTrackVertexPosition();
 
 	trueInfoData->includeVariable("pid", ghit->getPid());
+	trueInfoData->includeVariable("mpid", ghit->getMpid());
 	trueInfoData->includeVariable("tid", ghit->getTid());
+	trueInfoData->includeVariable("otid", 0);
 	trueInfoData->includeVariable("mtid", ghit->getMotherTid());
 	trueInfoData->includeVariable("totalEDeposited", ghit->getTotalEnergyDeposited());
+	trueInfoData->includeVariable("trackE", ghit->getTrackE());
 	trueInfoData->includeVariable("avgTime", ghit->getAverageTime());
 	trueInfoData->includeVariable("avgx", avgGlobalPos.getX());
 	trueInfoData->includeVariable("avgy", avgGlobalPos.getY());
@@ -52,10 +55,17 @@ std::unique_ptr<GTrueInfoData> GDynamicDigitization::collectTrueInformationImpl(
 	trueInfoData->includeVariable("mvx", motherTrackVertex.getX());
 	trueInfoData->includeVariable("mvy", motherTrackVertex.getY());
 	trueInfoData->includeVariable("mvz", motherTrackVertex.getZ());
+
+	G4ThreeVector momentum = ghit->getMomentum();
+	trueInfoData->includeVariable("px", momentum.getX());
+	trueInfoData->includeVariable("py", momentum.getY());
+	trueInfoData->includeVariable("pz", momentum.getZ());
+
+	trueInfoData->includeVariable("nsteps", static_cast<int>(ghit->getStepCount()));
 	trueInfoData->includeVariable("hitn", static_cast<int>(hitn)); // assume hitn < INT_MAX
 
-	// Bit 1 typically includes metadata like the process name.
 	trueInfoData->includeVariable("processName", ghit->getProcessName());
+	trueInfoData->includeVariable("procID", ghit->getProcID());
 
 	return trueInfoData;
 }

gemc/ghit/addHitInfos.cc

@@ -5,9 +5,7 @@
 #include "gutsConventions.h"
 
 // geant4
-#include "G4TouchableHistory.hh"
 #include "G4VProcess.hh"
-#include "subprojects/assimp/code/AssetLib/3MF/3MFXmlTags.h"
 
 // See header for API docs.
 
@@ -40,23 +38,33 @@ void GHit::addHitInfosForBitset(const HitBitSet hbs, const G4Step* step) {
 	auto trackVertex = track->GetVertexPosition();
 	int  trackId = track->GetTrackID();
 	int  motherTrackId = track->GetParentID();
+	int  currentPdg = track->GetDefinition()->GetPDGEncoding();
 
 	trackVertexById.emplace(trackId, trackVertex);
+	pdgById.emplace(trackId, currentPdg);
 
 	G4ThreeVector motherTrackVertex(UNINITIALIZEDNUMBERQUANTITY, UNINITIALIZEDNUMBERQUANTITY,
 	                                UNINITIALIZEDNUMBERQUANTITY);
+	int motherPdg = UNINITIALIZEDNUMBERQUANTITY;
 	if (motherTrackId > 0) {
 		auto motherVertex = trackVertexById.find(motherTrackId);
 		if (motherVertex != trackVertexById.end()) {
 			motherTrackVertex = motherVertex->second;
 		}
+		auto motherPdgIt = pdgById.find(motherTrackId);
+		if (motherPdgIt != pdgById.end()) {
+			motherPdg = motherPdgIt->second;
+		}
 	}
 
 	trackVertexPositions.push_back(trackVertex);
 	motherTrackVertexPositions.push_back(motherTrackVertex);
-	pids.push_back(track->GetDefinition()->GetPDGEncoding());
+	pids.push_back(currentPdg);
 	tids.push_back(trackId);
 	motherTids.push_back(motherTrackId);
+	momenta.push_back(preStepPoint->GetMomentum());
+	trackEs.push_back(preStepPoint->GetTotalEnergy());
+	motherPids.push_back(motherPdg);
 
 
 	// Iterate over each bit and call the helper method to add optional info.

gemc/ghit/ghit.cc

@@ -17,6 +17,7 @@ using std::vector;
 
 std::atomic<int> GHit::globalHitCounter{0};
 thread_local std::map<int, G4ThreeVector> GHit::trackVertexById;
+thread_local std::map<int, int> GHit::pdgById;
 
 // MT definitions, as from:
 // https://twiki.cern.ch/twiki/bin/view/Geant4/QuickMigrationGuideForGeant4V10
@@ -100,6 +101,7 @@ bool GHit::setColorSchema() {
 
 void GHit::clearTrackVertexCache() {
 	trackVertexById.clear();
+	pdgById.clear();
 }
 
 void GHit::randomizeHitForTesting(int nsteps) {
@@ -120,6 +122,9 @@ void GHit::randomizeHitForTesting(int nsteps) {
 		tids.emplace_back(i);
 		motherTids.emplace_back(0);
 		Es.emplace_back(G4UniformRand() * 10);
+		momenta.emplace_back(G4UniformRand() * 100, G4UniformRand() * 100, G4UniformRand() * 100);
+		trackEs.emplace_back(G4UniformRand() * 1000);
+		motherPids.emplace_back(2212); // proton as placeholder mother
 
 		pids.emplace_back(static_cast<int>(G4UniformRand() * 1000)); // Random particle ID
 	}

gemc/ghit/ghit.h

@@ -226,6 +226,37 @@ class GHit : public G4VHit
 	 */
 	std::vector<double> stepSize;
 
+	/**
+	 * \brief Track 3-momentum per recorded step (unconditional).
+	 *
+	 * Values are derived from the pre-step point momentum via \c G4StepPoint::GetMomentum().
+	 * Stored in Geant4 internal units (MeV).
+	 */
+	std::vector<G4ThreeVector> momenta;
+
+	/**
+	 * \brief Track total energy per recorded step (unconditional).
+	 *
+	 * Values are derived from \c preStepPoint->GetTotalEnergy() (kinetic + rest mass, in MeV).
+	 */
+	std::vector<double> trackEs;
+
+	/**
+	 * \brief Mother particle PDG encodings per recorded step (unconditional).
+	 *
+	 * Looked up from the per-thread \c pdgById cache using the parent track ID.
+	 * Stores the uninitialized sentinel when the parent track has not yet been seen.
+	 */
+	std::vector<int> motherPids;
+
+	/**
+	 * \brief Per-thread cache of track-id to particle PDG encoding.
+	 *
+	 * Populated alongside \c trackVertexById so that mother PDG can be resolved
+	 * when the parent track was already processed by GEMC hit logic.
+	 */
+	static thread_local std::map<int, int> pdgById;
+
 	// -------------------------------------------------------------------------
 	// Aggregated / calculated quantities (lazy)
 	// -------------------------------------------------------------------------
@@ -400,28 +431,84 @@ class GHit : public G4VHit
 	[[nodiscard]] inline int getMotherTid() const { return motherTids.front(); }
 
 	/**
-	 * \brief Get per-step total energies (when enabled).
+	 * \brief Get per-step total energies (when enabled by bit 0).
 	 * \return A copy of the vector of per-step energies.
 	 */
 	[[nodiscard]] inline std::vector<double> getEs() const { return Es; }
 
 	/**
-	 * \brief Convenience accessor for the first energy value.
+	 * \brief Convenience accessor for the first energy value (requires bit 0).
 	 * \return The first energy value.
 	 *
 	 * \warning This assumes the internal \c Es vector is non-empty.
 	 */
 	[[nodiscard]] inline double getE() const { return Es.front(); }
 
 	/**
-	 * \brief Number of recorded steps for the optional-energy vector.
+	 * \brief Number of recorded steps for the optional-energy vector (requires bit 0).
 	 * \return The size of the \c Es vector.
 	 *
 	 * \note Depending on the \c HitBitSet configuration, \c Es may remain empty even if
 	 *       always-present vectors have entries.
 	 */
 	[[nodiscard]] inline size_t nsteps() const { return Es.size(); }
 
+	/**
+	 * \brief True number of recorded steps (always-present edep vector).
+	 * \return The size of the \c edeps vector, which is always populated regardless of HitBitSet.
+	 */
+	[[nodiscard]] inline size_t getStepCount() const { return edeps.size(); }
+
+	/**
+	 * \brief Get per-step track 3-momenta (always present).
+	 * \return A copy of the vector of per-step momenta.
+	 */
+	[[nodiscard]] inline std::vector<G4ThreeVector> getMomenta() const { return momenta; }
+
+	/**
+	 * \brief Convenience accessor for the first step 3-momentum.
+	 * \return The first recorded track momentum.
+	 *
+	 * \warning This assumes the internal \c momenta vector is non-empty.
+	 */
+	[[nodiscard]] inline G4ThreeVector getMomentum() const { return momenta.front(); }
+
+	/**
+	 * \brief Get per-step track total energies (always present).
+	 * \return A copy of the vector of per-step track total energies (MeV).
+	 */
+	[[nodiscard]] inline std::vector<double> getTrackEs() const { return trackEs; }
+
+	/**
+	 * \brief Convenience accessor for the first step track total energy.
+	 * \return The first recorded track total energy (MeV).
+	 *
+	 * \warning This assumes the internal \c trackEs vector is non-empty.
+	 */
+	[[nodiscard]] inline double getTrackE() const { return trackEs.front(); }
+
+	/**
+	 * \brief Get per-step mother particle PDG encodings (always present).
+	 * \return A copy of the vector of per-step mother PDG codes.
+	 */
+	[[nodiscard]] inline std::vector<int> getMotherPids() const { return motherPids; }
+
+	/**
+	 * \brief Convenience accessor for the first step mother particle PDG encoding.
+	 * \return The first recorded mother PDG code (sentinel when parent not yet seen).
+	 *
+	 * \warning This assumes the internal \c motherPids vector is non-empty.
+	 */
+	[[nodiscard]] inline int getMpid() const { return motherPids.front(); }
+
+	/**
+	 * \brief Get the representative creator process name for this hit.
+	 *
+	 * Alias for \ref getProcessName() following G4 naming conventions.
+	 * \return The cached representative process name.
+	 */
+	[[nodiscard]] inline std::string getProcID() const { return processName; }
+
 	/**
 	 * \brief Get the representative process name for the hit.
 	 * \return The cached representative process name string.