exiting gui after 0.5 seconds in the examples, added logger to gstreamer but example not ready yet

Author: maureeungaro

g4dialog/examples/g4dialog_example.cc

@@ -9,6 +9,7 @@
 // qt
 #include <QApplication>
 #include <QMainWindow>
+#include <QTimer>
 
 int main(int argc, char* argv[]) {
 
@@ -20,27 +21,29 @@ int main(int argc, char* argv[]) {
 	auto visManager = new G4VisExecutive;
 	visManager->Initialize();
 
-	// main window
+    // main window and controls
 	auto window = new QMainWindow();
 	window->setWindowTitle(QString::fromUtf8("displayUI example"));
-
-	// controls
 	auto g4dialog = new G4Dialog(gopts, window);
 	window->setCentralWidget(g4dialog);
 
-
 	log->info(0, "g4 dialog example started");
+	int ret = EXIT_SUCCESS;
 
 	if (gopts->getSwitch("gui")) {
 		window->show();
-		return app.exec();
+
+		// --- quit after 0.5 s ---
+		QTimer::singleShot(500, &app, &QCoreApplication::quit);  // ⬅️ key line :contentReference[oaicite:0]{index=0}
+
+		ret = QApplication::exec();    // returns when the timer fires
 	}
 
 	delete g4dialog;
 	delete window;
 	delete visManager;
 	delete gopts;
 
-	return EXIT_SUCCESS;
+	return ret;
 
 }

g4display/examples/g4display_example.cc

@@ -1,7 +1,6 @@
 // geant4
 #include "G4VisExecutive.hh"
 #include "G4RunManagerFactory.hh"
-#include "FTFP_BERT.hh"
 
 // g4display
 #include "g4SceneProperties.h"
@@ -14,8 +13,10 @@
 // qt
 #include <QApplication>
 #include <QMainWindow>
+#include <QTimer>
 
 int main(int argc, char* argv[]) {
+
 	// Initialize options and logging
 	auto gopts = new GOptions(argc, argv, g4display::defineOptions());
 	auto log   = new GLogger(gopts, G4DISPLAY_LOGGER, "g4display example");
@@ -24,7 +25,6 @@ int main(int argc, char* argv[]) {
 	// Optional GUI setup (only if --gui is passed)
 	QApplication* app = nullptr;
 	QMainWindow* window = nullptr;
-	G4Display* g4display = nullptr;
 
 	if (gopts->getSwitch("gui")) {
 		log->info(0, "g4display", "Running in GUI mode...");
@@ -38,19 +38,25 @@ int main(int argc, char* argv[]) {
 
 	auto g4SceneProperties = new G4SceneProperties(gopts);
 
-	// If GUI, show window and run Qt loop
+	// If GUI, show the window and run Qt loop
 	if (gopts->getSwitch("gui")) {
 
-		g4display = new G4Display(gopts, window);
+		auto g4display = new G4Display(gopts, window);
 		window->setCentralWidget(g4display);
 		window->show();
+
+		/* ---------- quit after 0.5 s ---------- */
+		QTimer::singleShot(500, []
+		{
+			QCoreApplication::quit();          // stop the event loop
+		});
+
 		int appResult = QApplication::exec();
 
 		// Clean up GUI resources
 		delete g4display;
 		delete window;
 		delete app;
-		app = nullptr;
 
 		// Clean up Geant4 and custom logic
 		delete g4SceneProperties;

g4display/g4Text.cc

@@ -19,9 +19,9 @@ namespace g4display {
 
             st_item.text = gopts->get_variable_in_option<string>(g4t_item, "text", goptions::NODFLT);
             st_item.color = gopts->get_variable_in_option<string>(g4t_item, "color", "black");
-            st_item.x = gopts->get_variable_in_option<float>(g4t_item, "x", 0);
-            st_item.y = gopts->get_variable_in_option<float>(g4t_item, "y", 0);
-            st_item.z = gopts->get_variable_in_option<float>(g4t_item, "z", GNOT_SPECIFIED_SCENE_TEXT_Z);
+            st_item.x = gopts->get_variable_in_option<double>(g4t_item, "x", 0);
+            st_item.y = gopts->get_variable_in_option<double>(g4t_item, "y", 0);
+            st_item.z = gopts->get_variable_in_option<double>(g4t_item, "z", GNOT_SPECIFIED_SCENE_TEXT_Z);
             st_item.size = gopts->get_variable_in_option<double>(g4t_item, "size", 24.0);
             st.push_back(st_item);
         }

g4display/g4Text.h

@@ -13,9 +13,9 @@ namespace g4display {
     struct G4SceneText {
         string text;
         string color;
-        float x;
-        float y;
-        float z = GNOT_SPECIFIED_SCENE_TEXT_Z;
+        double x;
+        double y;
+        double z = GNOT_SPECIFIED_SCENE_TEXT_Z;
         int size;
     };
 

g4display/tabs/g4displayview.cc

@@ -21,13 +21,13 @@ using namespace gutilities;
  * @param logger Pointer to the shared GLogger instance for logging.
  * @param parent Optional pointer to the parent QWidget.
  */
-G4DisplayView::G4DisplayView(GOptions* gopts, 	std::shared_ptr<GLogger> logger, QWidget* parent) : QWidget(parent), log(logger) {
+G4DisplayView::G4DisplayView(GOptions* gopts, std::shared_ptr<GLogger> logger, QWidget* parent) : QWidget(parent), log(logger) {
 	log->debug(CONSTRUCTOR, "G4DisplayView");
 
 	G4Camera jcamera = getG4Camera(gopts);
 
 	double thetaValue = getG4Number(jcamera.theta);
-	double phiValue = getG4Number(jcamera.phi);
+	double phiValue   = getG4Number(jcamera.phi);
 
 	vector<string> toggle_button_titles;
 	toggle_button_titles.emplace_back("Hidden\nLines");
@@ -159,8 +159,8 @@ G4DisplayView::G4DisplayView(GOptions* gopts, 	std::shared_ptr<GLogger> logger,
 
 	// slice style: Intersection or Union
 	QGroupBox* sliceChoiceBox = new QGroupBox(tr("Slices Style"));
-	sliceSectn = new QRadioButton(tr("&Intersection"), sliceChoiceBox);
-	sliceUnion = new QRadioButton(tr("&Union"), sliceChoiceBox);
+	sliceSectn                = new QRadioButton(tr("&Intersection"), sliceChoiceBox);
+	sliceUnion                = new QRadioButton(tr("&Union"), sliceChoiceBox);
 	sliceSectn->setChecked(true);
 
 	connect(sliceSectn, &QRadioButton::toggled, this, &G4DisplayView::slice);
@@ -186,17 +186,17 @@ G4DisplayView::G4DisplayView(GOptions* gopts, 	std::shared_ptr<GLogger> logger,
 	connect(sliceYEdit, &QLineEdit::returnPressed, this, &G4DisplayView::slice);
 	connect(sliceZEdit, &QLineEdit::returnPressed, this, &G4DisplayView::slice);
 
-	connect(sliceXActi, &QCheckBox::stateChanged, this, &G4DisplayView::slice);
-	connect(sliceYActi, &QCheckBox::stateChanged, this, &G4DisplayView::slice);
-	connect(sliceZActi, &QCheckBox::stateChanged, this, &G4DisplayView::slice);
+	connect(sliceXActi, &QCheckBox::checkStateChanged, this, &G4DisplayView::slice);
+	connect(sliceYActi, &QCheckBox::checkStateChanged, this, &G4DisplayView::slice);
+	connect(sliceZActi, &QCheckBox::checkStateChanged, this, &G4DisplayView::slice);
 
-	connect(sliceXInve, &QCheckBox::stateChanged, this, &G4DisplayView::slice);
-	connect(sliceYInve, &QCheckBox::stateChanged, this, &G4DisplayView::slice);
-	connect(sliceZInve, &QCheckBox::stateChanged, this, &G4DisplayView::slice);
+	connect(sliceXInve, &QCheckBox::checkStateChanged, this, &G4DisplayView::slice);
+	connect(sliceYInve, &QCheckBox::checkStateChanged, this, &G4DisplayView::slice);
+	connect(sliceZInve, &QCheckBox::checkStateChanged, this, &G4DisplayView::slice);
 
 
 	QGroupBox* fieldPrecisionBox = new QGroupBox(tr("Number of Field Points"));
-	field_npoints = new QLineEdit(QString::number(field_NPOINTS), this);
+	field_npoints                = new QLineEdit(QString::number(field_NPOINTS), this);
 	field_npoints->setMaximumWidth(40);
 
 	QFont font = field_npoints->font();
@@ -234,8 +234,8 @@ G4DisplayView::G4DisplayView(GOptions* gopts, 	std::shared_ptr<GLogger> logger,
 void G4DisplayView::changeCameraDirection() {
 	// Construct the command using the current slider values.
 	string command = "/vis/viewer/set/viewpointThetaPhi " +
-					 to_string(cameraTheta->value()) + " " +
-					 to_string(cameraPhi->value());
+	                 to_string(cameraTheta->value()) + " " +
+	                 to_string(cameraPhi->value());
 	// Send the command to the Geant4 UImanager.
 	G4UImanager::GetUIpointer()->ApplyCommand(command);
 }
@@ -248,8 +248,8 @@ void G4DisplayView::changeCameraDirection() {
  */
 void G4DisplayView::changeLightDirection() {
 	string command = "/vis/viewer/set/lightsThetaPhi " +
-					 to_string(lightTheta->value()) + " " +
-					 to_string(lightPhi->value());
+	                 to_string(lightTheta->value()) + " " +
+	                 to_string(lightPhi->value());
 	G4UImanager::GetUIpointer()->ApplyCommand(command);
 }
 
@@ -280,21 +280,21 @@ void G4DisplayView::slice() {
 
 	if (sliceXActi->isChecked()) {
 		string command = "/vis/viewer/addCutawayPlane " + sliceXEdit->text().toStdString() + " 0  0 mm " +
-			to_string(sliceXInve->isChecked() ? -1 : 1) + " 0 0 ";
+		                 to_string(sliceXInve->isChecked() ? -1 : 1) + " 0 0 ";
 		cout << "X " << command << endl;
 		g4uim->ApplyCommand(command);
 	}
 
 	if (sliceYActi->isChecked()) {
 		string command = "/vis/viewer/addCutawayPlane 0 " + sliceYEdit->text().toStdString() + " 0 mm 0 " +
-			to_string(sliceYInve->isChecked() ? -1 : 1) + " 0 ";
+		                 to_string(sliceYInve->isChecked() ? -1 : 1) + " 0 ";
 		cout << "Y " << command << endl;
 		g4uim->ApplyCommand(command);
 	}
 
 	if (sliceZActi->isChecked()) {
 		string command = "/vis/viewer/addCutawayPlane 0 0 " + sliceZEdit->text().toStdString() + " mm 0 0 " +
-			to_string(sliceZInve->isChecked() ? -1 : 1);
+		                 to_string(sliceZInve->isChecked() ? -1 : 1);
 		cout << "Z " << command << endl;
 		g4uim->ApplyCommand(command);
 	}
@@ -382,7 +382,7 @@ void G4DisplayView::field_precision_changed() {
 		g4uim->ApplyCommand("/vis/scene/removeModel Field");
 
 		string npoints = to_string(field_NPOINTS);
-		command = string("/vis/scene/add/magneticField ") + npoints;
+		command        = string("/vis/scene/add/magneticField ") + npoints;
 		G4UImanager::GetUIpointer()->ApplyCommand(command);
 	}
 }

g4display/tabs/g4displayview.h

@@ -34,7 +34,7 @@ class G4DisplayView : public QWidget {
      * @param logger Pointer to the GLogger instance for logging messages. Must not be null. Passed from parent G4Display.
      * @param parent Optional parent QWidget for Qt's memory management.
      */
-	G4DisplayView(GOptions* gopts,	std::shared_ptr<GLogger>, QWidget* parent = nullptr);
+	G4DisplayView(GOptions* gopts,	std::shared_ptr<GLogger> logger, QWidget* parent = nullptr);
 
     /**
      * @brief Destructor. Logs the destruction event using the provided logger.

gdata/event/gDataCollection.h

@@ -18,7 +18,7 @@ class GDataCollection {
 	 * \brief Constructs a GDataCollection.
 	 * \param logger Pointer to a GLogger instance.
 	 */
-	explicit GDataCollection(std::shared_ptr<GLogger> logger) : log(std::move(logger)) {
+	explicit GDataCollection(std::shared_ptr<GLogger> logger) : log(logger) {
 		log->debug(CONSTRUCTOR, "GDataCollection");
 		trueInfosData = new std::vector<GTrueInfoData*>;
 		digitizedData = new std::vector<GDigitizedData*>;

gdata/event/gDigitizedData.cc

@@ -9,7 +9,7 @@
 #include <map>
 #include <vector>
 
-GDigitizedData::GDigitizedData(GHit *ghit, const std::shared_ptr<GLogger>& logger) : log(std::move(logger)) {
+GDigitizedData::GDigitizedData(GHit *ghit, const std::shared_ptr<GLogger>& logger) : log(logger) {
 	log->debug(CONSTRUCTOR, "GDigitizedData");
 	gidentity = ghit->getGID();
 }
@@ -25,18 +25,18 @@ std::map<std::string, int> GDigitizedData::getIntObservablesMap(int which) const
 	return filteredIntObservablesMap;
 }
 
-std::map<std::string, float> GDigitizedData::getFltObservablesMap(int which) const {
-	std::map<std::string, float> filteredFltObservablesMap;
+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)) {
-			filteredFltObservablesMap[varName] = value;
+			filteredDblObservablesMap[varName] = value;
 		}
 	}
 	log->debug(NORMAL, " getting ", which, " from doubleObservablesMap.");
-	return filteredFltObservablesMap;
+	return filteredDblObservablesMap;
 }
 
-bool GDigitizedData::validVarName(const std::string& varName, int which) const {
+bool GDigitizedData::validVarName(const std::string& varName, int which) {
 	bool isSROVar = (varName == CRATESTRINGID || varName == SLOTSTRINGID || varName == CHANNELSTRINGID ||
 					 varName == CHARGEATELECTRONICS || varName == TIMEATELECTRONICS);
 	if (which == 0) {
@@ -57,7 +57,7 @@ void GDigitizedData::includeVariable(const std::string& vname, int value) {
 }
 
 void GDigitizedData::includeVariable(const std::string& vname, double value) {
-	log->debug(NORMAL, "Including float variable ", vname, " with value ", value);
+	log->debug(NORMAL, "double variable ", vname, " with value ", value);
 	doubleObservablesMap[vname] = value;
 }
 
@@ -69,22 +69,22 @@ int GDigitizedData::getTimeAtElectronics() {
 	return intObservablesMap[TIMEATELECTRONICS];
 }
 
-int GDigitizedData::getIntObservable(std::string varName) {
+int GDigitizedData::getIntObservable(const std::string& varName) {
 	if (intObservablesMap.find(varName) == intObservablesMap.end()) {
 		log->error(EC__VARIABLENOTFOUND, "variable name <" + varName + "> not found in GDigitizedData::intObservablesMap");
 	}
 	return intObservablesMap[varName];
 }
 
-float GDigitizedData::getFltObservable(std::string varName) {
+double GDigitizedData::getDblObservable(const std::string& varName) {
 	if (doubleObservablesMap.find(varName) == doubleObservablesMap.end()) {
 		log->error(EC__VARIABLENOTFOUND, "variable name <" + varName + "> not found in GDigitizedData::doubleObservablesMap");
 	}
 	return doubleObservablesMap[varName];
 }
 
 std::string GDigitizedData::getIdentityString() {
-	std::string identifierString = "";
+	std::string identifierString;
 	for (size_t i = 0; i < gidentity.size() - 1; i++) {
 		identifierString += gidentity[i].getName() + "->" + std::to_string(gidentity[i].getValue()) + ", ";
 	}

gdata/event/gDigitizedData.h

@@ -38,7 +38,6 @@ class GDigitizedData {
 	void includeVariable(const std::string& vname, int value);
 	void includeVariable(const std::string& vname, double value);
 	// void includeVariable(std::string vname, std::vector<int> values);
-	// void includeVariable(std::string vname, std::vector<float> values);
 
 	/**
 	 * \brief Returns the filtered map of integer observables.
@@ -48,11 +47,11 @@ class GDigitizedData {
 	[[nodiscard]] std::map<std::string, int> getIntObservablesMap(int which) const;
 
 	/**
-	 * \brief Returns the filtered map of float observables.
+	 * \brief Returns the filtered map of double observables.
 	 * \param which 0: returns non-streaming variables; 1: returns streaming variables.
-	 * \return A map of variable names to float values.
+	 * \return A map of variable names to double values.
 	 */
-	[[nodiscard]] std::map<std::string, float> getFltObservablesMap(int which) const;
+	[[nodiscard]] std::map<std::string, double> getDblObservablesMap(int which) const;
 
 	/**
 	 * \brief Gets the time at electronics.
@@ -63,31 +62,27 @@ class GDigitizedData {
 	 */
 	int getTimeAtElectronics();
 
-	int   getIntObservable(std::string varName);
-	float getFltObservable(std::string varName);
+	int    getIntObservable(const std::string& varName);
+	double getDblObservable(const std::string& varName);
 
 	/**
 	 * \brief Returns the map of integer array observables.
 	 * \return A map of variable names to vectors of integers.
 	 */
-	[[nodiscard]] inline std::map<std::string, std::vector<int>> getArrayIntObservablesMap() const {
-		return arrayIntObservablesMap;
-	}
+	[[nodiscard]] inline std::map<std::string, std::vector<int>> getArrayIntObservablesMap() const { return arrayIntObservablesMap; }
 
 	/**
-	 * \brief Returns the map of float array observables.
-	 * \return A map of variable names to vectors of floats.
+	 * \brief Returns the map of double array observables.
+	 * \return A map of variable names to vectors of double.
 	 */
-	[[nodiscard]] inline std::map<std::string, std::vector<double>> getArrayFltObservablesMap() const {
-		return arrayDoubleObservablesMap;
-	}
+	[[nodiscard]] inline std::map<std::string, std::vector<double>> getArrayDblObservablesMap() const { return arrayDoubleObservablesMap; }
 
 private:
-	std::map<std::string, int> intObservablesMap; ///< Map of integer observables.
-	std::map<std::string, double> doubleObservablesMap; ///< Map of float observables.
-	std::map<std::string, std::vector<int>> arrayIntObservablesMap; ///< Map of integer array observables.
-	std::map<std::string, std::vector<double>> arrayDoubleObservablesMap; ///< Map of float array observables.
-	std::vector<GIdentifier> gidentity; ///< Identity extracted from the hit.
-	[[nodiscard]] bool validVarName(const std::string& varName, int which) const; ///< Validates variable names.
-	std::shared_ptr<GLogger> log; ///< Logger instance
+	std::map<std::string, int>                 intObservablesMap;                                   ///< Map of integer observables.
+	std::map<std::string, double>              doubleObservablesMap;                                ///< Map of double observables.
+	std::map<std::string, std::vector<int>>    arrayIntObservablesMap;                              ///< Map of integer array observables.
+	std::map<std::string, std::vector<double>> arrayDoubleObservablesMap;                           ///< Map of double array observables.
+	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
 };

gdata/event/gEventDataCollection.h

@@ -22,7 +22,7 @@ class GEventDataCollection {
 	 * \param header Pointer to the event header.
 	 * \param logger Pointer to a GLogger instance (using the 'gdata' name).
 	 */
-	GEventDataCollection(GEventDataCollectionHeader* header, std::shared_ptr<GLogger> logger) : log(std::move(logger)),
+	GEventDataCollection(GEventDataCollectionHeader* header, std::shared_ptr<GLogger> logger) : log(logger),
 		gheader(header) {
 		log->debug(CONSTRUCTOR, "GEventDataCollection");
 		gdataCollectionMap = new std::map<std::string, GDataCollection*>();