diff --git a/tests/splines/batched_2d_spline_builder.cpp b/tests/splines/batched_2d_spline_builder.cpp
index 74b075ade..9d5e42e10 100644
--- a/tests/splines/batched_2d_spline_builder.cpp
+++ b/tests/splines/batched_2d_spline_builder.cpp
@@ -100,9 +100,6 @@ struct DDimGPS : GrevillePoints<BSplines<X>>::interpolation_discrete_dimension_t
 {
 };
 
-template <typename X, typename I1, typename I2>
-using DDim = std::conditional_t<std::is_same_v<X, I1> || std::is_same_v<X, I2>, DDimGPS<X>, X>;
-
 #if defined(BC_PERIODIC)
 template <typename DDim1, typename DDim2>
 using evaluator_type = Evaluator2D::
@@ -121,10 +118,6 @@ using DVect = ddc::DiscreteVector<DDimX...>;
 template <typename... X>
 using Coord = ddc::Coordinate<X...>;
 
-// Extract batch dimensions from DDim (remove dimension of interest). Usefull
-template <typename I1, typename I2, typename... X>
-using BatchDims = ddc::type_seq_remove_t<ddc::detail::TypeSeq<X...>, ddc::detail::TypeSeq<I1, I2>>;
-
 // Templated function giving first coordinate of the mesh in given dimension.
 template <typename X>
 KOKKOS_FUNCTION Coord<X> x0()
@@ -171,11 +164,16 @@ void InterestDimInitializer(std::size_t const ncells)
 
 // Checks that when evaluating the spline at interpolation points one
 // recovers values that were used to build the spline
