Removed deprecated device type class templates

streeve · streeve · commit d6f1fe41619f · 2025-08-13T15:48:14.000-04:00
diff --git a/benchmark/grid/Cabana_Grid_InterpolationPerformance.cpp b/benchmark/grid/Cabana_Grid_InterpolationPerformance.cpp
@@ -312,7 +312,7 @@ void performanceTest( std::ostream& stream, const std::string& test_prefix,
 
             // Create a local grid and local mesh
             auto local_grid = createLocalGrid( global_grid, halo_width );
-            auto local_mesh = createLocalMesh<exec_space>( *local_grid );
+            auto local_mesh = createLocalMesh<memory_space>( *local_grid );
             auto owned_cells = local_grid->indexSpace( Own(), Cell(), Local() );
             int num_cells = owned_cells.size();
 
diff --git a/core/src/Cabana_AoSoA.hpp b/core/src/Cabana_AoSoA.hpp
@@ -136,15 +136,10 @@ class AoSoA
     //! Member data types.
     using member_types = DataTypes;
 
-    // FIXME: extracting the self type for backwards compatibility with previous
-    // template on DeviceType. Should simply be MemorySpace after next release.
-    //! Memory space.
-    using memory_space = typename MemorySpace::memory_space;
-    // FIXME: replace warning with memory space assert after next release.
-    static_assert( Impl::deprecated( Kokkos::is_device<MemorySpace>() ) );
-
-    //! Default device type.
-    using device_type [[deprecated]] = typename memory_space::device_type;
+    //! Kokkos memory space.
+    using memory_space = MemorySpace;
+    static_assert( Kokkos::is_memory_space<MemorySpace>() );
+
     //! Default execution space.
     using execution_space = typename memory_space::execution_space;
 
diff --git a/core/src/Cabana_CommunicationPlan.hpp b/core/src/Cabana_CommunicationPlan.hpp
@@ -437,15 +437,9 @@ template <class MemorySpace>
 class CommunicationPlan
 {
   public:
-    // FIXME: extracting the self type for backwards compatibility with previous
-    // template on DeviceType. Should simply be MemorySpace after next release.
-    //! Memory space.
-    using memory_space = typename MemorySpace::memory_space;
-    // FIXME: replace warning with memory space assert after next release.
-    static_assert( Impl::deprecated( Kokkos::is_device<MemorySpace>() ) );
-
-    //! Default device type.
-    using device_type [[deprecated]] = typename memory_space::device_type;
+    //! Kokkos memory space.
+    using memory_space = MemorySpace;
+    static_assert( Kokkos::is_memory_space<MemorySpace>() );
 
     //! Default execution space.
     using execution_space = typename memory_space::execution_space;
diff --git a/core/src/Cabana_Experimental_NeighborList.hpp b/core/src/Cabana_Experimental_NeighborList.hpp
@@ -454,37 +454,6 @@ auto makeNeighborList( Tag tag, Positions const& positions,
                              buffer_size );
 }
 
-/*!
-  \brief Neighbor list implementation using ArborX for particles within the
-  interaction distance with a 1D compressed layout for particles and neighbors.
-
-  \tparam DeviceType Kokkos device type.
-  \tparam Positions The position type.
-  \tparam Tag Tag indicating whether to build a full or half neighbor list.
-
-  \param tag Tag indicating whether to build a full or half neighbor list.
-  \param positions The particle positions.
-  \param first The beginning particle index to compute neighbors for.
-  \param last The end particle index to compute neighbors for.
-  \param radius The radius of the neighborhood. Particles within this radius are
-  considered neighbors.
-  \param buffer_size Optional guess for maximum number of neighbors.
-
-  Neighbor list implementation most appropriate for highly varying particle
-  densities.
-*/
-template <typename DeviceType, typename Positions, typename Tag>
-[[deprecated]] auto makeNeighborList( Tag tag, Positions const& positions,
-                                      typename Positions::size_type first,
-                                      typename Positions::size_type last,
-                                      typename Positions::value_type radius,
-                                      int buffer_size = 0 )
-{
-    using exec_space = typename DeviceType::execution_space;
-    return makeNeighborList( exec_space{}, tag, positions, first, last, radius,
-                             buffer_size );
-}
-
 //---------------------------------------------------------------------------//
 //! 2d ArborX neighbor list storage layout.
 template <typename MemorySpace, typename Tag>
@@ -626,38 +595,6 @@ auto make2DNeighborList( Tag tag, Positions const& positions,
                                radius, buffer_size );
 }
 
