filling some arrays

Author: lobis

application/.clang-format .clang-format

@@ -41,7 +41,7 @@ IndentPPDirectives: None
 IndentWidth: 4
 KeepEmptyLinesAtTheStartOfBlocks: true
 MaxEmptyLinesToKeep: 2
-NamespaceIndentation: All
+NamespaceIndentation: None
 ObjCSpaceAfterProperty: false
 ObjCSpaceBeforeProtocolList: true
 PointerAlignment: Left

application/include/geant4/Application.h

@@ -13,26 +13,26 @@
 
 namespace geant4 {
 
-    class Application {
-    private:
-        std::unique_ptr<G4RunManager> runManager = nullptr;
-        bool isInitialized = false;
-
-    public:
-        Application();
-        ~Application() = default;
-
-        void SetupManager(unsigned short nThreads = 0);
-        void SetupDetector(std::string gdml, const std::set<std::string>& sensitiveVolumes = {});
-        void SetupPhysics();
-        void SetupAction();
-
-        void Initialize();
-        void Run(int nEvents);
-
-        bool IsSetup() const;
-        bool IsInitialized() const;
-    };
+class Application {
+private:
+    std::unique_ptr<G4RunManager> runManager = nullptr;
+    bool isInitialized = false;
+
+public:
+    Application();
+    ~Application() = default;
+
+    void SetupManager(unsigned short nThreads = 0);
+    void SetupDetector(std::string gdml, const std::set<std::string>& sensitiveVolumes = {});
+    void SetupPhysics();
+    void SetupAction();
+
+    void Initialize();
+    void Run(int nEvents);
+
+    bool IsSetup() const;
+    bool IsInitialized() const;
+};
 
 }// namespace geant4
 

application/include/geant4/DataModel.h

@@ -0,0 +1,39 @@
+#ifndef GEANT4PYTHONICAPPLICATION_DATAMODEL_H
+#define GEANT4PYTHONICAPPLICATION_DATAMODEL_H
+
+#include "awkward/LayoutBuilder.h"
+
+class G4Event;
+class G4Track;
+class G4Step;
+
+namespace geant4::data {
+
+// Enum to represent fields
+enum Field : std::size_t { energy,
+                           time };
+
+using UserDefinedMap = std::map<std::size_t, std::string>;
+
+
+template<std::size_t field_name, class BUILDER>
+using RecordField = awkward::LayoutBuilder::Field<field_name, BUILDER>;
+
+template<class... BUILDERS>
+using RecordBuilder = awkward::LayoutBuilder::Record<UserDefinedMap, BUILDERS...>;
+
+template<class PRIMITIVE>
+using NumpyBuilder = awkward::LayoutBuilder::Numpy<PRIMITIVE>;
+
+using Builder = RecordBuilder<RecordField<static_cast<std::size_t>(Field::energy), NumpyBuilder<double>>,
+                              RecordField<static_cast<std::size_t>(Field::time), NumpyBuilder<double>>>;
+
+
+void InsertEvent(const G4Event* track, Builder& builder);
+void InsertTrack(const G4Track* track, Builder& builder);
+void InsertStep(const G4Event* track, Builder& builder);
+
+}// namespace geant4::data
+
+
+#endif// GEANT4PYTHONICAPPLICATION_DATAMODEL_H

application/include/geant4/RunAction.h

@@ -2,9 +2,10 @@
 #ifndef GEANT4_APPLICATION_RUNACTION_H
 #define GEANT4_APPLICATION_RUNACTION_H
 
+#include <G4RunManager.hh>
 #include <G4UserRunAction.hh>
 
-#include "awkward/LayoutBuilder.h"
+#include "geant4/DataModel.h"
 
 class RunAction : public G4UserRunAction {
 public:
@@ -13,6 +14,11 @@ class RunAction : public G4UserRunAction {
     void BeginOfRunAction(const G4Run*) override;
 
     void EndOfRunAction(const G4Run*) override;
+
+    geant4::data::Builder& GetBuilder() { return builder; }
+
+private:
+    geant4::data::Builder builder;
 };
 
 #endif// GEANT4_APPLICATION_RUNACTION_H

application/src/geant4/DataModel.cpp

@@ -0,0 +1,28 @@
+
+#include "geant4/DataModel.h"
+
+#include <G4Event.hh>
+#include <G4ParticleDefinition.hh>
+#include <G4ParticleTypes.hh>
+#include <G4Step.hh>
+#include <G4SystemOfUnits.hh>
+#include <G4Track.hh>
+#include <G4UnitsTable.hh>
+#include <iostream>
+
+
+using namespace geant4::data;
+
+void InsertEvent(const G4Event* event, Builder& builder) {
+}
+
+void InsertTrack(const G4Track* track, Builder& builder) {
+    auto& energyBuilder = builder.content<Field::energy>();
+    auto& timeBuilder = builder.content<Field::time>();
+
+    energyBuilder.append(track->GetKineticEnergy());
+    timeBuilder.append(track->GetGlobalTime());
+}
+
+void InsertStep(const G4Step* step, Builder& builder) {
+}

application/src/geant4/RunAction.cpp

@@ -1,16 +1,28 @@
 
 #include "geant4/RunAction.h"
-#include <G4Threading.hh>
 #include <iostream>
 
 using namespace std;
 
 RunAction::RunAction() : G4UserRunAction() {}
 
 void RunAction::BeginOfRunAction(const G4Run*) {
-    cout << "Begin of run for thread " << G4Threading::G4GetThreadId() << endl;
+
+    if (IsMaster()) {
+        cout << "RunAction::BeginOfRunAction" << endl;
+    } else {
+        cout << "RunAction::BeginOfRunAction (worker)" << endl;
+    }
 }
 
 void RunAction::EndOfRunAction(const G4Run*) {
-    G4cout << "END OF RUN" << G4endl;
+    if (IsMaster()) {
+        cout << "RunAction::EndOfRunAction" << endl;
+    } else {
+        cout << "RunAction::EndOfRunAction (worker)" << endl;
+        string error;
+        if (!builder.is_valid(error)) {
+            throw std::runtime_error("Builder is not valid: " + error);
+        }
+    }
 }

application/src/geant4/TrackingAction.cpp

@@ -3,6 +3,7 @@
 //
 
 #include "geant4/TrackingAction.h"
+#include "geant4/RunAction.h"
 
 #include <G4ParticleDefinition.hh>
 #include <G4ParticleTypes.hh>
@@ -17,6 +18,8 @@ using namespace std;
 TrackingAction::TrackingAction() : G4UserTrackingAction() {}
 
 void TrackingAction::PreUserTrackingAction(const G4Track* track) {
+    auto runAction = dynamic_cast<RunAction*>(const_cast<G4UserRunAction*>(G4RunManager::GetRunManager()->GetUserRunAction()));
+    // auto& builder = runAction->GetBuilder();
 }
 
 void TrackingAction::PostUserTrackingAction(const G4Track* track) {

application/tests/testApplication.cpp

@@ -49,7 +49,7 @@ const std::string gdml = R"(
 TEST(Application, Run) {
     Application app;
     EXPECT_FALSE(app.IsSetup());
-    app.SetupManager();
+    app.SetupManager(4);
     EXPECT_FALSE(app.IsSetup());
     app.SetupDetector(gdml);
     EXPECT_FALSE(app.IsSetup());