-template <typename ExecSpace, typename MemorySpace, typename I1, typename I2, typename... X>
+template <
+        typename ExecSpace,
+        typename MemorySpace,
+        typename DDimI1,
+        typename DDimI2,
+        typename... DDims>
 void Batched2dSplineTest()
 {
-    using DDimI1 = DDimGPS<I1>;
-    using DDimI2 = DDimGPS<I2>;
+    using I1 = typename DDimI1::continuous_dimension_type;
+    using I2 = typename DDimI2::continuous_dimension_type;
 
     // Instantiate execution spaces and initialize spaces
     ExecSpace const exec_space;
@@ -188,14 +186,13 @@ void Batched2dSplineTest()
             = GrevillePoints<BSplines<I1>>::template get_domain<DDimI1>();
     ddc::DiscreteDomain<DDimI2> const interpolation_domain2
             = GrevillePoints<BSplines<I2>>::template get_domain<DDimI2>();
-    ddc::DiscreteDomain<DDimI1, DDimI2> const
-            interpolation_domain(interpolation_domain1, interpolation_domain2);
-    // If we remove auto using the constructor syntax, nvcc does not compile
-    auto const dom_vals_tmp
-            = ddc::DiscreteDomain<X...>(ddc::DiscreteDomain<X>(DElem<X>(0), DVect<X>(ncells))...);
-    ddc::DiscreteDomain<DDim<X, I1, I2>...> const dom_vals = ddc::replace_dim_of<I1, DDimI1>(
-            ddc::replace_dim_of<I2, DDimI2>(dom_vals_tmp, interpolation_domain),
-            interpolation_domain);
+    // The following line creates a discrete domain over all dimensions (DDims...) where we immediately
+    // remove the dimensions DDimI1 and DDimI2.
+    ddc::remove_dims_of_t<ddc::DiscreteDomain<DDims...>, DDimI1, DDimI2> const dom_vals_tmp(
+            ddc::DiscreteDomain<DDims...>(
+                    ddc::DiscreteDomain<DDims>(DElem<DDims>(0), DVect<DDims>(ncells))...));
+    ddc::DiscreteDomain<DDims...> const
+            dom_vals(dom_vals_tmp, interpolation_domain1, interpolation_domain2);
 
 #if defined(BC_HERMITE)
     // Create the derivs domain
@@ -226,7 +223,7 @@ void Batched2dSplineTest()
             s_bcl,
             s_bcr,
             ddc::SplineSolver::GINKGO,
-            DDim<X, I1, I2>...> const spline_builder(dom_vals);
+            DDims...> const spline_builder(dom_vals);
 
     // Compute usefull domains (dom_interpolation, dom_batch, dom_bsplines and dom_spline)
     ddc::DiscreteDomain<DDimI1, DDimI2> const dom_interpolation
@@ -246,7 +243,7 @@ void Batched2dSplineTest()
     ddc::parallel_for_each(
             exec_space,
             vals.domain(),
-            KOKKOS_LAMBDA(DElem<DDim<X, I1, I2>...> const e) {
+            KOKKOS_LAMBDA(DElem<DDims...> const e) {
                 vals(e) = vals_1d(DElem<DDimI1, DDimI2>(e));
             });
 
@@ -478,7 +475,7 @@ void Batched2dSplineTest()
             extrapolation_rule_1_type,
             extrapolation_rule_2_type,
             extrapolation_rule_2_type,
-            DDim<X, I1, I2>...> const
+            DDims...> const
             spline_evaluator(
                     extrapolation_rule_1,
                     extrapolation_rule_1,
@@ -491,7 +488,7 @@ void Batched2dSplineTest()
     ddc::parallel_for_each(
             exec_space,
             coords_eval.domain(),
-            KOKKOS_LAMBDA(DElem<DDim<X, I1, I2>...> const e) {
+            KOKKOS_LAMBDA(DElem<DDims...> const e) {
                 coords_eval(e) = ddc::coordinate(DElem<DDimI1, DDimI2>(e));
             });
 
@@ -522,7 +519,7 @@ void Batched2dSplineTest()
             spline_eval.domain(),
             0.,
             ddc::reducer::max<double>(),
-            KOKKOS_LAMBDA(DElem<DDim<X, I1, I2>...> const e) {
+            KOKKOS_LAMBDA(DElem<DDims...> const e) {
                 return Kokkos::abs(spline_eval(e) - vals(e));
             });
     double const max_norm_error_diff1 = ddc::parallel_transform_reduce(
@@ -530,7 +527,7 @@ void Batched2dSplineTest()
             spline_eval_deriv1.domain(),
             0.,
             ddc::reducer::max<double>(),
-            KOKKOS_LAMBDA(DElem<DDim<X, I1, I2>...> const e) {
+            KOKKOS_LAMBDA(DElem<DDims...> const e) {
                 Coord<I1> const x = ddc::coordinate(DElem<DDimI1>(e));
                 Coord<I2> const y = ddc::coordinate(DElem<DDimI2>(e));
                 return Kokkos::abs(spline_eval_deriv1(e) - evaluator.deriv(x, y, 1, 0));
@@ -540,7 +537,7 @@ void Batched2dSplineTest()
             spline_eval_deriv2.domain(),
             0.,
             ddc::reducer::max<double>(),
-            KOKKOS_LAMBDA(DElem<DDim<X, I1, I2>...> const e) {
+            KOKKOS_LAMBDA(DElem<DDims...> const e) {
                 Coord<I1> const x = ddc::coordinate(DElem<DDimI1>(e));
                 Coord<I2> const y = ddc::coordinate(DElem<DDimI2>(e));
                 return Kokkos::abs(spline_eval_deriv2(e) - evaluator.deriv(x, y, 0, 1));
@@ -550,7 +547,7 @@ void Batched2dSplineTest()
             spline_eval_deriv1.domain(),
             0.,
             ddc::reducer::max<double>(),
-            KOKKOS_LAMBDA(DElem<DDim<X, I1, I2>...> const e) {
+            KOKKOS_LAMBDA(DElem<DDims...> const e) {
                 Coord<I1> const x = ddc::coordinate(DElem<DDimI1>(e));
                 Coord<I2> const y = ddc::coordinate(DElem<DDimI2>(e));
                 return Kokkos::abs(spline_eval_deriv12(e) - evaluator.deriv(x, y, 1, 1));
@@ -619,10 +616,10 @@ TEST(SUFFIX(Batched2dSplineHost), 2DXY)
     Batched2dSplineTest<
             Kokkos::DefaultHostExecutionSpace,
             Kokkos::DefaultHostExecutionSpace::memory_space,
-            DimX,
-            DimY,
-            DimX,
-            DimY>();
+            DDimGPS<DimX>,
+            DDimGPS<DimY>,
+            DDimGPS<DimX>,
+            DDimGPS<DimY>>();
 }
 
 TEST(SUFFIX(Batched2dSplineDevice), 2DXY)
@@ -630,10 +627,10 @@ TEST(SUFFIX(Batched2dSplineDevice), 2DXY)
     Batched2dSplineTest<
             Kokkos::DefaultExecutionSpace,
             Kokkos::DefaultExecutionSpace::memory_space,
-            DimX,
-            DimY,
-            DimX,
-            DimY>();
+            DDimGPS<DimX>,
+            DDimGPS<DimY>,
+            DDimGPS<DimX>,
+            DDimGPS<DimY>>();
 }
 
 TEST(SUFFIX(Batched2dSplineHost), 3DXY)
@@ -641,10 +638,10 @@ TEST(SUFFIX(Batched2dSplineHost), 3DXY)
     Batched2dSplineTest<
             Kokkos::DefaultHostExecutionSpace,
             Kokkos::DefaultHostExecutionSpace::memory_space,
-            DimX,
-            DimY,
-            DimX,
-            DimY,
+            DDimGPS<DimX>,
+            DDimGPS<DimY>,
+            DDimGPS<DimX>,
+            DDimGPS<DimY>,
             DDimBatch>();
 }
 
@@ -653,11 +650,11 @@ TEST(SUFFIX(Batched2dSplineHost), 3DXZ)
     Batched2dSplineTest<
             Kokkos::DefaultHostExecutionSpace,
             Kokkos::DefaultHostExecutionSpace::memory_space,
-            DimX,
-            DimZ,
-            DimX,
+            DDimGPS<DimX>,
+            DDimGPS<DimZ>,
+            DDimGPS<DimX>,
             DDimBatch,
-            DimZ>();
+            DDimGPS<DimZ>>();
 }
 
 TEST(SUFFIX(Batched2dSplineHost), 3DYZ)
@@ -665,11 +662,11 @@ TEST(SUFFIX(Batched2dSplineHost), 3DYZ)
     Batched2dSplineTest<
             Kokkos::DefaultHostExecutionSpace,
             Kokkos::DefaultHostExecutionSpace::memory_space,
-            DimY,
-            DimZ,
+            DDimGPS<DimY>,
+            DDimGPS<DimZ>,
             DDimBatch,
-            DimY,
-            DimZ>();
+            DDimGPS<DimY>,
+            DDimGPS<DimZ>>();
 }
 
 TEST(SUFFIX(Batched2dSplineDevice), 3DXY)
@@ -677,10 +674,10 @@ TEST(SUFFIX(Batched2dSplineDevice), 3DXY)
     Batched2dSplineTest<
             Kokkos::DefaultExecutionSpace,
             Kokkos::DefaultExecutionSpace::memory_space,
-            DimX,
-            DimY,
-            DimX,
-            DimY,
+            DDimGPS<DimX>,
+            DDimGPS<DimY>,
+            DDimGPS<DimX>,
+            DDimGPS<DimY>,
             DDimBatch>();
 }
 
@@ -689,11 +686,11 @@ TEST(SUFFIX(Batched2dSplineDevice), 3DXZ)
     Batched2dSplineTest<
             Kokkos::DefaultExecutionSpace,
             Kokkos::DefaultExecutionSpace::memory_space,
-            DimX,
-            DimZ,
-            DimX,
+            DDimGPS<DimX>,
+            DDimGPS<DimZ>,
+            DDimGPS<DimX>,
             DDimBatch,
-            DimZ>();
+            DDimGPS<DimZ>>();
 }
 
 TEST(SUFFIX(Batched2dSplineDevice), 3DYZ)
@@ -701,9 +698,9 @@ TEST(SUFFIX(Batched2dSplineDevice), 3DYZ)
     Batched2dSplineTest<
             Kokkos::DefaultExecutionSpace,
             Kokkos::DefaultExecutionSpace::memory_space,
-            DimY,
-            DimZ,
+            DDimGPS<DimY>,
+            DDimGPS<DimZ>,
             DDimBatch,
-            DimY,
-            DimZ>();
+            DDimGPS<DimY>,
+            DDimGPS<DimZ>>();
 }
diff --git a/tests/splines/batched_spline_builder.cpp b/tests/splines/batched_spline_builder.cpp
index 1d9a5ac3d..3165c00a7 100644
--- a/tests/splines/batched_spline_builder.cpp
+++ b/tests/splines/batched_spline_builder.cpp
@@ -113,9 +113,6 @@ struct DDimGPS : GrevillePoints<BSplines<X>>::interpolation_discrete_dimension_t
 {
 };
 
-template <typename X, typename Y>
-using DDim = std::conditional_t<std::is_same_v<X, Y>, DDimGPS<X>, X>;
-
 template <typename DDimX>
 using evaluator_type = CosineEvaluator::Evaluator<DDimX>;
 
@@ -126,10 +123,6 @@ using DVect = ddc::DiscreteVector<DDimX...>;
 template <typename... X>
 using Coord = ddc::Coordinate<X...>;
 
-// Extract batch dimensions from DDim (remove dimension of interest). Usefull
-template <typename X, typename... Y>
-using BatchDims = ddc::type_seq_remove_t<ddc::detail::TypeSeq<Y...>, ddc::detail::TypeSeq<X>>;
-
 // Templated function giving first coordinate of the mesh in given dimension.
 template <typename X>
 KOKKOS_FUNCTION Coord<X> x0()
@@ -176,10 +169,10 @@ void InterestDimInitializer(std::size_t const ncells)
 
 // Checks that when evaluating the spline at interpolation points one
 // recovers values that were used to build the spline
-template <typename ExecSpace, typename MemorySpace, typename I, typename... X>
+template <typename ExecSpace, typename MemorySpace, typename DDimI, typename... DDims>
 void BatchedSplineTest()
 {
-    using DDimI = DDimGPS<I>;
+    using I = typename DDimI::continuous_dimension_type;
 
     // Instantiate execution spaces and initialize spaces
     ExecSpace const exec_space;
@@ -190,11 +183,12 @@ void BatchedSplineTest()
     // Create the values domain (mesh)
     ddc::DiscreteDomain<DDimI> const interpolation_domain
             = GrevillePoints<BSplines<I>>::template get_domain<DDimI>();
-    // If we remove auto using the constructor syntax, nvcc does not compile
-    auto const dom_vals_tmp
-            = ddc::DiscreteDomain<X...>(ddc::DiscreteDomain<X>(DElem<X>(0), DVect<X>(ncells))...);
-    ddc::DiscreteDomain<DDim<X, I>...> const dom_vals
-            = ddc::replace_dim_of<I, DDimI>(dom_vals_tmp, interpolation_domain);
+    // The following line creates a discrete domain over all dimensions (DDims...) where we immediately
+    // remove the dimension DDimI.
+    ddc::remove_dims_of_t<ddc::DiscreteDomain<DDims...>, DDimI> const dom_vals_tmp(
+            ddc::DiscreteDomain<DDims...>(
+                    ddc::DiscreteDomain<DDims>(DElem<DDims>(0), DVect<DDims>(ncells))...));
+    ddc::DiscreteDomain<DDims...> const dom_vals(dom_vals_tmp, interpolation_domain);
 
 #if defined(BC_HERMITE)
     // Create the derivs domain
@@ -216,7 +210,7 @@ void BatchedSplineTest()
 #elif defined(SOLVER_GINKGO)
             ddc::SplineSolver::GINKGO,
 #endif
-            DDim<X, I>...> const spline_builder(dom_vals);
+            DDims...> const spline_builder(dom_vals);
 
     // Compute usefull domains (dom_interpolation, dom_batch, dom_bsplines and dom_spline)
     ddc::DiscreteDomain<DDimI> const dom_interpolation = spline_builder.interpolation_domain();
@@ -236,7 +230,7 @@ void BatchedSplineTest()
     ddc::parallel_for_each(
             exec_space,
             vals.domain(),
-            KOKKOS_LAMBDA(DElem<DDim<X, I>...> const e) { vals(e) = vals_1d(DElem<DDimI>(e)); });
+            KOKKOS_LAMBDA(DElem<DDims...> const e) { vals(e) = vals_1d(DElem<DDimI>(e)); });
 
 #if defined(BC_HERMITE)
     // Allocate and fill a chunk containing derivs to be passed as input to spline_builder.
@@ -317,7 +311,7 @@ void BatchedSplineTest()
             DDimI,
             extrapolation_rule_type,
             extrapolation_rule_type,
-            DDim<X, I>...> const spline_evaluator_batched(extrapolation_rule, extrapolation_rule);
+            DDims...> const spline_evaluator_batched(extrapolation_rule, extrapolation_rule);
 
     // Instantiate chunk of coordinates of dom_interpolation
     ddc::Chunk coords_eval_alloc(dom_vals, ddc::KokkosAllocator<Coord<I>, MemorySpace>());
@@ -325,7 +319,7 @@ void BatchedSplineTest()
     ddc::parallel_for_each(
             exec_space,
             coords_eval.domain(),
-            KOKKOS_LAMBDA(DElem<DDim<X, I>...> const e) {
+            KOKKOS_LAMBDA(DElem<DDims...> const e) {
                 coords_eval(e) = ddc::coordinate(DElem<DDimI>(e));
             });
 
@@ -349,7 +343,7 @@ void BatchedSplineTest()
             spline_eval.domain(),
             0.,
             ddc::reducer::max<double>(),
-            KOKKOS_LAMBDA(DElem<DDim<X, I>...> const e) {
+            KOKKOS_LAMBDA(DElem<DDims...> const e) {
                 return Kokkos::abs(spline_eval(e) - vals(e));
             });
 
@@ -358,7 +352,7 @@ void BatchedSplineTest()
             spline_eval_deriv.domain(),
             0.,
             ddc::reducer::max<double>(),
-            KOKKOS_LAMBDA(DElem<DDim<X, I>...> const e) {
+            KOKKOS_LAMBDA(DElem<DDims...> const e) {
                 Coord<I> const x = ddc::coordinate(DElem<DDimI>(e));
                 return Kokkos::abs(spline_eval_deriv(e) - evaluator.deriv(x, 1));
             });
@@ -427,8 +421,8 @@ TEST(SUFFIX(BatchedSplineHost), 1DX)
     BatchedSplineTest<
             Kokkos::DefaultHostExecutionSpace,
             Kokkos::DefaultHostExecutionSpace::memory_space,
-            DimX,
-            DimX>();
+            DDimGPS<DimX>,
+            DDimGPS<DimX>>();
 }
 
 TEST(SUFFIX(BatchedSplineDevice), 1DX)
@@ -436,8 +430,8 @@ TEST(SUFFIX(BatchedSplineDevice), 1DX)
     BatchedSplineTest<
             Kokkos::DefaultExecutionSpace,
             Kokkos::DefaultExecutionSpace::memory_space,
-            DimX,
-            DimX>();
+            DDimGPS<DimX>,
+            DDimGPS<DimX>>();
 }
 
 TEST(SUFFIX(BatchedSplineHost), 2DX)
@@ -445,8 +439,8 @@ TEST(SUFFIX(BatchedSplineHost), 2DX)
     BatchedSplineTest<
             Kokkos::DefaultHostExecutionSpace,
             Kokkos::DefaultHostExecutionSpace::memory_space,
-            DimX,
-            DimX,
+            DDimGPS<DimX>,
+            DDimGPS<DimX>,
             DDimBatch1>();
 }
 
@@ -455,9 +449,9 @@ TEST(SUFFIX(BatchedSplineHost), 2DY)
     BatchedSplineTest<
             Kokkos::DefaultHostExecutionSpace,
             Kokkos::DefaultHostExecutionSpace::memory_space,
-            DimY,
+            DDimGPS<DimY>,
             DDimBatch1,
-            DimY>();
+            DDimGPS<DimY>>();
 }
 
 TEST(SUFFIX(BatchedSplineDevice), 2DX)