-/*!
-  \brief Neighbor list implementation using ArborX for particles within the
-  interaction distance with a 2D layout for particles and neighbors.
-
-  \tparam DeviceType Kokkos device type.
-  \tparam Positions The position type.
-  \tparam Tag Tag indicating whether to build a full or half neighbor list.
-
-  \param tag Tag indicating whether to build a full or half neighbor list.
-  \param positions The particle positions.
-  \param first The beginning particle index to compute neighbors for.
-  \param last The end particle index to compute neighbors for.
-  \param radius The radius of the neighborhood. Particles within this radius are
-  considered neighbors.
-  \param buffer_size Optional guess for maximum number of neighbors per
-  particle.
-
-  Neighbor list implementation most appropriate for highly varying particle
-  densities.
-*/
-template <typename DeviceType, typename Positions, typename Tag>
-[[deprecated]] auto make2DNeighborList( Tag tag, Positions const& positions,
-                                        typename Positions::size_type first,
-                                        typename Positions::size_type last,
-                                        typename Positions::value_type radius,
-                                        int buffer_size = 0 )
-{
-    using exec_space = typename DeviceType::execution_space;
-    return make2DNeighborList( exec_space{}, tag, positions, first, last,
-                               radius, buffer_size );
-}
-
 } // namespace Experimental
 
 //! 1d ArborX NeighborList interface.
