diff --git a/examples/Example1/src/DetectorConstruction.cc b/examples/Example1/src/DetectorConstruction.cc
index 2b553d8a..9a332983 100644
--- a/examples/Example1/src/DetectorConstruction.cc
+++ b/examples/Example1/src/DetectorConstruction.cc
@@ -68,11 +68,10 @@ void DetectorConstruction::ConstructSDandField()
 
     field = std::make_unique<CovfieField>(fFieldFile);
 #else
-  // Set a 3D magnetic field vector for a uniform field in Bz. If no file is provided, no magnetic field is used in the
+  // Set a 3D magnetic field vector for a uniform B field. If no field is provided, no magnetic field is used in the
   // G4 transport
-  if (std::abs(fMagFieldVector[2]) > 0.0) {
-    G4cout << G4endl
-           << " *** SETTING CONSTANT MAGNETIC FIELD IN Z: fieldValue in z = " << fMagFieldVector[2] / kilogauss
+  if (fMagFieldVector.mag2() > 0.0) {
+    G4cout << G4endl << " *** SETTING CONSTANT MAGNETIC FIELD: fieldValues = " << fMagFieldVector / kilogauss
            << " [kilogauss] *** " << G4endl << G4endl;
 
     field = std::make_unique<UniformField>(fMagFieldVector);
diff --git a/examples/IntegrationBenchmark/src/DetectorConstruction.cc b/examples/IntegrationBenchmark/src/DetectorConstruction.cc
index 2b553d8a..9a332983 100644
--- a/examples/IntegrationBenchmark/src/DetectorConstruction.cc
+++ b/examples/IntegrationBenchmark/src/DetectorConstruction.cc
@@ -68,11 +68,10 @@ void DetectorConstruction::ConstructSDandField()
 
     field = std::make_unique<CovfieField>(fFieldFile);
 #else
-  // Set a 3D magnetic field vector for a uniform field in Bz. If no file is provided, no magnetic field is used in the
+  // Set a 3D magnetic field vector for a uniform B field. If no field is provided, no magnetic field is used in the
   // G4 transport
-  if (std::abs(fMagFieldVector[2]) > 0.0) {
-    G4cout << G4endl
-           << " *** SETTING CONSTANT MAGNETIC FIELD IN Z: fieldValue in z = " << fMagFieldVector[2] / kilogauss
+  if (fMagFieldVector.mag2() > 0.0) {
+    G4cout << G4endl << " *** SETTING CONSTANT MAGNETIC FIELD: fieldValues = " << fMagFieldVector / kilogauss
            << " [kilogauss] *** " << G4endl << G4endl;
 
     field = std::make_unique<UniformField>(fMagFieldVector);
diff --git a/include/AdePT/core/AdePTTransport.cuh b/include/AdePT/core/AdePTTransport.cuh
index 8ad0261b..044f0927 100644
--- a/include/AdePT/core/AdePTTransport.cuh
+++ b/include/AdePT/core/AdePTTransport.cuh
@@ -56,7 +56,6 @@ inline __constant__ __device__ struct G4HepEmParameters g4HepEmPars;
 inline __constant__ __device__ struct G4HepEmData g4HepEmData;
 
 inline __constant__ __device__ adeptint::VolAuxData *gVolAuxData = nullptr;
-inline __constant__ __device__ double BzFieldValue               = 0;
 inline __constant__ __device__ bool ApplyCuts                    = false;
 
 bool InitializeVolAuxArray(adeptint::VolAuxArray &array)
@@ -228,44 +227,33 @@ __global__ void ClearLeakedQueues(LeakedTracks all)
   all.leakedGammas->clear();
 }
 
-bool InitializeField(double bz)
-{
-  // Initialize field
-  COPCORE_CUDA_CHECK(cudaMemcpyToSymbol(BzFieldValue, &bz, sizeof(double)));
-  return true;
-}
-
-bool InitializeGeneralField(GeneralMagneticField &magneticField)
+template <typename FieldType>
+bool InitializeBField(FieldType &magneticField)
 {
 
-#ifdef ADEPT_USE_EXT_BFIELD
-
-  // Allocate and copy the GeneralMagneticField instance (not the field array itself), and set the global device pointer
-  GeneralMagneticField *dMagneticFieldInstance = nullptr;
-  COPCORE_CUDA_CHECK(cudaMalloc(&dMagneticFieldInstance, sizeof(GeneralMagneticField)));
-  COPCORE_CUDA_CHECK(
-      cudaMemcpy(dMagneticFieldInstance, &magneticField, sizeof(GeneralMagneticField), cudaMemcpyHostToDevice));
-  COPCORE_CUDA_CHECK(cudaMemcpyToSymbol(gMagneticField, &dMagneticFieldInstance, sizeof(GeneralMagneticField *)));
+  // Allocate and copy the FieldType instance (not the field array itself), and set the global device pointer
+  FieldType *dMagneticFieldInstance = nullptr;
+  COPCORE_CUDA_CHECK(cudaMalloc(&dMagneticFieldInstance, sizeof(FieldType)));
+  COPCORE_CUDA_CHECK(cudaMemcpy(dMagneticFieldInstance, &magneticField, sizeof(FieldType), cudaMemcpyHostToDevice));
+  COPCORE_CUDA_CHECK(cudaMemcpyToSymbol(gMagneticField, &dMagneticFieldInstance, sizeof(FieldType *)));
 
-#endif
   return true;
 }
 
-void FreeGeneralField()
+template <typename FieldType>
+void FreeBField()
 {
-#ifdef ADEPT_USE_EXT_BFIELD
-  GeneralMagneticField *dMagneticFieldInstance = nullptr;
+  FieldType *dMagneticFieldInstance = nullptr;
 
   // Retrieve the global device pointer from the symbol
-  COPCORE_CUDA_CHECK(cudaMemcpyFromSymbol(&dMagneticFieldInstance, gMagneticField, sizeof(GeneralMagneticField *)));
+  COPCORE_CUDA_CHECK(cudaMemcpyFromSymbol(&dMagneticFieldInstance, gMagneticField, sizeof(FieldType *)));
 
   if (dMagneticFieldInstance) {
     // Free the device memory and reset global device pointer
     COPCORE_CUDA_CHECK(cudaFree(dMagneticFieldInstance));
-    GeneralMagneticField *nullPtr = nullptr;
-    COPCORE_CUDA_CHECK(cudaMemcpyToSymbol(gMagneticField, &nullPtr, sizeof(GeneralMagneticField *)));
+    FieldType *nullPtr = nullptr;
+    COPCORE_CUDA_CHECK(cudaMemcpyToSymbol(gMagneticField, &nullPtr, sizeof(FieldType *)));
   }
-#endif
 }
 
 void PrepareLeakedBuffers(int numLeaked, adeptint::TrackBuffer &buffer, GPUstate &gpuState)
@@ -377,8 +365,12 @@ void FreeGPU(GPUstate &gpuState, G4HepEmState *g4hepem_state)
   FreeG4HepEmData(g4hepem_state->fData);
   delete g4hepem_state;
 
-  // Free magnetic field map
-  FreeGeneralField();
+// Free magnetic field
+#ifdef ADEPT_USE_EXT_BFIELD
+  FreeBField<GeneralMagneticField>();
+#else
+  FreeBField<UniformMagneticField>();
+#endif
 }
 
 template <typename IntegrationLayer>
@@ -623,6 +615,11 @@ void ShowerGPU(IntegrationLayer &integration, int event, adeptint::TrackBuffer &
 
   adept_scoring::EndOfTransport<IntegrationLayer>(*scoring, scoring_dev, gpuState.stream, integration);
 }
+
+// explicit instantiation
+template bool InitializeBField<GeneralMagneticField>(GeneralMagneticField &);
+template bool InitializeBField<UniformMagneticField>(UniformMagneticField &);
+
 } // namespace adept_impl
 
 #endif
diff --git a/include/AdePT/core/AdePTTransport.h b/include/AdePT/core/AdePTTransport.h
index b8cc86ba..9d1d2d8c 100644
--- a/include/AdePT/core/AdePTTransport.h
+++ b/include/AdePT/core/AdePTTransport.h
@@ -14,6 +14,7 @@
 #include <AdePT/core/HostScoringStruct.cuh>
 #include <AdePT/core/AdePTConfiguration.hh>
 #include <AdePT/magneticfield/GeneralMagneticField.h>
+#include <AdePT/magneticfield/UniformMagneticField.h>
 
 #include <VecGeom/base/Config.h>
 #ifdef VECGEOM_ENABLE_CUDA
@@ -108,8 +109,8 @@ class AdePTTransport : public AdePTTransportInterface {
   /// @brief Used to map VecGeom to Geant4 volumes for scoring
   void InitializeSensitiveVolumeMapping(const G4VPhysicalVolume *g4world, const vecgeom::VPlacedVolume *world);
   void InitBVH();
-  bool InitializeField(double bz);
-  bool InitializeGeneralField();
+  bool InitializeBField();
+  bool InitializeBField(UniformMagneticField &Bfield);
   bool InitializeGeometry(const vecgeom::cxx::VPlacedVolume *world);
   bool InitializePhysics();
 };
diff --git a/include/AdePT/core/AdePTTransport.icc b/include/AdePT/core/AdePTTransport.icc
index c1eb72f0..f2b365c2 100644
--- a/include/AdePT/core/AdePTTransport.icc
+++ b/include/AdePT/core/AdePTTransport.icc
@@ -24,12 +24,13 @@
 namespace adept_impl {
 /// Forward declarations for methods implemented in AdePTTransport.cu
 using TrackBuffer = adeptint::TrackBuffer;
-bool InitializeField(double);
+template <typename FieldType>
+bool InitializeBField(FieldType &);
+template <typename FieldType>
+void FreeField();
 bool InitializeApplyCuts(bool);
-bool InitializeGeneralField(GeneralMagneticField &);
 bool InitializeVolAuxArray(adeptint::VolAuxArray &);
 void FreeVolAuxArray(adeptint::VolAuxArray &);
-void FreeGeneralField(GeneralMagneticField &);
 G4HepEmState *InitG4HepEm();
 GPUstate *InitializeGPU(TrackBuffer &, int, int);
 AdeptScoring *InitializeScoringGPU(AdeptScoring *scoring);
@@ -60,19 +61,7 @@ AdePTTransport<IntegrationLayer>::AdePTTransport(AdePTConfiguration &configurati
 }
 
 template <typename IntegrationLayer>
-bool AdePTTransport<IntegrationLayer>::InitializeField(double bz)
-{
-  return adept_impl::InitializeField(bz);
-}
-
-template <typename IntegrationLayer>
-bool AdePTTransport<IntegrationLayer>::InitializeApplyCuts(bool applycuts)
-{
-  return adept_impl::InitializeApplyCuts(applycuts);
-}
-
-template <typename IntegrationLayer>
-bool AdePTTransport<IntegrationLayer>::InitializeGeneralField()
+bool AdePTTransport<IntegrationLayer>::InitializeBField()
 {
   if (!fBfieldFile.empty()) {
     // Initialize magnetic field data from file
@@ -81,11 +70,33 @@ bool AdePTTransport<IntegrationLayer>::InitializeGeneralField()
     }
 
     // Delegate the setup of the global view pointer to adept_impl
-    return adept_impl::InitializeGeneralField(fMagneticField);
+    return adept_impl::InitializeBField(fMagneticField);
   }
   return true; // no file provided, but no error encountered, so true is returned
 }
 
+template <typename IntegrationLayer>
+bool AdePTTransport<IntegrationLayer>::InitializeBField(UniformMagneticField &Bfield)
+{
+  vecgeom::Vector3D<float> position{
+      0.,
+      0.,
+      0.,
+  };
+  auto field_value = Bfield.Evaluate(position);
+  if (field_value.Mag2() > 0) {
+    // Delegate the setup of the global view pointer to adept_impl
+    return adept_impl::InitializeBField(Bfield);
+  }
+  return true; // no B field provided, but no error encountered, so true is returned
+}
+
+template <typename IntegrationLayer>
+bool AdePTTransport<IntegrationLayer>::InitializeApplyCuts(bool applycuts)
+{
+  return adept_impl::InitializeApplyCuts(applycuts);
+}
+
 template <typename IntegrationLayer>
 void AdePTTransport<IntegrationLayer>::AddTrack(
     int pdg, int parent_id, double energy, double vertexEnergy, double x, double y, double z, double dirx, double diry,
@@ -184,22 +195,17 @@ void AdePTTransport<IntegrationLayer>::Initialize(bool common_data)
       throw std::runtime_error("AdePTTransport<IntegrationLayer>::Initialize cannot initialize physics on GPU");
 
 #ifdef ADEPT_USE_EXT_BFIELD
-    // Try to initialize field from file, otherwise initialize from vector
-    if (!InitializeGeneralField()) {
+    // Try to initialize field from file
+    if (!InitializeBField()) {
       throw std::runtime_error(
           "AdePTTransport<IntegrationLayer>::Initialize cannot initialize GeneralMagneticField on GPU");
-      // NOTE: if the field option is a run-time option and not a compile time option, uncomment the code below
-      // to use uniform field in case no file was provided. ToDo: this requires changing the return of
-      // InitializeGeneralField
-      //   double bz = fIntegrationLayer.GetUniformFieldZ();
-      //   if (!InitializeField(bz))
-      //     throw std::runtime_error("AdePTTransport<IntegrationLayer>::Initialize cannot initialize field on GPU");
     }
-#endif
-    // Initialize field from vector
-    double bz = fIntegrationLayer.GetUniformFieldZ();
-    if (!InitializeField(bz))
+#else
+    auto field_values                            = fIntegrationLayer.GetUniformField(); // Get the field value
+    std::unique_ptr<UniformMagneticField> Bfield = std::make_unique<UniformMagneticField>(field_values);
+    if (!InitializeBField(*Bfield))
       throw std::runtime_error("AdePTTransport<IntegrationLayer>::Initialize cannot initialize field on GPU");
+#endif
 
     // Do the material-cut couple index mapping once
     // as well as set flags for sensitive volumes and region
diff --git a/include/AdePT/core/AdePTTransportStruct.cuh b/include/AdePT/core/AdePTTransportStruct.cuh
index 4b5422e0..093f01ca 100644
--- a/include/AdePT/core/AdePTTransportStruct.cuh
+++ b/include/AdePT/core/AdePTTransportStruct.cuh
@@ -7,6 +7,7 @@
 #include <AdePT/core/CommonStruct.h>
 #include <AdePT/core/HostScoringStruct.cuh>
 #include <AdePT/magneticfield/GeneralMagneticField.h>
+#include <AdePT/magneticfield/UniformMagneticField.h>
 
 #include "Track.cuh"
 #include <AdePT/base/TrackManager.cuh>
@@ -91,10 +92,11 @@ extern __constant__ struct G4HepEmParameters g4HepEmPars;
 extern __constant__ struct G4HepEmData g4HepEmData;
 
 extern __constant__ __device__ adeptint::VolAuxData *gVolAuxData;
-extern __constant__ __device__ double BzFieldValue;
 extern __constant__ __device__ bool ApplyCuts;
 #ifdef ADEPT_USE_EXT_BFIELD
 __device__ GeneralMagneticField *gMagneticField = nullptr;
+#else
+__device__ UniformMagneticField *gMagneticField = nullptr;
 #endif
 
 } // namespace adept_impl
diff --git a/include/AdePT/core/AsyncAdePTTransport.cuh b/include/AdePT/core/AsyncAdePTTransport.cuh
index cd1c4f93..5bae2484 100644
--- a/include/AdePT/core/AsyncAdePTTransport.cuh
+++ b/include/AdePT/core/AsyncAdePTTransport.cuh
@@ -446,44 +446,33 @@ G4HepEmState *InitG4HepEm()
   return state;
 }
 
-bool InitializeField(double bz)
-{
-  // Initialize field
-  COPCORE_CUDA_CHECK(cudaMemcpyToSymbol(BzFieldValue, &bz, sizeof(double)));
-  return true;
-}
-
-bool InitializeGeneralField(GeneralMagneticField &magneticField)
+template <typename FieldType>
+bool InitializeBField(FieldType &magneticField)
 {
 
-#ifdef ADEPT_USE_EXT_BFIELD
-
-  // Allocate and copy the GeneralMagneticField instance (not the field array itself), and set the global device pointer
-  GeneralMagneticField *dMagneticFieldInstance = nullptr;
-  COPCORE_CUDA_CHECK(cudaMalloc(&dMagneticFieldInstance, sizeof(GeneralMagneticField)));
-  COPCORE_CUDA_CHECK(
-      cudaMemcpy(dMagneticFieldInstance, &magneticField, sizeof(GeneralMagneticField), cudaMemcpyHostToDevice));
-  COPCORE_CUDA_CHECK(cudaMemcpyToSymbol(gMagneticField, &dMagneticFieldInstance, sizeof(GeneralMagneticField *)));
+  // Allocate and copy the FieldType instance (not the field array itself), and set the global device pointer
+  FieldType *dMagneticFieldInstance = nullptr;
+  COPCORE_CUDA_CHECK(cudaMalloc(&dMagneticFieldInstance, sizeof(FieldType)));
+  COPCORE_CUDA_CHECK(cudaMemcpy(dMagneticFieldInstance, &magneticField, sizeof(FieldType), cudaMemcpyHostToDevice));
+  COPCORE_CUDA_CHECK(cudaMemcpyToSymbol(gMagneticField, &dMagneticFieldInstance, sizeof(FieldType *)));
 
-#endif
   return true;
 }
 
-void FreeGeneralField()
+template <typename FieldType>
+void FreeBField()
 {
-#ifdef ADEPT_USE_EXT_BFIELD
-  GeneralMagneticField *dMagneticFieldInstance = nullptr;
+  FieldType *dMagneticFieldInstance = nullptr;
 
   // Retrieve the global device pointer from the symbol
-  COPCORE_CUDA_CHECK(cudaMemcpyFromSymbol(&dMagneticFieldInstance, gMagneticField, sizeof(GeneralMagneticField *)));
+  COPCORE_CUDA_CHECK(cudaMemcpyFromSymbol(&dMagneticFieldInstance, gMagneticField, sizeof(FieldType *)));
 
   if (dMagneticFieldInstance) {
     // Free the device memory and reset global device pointer
     COPCORE_CUDA_CHECK(cudaFree(dMagneticFieldInstance));
-    GeneralMagneticField *nullPtr = nullptr;
-    COPCORE_CUDA_CHECK(cudaMemcpyToSymbol(gMagneticField, &nullPtr, sizeof(GeneralMagneticField *)));
+    FieldType *nullPtr = nullptr;
+    COPCORE_CUDA_CHECK(cudaMemcpyToSymbol(gMagneticField, &nullPtr, sizeof(FieldType *)));
   }
-#endif
 }
 
 bool InitializeApplyCuts(bool applycuts)
@@ -1204,10 +1193,18 @@ void FreeGPU(std::unique_ptr<AsyncAdePT::GPUstate, AsyncAdePT::GPUstateDeleter>
   // Free G4HepEm data
   FreeG4HepEmData(g4hepem_state.fData);
 
-  // Free magnetic field map
-  FreeGeneralField();
+  // Free magnetic field
+#ifdef ADEPT_USE_EXT_BFIELD
+  FreeBField<GeneralMagneticField>();
+#else
+  FreeBField<UniformMagneticField>();
+#endif
 }
 
+// explicit instantiation
+template bool InitializeBField<GeneralMagneticField>(GeneralMagneticField &);
+template bool InitializeBField<UniformMagneticField>(UniformMagneticField &);
+
 } // namespace async_adept_impl
 
 namespace AsyncAdePT {
@@ -1216,7 +1213,6 @@ __constant__ __device__ struct G4HepEmParameters g4HepEmPars;
 __constant__ __device__ struct G4HepEmData g4HepEmData;
 
 __constant__ __device__ adeptint::VolAuxData *gVolAuxData = nullptr;
-__constant__ __device__ double BzFieldValue               = 0;
 __constant__ __device__ bool ApplyCuts                    = false;
 
 /// Transfer volume auxiliary data to GPU
diff --git a/include/AdePT/core/AsyncAdePTTransport.hh b/include/AdePT/core/AsyncAdePTTransport.hh
index 6a68cc36..8f861ad8 100644
--- a/include/AdePT/core/AsyncAdePTTransport.hh
+++ b/include/AdePT/core/AsyncAdePTTransport.hh
@@ -17,6 +17,7 @@
 #include <AdePT/core/AsyncAdePTTransportStruct.hh>
 #include <AdePT/core/PerEventScoringStruct.cuh>
 #include <AdePT/magneticfield/GeneralMagneticField.h>
+#include <AdePT/magneticfield/UniformMagneticField.h>
 
 #include <VecGeom/base/Config.h>
 #include <VecGeom/management/CudaManager.h> // forward declares vecgeom::cxx::VPlacedVolume
@@ -74,8 +75,8 @@ private:
 
   void Initialize();
   void InitBVH();
-  bool InitializeField(double bz);
-  bool InitializeGeneralField();
+  bool InitializeBField();
+  bool InitializeBField(UniformMagneticField &Bfield);
   bool InitializeGeometry(const vecgeom::cxx::VPlacedVolume *world);
   bool InitializePhysics();
 
diff --git a/include/AdePT/core/AsyncAdePTTransport.icc b/include/AdePT/core/AsyncAdePTTransport.icc
index 4607f108..39fbe255 100644
--- a/include/AdePT/core/AsyncAdePTTransport.icc
+++ b/include/AdePT/core/AsyncAdePTTransport.icc
@@ -44,9 +44,10 @@
 /// Forward declarations
 namespace async_adept_impl {
 void CopySurfaceModelToGPU();
-bool InitializeField(double);
-bool InitializeGeneralField(GeneralMagneticField &);
-void FreeGeneralField(GeneralMagneticField &);
+template <typename FieldType>
+bool InitializeBField(FieldType &);
+template <typename FieldType>
+void FreeField();
 bool InitializeApplyCuts(bool applycuts);
 G4HepEmState *InitG4HepEm();
 void FlushScoring(AdePTScoring &);
@@ -167,13 +168,7 @@ void AsyncAdePTTransport<IntegrationLayer>::AddTrack(
 }
 
 template <typename IntegrationLayer>
-bool AsyncAdePTTransport<IntegrationLayer>::InitializeField(double bz)
-{
-  return async_adept_impl::InitializeField(bz);
-}
-
-template <typename IntegrationLayer>
-bool AsyncAdePTTransport<IntegrationLayer>::InitializeGeneralField()
+bool AsyncAdePTTransport<IntegrationLayer>::InitializeBField()
 {
   if (!fBfieldFile.empty()) {
     // Initialize magnetic field data from file
@@ -182,11 +177,27 @@ bool AsyncAdePTTransport<IntegrationLayer>::InitializeGeneralField()
     }
 
     // Delegate the setup of the global view pointer to adept_impl
-    return async_adept_impl::InitializeGeneralField(fMagneticField);
+    return async_adept_impl::InitializeBField(fMagneticField);
   }
   return true; // no file provided, but no error encountered, so true is returned
 }
 
+template <typename IntegrationLayer>
+bool AsyncAdePTTransport<IntegrationLayer>::InitializeBField(UniformMagneticField &Bfield)
+{
+  vecgeom::Vector3D<float> position{
+      0.,
+      0.,
+      0.,
+  };
+  auto field_value = Bfield.Evaluate(position);
+  if (field_value.Mag2() > 0) {
+    // Delegate the setup of the global view pointer to adept_impl
+    return async_adept_impl::InitializeBField(Bfield);
+  }
+  return true; // no B field provided, but no error encountered, so true is returned
+}
+
 template <typename IntegrationLayer>
 bool AsyncAdePTTransport<IntegrationLayer>::InitializeApplyCuts(bool applycuts)
 {
@@ -258,28 +269,22 @@ void AsyncAdePTTransport<IntegrationLayer>::Initialize()
     throw std::runtime_error("AsyncAdePTTransport::Initialize: Cannot initialize geometry on GPU");
 
   // Initialize G4HepEm
-  fIntegrationLayerObjects.front().GetUniformFieldZ();
   if (!InitializePhysics())
     throw std::runtime_error("AsyncAdePTTransport::Initialize cannot initialize physics on GPU");
 
   // Initialize field
-  const double bz =
-      fIntegrationLayerObjects[0].GetUniformFieldZ(); // Get the field value from one of the worker threads
-  if (!InitializeField(bz))
-    throw std::runtime_error("AdePTTransport<IntegrationLayer>::Initialize cannot initialize field on GPU");
-
 #ifdef ADEPT_USE_EXT_BFIELD
-  // Try to initialize field from file, otherwise initialize from vector
-  if (!InitializeGeneralField()) {
+  // Try to initialize field from file
+  if (!InitializeBField()) {
     throw std::runtime_error(
         "AdePTTransport<IntegrationLayer>::Initialize cannot initialize GeneralMagneticField on GPU");
-    // NOTE: if the field option is a run-time option and not a compile time option, uncomment the code below
-    // to use uniform field in case no file was provided. ToDo: this requires changing the return of
-    // InitializeGeneralField
-    //   double bz = fIntegrationLayer.GetUniformFieldZ();
-    //   if (!InitializeField(bz))
-    //     throw std::runtime_error("AdePTTransport<IntegrationLayer>::Initialize cannot initialize field on GPU");
   }
+#else
+  auto field_values =
+      fIntegrationLayerObjects[0].GetUniformField(); // Get the field value from one of the worker threads
+  std::unique_ptr<UniformMagneticField> Bfield = std::make_unique<UniformMagneticField>(field_values);
+  if (!InitializeBField(*Bfield))
+    throw std::runtime_error("AdePTTransport<IntegrationLayer>::Initialize cannot initialize field on GPU");
 #endif
 
   // Check VecGeom geometry matches Geant4. Initialize auxiliary per-LV data. Initialize scoring map.
diff --git a/include/AdePT/core/AsyncAdePTTransportStruct.cuh b/include/AdePT/core/AsyncAdePTTransportStruct.cuh
index bdda6abc..2027e71d 100644
--- a/include/AdePT/core/AsyncAdePTTransportStruct.cuh
+++ b/include/AdePT/core/AsyncAdePTTransportStruct.cuh
@@ -10,6 +10,7 @@
 #include <AdePT/core/PerEventScoringImpl.cuh>
 #include <AdePT/core/Track.cuh>
 #include <AdePT/magneticfield/GeneralMagneticField.h>
+#include <AdePT/magneticfield/UniformMagneticField.h>
 
 #include <AdePT/base/SlotManager.cuh>
 #include <AdePT/base/ResourceManagement.cuh>
@@ -210,12 +211,12 @@ extern __constant__ __device__ struct G4HepEmData g4HepEmData;
 // Pointer for array of volume auxiliary data on device
 extern __constant__ __device__ adeptint::VolAuxData *gVolAuxData;
 
-// constexpr float BzFieldValue = 0.1 * copcore::units::tesla;
-extern __constant__ __device__ double BzFieldValue;
 extern __constant__ __device__ bool ApplyCuts;
 constexpr double kPush = 1.e-8 * copcore::units::cm;
 #ifdef ADEPT_USE_EXT_BFIELD
 __device__ GeneralMagneticField *gMagneticField = nullptr;
+#else
+__device__ UniformMagneticField *gMagneticField = nullptr;
 #endif
 
 } // namespace AsyncAdePT
diff --git a/include/AdePT/integration/AdePTGeant4Integration.hh b/include/AdePT/integration/AdePTGeant4Integration.hh
index 852f7c57..ccbf42c4 100644
--- a/include/AdePT/integration/AdePTGeant4Integration.hh
+++ b/include/AdePT/integration/AdePTGeant4Integration.hh
@@ -71,7 +71,7 @@ public:
 
   /// @brief Returns the Z value of the user-defined uniform magnetic field
   /// @details This function can only be called when the user-defined field is a G4UniformMagField
-  double GetUniformFieldZ() const;
+  vecgeom::Vector3D<float> GetUniformField() const;
 
   int GetEventID() const { return G4EventManager::GetEventManager()->GetConstCurrentEvent()->GetEventID(); }
 
diff --git a/include/AdePT/kernels/electrons.cuh b/include/AdePT/kernels/electrons.cuh
index 9711a7e8..cd76a0f0 100644
--- a/include/AdePT/kernels/electrons.cuh
+++ b/include/AdePT/kernels/electrons.cuh
@@ -3,12 +3,10 @@
 
 #include <AdePT/navigation/AdePTNavigator.h>
 
-#include <AdePT/magneticfield/fieldPropagatorConstBz.h>
 // Classes for Runge-Kutta integration
 #include <AdePT/magneticfield/MagneticFieldEquation.h>
 #include <AdePT/magneticfield/DormandPrinceRK45.h>
 #include <AdePT/magneticfield/fieldPropagatorRungeKutta.h>
-#include <AdePT/magneticfield/fieldPropagatorConstBz.h>
 
 #include <AdePT/copcore/PhysicalConstants.h>
 
@@ -57,20 +55,20 @@ static __device__ __forceinline__ void TransportElectrons(Track *electrons, cons
   constexpr unsigned short maxSteps = 10'000;
   constexpr int Charge              = IsElectron ? -1 : 1;
   constexpr double restMass         = copcore::units::kElectronMassC2;
-#ifdef ADEPT_USE_EXT_BFIELD
-  constexpr int Nvar           = 6;
-  using Field_t                = GeneralMagneticField; // UniformMagneticField;
-  using Equation_t             = MagneticFieldEquation<Field_t>;
-  using Stepper_t              = DormandPrinceRK45<Equation_t, Field_t, Nvar, vecgeom::Precision>;
-  using RkDriver_t             = RkIntegrationDriver<Stepper_t, vecgeom::Precision, int, Equation_t, Field_t>;
-  constexpr int max_iterations = 10;
-
-  // Field_t magField(vecgeom::Vector3D<float>(0.0, 0.0, BzFieldValue));
+  constexpr int Nvar                = 6;
+  constexpr int max_iterations      = 10;
 
-  auto &magneticField = *gMagneticField;
+#ifdef ADEPT_USE_EXT_BFIELD
+  using Field_t = GeneralMagneticField;
 #else
-  fieldPropagatorConstBz fieldPropagatorBz(BzFieldValue);
+  using Field_t = UniformMagneticField;
 #endif
+  using Equation_t = MagneticFieldEquation<Field_t>;
+  using Stepper_t  = DormandPrinceRK45<Equation_t, Field_t, Nvar, vecgeom::Precision>;
+  using RkDriver_t = RkIntegrationDriver<Stepper_t, vecgeom::Precision, int, Equation_t, Field_t>;
+
+  auto &magneticField = *gMagneticField;
+
   int activeSize = active->size();
   for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < activeSize; i += blockDim.x * gridDim.x) {
     const int slot           = (*active)[i];
@@ -101,20 +99,19 @@ static __device__ __forceinline__ void TransportElectrons(adept::TrackManager<Tr
   constexpr int Charge              = IsElectron ? -1 : 1;
   constexpr double restMass         = copcore::units::kElectronMassC2;
   constexpr int Pdg                 = IsElectron ? 11 : -11;
-#ifdef ADEPT_USE_EXT_BFIELD
-  constexpr int Nvar           = 6;
-  using Field_t                = GeneralMagneticField; // UniformMagneticField;
-  using Equation_t             = MagneticFieldEquation<Field_t>;
-  using Stepper_t              = DormandPrinceRK45<Equation_t, Field_t, Nvar, vecgeom::Precision>;
-  using RkDriver_t             = RkIntegrationDriver<Stepper_t, vecgeom::Precision, int, Equation_t, Field_t>;
-  constexpr int max_iterations = 10;
-
-  // Field_t magneticField(vecgeom::Vector3D<float>(0.0, 0.0, BzFieldValue)); // needed for UniformMagneticField
+  constexpr int Nvar                = 6;
+  constexpr int max_iterations      = 10;
 
-  auto &magneticField = *gMagneticField;
+#ifdef ADEPT_USE_EXT_BFIELD
+  using Field_t = GeneralMagneticField;
 #else
-  fieldPropagatorConstBz fieldPropagatorBz(BzFieldValue);
+  using Field_t = UniformMagneticField;
 #endif
+  using Equation_t = MagneticFieldEquation<Field_t>;
+  using Stepper_t  = DormandPrinceRK45<Equation_t, Field_t, Nvar, vecgeom::Precision>;
+  using RkDriver_t = RkIntegrationDriver<Stepper_t, vecgeom::Precision, int, Equation_t, Field_t>;
+
+  auto &magneticField = *gMagneticField;
 
   int activeSize = electrons->fActiveTracks->size();
   for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < activeSize; i += blockDim.x * gridDim.x) {
@@ -238,15 +235,11 @@ static __device__ __forceinline__ void TransportElectrons(adept::TrackManager<Tr
 
     double safeLength = 0.;
 
-#ifdef ADEPT_USE_EXT_BFIELD
     if (gMagneticField) {
-#else
-    if (BzFieldValue != 0) {
-#endif
+
       const double momentumMag = sqrt(eKin * (eKin + 2.0 * restMass));
       // Distance along the track direction to reach the maximum allowed error
 
-#ifdef ADEPT_USE_EXT_BFIELD
       // SEVERIN: to be checked if we can use float
       vecgeom::Vector3D<double> momentumVec = momentumMag * dir;
       vecgeom::Vector3D<double> B0fieldVec =
@@ -254,9 +247,7 @@ static __device__ __forceinline__ void TransportElectrons(adept::TrackManager<Tr
       safeLength =
           fieldPropagatorRungeKutta<Field_t, RkDriver_t, Precision, AdePTNavigator>::ComputeSafeLength /*<Real_t>*/ (
               momentumVec, B0fieldVec, Charge);
-#else
-      safeLength = fieldPropagatorBz.ComputeSafeLength(momentumMag, Charge, dir);
-#endif
+
       constexpr int MaxSafeLength = 10;
       double limit                = MaxSafeLength * safeLength;
       limit                       = safety > limit ? safety : limit;
@@ -302,7 +293,6 @@ static __device__ __forceinline__ void TransportElectrons(adept::TrackManager<Tr
     double geometryStepLength;
     vecgeom::NavigationState nextState;
 
-#ifdef ADEPT_USE_EXT_BFIELD
     if (gMagneticField) {
       int iterDone = -1;
       geometryStepLength =
@@ -311,12 +301,6 @@ static __device__ __forceinline__ void TransportElectrons(adept::TrackManager<Tr
               nextState, hitsurf_index, propagated, /*lengthDone,*/ safety,
               // activeSize < 100 ? max_iterations : max_iters_tail ), // Was
               max_iterations, iterDone, slot);
-#else
-    if (BzFieldValue != 0) {
-      geometryStepLength = fieldPropagatorBz.ComputeStepAndNextVolume<AdePTNavigator>(
-          eKin, restMass, Charge, geometricalStepLengthFromPhysics, pos, dir, navState, nextState, hitsurf_index,
-          propagated, safety);
-#endif
     } else {
 #ifdef ADEPT_USE_SURF
       geometryStepLength = AdePTNavigator::ComputeStepAndNextVolume(pos, dir, geometricalStepLengthFromPhysics,
diff --git a/src/AdePTGeant4Integration.cpp b/src/AdePTGeant4Integration.cpp
index 9be65419..2359d450 100644
--- a/src/AdePTGeant4Integration.cpp
+++ b/src/AdePTGeant4Integration.cpp
@@ -615,15 +615,19 @@ void AdePTGeant4Integration::ReturnTrack(adeptint::TrackData const &track, unsig
   G4EventManager::GetEventManager()->GetStackManager()->PushOneTrack(secondary);
 }
 
-double AdePTGeant4Integration::GetUniformFieldZ() const
+vecgeom::Vector3D<float> AdePTGeant4Integration::GetUniformField() const
 {
+  vecgeom::Vector3D<float> Bfield(0., 0., 0.);
+
   G4MagneticField *field =
       (G4MagneticField *)G4TransportationManager::GetTransportationManager()->GetFieldManager()->GetDetectorField();
+
   if (field) {
     G4double origin[3] = {0., 0., 0.};
-    G4double Bfield[3] = {0., 0., 0.};
-    field->GetFieldValue(origin, Bfield);
-    return Bfield[2];
-  } else
-    return 0;
+    G4double temp[3]   = {0., 0., 0.};
+    field->GetFieldValue(origin, temp);
+    Bfield.Set(temp[0], temp[1], temp[2]);
+  }
+
+  return Bfield;
 }