@@ -465,8 +459,8 @@ TEST(SUFFIX(BatchedSplineDevice), 2DX)
     BatchedSplineTest<
             Kokkos::DefaultExecutionSpace,
             Kokkos::DefaultExecutionSpace::memory_space,
-            DimX,
-            DimX,
+            DDimGPS<DimX>,
+            DDimGPS<DimX>,
             DDimBatch1>();
 }
 
@@ -475,9 +469,9 @@ TEST(SUFFIX(BatchedSplineDevice), 2DY)
     BatchedSplineTest<
             Kokkos::DefaultExecutionSpace,
             Kokkos::DefaultExecutionSpace::memory_space,
-            DimY,
+            DDimGPS<DimY>,
             DDimBatch1,
-            DimY>();
+            DDimGPS<DimY>>();
 }
 
 TEST(SUFFIX(BatchedSplineHost), 3DX)
@@ -485,8 +479,8 @@ TEST(SUFFIX(BatchedSplineHost), 3DX)
     BatchedSplineTest<
             Kokkos::DefaultHostExecutionSpace,
             Kokkos::DefaultHostExecutionSpace::memory_space,
-            DimX,
-            DimX,
+            DDimGPS<DimX>,
+            DDimGPS<DimX>,
             DDimBatch1,
             DDimBatch2>();
 }
