diff --git a/application/CMakeLists.txt b/application/CMakeLists.txt
index a28ea17..4eb5e9b 100644
--- a/application/CMakeLists.txt
+++ b/application/CMakeLists.txt
@@ -45,6 +45,8 @@ file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS
      "${PROJECT_SOURCE_DIR}/src/geant4/*.cpp")
 
 add_library(${PROJECT_NAME} SHARED ${SOURCES})
+set_target_properties(${PROJECT_NAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY
+                                                 ${PROJECT_BINARY_DIR}/lib)
 
 target_include_directories(${PROJECT_NAME} PUBLIC ${PROJECT_SOURCE_DIR}/include
                                                   ${Geant4_INCLUDE_DIRS})
diff --git a/application/include/geant4/DataModel.h b/application/include/geant4/DataModel.h
index d52f4f4..f736314 100644
--- a/application/include/geant4/DataModel.h
+++ b/application/include/geant4/DataModel.h
@@ -17,12 +17,15 @@ class G4Step;
 namespace geant4::data {
 
 enum Field : std::size_t { eventId,
+                           //
                            trackId,
                            trackParentId,
-                           trackEnergy,
+                           trackInitialEnergy,
                            trackTime,
-                           trackHitsEnergy,
-                           trackHitsTime,
+                           //
+                           hitsEnergy,
+                           hitsTime,
+                           hitsProcess,
 };
 
 using UserDefinedMap = std::map<std::size_t, std::string>;
@@ -43,21 +46,25 @@ typedef unsigned int id;
 using Builder = RecordBuilder<RecordField<static_cast<std::size_t>(Field::eventId), NumpyBuilder<id>>,
                               RecordField<static_cast<std::size_t>(Field::trackId), ListOffsetBuilder<id, NumpyBuilder<id>>>,
                               RecordField<static_cast<std::size_t>(Field::trackParentId), ListOffsetBuilder<id, NumpyBuilder<id>>>,
-                              RecordField<static_cast<std::size_t>(Field::trackEnergy), ListOffsetBuilder<id, NumpyBuilder<float>>>,
+                              RecordField<static_cast<std::size_t>(Field::trackInitialEnergy), ListOffsetBuilder<id, NumpyBuilder<float>>>,
                               RecordField<static_cast<std::size_t>(Field::trackTime), ListOffsetBuilder<id, NumpyBuilder<float>>>,
-                              RecordField<static_cast<std::size_t>(Field::trackHitsEnergy), ListOffsetBuilder<id, ListOffsetBuilder<id, NumpyBuilder<float>>>>,
-                              RecordField<static_cast<std::size_t>(Field::trackHitsTime), ListOffsetBuilder<id, ListOffsetBuilder<id, NumpyBuilder<float>>>>>;
+                              RecordField<static_cast<std::size_t>(Field::hitsEnergy), ListOffsetBuilder<id, ListOffsetBuilder<id, NumpyBuilder<float>>>>,
+                              RecordField<static_cast<std::size_t>(Field::hitsTime), ListOffsetBuilder<id, ListOffsetBuilder<id, NumpyBuilder<float>>>>
+                              // RecordField<static_cast<std::size_t>(Field::hitsProcess), ListOffsetBuilder<id, ListOffsetBuilder<id, NumpyBuilder<std::string>>>>
+                              >;
 
 inline Builder MakeBuilder() {
     return {
-            {{Field::eventId, "event_id"},
-             {Field::trackId, "track.id"},
-             {Field::trackParentId, "track.parent_id"},
-             {Field::trackEnergy, "track.energy"},
-             {Field::trackTime, "track.time"},
-             {Field::trackHitsEnergy, "track.hits.energy"},
-             {Field::trackHitsTime, "track.hits.time"}},
-    };
+            {
+                    {Field::eventId, "event_id"},
+                    {Field::trackId, "track.id"},
+                    {Field::trackParentId, "track.parent_id"},
+                    {Field::trackInitialEnergy, "track.initial_energy"},
+                    {Field::trackTime, "track.time"},
+                    {Field::hitsEnergy, "track.hits.energy"},
+                    {Field::hitsTime, "track.hits.time"},
+                    // {Field::hitsProcess, "track.hits.process"}},
+            }};
 }
 
 void InsertEventBegin(const G4Event* event, Builder& builder);
diff --git a/application/src/geant4/DataModel.cpp b/application/src/geant4/DataModel.cpp
index 0f8aca1..17dc42d 100644
--- a/application/src/geant4/DataModel.cpp
+++ b/application/src/geant4/DataModel.cpp
@@ -2,11 +2,14 @@
 #include "geant4/DataModel.h"
 
 #include <G4Event.hh>
+#include <G4HadronicProcess.hh>
+#include <G4Nucleus.hh>
 #include <G4ParticleDefinition.hh>
 #include <G4ParticleTypes.hh>
 #include <G4Step.hh>
 #include <G4Track.hh>
 #include <G4UnitsTable.hh>
+#include <G4VProcess.hh>
 #include <iostream>
 
 #include <pybind11/numpy.h>
@@ -19,42 +22,29 @@ namespace geant4::data {
 void InsertEventBegin(const G4Event* event, Builder& builder) {
     builder.content<Field::eventId>().append(event->GetEventID());
 
-    auto& trackId = builder.content<Field::trackId>();
-    auto& trackParentId = builder.content<Field::trackParentId>();
-    auto& trackEnergy = builder.content<Field::trackEnergy>();
-    auto& trackTime = builder.content<Field::trackTime>();
-    auto& trackHitsEnergy = builder.content<Field::trackHitsEnergy>();
-    auto& trackHitsTime = builder.content<Field::trackHitsTime>();
-
-    trackId.begin_list();
-    trackParentId.begin_list();
-    trackEnergy.begin_list();
-    trackTime.begin_list();
-    trackHitsEnergy.begin_list();
-    trackHitsTime.begin_list();
+    builder.content<Field::trackId>().begin_list();
+    builder.content<Field::trackParentId>().begin_list();
+    builder.content<Field::trackInitialEnergy>().begin_list();
+    builder.content<Field::trackTime>().begin_list();
+    builder.content<Field::hitsEnergy>().begin_list();
+    builder.content<Field::hitsTime>().begin_list();
+    // builder.content<Field::hitsProcess>().begin_list();
 }
 
 void InsertEventEnd(const G4Event*, Builder& builder) {
-
-    auto& trackId = builder.content<Field::trackId>();
-    auto& trackParentId = builder.content<Field::trackParentId>();
-    auto& trackEnergy = builder.content<Field::trackEnergy>();
-    auto& trackTime = builder.content<Field::trackTime>();
-    auto& trackHitsEnergy = builder.content<Field::trackHitsEnergy>();
-    auto& trackHitsTime = builder.content<Field::trackHitsTime>();
-
-    trackId.end_list();
-    trackParentId.end_list();
-    trackEnergy.end_list();
-    trackTime.end_list();
-    trackHitsEnergy.end_list();
-    trackHitsTime.end_list();
+    builder.content<Field::trackId>().end_list();
+    builder.content<Field::trackParentId>().end_list();
+    builder.content<Field::trackInitialEnergy>().end_list();
+    builder.content<Field::trackTime>().end_list();
+    builder.content<Field::hitsEnergy>().end_list();
+    builder.content<Field::hitsTime>().end_list();
+    // builder.content<Field::hitsProcess>().end_list();
 }
 
 void InsertTrackBegin(const G4Track* track, Builder& builder) {
     auto& trackId = builder.content<Field::trackId>();
     auto& trackParentId = builder.content<Field::trackParentId>();
-    auto& trackEnergy = builder.content<Field::trackEnergy>();
+    auto& trackEnergy = builder.content<Field::trackInitialEnergy>();
     auto& trackTime = builder.content<Field::trackTime>();
 
     trackId.content().append(track->GetTrackID());
@@ -62,29 +52,40 @@ void InsertTrackBegin(const G4Track* track, Builder& builder) {
     trackEnergy.content().append(track->GetKineticEnergy() / units::energy);
     trackTime.content().append(track->GetGlobalTime() / units::time);
 
-    builder.content<Field::trackHitsEnergy>().content().begin_list();
-    builder.content<Field::trackHitsTime>().content().begin_list();
+    builder.content<Field::hitsEnergy>().content().begin_list();
+    builder.content<Field::hitsTime>().content().begin_list();
+    // builder.content<Field::hitsProcess>().content().begin_list();
 
-    // we should probably insert a step here to mark the beginning of the track
+    // we should probably insert a step here to mark the beginning of the track / use stepping verbose
 }
 
 void InsertTrackEnd(const G4Track*, Builder& builder) {
-    auto& trackHitsEnergy = builder.content<Field::trackHitsEnergy>();
-    auto& trackHitsTime = builder.content<Field::trackHitsTime>();
-
-    trackHitsEnergy.content().end_list();
-    trackHitsTime.content().end_list();
+    builder.content<Field::hitsEnergy>().content().end_list();
+    builder.content<Field::hitsTime>().content().end_list();
+    // builder.content<Field::hitsProcess>().content().end_list();
 }
 
 void InsertStep(const G4Step* step, Builder& builder) {
-    auto& trackHitsEnergy = builder.content<Field::trackHitsEnergy>();
-    auto& trackHitsTime = builder.content<Field::trackHitsTime>();
+    auto& hitsEnergy = builder.content<Field::hitsEnergy>();
+    auto& hitsTime = builder.content<Field::hitsTime>();
+
+    const G4Track* track = step->GetTrack();
 
     const auto& stepPost = step->GetPostStepPoint();
     const auto& stepPre = step->GetPreStepPoint();
 
-    trackHitsEnergy.content().content().append(step->GetTotalEnergyDeposit() / units::energy);
-    trackHitsTime.content().content().append(stepPost->GetGlobalTime() / units::time);
+    const auto process = step->GetPostStepPoint()->GetProcessDefinedStep();
+    G4String processName = "Init";
+    G4String processTypeName = "Init";
+    if (track->GetCurrentStepNumber() != 0) {
+        // 0 = Init step (G4SteppingVerbose) process is not defined for this step
+        processName = process->GetProcessName();
+        processTypeName = G4VProcess::GetProcessTypeName(process->GetProcessType());
+    }
+
+    builder.content<Field::hitsEnergy>().content().content().append(step->GetTotalEnergyDeposit() / units::energy);
+    builder.content<Field::hitsTime>().content().content().append(stepPost->GetGlobalTime() / units::time);
+    // builder.content<Field::hitsProcess>().content().content().append(processName);
 }
 
 py::object SnapshotBuilder(Builder& builder) {