diff --git a/core/src/Cabana_LinkedCellList.hpp b/core/src/Cabana_LinkedCellList.hpp
@@ -94,17 +94,10 @@ template <class MemorySpace, class Scalar = double>
 class LinkedCellList
 {
   public:
-    // FIXME: add static_assert that this is a valid MemorySpace.
-
-    // FIXME: extracting the self type for backwards compatibility with previous
-    // template on DeviceType. Should simply be MemorySpace after next release.
-    //! Memory space.
-    using memory_space = typename MemorySpace::memory_space;
-    // FIXME: replace warning with memory space assert after next release.
-    static_assert( Impl::deprecated( Kokkos::is_device<MemorySpace>() ) );
+    //! Kokkos memory space.
+    using memory_space = MemorySpace;
+    static_assert( Kokkos::is_memory_space<MemorySpace>() );
 
-    //! Default device type.
-    using device_type [[deprecated]] = typename memory_space::device_type;
     //! Default execution space.
     using execution_space = typename memory_space::execution_space;
     //! Memory space size type.
diff --git a/core/src/Cabana_SiloParticleOutput.hpp b/core/src/Cabana_SiloParticleOutput.hpp
@@ -96,7 +96,7 @@ void writeFields(
 {
     // Reorder in a contiguous blocked format.
     Kokkos::View<typename SliceType::value_type*,
-                 typename SliceType::device_type>
+                 typename SliceType::memory_space>
         view( Kokkos::ViewAllocateWithoutInitializing( "scalar_field" ),
               end - begin );
     copySliceToView( view, slice, begin, end );
@@ -122,7 +122,7 @@ void writeFields(
 {
     // Reorder in a contiguous blocked format.
     Kokkos::View<typename SliceType::value_type**, Kokkos::LayoutLeft,
-                 typename SliceType::device_type>
+                 typename SliceType::memory_space>
         view( Kokkos::ViewAllocateWithoutInitializing( "vector_field" ),
               end - begin, slice.extent( 2 ) );
     copySliceToView( view, slice, begin, end );
@@ -153,7 +153,7 @@ void writeFields(
 {
     // Reorder in a contiguous blocked format.
     Kokkos::View<typename SliceType::value_type***, Kokkos::LayoutLeft,
-                 typename SliceType::device_type>
+                 typename SliceType::memory_space>
         view( Kokkos::ViewAllocateWithoutInitializing( "matrix_field" ),
               end - begin, slice.extent( 2 ), slice.extent( 3 ) );
     copySliceToView( view, slice, begin, end );
@@ -439,7 +439,7 @@ void writePartialRangeTimeStep( const std::string& prefix, MPI_Comm comm,
 
     // Reorder the coordinates in a blocked format.
     Kokkos::View<typename CoordSliceType::value_type**, Kokkos::LayoutLeft,
-                 typename CoordSliceType::device_type>
+                 typename CoordSliceType::memory_space>
         view( Kokkos::ViewAllocateWithoutInitializing( "coords" ), end - begin,
               coords.extent( 2 ) );
     copySliceToView( view, coords, begin, end );
diff --git a/core/src/Cabana_Slice.hpp b/core/src/Cabana_Slice.hpp
@@ -509,15 +509,10 @@ class Slice
     using slice_type =
         Slice<DataType, MemorySpace, MemoryAccessType, VectorLength, Stride>;
 
-    // FIXME: extracting the self type for backwards compatibility with previous
-    // template on DeviceType. Should simply be MemorySpace after next release.
-    //! Memory space.
-    using memory_space = typename MemorySpace::memory_space;
-    // FIXME: replace warning with memory space assert after next release.
-    static_assert( Impl::deprecated( Kokkos::is_device<MemorySpace>() ) );
-
-    //! Default device type.
-    using device_type [[deprecated]] = typename memory_space::device_type;
+    //! Kokkos memory space.
+    using memory_space = MemorySpace;
+    static_assert( Kokkos::is_memory_space<MemorySpace>() );
+
     //! Default execution space.
     using execution_space = typename memory_space::execution_space;
 
diff --git a/core/src/Cabana_Sort.hpp b/core/src/Cabana_Sort.hpp
@@ -38,15 +38,10 @@ template <class MemorySpace>
 class BinningData
 {
   public:
-    // FIXME: extracting the self type for backwards compatibility with previous
-    // template on DeviceType. Should simply be MemorySpace after next release.
-    //! Memory space.
-    using memory_space = typename MemorySpace::memory_space;
-    // FIXME: replace warning with memory space assert after next release.
-    static_assert( Impl::deprecated( Kokkos::is_device<MemorySpace>() ) );
-
-    //! Default device type.
-    using device_type [[deprecated]] = typename memory_space::device_type;
+    //! Kokkos memory space.
+    using memory_space = MemorySpace;
+    static_assert( Kokkos::is_memory_space<MemorySpace>() );
+
     //! Default execution space.
     using execution_space = typename memory_space::execution_space;
     //! Memory space size type.
@@ -673,7 +668,7 @@ void permute(
   \param view The view to permute.
  */
 template <class BinningDataType, class ViewType,
-          class DeviceType = typename BinningDataType::device_type>
+          class MemorySpace = typename BinningDataType::memory_space>
 void permute(
     const BinningDataType& binning_data, ViewType& view,
     typename std::enable_if<( is_binning_data<BinningDataType>::value &&
@@ -690,7 +685,7 @@ void permute(
     for ( std::size_t d = 1; d < view.rank; ++d )
         num_comp *= view.extent( d );
 
-    Kokkos::View<typename ViewType::value_type**, DeviceType> scratch(
+    Kokkos::View<typename ViewType::value_type**, MemorySpace> scratch(
         Kokkos::ViewAllocateWithoutInitializing( "scratch" ), end - begin,
         num_comp );
 
@@ -701,7 +696,8 @@ void permute(
             scratch( i - begin, n ) = view( permute_i, n );
     };
     auto policy =
-        Kokkos::RangePolicy<typename DeviceType::execution_space>( begin, end );
+        Kokkos::RangePolicy<typename BinningDataType::execution_space>( begin,
+                                                                        end );
     Kokkos::parallel_for( "Cabana::kokkosBinSort::permute_to_scratch", policy,
                           permute_to_scratch );
     Kokkos::fence();
diff --git a/core/src/Cabana_Utils.hpp b/core/src/Cabana_Utils.hpp
@@ -26,12 +26,10 @@ namespace Impl
 {
 //! \cond Impl
 
-// Custom warning for switch from device_type to memory_space.
+// Custom warning for use within static_assert.
 constexpr bool deprecated( std::false_type ) { return true; }
 
-[[deprecated(
-    "Template parameter should be converted from Kokkos device type to "
-    "Kokkos memory space." )]] constexpr bool
+[[deprecated( "Cabana deprecation." )]] constexpr bool
 deprecated( std::true_type )
 {
     return true;
diff --git a/example/grid_tutorial/14_spline/spline_example.cpp b/example/grid_tutorial/14_spline/spline_example.cpp
@@ -36,7 +36,6 @@ void splineExample()
       This includes the creation of a simple uniform mesh and a single particle
       position.
     */
-    using ExecutionSpace = Kokkos::DefaultHostExecutionSpace;
 
     // Create a 3-dimensional global uniform mesh
     // Global bounding box.
@@ -67,7 +66,7 @@ void splineExample()
 
     // Get the local mesh for this rank.
     auto local_mesh =
-        Cabana::Grid::createLocalMesh<ExecutionSpace>( *local_grid );
+        Cabana::Grid::createLocalMesh<Kokkos::HostSpace>( *local_grid );
 
     // Create a particle position vector.
     double xp[3] = { 0.5, 2, 1.5 };
diff --git a/example/grid_tutorial/15_interpolation/interpolation_example.cpp b/example/grid_tutorial/15_interpolation/interpolation_example.cpp
@@ -130,6 +130,7 @@ void interpolationExample()
       This example is all in 2D.
     */
     using ExecutionSpace = Kokkos::DefaultHostExecutionSpace;
+    using MemorySpace = Kokkos::HostSpace;
 
     // Create the global mesh.
     std::array<double, 2> low_corner = { -1.2, 0.1 };
@@ -147,14 +148,13 @@ void interpolationExample()
     // Create a  grid local_grid.
     int halo_width = 1;
     auto local_grid = Cabana::Grid::createLocalGrid( global_grid, halo_width );
-    auto local_mesh =
-        Cabana::Grid::createLocalMesh<ExecutionSpace>( *local_grid );
+    auto local_mesh = Cabana::Grid::createLocalMesh<MemorySpace>( *local_grid );
 
     // Create a point in the center of every cell.
     auto cell_space = local_grid->indexSpace(
         Cabana::Grid::Own(), Cabana::Grid::Cell(), Cabana::Grid::Local() );
     int num_particles = cell_space.size();
-    Kokkos::View<double* [2], ExecutionSpace> particle_positions(
+    Kokkos::View<double* [2], MemorySpace> particle_positions(
         Kokkos::ViewAllocateWithoutInitializing( "positions" ), num_particles );
     Kokkos::parallel_for(
         "fill_positions", createExecutionPolicy( cell_space, ExecutionSpace() ),
@@ -176,7 +176,7 @@ void interpolationExample()
     // information on these functions.
     auto scalar_layout =
         Cabana::Grid::createArrayLayout( local_grid, 1, Cabana::Grid::Node() );
-    auto scalar_grid_field = Cabana::Grid::createArray<double, ExecutionSpace>(
+    auto scalar_grid_field = Cabana::Grid::createArray<double, MemorySpace>(
         "scalar_grid_field", scalar_layout );
 
     // Create a halo for scatter operations. This concept is discussed in more
@@ -187,24 +187,24 @@ void interpolationExample()
     // Create a vector field on the grid.
     auto vector_layout =
         Cabana::Grid::createArrayLayout( local_grid, 2, Cabana::Grid::Node() );
-    auto vector_grid_field = Cabana::Grid::createArray<double, ExecutionSpace>(
+    auto vector_grid_field = Cabana::Grid::createArray<double, MemorySpace>(
         "vector_grid_field", vector_layout );
     auto vector_halo = Cabana::Grid::createHalo(
         Cabana::Grid::NodeHaloPattern<2>(), halo_width, *vector_grid_field );
 
     // Simple Kokkos::Views may be used to represent particle data.
     // Create a scalar point field.
-    Kokkos::View<double*, ExecutionSpace> scalar_particle_field(
+    Kokkos::View<double*, MemorySpace> scalar_particle_field(
         Kokkos::ViewAllocateWithoutInitializing( "particle_scalar" ),
         num_particles );
 
     // Create a vector point field.
-    Kokkos::View<double* [2], ExecutionSpace> vector_particle_field(
+    Kokkos::View<double* [2], MemorySpace> vector_particle_field(
         Kokkos::ViewAllocateWithoutInitializing( "particle_vector" ),
         num_particles );
 
     // Create a tensor point field.
-    Kokkos::View<double* [2][2], ExecutionSpace> tensor_particle_field(
+    Kokkos::View<double* [2][2], MemorySpace> tensor_particle_field(
         Kokkos::ViewAllocateWithoutInitializing( "particle_tensor" ),
         num_particles );
 
@@ -350,8 +350,8 @@ void interpolationExample()
      * aggregated fields will be considered in a separate example.
      * ************************************************************************/
 
-    P2GExampleFunctor<Kokkos::View<double*, ExecutionSpace>,
-                      Kokkos::View<double* [2], ExecutionSpace>>
+    P2GExampleFunctor<Kokkos::View<double*, MemorySpace>,
+                      Kokkos::View<double* [2], MemorySpace>>
         example_p2g { scalar_particle_field, vector_particle_field };
     Cabana::Grid::p2g( example_p2g, particle_positions, num_particles,
                        Cabana::Grid::Spline<1>(), *scalar_halo,
@@ -455,8 +455,8 @@ void interpolationExample()
      * interpolation function, but is also useful when combined in fused kernel
      * operations.
      * *************************************************************************/
-    G2PExampleFunctor<Kokkos::View<double*, ExecutionSpace>,
-                      Kokkos::View<double* [2][2], ExecutionSpace>>
+    G2PExampleFunctor<Kokkos::View<double*, MemorySpace>,
+                      Kokkos::View<double* [2][2], MemorySpace>>
         example_g2p { scalar_particle_field, tensor_particle_field };
     Cabana::Grid::g2p( *vector_grid_field, *vector_halo, particle_positions,
                        num_particles, Cabana::Grid::Spline<1>(), example_g2p );
diff --git a/grid/src/Cabana_Grid_Array.hpp b/grid/src/Cabana_Grid_Array.hpp
@@ -249,10 +249,10 @@ class Array
         std::conditional_t<2 == num_space_dim,
                            Kokkos::View<value_type***, Params...>, void>>;
 
-    //! Memory space.
+    //! Kokkos memory space.
     using memory_space = typename view_type::memory_space;
-    //! Default device type.
-    using device_type [[deprecated]] = typename memory_space::device_type;
+    static_assert( Kokkos::is_memory_space<memory_space>() );
+
     //! Default execution space.
     using execution_space = typename memory_space::execution_space;
 
diff --git a/grid/src/Cabana_Grid_FastFourierTransform.hpp b/grid/src/Cabana_Grid_FastFourierTransform.hpp
diff --git a/grid/src/Cabana_Grid_LocalMesh.hpp b/grid/src/Cabana_Grid_LocalMesh.hpp
diff --git a/grid/src/Cabana_Grid_ParticleInit.hpp b/grid/src/Cabana_Grid_ParticleInit.hpp
diff --git a/grid/src/Cabana_Grid_ReferenceStructuredSolver.hpp b/grid/src/Cabana_Grid_ReferenceStructuredSolver.hpp
diff --git a/grid/src/Cabana_Grid_SparseArray.hpp b/grid/src/Cabana_Grid_SparseArray.hpp
diff --git a/grid/src/Cabana_Grid_SparseDimPartitioner.hpp b/grid/src/Cabana_Grid_SparseDimPartitioner.hpp

Original file line number	Diff line number	Diff line change
`@@ -26,12 +26,10 @@ namespace Impl`
`26`	`26`	`{`
`27`	`27`	`//! \cond Impl`
`28`	`28`
`29`		`-// Custom warning for switch from device_type to memory_space.`
	`29`	`+// Custom warning for use within static_assert.`
`30`	`30`	`constexpr bool deprecated( std::false_type ) { return true; }`
`31`	`31`
`32`		`-[[deprecated(`
`33`		`- "Template parameter should be converted from Kokkos device type to "`
`34`		`- "Kokkos memory space." )]] constexpr bool`
	`32`	`+[[deprecated( "Cabana deprecation." )]] constexpr bool`
`35`	`33`	`deprecated( std::true_type )`
`36`	`34`	`{`
`37`	`35`	`return true;`