@@ -496,9 +490,9 @@ TEST(SUFFIX(BatchedSplineHost), 3DY)
     BatchedSplineTest<
             Kokkos::DefaultHostExecutionSpace,
             Kokkos::DefaultHostExecutionSpace::memory_space,
-            DimY,
+            DDimGPS<DimY>,
             DDimBatch1,
-            DimY,
+            DDimGPS<DimY>,
             DDimBatch2>();
 }
 
@@ -507,10 +501,10 @@ TEST(SUFFIX(BatchedSplineHost), 3DZ)
     BatchedSplineTest<
             Kokkos::DefaultHostExecutionSpace,
             Kokkos::DefaultHostExecutionSpace::memory_space,
-            DimZ,
+            DDimGPS<DimZ>,
             DDimBatch1,
             DDimBatch2,
-            DimZ>();
+            DDimGPS<DimZ>>();
 }
 
 TEST(SUFFIX(BatchedSplineDevice), 3DX)
@@ -518,8 +512,8 @@ TEST(SUFFIX(BatchedSplineDevice), 3DX)
     BatchedSplineTest<
             Kokkos::DefaultExecutionSpace,
             Kokkos::DefaultExecutionSpace::memory_space,
-            DimX,
-            DimX,
+            DDimGPS<DimX>,
+            DDimGPS<DimX>,
             DDimBatch1,
             DDimBatch2>();
 }
@@ -529,9 +523,9 @@ TEST(SUFFIX(BatchedSplineDevice), 3DY)
     BatchedSplineTest<
             Kokkos::DefaultExecutionSpace,
             Kokkos::DefaultExecutionSpace::memory_space,
-            DimY,
+            DDimGPS<DimY>,
             DDimBatch1,
-            DimY,
+            DDimGPS<DimY>,
             DDimBatch2>();
 }
 
@@ -540,10 +534,10 @@ TEST(SUFFIX(BatchedSplineDevice), 3DZ)
     BatchedSplineTest<
             Kokkos::DefaultExecutionSpace,
             Kokkos::DefaultExecutionSpace::memory_space,
-            DimZ,
+            DDimGPS<DimZ>,
             DDimBatch1,
             DDimBatch2,
-            DimZ>();
+            DDimGPS<DimZ>>();
 }
 
 
@@ -552,8 +546,8 @@ TEST(SUFFIX(BatchedSplineHost), 4DX)
     BatchedSplineTest<
             Kokkos::DefaultHostExecutionSpace,
             Kokkos::DefaultHostExecutionSpace::memory_space,
-            DimX,
-            DimX,
+            DDimGPS<DimX>,
+            DDimGPS<DimX>,
             DDimBatch1,
             DDimBatch2,
             DDimBatch3>();
@@ -564,9 +558,9 @@ TEST(SUFFIX(BatchedSplineHost), 4DY)
     BatchedSplineTest<
             Kokkos::DefaultHostExecutionSpace,
             Kokkos::DefaultHostExecutionSpace::memory_space,
-            DimY,
+            DDimGPS<DimY>,
             DDimBatch1,
-            DimY,
+            DDimGPS<DimY>,
             DDimBatch2,
             DDimBatch3>();
 }
@@ -576,10 +570,10 @@ TEST(SUFFIX(BatchedSplineHost), 4DZ)
     BatchedSplineTest<
             Kokkos::DefaultHostExecutionSpace,
             Kokkos::DefaultHostExecutionSpace::memory_space,
-            DimZ,
+            DDimGPS<DimZ>,
             DDimBatch1,
             DDimBatch2,
-            DimZ,
+            DDimGPS<DimZ>,
             DDimBatch3>();
 }
 
@@ -588,11 +582,11 @@ TEST(SUFFIX(BatchedSplineHost), 4DT)
     BatchedSplineTest<
             Kokkos::DefaultHostExecutionSpace,
             Kokkos::DefaultHostExecutionSpace::memory_space,
-            DimT,
+            DDimGPS<DimT>,
             DDimBatch1,
             DDimBatch2,
             DDimBatch3,
-            DimT>();
+            DDimGPS<DimT>>();
 }
 
 TEST(SUFFIX(BatchedSplineDevice), 4DX)
@@ -600,8 +594,8 @@ TEST(SUFFIX(BatchedSplineDevice), 4DX)
     BatchedSplineTest<
             Kokkos::DefaultExecutionSpace,
             Kokkos::DefaultExecutionSpace::memory_space,
-            DimX,
-            DimX,
+            DDimGPS<DimX>,
+            DDimGPS<DimX>,
             DDimBatch1,
             DDimBatch2,
             DDimBatch3>();
@@ -612,9 +606,9 @@ TEST(SUFFIX(BatchedSplineDevice), 4DY)
     BatchedSplineTest<
             Kokkos::DefaultExecutionSpace,
             Kokkos::DefaultExecutionSpace::memory_space,
-            DimY,
+            DDimGPS<DimY>,
             DDimBatch1,
-            DimY,
+            DDimGPS<DimY>,
             DDimBatch2,
             DDimBatch3>();
 }
@@ -624,10 +618,10 @@ TEST(SUFFIX(BatchedSplineDevice), 4DZ)
     BatchedSplineTest<
             Kokkos::DefaultExecutionSpace,
             Kokkos::DefaultExecutionSpace::memory_space,
-            DimZ,
+            DDimGPS<DimZ>,
             DDimBatch1,
             DDimBatch2,
-            DimZ,
+            DDimGPS<DimZ>,
             DDimBatch3>();
 }
 
@@ -636,9 +630,9 @@ TEST(SUFFIX(BatchedSplineDevice), 4DT)
     BatchedSplineTest<
             Kokkos::DefaultExecutionSpace,
             Kokkos::DefaultExecutionSpace::memory_space,
-            DimT,
+            DDimGPS<DimT>,
             DDimBatch1,
             DDimBatch2,
             DDimBatch3,
-            DimT>();
+            DDimGPS<DimT>>();
 }
diff --git a/tests/splines/extrapolation_rule.cpp b/tests/splines/extrapolation_rule.cpp
index 1c31c6fc0..a91eac67a 100644
--- a/tests/splines/extrapolation_rule.cpp
+++ b/tests/splines/extrapolation_rule.cpp
@@ -86,12 +86,6 @@ struct DDimGPS2 : GrevillePoints2<BSplines<X>>::interpolation_discrete_dimension
 {
 };
 
-template <typename X, typename I1, typename I2>
-using DDim = std::conditional_t<
-        std::is_same_v<X, I1>,
-        DDimGPS1<X>,
-        std::conditional_t<std::is_same_v<X, I2>, DDimGPS2<X>, X>>;
-
 #if defined(BC_PERIODIC)
 template <typename DDim1, typename DDim2>
 using evaluator_type = Evaluator2D::
@@ -110,10 +104,6 @@ using DVect = ddc::DiscreteVector<DDimX...>;
 template <typename... X>
 using Coord = ddc::Coordinate<X...>;
 
-// Extract batch dimensions from DDim (remove dimension of interest). Usefull
-template <typename I1, typename I2, typename... X>
-using BatchDims = ddc::type_seq_remove_t<ddc::detail::TypeSeq<X...>, ddc::detail::TypeSeq<I1, I2>>;
-
 // Templated function giving first coordinate of the mesh in given dimension.
 template <typename X>
 KOKKOS_FUNCTION Coord<X> x0()
@@ -159,11 +149,16 @@ void InterestDimInitializer(std::size_t const ncells)
 
 // Checks that when evaluating the spline at interpolation points one
 // recovers values that were used to build the spline
-template <typename ExecSpace, typename MemorySpace, typename I1, typename I2, typename... X>
+template <
+        typename ExecSpace,
+        typename MemorySpace,
+        typename DDimI1,
+        typename DDimI2,
+        typename... DDims>
 void ExtrapolationRuleSplineTest()
 {
-    using DDimI1 = DDimGPS1<I1>;
-    using DDimI2 = DDimGPS2<I2>;
+    using I1 = typename DDimI1::continuous_dimension_type;
+    using I2 = typename DDimI2::continuous_dimension_type;
 
     // Instantiate execution spaces and initialize spaces
     ExecSpace const exec_space;
@@ -179,12 +174,12 @@ void ExtrapolationRuleSplineTest()
     ddc::DiscreteDomain<DDimI1, DDimI2> const interpolation_domain(
             GrevillePoints1<BSplines<I1>>::template get_domain<DDimI1>(),
             GrevillePoints2<BSplines<I2>>::template get_domain<DDimI2>());
-    // If we remove auto using the constructor syntax, nvcc does not compile
-    auto const dom_vals_tmp
-            = ddc::DiscreteDomain<X...>(ddc::DiscreteDomain<X>(DElem<X>(0), DVect<X>(ncells))...);
-    ddc::DiscreteDomain<DDim<X, I1, I2>...> const dom_vals = ddc::replace_dim_of<I1, DDimI1>(
-            ddc::replace_dim_of<I2, DDimI2>(dom_vals_tmp, interpolation_domain),
-            interpolation_domain);
+    // The following line creates a discrete domain over all dimensions (DDims...) where we immediately
+    // remove the dimensions DDimI1 and DDimI2.
+    ddc::remove_dims_of_t<ddc::DiscreteDomain<DDims...>, DDimI1, DDimI2> const dom_vals_tmp(
+            ddc::DiscreteDomain<DDims...>(
+                    ddc::DiscreteDomain<DDims>(DElem<DDims>(0), DVect<DDims>(ncells))...));
+    ddc::DiscreteDomain<DDims...> const dom_vals(dom_vals_tmp, interpolation_domain);
 
     // Create a SplineBuilder over BSplines<I> and batched along other dimensions using some boundary conditions
     ddc::SplineBuilder2D<
@@ -199,7 +194,7 @@ void ExtrapolationRuleSplineTest()
             s_bcl2,
             s_bcr2,
             ddc::SplineSolver::GINKGO,
-            DDim<X, I1, I2>...> const spline_builder(dom_vals);
+            DDims...> const spline_builder(dom_vals);
 
     // Compute usefull domains (dom_interpolation, dom_batch, dom_bsplines and dom_spline)
     ddc::DiscreteDomain<DDimI1, DDimI2> const dom_interpolation
@@ -219,7 +214,7 @@ void ExtrapolationRuleSplineTest()
     ddc::parallel_for_each(
             exec_space,
             vals.domain(),
-            KOKKOS_LAMBDA(DElem<DDim<X, I1, I2>...> const e) {
+            KOKKOS_LAMBDA(DElem<DDims...> const e) {
                 vals(e) = vals_1d(DElem<DDimI1, DDimI2>(e));
             });
 
@@ -275,7 +270,7 @@ void ExtrapolationRuleSplineTest()
             extrapolation_rule_dim_1_type,
             extrapolation_rule_dim_2_type,
             extrapolation_rule_dim_2_type,
-            DDim<X, I1, I2>...> const
+            DDims...> const
             spline_evaluator_batched(
                     extrapolation_rule_left_dim_1,
                     extrapolation_rule_right_dim_1,
@@ -292,7 +287,7 @@ void ExtrapolationRuleSplineTest()
     ddc::parallel_for_each(
             exec_space,
             coords_eval.domain(),
-            KOKKOS_LAMBDA(DElem<DDim<X, I1, I2>...> const e) {
+            KOKKOS_LAMBDA(DElem<DDims...> const e) {
                 coords_eval(e) = ddc::coordinate(DElem<DDimI1, DDimI2>(e)) + displ;
             });
 
@@ -310,7 +305,7 @@ void ExtrapolationRuleSplineTest()
             spline_eval.domain(),
             0.,
             ddc::reducer::max<double>(),
-            KOKKOS_LAMBDA(DElem<DDim<X, I1, I2>...> const e) {
+            KOKKOS_LAMBDA(DElem<DDims...> const e) {
 #if defined(ER_NULL)
                 return Kokkos::abs(spline_eval(e));
 #elif defined(ER_CONSTANT)
@@ -321,7 +316,7 @@ void ExtrapolationRuleSplineTest()
                 double tmp;
                 if (Coord<I2>(coords_eval(e)) > xN<I2>()) {
 #if defined(BC_PERIODIC)
-                    tmp = vals(ddc::DiscreteElement<DDim<X, I1, I2>...>(
+                    tmp = vals(ddc::DiscreteElement<DDims...>(
                             vals.template domain<DDimI1>().back(),
                             e_without_interest));
 #else
@@ -329,13 +324,13 @@ void ExtrapolationRuleSplineTest()
                             vals.domain(),
                             vals.template domain<DDimI1, DDimI2>()))::discrete_element_type const
                             e_batch(e);
-                    tmp = vals(ddc::DiscreteElement<DDim<X, I1, I2>...>(
+                    tmp = vals(ddc::DiscreteElement<DDims...>(
                             vals.template domain<DDimI1>().back(),
                             vals.template domain<DDimI2>().back(),
                             e_batch));
 #endif
                 } else {
-                    tmp = vals(ddc::DiscreteElement<DDim<X, I1, I2>...>(
+                    tmp = vals(ddc::DiscreteElement<DDims...>(
                             vals.template domain<DDimI1>().back(),
                             e_without_interest));
                 }
@@ -373,10 +368,10 @@ TEST(SUFFIX(ExtrapolationRuleSplineHost), 2DXY)
     ExtrapolationRuleSplineTest<
             Kokkos::DefaultHostExecutionSpace,
             Kokkos::DefaultHostExecutionSpace::memory_space,
-            DimX,
-            DimY,
-            DimX,
-            DimY>();
+            DDimGPS1<DimX>,
+            DDimGPS2<DimY>,
+            DDimGPS1<DimX>,
+            DDimGPS2<DimY>>();
 }
 
 TEST(SUFFIX(ExtrapolationRuleSplineDevice), 2DXY)
@@ -384,8 +379,8 @@ TEST(SUFFIX(ExtrapolationRuleSplineDevice), 2DXY)
     ExtrapolationRuleSplineTest<
             Kokkos::DefaultExecutionSpace,
             Kokkos::DefaultExecutionSpace::memory_space,
-            DimX,
-            DimY,
-            DimX,
-            DimY>();
+            DDimGPS1<DimX>,
+            DDimGPS2<DimY>,
+            DDimGPS1<DimX>,
+            DDimGPS2<DimY>>();
 }