From dd78405a41cb78c5b57a6e9dc2205df7a03b54e6 Mon Sep 17 00:00:00 2001 From: Emily Bourne Date: Tue, 30 Jul 2024 05:16:03 +0000 Subject: [PATCH] Merge branch 'renaming_advection' into 'main' Update naming conventions in advection See merge request gysela-developpers/gyselalibxx!614 --- bin/update_naming_conventions.py | 4 +- src/advection/bsl_advection_1d.hpp | 169 +++++++------- src/advection/bsl_advection_vx.hpp | 79 ++++--- src/advection/bsl_advection_x.hpp | 69 +++--- src/advection/iadvectionvx.hpp | 14 +- src/advection/iadvectionx.hpp | 9 +- src/advection/nulladvectionvx.hpp | 26 ++- tests/advection/1d_advection_x.cpp | 80 +++---- tests/advection/1d_advection_xvx.cpp | 128 +++++------ tests/advection/1d_advection_xyvxvy.cpp | 256 +++++++++++----------- tests/advection/spatial_advection_1d.cpp | 132 +++++------ tests/advection/velocity_advection_1d.cpp | 190 ++++++++-------- 12 files changed, 586 insertions(+), 570 deletions(-) diff --git a/bin/update_naming_conventions.py b/bin/update_naming_conventions.py index d3096a053..6fc442791 100644 --- a/bin/update_naming_conventions.py +++ b/bin/update_naming_conventions.py @@ -271,11 +271,11 @@ def get_geometry_name_shortcuts(geometry_file): struct_name = s[2] if struct_name in species_names: continue - if struct_name == 'RDim': + if struct_name in ('RDim', 'CDim'): name_map[struct_name] = 'Dim' elif struct_name in ('DDim', 'IDim'): name_map[struct_name] = 'Grid1D' - elif struct_name.startswith('RDim'): + elif struct_name.startswith('RDim') or struct_name.startswith('CDim'): new_name = struct_name[4:] if not new_name[0].isalpha(): new_name = 'Dim' + new_name diff --git a/src/advection/bsl_advection_1d.hpp b/src/advection/bsl_advection_1d.hpp index 9d1b0e1a8..788ec2309 100644 --- a/src/advection/bsl_advection_1d.hpp +++ b/src/advection/bsl_advection_1d.hpp @@ -1,44 +1,44 @@ // SPDX-License-Identifier: MIT #pragma once - #include #include +#include "ddc_aliases.hpp" #include "ddc_helper.hpp" #include "euler.hpp" #include "iinterpolator.hpp" /** - * @brief A class which computes the advection along the dimension of interest IDimInterest. + * @brief A class which computes the advection along the dimension of interest GridInterest. * * This operator solves the following equation type * * @f$ \partial_t f_s(t,x) + A_{s, x_i} (x') \cdot \partial_{x_i} f_s (t, x) = 0, \qquad x\in \Omega, x'\in\Omega'@f$ * * with - * * @f$ f @f$, a function defined on a domain @f$ \Omega @f$; - * * @f$ A @f$, an advection field defined on subdomain @f$ \Omega'\subset \Omega @f$; + * * @f$ f @f$, a function defined on an index range @f$ \Omega @f$; + * * @f$ A @f$, an advection field defined on subindex range @f$ \Omega'\subset \Omega @f$; * * @f$ x_i @f$, an advection dimension. * * - * The characteristic equation is solved on the advection domain @f$ \Omega'@f$. + * The characteristic equation is solved on the advection index range @f$ \Omega'@f$. * Then the feet on @f$ \Omega@f$ are computed from the characteristic feet on @f$ \Omega'@f$ and the function * @f$ f @f$ is interpolated at the feet in @f$ \Omega @f$. * * The characteristic equation is solved using a time integration method (ITimeStepper). * * - * @tparam IDimInterest + * @tparam GridInterest * The dimension along which the advection is computed. * It refers to the dimension of @f$ x_i @f$ in the equation. - * @tparam AdvectionDomain - * The domain @f$ \Omega' @f$ where the characteristic equation is solved. - * It also refers to the domain of the advection field. - * It had to also be defined on the IDimInterest for the time integration method. - * @tparam FunctionDomain - * The domain @f$ \Omega @f$ where allfdistribu is defined. + * @tparam AdvectionIdxRange + * The index range @f$ \Omega' @f$ where the characteristic equation is solved. + * It also refers to the index range of the advection field. + * It had to also be defined on the GridInterest for the time integration method. + * @tparam FunctionIdxRange + * The index range @f$ \Omega @f$ where allfdistribu is defined. * @tparam AdvectionFieldBuilder * The type of the spline builder for the advection field (see SplineBuilder). * @tparam AdvectionFieldEvaluator @@ -48,64 +48,64 @@ * The method is picked among the child classes of ITimeStepper. */ template < - class IDimInterest, - class AdvectionDomain, - class FunctionDomain, + class GridInterest, + class AdvectionIdxRange, + class FunctionIdxRange, class AdvectionFieldBuilder, class AdvectionFieldEvaluator, class TimeStepper - = Euler, - AdvectionDomain>>, - device_t>>> + = Euler, + AdvectionIdxRange>, + FieldMem>> class BslAdvection1D { private: - // Advection domain element: - using AdvectionIndex = typename AdvectionDomain::discrete_element_type; + // Advection index range element: + using AdvectionIdx = typename AdvectionIdxRange::discrete_element_type; - // Full domain element: - using FunctionIndex = typename FunctionDomain::discrete_element_type; + // Full index range element: + using FunctionIdx = typename FunctionIdxRange::discrete_element_type; // Advection dimension (or Interest dimension): - using RDimInterest = typename IDimInterest::continuous_dimension_type; - using CoordInterest = ddc::Coordinate; - using DomainInterest = ddc::DiscreteDomain; - using IndexInterest = typename DomainInterest::discrete_element_type; + using DimInterest = typename GridInterest::continuous_dimension_type; + using CoordInterest = Coord; + using IdxRangeInterest = IdxRange; + using IdxInterest = typename IdxRangeInterest::discrete_element_type; // Type for the feet and advection field: - using FeetChunk = device_t>; - using FeetSpan = typename FeetChunk::span_type; - using FeetView = typename FeetChunk::view_type; + using FeetFieldMem = FieldMem; + using FeetField = typename FeetFieldMem::span_type; + using FeetConstField = typename FeetFieldMem::view_type; - using AdvecFieldChunk = device_t>; - using AdvecFieldSpan = typename AdvecFieldChunk::span_type; + using AdvecFieldMem = FieldMem; + using AdvecField = typename AdvecFieldMem::span_type; - using FunctionSpan = device_t>; + using FunctionField = Field; // Type for spline representation of the advection field - using BSAdvectionDomain = typename AdvectionFieldBuilder::batched_spline_domain_type; - using AdvecFieldSplineChunk = device_t>; - using AdvecFieldSplineSpan = device_t>; + using BSAdvectionIdxRange = typename AdvectionFieldBuilder::batched_spline_domain_type; + using AdvecFieldSplineMem = FieldMem; + using AdvecFieldSplineCoeffs = Field; // Type for the derivatives of the advection field - using DerivDim = ddc::Deriv; - using DomainInterestDeriv = ddc::DiscreteDomain; - using AdvecFieldDerivDomain = ddc::replace_dim_of_t; - using AdvecFieldDerivView = device_t>; + using DerivDim = ddc::Deriv; + using AdvecFieldDerivIdxRange + = ddc::replace_dim_of_t; + using AdvecFieldDerivConstField = Field; // Interpolators: using FunctionPreallocatableInterpolatorType = interpolator_on_idx_range_t< IPreallocatableInterpolator, - IDimInterest, - FunctionDomain>; + GridInterest, + FunctionIdxRange>; using FunctionInterpolatorType - = interpolator_on_idx_range_t; + = interpolator_on_idx_range_t; // Type for the derivatives of the function - using FunctionDerivDomain = typename FunctionInterpolatorType::batched_derivs_idx_range_type; - using FunctionDerivChunk = device_t>; + using FunctionDerivIdxRange = typename FunctionInterpolatorType::batched_derivs_idx_range_type; + using FunctionDerivFieldMem = FieldMem; FunctionPreallocatableInterpolatorType const& m_function_interpolator; @@ -116,20 +116,20 @@ class BslAdvection1D public: /** - * @brief Constructor when the advection domain and the function domain are different. + * @brief Constructor when the advection index range and the function index range are different. * - * When AdvectionDomain and FunctionDomain are different, we need one interpolator for - * each domain. + * When AdvectionIdxRange and FunctionIdxRange are different, we need one interpolator for + * each index range. * * We can also use it when we want two differents interpolators but defined on the same - * domain (e.g. different boundary conditions for the evaluators). + * index range (e.g. different boundary conditions for the evaluators). * - * @param[in] function_interpolator interpolator along the IDimInterest direction to interpolate - * the advected function (allfdistribu) on the domain of the function. - * @param[in] adv_field_builder builder along the IDimInterest direction to build a spline representation - * of the advection field on the function domain. - * @param[in] adv_field_evaluator evaluator along the IDimInterest direction to evaluate - * the advection field spline representation on the function domain. + * @param[in] function_interpolator interpolator along the GridInterest direction to interpolate + * the advected function (allfdistribu) on the index range of the function. + * @param[in] adv_field_builder builder along the GridInterest direction to build a spline representation + * of the advection field on the function index range. + * @param[in] adv_field_evaluator evaluator along the GridInterest direction to evaluate + * the advection field spline representation on the function index range. * @param[in] time_stepper time integration method for the characteristic equation. */ explicit BslAdvection1D( @@ -147,7 +147,7 @@ class BslAdvection1D ~BslAdvection1D() = default; /** - * @brief Advects allfdistribu along the advection dimension IDimInterest for a duration dt. + * @brief Advects allfdistribu along the advection dimension GridInterest for a duration dt. * * @param[in, out] allfdistribu Reference to the advected function, allocated on the device * @param[in] advection_field Reference to the advection field, allocated on the device. @@ -159,21 +159,22 @@ class BslAdvection1D * * @return A reference to the allfdistribu array after advection on dt. */ - FunctionSpan operator()( - FunctionSpan const allfdistribu, - AdvecFieldSpan const advection_field, + FunctionField operator()( + FunctionField const allfdistribu, + AdvecField const advection_field, double const dt, - std::optional const advection_field_derivatives_min = std::nullopt, - std::optional const advection_field_derivatives_max + std::optional const advection_field_derivatives_min + = std::nullopt, + std::optional const advection_field_derivatives_max = std::nullopt) const { Kokkos::Profiling::pushRegion("BslAdvection1D"); - // Get domains and operators ............................................................. - FunctionDomain const function_dom = allfdistribu.domain(); - AdvectionDomain const advection_dom = advection_field.domain(); + // Get index ranges and operators ............................................................. + FunctionIdxRange const function_dom = get_idx_range(allfdistribu); + AdvectionIdxRange const advection_dom = get_idx_range(advection_field); auto const batch_dom = ddc::remove_dims_of(function_dom, advection_dom); - DomainInterest const interest_dom(advection_dom); + IdxRangeInterest const interest_dom(advection_dom); std::unique_ptr const function_interpolator_ptr = m_function_interpolator.preallocate(); @@ -181,20 +182,20 @@ class BslAdvection1D // Build spline representation of the advection field .................................... - AdvecFieldSplineChunk advection_field_coefs_alloc( + AdvecFieldSplineMem advection_field_coefs_alloc( m_adv_field_builder.batched_spline_domain()); - AdvecFieldSplineSpan advection_field_coefs = advection_field_coefs_alloc.span_view(); + AdvecFieldSplineCoeffs advection_field_coefs = get_field(advection_field_coefs_alloc); m_adv_field_builder( advection_field_coefs, - advection_field.span_cview(), + get_const_field(advection_field), advection_field_derivatives_min, advection_field_derivatives_max); // Build derivatives on boundaries and fill with zeros.................................... - FunctionDerivChunk function_derivatives_min( + FunctionDerivFieldMem function_derivatives_min( m_function_interpolator.batched_derivs_idx_range_xmin(function_dom)); - FunctionDerivChunk function_derivatives_max( + FunctionDerivFieldMem function_derivatives_max( m_function_interpolator.batched_derivs_idx_range_xmax(function_dom)); ddc::parallel_fill(Kokkos::DefaultExecutionSpace(), function_derivatives_min, 0.); ddc::parallel_fill(Kokkos::DefaultExecutionSpace(), function_derivatives_max, 0.); @@ -202,16 +203,16 @@ class BslAdvection1D // Initialise the characteristics on the mesh points ..................................... /* For the time integration solver, the function we advect (here the characteristics) - need to be defined on the same domain as the advection field. We then work on space + need to be defined on the same index range as the advection field. We then work on space slices of the characteristic feet. */ - FeetChunk slice_feet_alloc(advection_dom); - FeetSpan slice_feet = slice_feet_alloc.span_view(); + FeetFieldMem slice_feet_alloc(advection_dom); + FeetField slice_feet = get_field(slice_feet_alloc); ddc::parallel_for_each( Kokkos::DefaultExecutionSpace(), advection_dom, - KOKKOS_LAMBDA(AdvectionIndex const idx) { - slice_feet(idx) = ddc::coordinate(IndexInterest(idx)); + KOKKOS_LAMBDA(AdvectionIdx const idx) { + slice_feet(idx) = ddc::coordinate(IdxInterest(idx)); }); @@ -223,19 +224,19 @@ class BslAdvection1D * update_adv_field: evaluate the advection field spline at the updated feet. */ // The function describing how the derivative of the evolve function is calculated. - std::function update_adv_field - = [&](AdvecFieldSpan updated_advection_field, FeetView slice_feet) { + std::function update_adv_field + = [&](AdvecField updated_advection_field, FeetConstField slice_feet) { m_adv_field_evaluator( updated_advection_field, slice_feet, - advection_field_coefs.span_cview()); + get_const_field(advection_field_coefs)); }; // Solve the characteristic equation with a time integration method m_time_stepper .update(Kokkos::DefaultExecutionSpace(), - slice_feet.span_view(), + get_field(slice_feet), -dt, update_adv_field); @@ -243,15 +244,15 @@ class BslAdvection1D // Interpolate the function .............................................................. /* To interpolate the function we want to advect, we build for the feet a Chunk defined - on the domain where the function is defined. + on the index range where the function is defined. */ - device_t> feet_alloc(function_dom); - ddc::ChunkSpan feet = feet_alloc.span_view(); + FieldMem feet_alloc(function_dom); + ddc::ChunkSpan feet = get_field(feet_alloc); ddc::parallel_for_each( Kokkos::DefaultExecutionSpace(), function_dom, - KOKKOS_LAMBDA(FunctionIndex const idx) { - AdvectionIndex slice_foot_index(idx); + KOKKOS_LAMBDA(FunctionIdx const idx) { + AdvectionIdx slice_foot_index(idx); feet(idx) = slice_feet(slice_foot_index); }); diff --git a/src/advection/bsl_advection_vx.hpp b/src/advection/bsl_advection_vx.hpp index 53fe2f762..ee7cffeba 100644 --- a/src/advection/bsl_advection_vx.hpp +++ b/src/advection/bsl_advection_vx.hpp @@ -1,42 +1,41 @@ // SPDX-License-Identifier: MIT #pragma once - #include #include #include #include +#include "ddc_aliases.hpp" #include "iadvectionvx.hpp" /** - * @brief A class which computes the velocity advection along the dimension of interest DDimV. Working for every cartesian geometry. + * @brief A class which computes the velocity advection along the dimension of interest GridV. Working for every cartesian geometry. */ -template -class BslAdvectionVelocity : public IAdvectionVelocity +template +class BslAdvectionVelocity : public IAdvectionVelocity { - using FdistribuDDom = typename Geometry::FdistribuDDom; - using SpatialDDom = typename Geometry::SpatialDDom; - using DElemV = ddc::DiscreteElement; - using DElemSp = ddc::DiscreteElement; - using CDimV = typename DDimV::continuous_dimension_type; + using FdistribuIdxRange = typename Geometry::FdistribuDDom; + using SpatialIdxRange = typename Geometry::SpatialDDom; + using IdxV = Idx; + using DimV = typename GridV::continuous_dimension_type; private: using PreallocatableInterpolatorType = interpolator_on_idx_range_t< IPreallocatableInterpolator, - DDimV, + GridV, ddc::cartesian_prod_t>; using InterpolatorType = interpolator_on_idx_range_t< IInterpolator, - DDimV, + GridV, ddc::cartesian_prod_t>; PreallocatableInterpolatorType const& m_interpolator_v; public: /** * @brief Constructor - * @param[in] interpolator_v interpolator along the DDimV direction which refers to the velocity space. + * @param[in] interpolator_v interpolator along the GridV direction which refers to the velocity space. */ explicit BslAdvectionVelocity(PreallocatableInterpolatorType const& interpolator_v) : m_interpolator_v(interpolator_v) @@ -46,68 +45,66 @@ class BslAdvectionVelocity : public IAdvectionVelocity ~BslAdvectionVelocity() override = default; /** - * @brief Advects fdistribu along DDimV for a duration dt. + * @brief Advects fdistribu along GridV for a duration dt. * @param[in, out] allfdistribu Reference to the whole distribution function for one species, allocated on the device (ie it lets the choice of the location depend on the build configuration). * @param[in] electric_field Reference to the electric field which derives from electrostatic potential, allocated on the device. * @param[in] dt Time step * @return A reference to the allfdistribu array containing the value of the function at the coordinates. */ - device_t> operator()( - device_t> const allfdistribu, - device_t> const electric_field, + Field operator()( + Field const allfdistribu, + Field const electric_field, double const dt) const override { Kokkos::Profiling::pushRegion("BslAdvectionVelocity"); - FdistribuDDom const dom = allfdistribu.domain(); - ddc::DiscreteDomain const v_dom = ddc::select(dom); - ddc::DiscreteDomain const sp_dom = ddc::select(dom); - - device_t> - derivs_min(m_interpolator_v.batched_derivs_idx_range_xmin( - ddc::remove_dims_of(dom))); - device_t> - derivs_max(m_interpolator_v.batched_derivs_idx_range_xmax( - ddc::remove_dims_of(dom))); + FdistribuIdxRange const dom = get_idx_range(allfdistribu); + IdxRange const v_dom = ddc::select(dom); + IdxRange const sp_dom = ddc::select(dom); + + FieldMem derivs_min( + m_interpolator_v.batched_derivs_idx_range_xmin(ddc::remove_dims_of(dom))); + FieldMem derivs_max( + m_interpolator_v.batched_derivs_idx_range_xmax(ddc::remove_dims_of(dom))); ddc::parallel_fill(derivs_min, 0.); ddc::parallel_fill(derivs_max, 0.); // pre-allocate some memory to prevent allocation later in loop ddc::Chunk feet_coords_alloc( ddc::remove_dims_of(dom, sp_dom), - ddc::DeviceAllocator>()); - ddc::ChunkSpan feet_coords = feet_coords_alloc.span_view(); + ddc::DeviceAllocator>()); + ddc::ChunkSpan feet_coords = get_field(feet_coords_alloc); std::unique_ptr const interpolator_v_ptr = m_interpolator_v.preallocate(); InterpolatorType const& interpolator_v = *interpolator_v_ptr; - SpatialDDom const spatial_dom(allfdistribu.domain()); + SpatialIdxRange const spatial_dom(get_idx_range(allfdistribu)); - auto c_dom = ddc::remove_dims_of(ddc::remove_dims_of(dom, sp_dom), v_dom); - using DElemC = typename decltype(c_dom)::discrete_element_type; - using DElemSpatial = typename SpatialDDom::discrete_element_type; + auto batch_idx_range = ddc::remove_dims_of(ddc::remove_dims_of(dom, sp_dom), v_dom); + using IdxB = typename decltype(batch_idx_range)::discrete_element_type; + using IdxSpatial = typename SpatialIdxRange::discrete_element_type; - ddc::for_each(sp_dom, [&](DElemSp const isp) { + ddc::for_each(sp_dom, [&](IdxSp const isp) { double const charge_proxy = charge(isp); // TODO: consider proper way to access charge from device double const sqrt_me_on_mspecies = std::sqrt(mass(ielec()) / mass(isp)); ddc::parallel_for_each( Kokkos::DefaultExecutionSpace(), - c_dom, - KOKKOS_LAMBDA(DElemC const ic) { - DElemSpatial const ix(ic); + batch_idx_range, + KOKKOS_LAMBDA(IdxB const ib) { + IdxSpatial const ix(ib); // compute the displacement double const dvx = charge_proxy * sqrt_me_on_mspecies * dt * electric_field(ix); // compute the coordinates of the feet - for (DElemV const iv : v_dom) { - feet_coords(iv, ic) = ddc::Coordinate(ddc::coordinate(iv) - dvx); + for (IdxV const iv : v_dom) { + feet_coords(iv, ib) = Coord(ddc::coordinate(iv) - dvx); } }); interpolator_v( allfdistribu[isp], - feet_coords.span_cview(), - derivs_min.span_cview(), - derivs_max.span_cview()); + get_const_field(feet_coords), + get_const_field(derivs_min), + get_const_field(derivs_max)); }); Kokkos::Profiling::popRegion(); diff --git a/src/advection/bsl_advection_x.hpp b/src/advection/bsl_advection_x.hpp index afc613a09..820fbcdfe 100644 --- a/src/advection/bsl_advection_x.hpp +++ b/src/advection/bsl_advection_x.hpp @@ -1,44 +1,42 @@ // SPDX-License-Identifier: MIT #pragma once - #include #include #include +#include "ddc_aliases.hpp" #include "iadvectionx.hpp" /** - * @brief A class which computes the spatial advection along the dimension of interest DDimX. Working for every cartesian geometry. + * @brief A class which computes the spatial advection along the dimension of interest GridX. Working for every cartesian geometry. */ -template -class BslAdvectionSpatial : public IAdvectionSpatial +template +class BslAdvectionSpatial : public IAdvectionSpatial { - using DDimV = typename Geometry::template velocity_dim_for; - using DDom = typename Geometry::FdistribuDDom; - using DElemX = ddc::DiscreteElement; - using DElemV = ddc::DiscreteElement; - using DElemSp = ddc::DiscreteElement; - using DElemSpV = ddc::DiscreteElement; - using CDimX = typename DDimX::continuous_dimension_type; - using CDimV = typename DDimV::continuous_dimension_type; + using GridV = typename Geometry::template velocity_dim_for; + using FdistribIdxRange = typename Geometry::FdistribuDDom; + using IdxX = Idx; + using IdxV = Idx; + using DimX = typename GridX::continuous_dimension_type; + using DimV = typename GridV::continuous_dimension_type; private: using PreallocatableInterpolatorType = interpolator_on_idx_range_t< IPreallocatableInterpolator, - DDimX, + GridX, ddc::cartesian_prod_t>; using InterpolatorType = interpolator_on_idx_range_t< IInterpolator, - DDimX, + GridX, ddc::cartesian_prod_t>; PreallocatableInterpolatorType const& m_interpolator_x; public: /** * @brief Constructor - * @param[in] interpolator_x interpolator along the DDimX direction which refers to the spatial space. + * @param[in] interpolator_x interpolator along the GridX direction which refers to the spatial space. */ explicit BslAdvectionSpatial(PreallocatableInterpolatorType const& interpolator_x) : m_interpolator_x(interpolator_x) @@ -48,49 +46,50 @@ class BslAdvectionSpatial : public IAdvectionSpatial ~BslAdvectionSpatial() override = default; /** - * @brief Advects fdistribu along DDimX for a duration dt. + * @brief Advects fdistribu along GridX for a duration dt. * @param[in, out] allfdistribu Reference to the whole distribution function for one species, allocated on the device (ie it lets the choice of the location depend on the build configuration). * @param[in] dt Time step * @return A reference to the allfdistribu array containing the value of the function at the coordinates. */ - device_t> operator()( - device_t> const allfdistribu, + Field operator()( + Field const allfdistribu, double const dt) const override { Kokkos::Profiling::pushRegion("BslAdvectionSpatial"); - DDom const dom = allfdistribu.domain(); - ddc::DiscreteDomain const x_dom = ddc::select(dom); - ddc::DiscreteDomain const v_dom = ddc::select(dom); - ddc::DiscreteDomain const sp_dom = ddc::select(dom); + FdistribIdxRange const dom = get_idx_range(allfdistribu); + IdxRange const x_idx_range = ddc::select(dom); + IdxRange const v_idx_range = ddc::select(dom); + IdxRange const sp_idx_range = ddc::select(dom); // pre-allocate some memory to prevent allocation later in loop ddc::Chunk feet_coords_alloc( - ddc::remove_dims_of(dom, sp_dom), - ddc::DeviceAllocator>()); - ddc::ChunkSpan feet_coords = feet_coords_alloc.span_view(); + ddc::remove_dims_of(dom, sp_idx_range), + ddc::DeviceAllocator>()); + ddc::ChunkSpan feet_coords = get_field(feet_coords_alloc); std::unique_ptr const interpolator_x_ptr = m_interpolator_x.preallocate(); InterpolatorType const& interpolator_x = *interpolator_x_ptr; - auto c_dom = ddc::remove_dims_of(dom, ddc::DiscreteDomain(sp_dom, x_dom)); - using DElemC = typename decltype(c_dom)::discrete_element_type; + auto batch_idx_range + = ddc::remove_dims_of(dom, IdxRange(sp_idx_range, x_idx_range)); + using IdxB = typename decltype(batch_idx_range)::discrete_element_type; - for (DElemSp const isp : sp_dom) { + for (IdxSp const isp : sp_idx_range) { double const sqrt_me_on_mspecies = std::sqrt(mass(ielec()) / mass(isp)); ddc::parallel_for_each( Kokkos::DefaultExecutionSpace(), - c_dom, - KOKKOS_LAMBDA(DElemC const ic) { + batch_idx_range, + KOKKOS_LAMBDA(IdxB const ib) { // compute the displacement - DElemV const iv(ic); - ddc::Coordinate const coord_iv = ddc::coordinate(iv); + IdxV const iv(ib); + Coord const coord_iv = ddc::coordinate(iv); double const dx = sqrt_me_on_mspecies * dt * coord_iv; // compute the coordinates of the feet - for (DElemX const ix : x_dom) { - feet_coords(ix, ic) = ddc::Coordinate(ddc::coordinate(ix) - dx); + for (IdxX const ix : x_idx_range) { + feet_coords(ix, ib) = Coord(ddc::coordinate(ix) - dx); } }); - interpolator_x(allfdistribu[isp], feet_coords.span_cview()); + interpolator_x(allfdistribu[isp], get_const_field(feet_coords)); } Kokkos::Profiling::popRegion(); diff --git a/src/advection/iadvectionvx.hpp b/src/advection/iadvectionvx.hpp index 30a5c5475..dd45ea160 100644 --- a/src/advection/iadvectionvx.hpp +++ b/src/advection/iadvectionvx.hpp @@ -1,18 +1,19 @@ // SPDX-License-Identifier: MIT #pragma once - #include #include +#include "ddc_aliases.hpp" + /** * @brief A class which provides an advection operator. * * An abstract class which implements a function that * applies the transport along a velocity direction of the phase space. */ -template +template class IAdvectionVelocity { public: @@ -22,14 +23,13 @@ class IAdvectionVelocity * @brief operates a transport of the distribution function. * * @param[in, out] allfdistribu Reference to an array containing the value of the distribution function. - * @param[in] electrostatic_potential The electrostatic potential which is the advection speed. + * @param[in] electric_field The electric field which derives from electrostatic potential and is the advection speed. * @param[in] dt Time step. * * @return A reference to an array containing the value of distribution the function at the updated time t+dt. */ - virtual device_t> operator()( - device_t> allfdistribu, - device_t> - electrostatic_potential, + virtual Field operator()( + Field allfdistribu, + Field electric_field, double dt) const = 0; }; diff --git a/src/advection/iadvectionx.hpp b/src/advection/iadvectionx.hpp index 09400c27a..f9a57654c 100644 --- a/src/advection/iadvectionx.hpp +++ b/src/advection/iadvectionx.hpp @@ -1,16 +1,17 @@ // SPDX-License-Identifier: MIT #pragma once - #include +#include "ddc_aliases.hpp" + /** * @brief A class which provides an advection operator. * * An abstract class which implements a function that * applies the transport along a physical space direction of the phase space. */ -template +template class IAdvectionSpatial { public: @@ -23,7 +24,7 @@ class IAdvectionSpatial * * @return A reference to an array containing the value of distribution the function at the updated time T+dt. */ - virtual device_t> operator()( - device_t> allfdistribu, + virtual Field operator()( + Field allfdistribu, double dt) const = 0; }; diff --git a/src/advection/nulladvectionvx.hpp b/src/advection/nulladvectionvx.hpp index 0782e71b9..7b4f6e2e8 100644 --- a/src/advection/nulladvectionvx.hpp +++ b/src/advection/nulladvectionvx.hpp @@ -1,20 +1,34 @@ // SPDX-License-Identifier: MIT #pragma once - +#include "ddc_aliases.hpp" #include "iadvectionvx.hpp" -template -class NullAdvectionVelocity : public IAdvectionV +/** + * @brief This is a class which imitates a velocity advection. + * It inherits from IAdvectionV and can be used as an advection operator but does not + * actually modify the distribution function. This can be useful for debugging purposes. + */ +template +class NullAdvectionVelocity : public IAdvectionV { public: NullAdvectionVelocity() = default; ~NullAdvectionVelocity() override = default; - ddc::ChunkSpan operator()( - ddc::ChunkSpan allfdistribu, - [[maybe_unused]] ddc::ChunkSpan electrostatic_potential, + /** + * @brief Do nothing instead of advecting fdistribu along GridV for a duration dt. + * + * @param[in, out] allfdistribu Reference to an array containing the value of the distribution function. + * @param[in] electric_field The electric field which derives from electrostatic potential and is the advection speed. + * @param[in] dt Time step + * + * @return A reference to the allfdistribu array containing the value of the function at the coordinates. + */ + Field operator()( + Field allfdistribu, + [[maybe_unused]] Field electric_field, [[maybe_unused]] double dt) const override { return allfdistribu; diff --git a/tests/advection/1d_advection_x.cpp b/tests/advection/1d_advection_x.cpp index c99291c90..0e75379aa 100644 --- a/tests/advection/1d_advection_x.cpp +++ b/tests/advection/1d_advection_x.cpp @@ -17,16 +17,16 @@ namespace { // Continuous dimension /// @brief A class which describes the real space in the first spatial direction X. -struct RDimX +struct X { /// @brief A boolean indicating if the dimension is periodic. static bool constexpr PERIODIC = true; }; -using CoordX = ddc::Coordinate; +using CoordX = Coord; // Spline -struct BSplinesX : ddc::UniformBSplines +struct BSplinesX : ddc::UniformBSplines { }; @@ -34,26 +34,26 @@ ddc::BoundCond constexpr SplineXBoundary = ddc::BoundCond::PERIODIC; // Discrete dimension -struct IDimX : ddc::UniformPointSampling +struct GridX : UniformGridBase { }; using SplineInterpPointsX = ddc::GrevilleInterpolationPoints; -using IDomainX = ddc::DiscreteDomain; -using IndexX = ddc::DiscreteElement; -using IVectX = ddc::DiscreteVector; +using IdxRangeX = IdxRange; +using IdxX = Idx; +using IdxStepX = IdxStep; // Chunks, Spans and Views template -using FieldX = device_t>; -using DFieldX = FieldX; +using FieldMemX = FieldMem; +using DFieldMemX = FieldMemX; template -using SpanX = device_t>; -using DSpanX = SpanX; +using FieldX = Field; +using DFieldX = FieldX; // Operators @@ -61,20 +61,20 @@ using SplineXBuilder = ddc::SplineBuilder< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesX, - IDimX, + GridX, SplineXBoundary, SplineXBoundary, ddc::SplineSolver::LAPACK, - IDimX>; + GridX>; using SplineXEvaluator = ddc::SplineEvaluator< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesX, - IDimX, - ddc::PeriodicExtrapolationRule, - ddc::PeriodicExtrapolationRule, - IDimX>; + GridX, + ddc::PeriodicExtrapolationRule, + ddc::PeriodicExtrapolationRule, + GridX>; class XAdvection1DTest : public ::testing::Test @@ -82,12 +82,12 @@ class XAdvection1DTest : public ::testing::Test protected: static constexpr CoordX x_min = CoordX(-M_PI); static constexpr CoordX x_max = CoordX(M_PI); - static constexpr IVectX x_size = IVectX(32); + static constexpr IdxStepX x_size = IdxStepX(32); - IDomainX const interpolation_domain; + IdxRangeX const interpolation_idx_range; public: - XAdvection1DTest() : interpolation_domain(SplineInterpPointsX::get_domain()) {}; + XAdvection1DTest() : interpolation_idx_range(SplineInterpPointsX::get_domain()) {}; ~XAdvection1DTest() = default; @@ -95,7 +95,7 @@ class XAdvection1DTest : public ::testing::Test static void SetUpTestSuite() { ddc::init_discrete_space(x_min, x_max, x_size); - ddc::init_discrete_space(SplineInterpPointsX::get_sampling()); + ddc::init_discrete_space(SplineInterpPointsX::get_sampling()); } template @@ -107,16 +107,16 @@ class XAdvection1DTest : public ::testing::Test int const time_iter = int(final_t / dt); // INITIALISATION ---------------------------------------------------------------------------- - DFieldX function_alloc(interpolation_domain); - DSpanX function = function_alloc.span_view(); + DFieldMemX function_alloc(interpolation_idx_range); + DFieldX function = get_field(function_alloc); - DFieldX advection_field_alloc(interpolation_domain); - DSpanX advection_field = advection_field_alloc.span_view(); + DFieldMemX advection_field_alloc(interpolation_idx_range); + DFieldX advection_field = get_field(advection_field_alloc); ddc::parallel_for_each( Kokkos::DefaultExecutionSpace(), - interpolation_domain, - KOKKOS_LAMBDA(IndexX const idx) { + interpolation_idx_range, + KOKKOS_LAMBDA(IdxX const idx) { double const x = ddc::coordinate(idx); function(idx) = Kokkos::sin(2 * x); advection_field(idx) = Kokkos::sin(x); @@ -124,12 +124,12 @@ class XAdvection1DTest : public ::testing::Test // EXACT ADVECTED FUNCTION ------------------------------------------------------------------- - host_t exact_function(interpolation_domain); - ddc::for_each(interpolation_domain, [&](IndexX const idx) { + host_t exact_function(interpolation_idx_range); + ddc::for_each(interpolation_idx_range, [&](IdxX const idx) { double const x0 = ddc::coordinate(idx); double x = 2 * std::atan(std::tan(x0 / 2.) * std::exp(-final_t)); - // Replace inside the domain the feet if the dimension if periodic - if (RDimX::PERIODIC) { + // Replace inside the index range the feet if the dimension if periodic + if (X::PERIODIC) { x = fmod(x - double(x_min), double(x_max - x_min)) + double(x_min); x = x > double(x_min) ? x : x + double(x_max - x_min); } @@ -148,7 +148,7 @@ class XAdvection1DTest : public ::testing::Test */ auto function_host = ddc::create_mirror_view_and_copy(function); double max_relative_error = 0; - ddc::for_each(interpolation_domain, [&](IndexX const idx) { + ddc::for_each(interpolation_idx_range, [&](IdxX const idx) { double const relative_error = abs(function_host(idx) - exact_function(idx)); max_relative_error = max_relative_error > relative_error ? max_relative_error : relative_error; @@ -165,23 +165,23 @@ class XAdvection1DTest : public ::testing::Test TEST_F(XAdvection1DTest, AdvectionX) { // CREATING OPERATORS ------------------------------------------------------------------------ - SplineXBuilder const builder(interpolation_domain); + SplineXBuilder const builder(interpolation_idx_range); - ddc::PeriodicExtrapolationRule bv_x_min; - ddc::PeriodicExtrapolationRule bv_x_max; + ddc::PeriodicExtrapolationRule bv_x_min; + ddc::PeriodicExtrapolationRule bv_x_max; SplineXEvaluator const spline_evaluator(bv_x_min, bv_x_max); PreallocatableSplineInterpolator const spline_interpolator(builder, spline_evaluator); - RK2, DFieldX> time_stepper(interpolation_domain); + RK2, DFieldMemX> time_stepper(interpolation_idx_range); BslAdvection1D< - IDimX, - IDomainX, - IDomainX, + GridX, + IdxRangeX, + IdxRangeX, SplineXBuilder, SplineXEvaluator, - RK2, DFieldX>> const + RK2, DFieldMemX>> const advection(spline_interpolator, builder, spline_evaluator, time_stepper); double const max_relative_error = AdvectionX(advection); diff --git a/tests/advection/1d_advection_xvx.cpp b/tests/advection/1d_advection_xvx.cpp index e6b53c5a5..198da9aa1 100644 --- a/tests/advection/1d_advection_xvx.cpp +++ b/tests/advection/1d_advection_xvx.cpp @@ -19,27 +19,27 @@ namespace { // Continuous dimension /// @brief A class which describes the real space in the first spatial direction X. -struct RDimX +struct X { /// @brief A boolean indicating if the dimension is periodic. static bool constexpr PERIODIC = true; }; /// @brief A class which describes the real space in the first velocity direction Vx. -struct RDimVx +struct Vx { /// @brief A boolean indicating if the dimension is periodic. static bool constexpr PERIODIC = false; }; -using CoordX = ddc::Coordinate; -using CoordVx = ddc::Coordinate; +using CoordX = Coord; +using CoordVx = Coord; // Spline -struct BSplinesX : ddc::UniformBSplines +struct BSplinesX : ddc::UniformBSplines { }; -struct BSplinesVx : ddc::UniformBSplines +struct BSplinesVx : ddc::UniformBSplines { }; @@ -48,10 +48,10 @@ ddc::BoundCond constexpr SplineVxBoundary = ddc::BoundCond::HERMITE; // Discrete dimension -struct IDimX : ddc::UniformPointSampling +struct GridX : UniformGridBase { }; -struct IDimVx : ddc::UniformPointSampling +struct GridVx : UniformGridBase { }; @@ -62,40 +62,40 @@ using SplineInterpPointsVx = ddc::GrevilleInterpolationPoints; -using IDomainX = ddc::DiscreteDomain; -using IndexX = ddc::DiscreteElement; -using IVectX = ddc::DiscreteVector; +using IdxRangeX = IdxRange; +using IdxX = Idx; +using IdxStepX = IdxStep; -using IDomainVx = ddc::DiscreteDomain; -using IndexVx = ddc::DiscreteElement; -using IVectVx = ddc::DiscreteVector; +using IdxRangeVx = IdxRange; +using IdxVx = Idx; +using IdxStepVx = IdxStep; -using IDomainXVx = ddc::DiscreteDomain; -using IndexXVx = ddc::DiscreteElement; +using IdxRangeXVx = IdxRange; +using IdxXVx = Idx; // Chunks, Spans and Views template -using FieldX = device_t>; -using DFieldX = FieldX; +using FieldMemX = FieldMem; +using DFieldMemX = FieldMemX; template -using FieldVx = device_t>; +using FieldMemVx = FieldMem; template -using FieldXVx = device_t>; -using DFieldXVx = FieldXVx; +using FieldMemXVx = FieldMem; +using DFieldMemXVx = FieldMemXVx; template -using SpanX = device_t>; -using DSpanX = SpanX; +using FieldX = Field; +using DFieldX = FieldX; template -using SpanVx = device_t>; +using FieldVx = Field; template -using SpanXVx = device_t>; -using DSpanXVx = SpanXVx; +using FieldXVx = Field; +using DFieldXVx = FieldXVx; @@ -104,21 +104,21 @@ using SplineXBuilder = ddc::SplineBuilder< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesX, - IDimX, + GridX, SplineXBoundary, SplineXBoundary, ddc::SplineSolver::LAPACK, - IDimX, - IDimVx>; + GridX, + GridVx>; using SplineXEvaluator = ddc::SplineEvaluator< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesX, - IDimX, - ddc::PeriodicExtrapolationRule, - ddc::PeriodicExtrapolationRule, - IDimX, - IDimVx>; + GridX, + ddc::PeriodicExtrapolationRule, + ddc::PeriodicExtrapolationRule, + GridX, + GridVx>; class XVxAdvection1DTest : public ::testing::Test @@ -126,20 +126,20 @@ class XVxAdvection1DTest : public ::testing::Test protected: static constexpr CoordX x_min = CoordX(-M_PI); static constexpr CoordX x_max = CoordX(M_PI); - static constexpr IVectX x_size = IVectX(100); + static constexpr IdxStepX x_size = IdxStepX(100); static constexpr CoordVx vx_min = CoordVx(-6); static constexpr CoordVx vx_max = CoordVx(6); - static constexpr IVectVx vx_size = IVectVx(50); + static constexpr IdxStepVx vx_size = IdxStepVx(50); - IDomainX const x_dom; - IDomainVx const vx_dom; - IDomainXVx const xvx_dom; + IdxRangeX const x_dom; + IdxRangeVx const vx_dom; + IdxRangeXVx const xvx_dom; public: XVxAdvection1DTest() - : x_dom(SplineInterpPointsX::get_domain()) - , vx_dom(SplineInterpPointsVx::get_domain()) + : x_dom(SplineInterpPointsX::get_domain()) + , vx_dom(SplineInterpPointsVx::get_domain()) , xvx_dom(x_dom, vx_dom) {}; ~XVxAdvection1DTest() = default; @@ -150,8 +150,8 @@ class XVxAdvection1DTest : public ::testing::Test ddc::init_discrete_space(x_min, x_max, x_size); ddc::init_discrete_space(vx_min, vx_max, vx_size); - ddc::init_discrete_space(SplineInterpPointsX::get_sampling()); - ddc::init_discrete_space(SplineInterpPointsVx::get_sampling()); + ddc::init_discrete_space(SplineInterpPointsX::get_sampling()); + ddc::init_discrete_space(SplineInterpPointsVx::get_sampling()); } template @@ -163,32 +163,32 @@ class XVxAdvection1DTest : public ::testing::Test int const time_iter = int(final_t / dt); // INITIALISATION ---------------------------------------------------------------------------- - DFieldXVx function_alloc(xvx_dom); - DSpanXVx function = function_alloc.span_view(); + DFieldMemXVx function_alloc(xvx_dom); + DFieldXVx function = get_field(function_alloc); - DFieldXVx advection_field_alloc(xvx_dom); - DSpanXVx advection_field = advection_field_alloc.span_view(); + DFieldMemXVx advection_field_alloc(xvx_dom); + DFieldXVx advection_field = get_field(advection_field_alloc); ddc::parallel_for_each( Kokkos::DefaultExecutionSpace(), xvx_dom, - KOKKOS_LAMBDA(IndexXVx const xv_idx) { - double const x = ddc::coordinate(IndexX(xv_idx)); + KOKKOS_LAMBDA(IdxXVx const xv_idx) { + double const x = ddc::coordinate(IdxX(xv_idx)); function(xv_idx) = Kokkos::cos(x); - double const v = ddc::coordinate(IndexVx(xv_idx)); + double const v = ddc::coordinate(IdxVx(xv_idx)); advection_field(xv_idx) = v; }); // EXACT ADVECTED FUNCTION ------------------------------------------------------------------- - host_t exact_function(xvx_dom); - ddc::for_each(xvx_dom, [&](IndexXVx const xv_idx) { - double const x0 = ddc::coordinate(IndexX(xv_idx)); - double const v = ddc::coordinate(IndexVx(xv_idx)); + host_t exact_function(xvx_dom); + ddc::for_each(xvx_dom, [&](IdxXVx const xv_idx) { + double const x0 = ddc::coordinate(IdxX(xv_idx)); + double const v = ddc::coordinate(IdxVx(xv_idx)); double x = x0 - final_t * v; - // Replace inside the domain the feet if the dimension if periodic - if (RDimX::PERIODIC) { + // Replace inside the index range the feet if the dimension if periodic + if (X::PERIODIC) { x = fmod(x - double(x_min), double(x_max - x_min)) + double(x_min); x = x > double(x_min) ? x : x + double(x_max - x_min); } @@ -207,7 +207,7 @@ class XVxAdvection1DTest : public ::testing::Test */ auto function_host = ddc::create_mirror_view_and_copy(function); double max_relative_error = 0; - ddc::for_each(xvx_dom, [&](IndexXVx const xv_idx) { + ddc::for_each(xvx_dom, [&](IdxXVx const xv_idx) { double const relative_error = abs(function_host(xv_idx) - exact_function(xv_idx)); EXPECT_LE(relative_error, 5.e-7); max_relative_error @@ -227,20 +227,20 @@ TEST_F(XVxAdvection1DTest, AdvectionXVx) // CREATING OPERATORS ------------------------------------------------------------------------ SplineXBuilder const builder_x(xvx_dom); - ddc::PeriodicExtrapolationRule bv_x_min; - ddc::PeriodicExtrapolationRule bv_x_max; + ddc::PeriodicExtrapolationRule bv_x_min; + ddc::PeriodicExtrapolationRule bv_x_max; SplineXEvaluator const spline_evaluator_x(bv_x_min, bv_x_max); PreallocatableSplineInterpolator const spline_interpolator_x(builder_x, spline_evaluator_x); - RK2, DFieldXVx> time_stepper(xvx_dom); + RK2, DFieldMemXVx> time_stepper(xvx_dom); BslAdvection1D< - IDimX, - IDomainXVx, - IDomainXVx, + GridX, + IdxRangeXVx, + IdxRangeXVx, SplineXBuilder, SplineXEvaluator, - RK2, DFieldXVx>> const + RK2, DFieldMemXVx>> const advection(spline_interpolator_x, builder_x, spline_evaluator_x, time_stepper); double const max_relative_error = AdvectionXVx(advection); diff --git a/tests/advection/1d_advection_xyvxvy.cpp b/tests/advection/1d_advection_xyvxvy.cpp index 2660bdcc3..01c5f0b3f 100644 --- a/tests/advection/1d_advection_xyvxvy.cpp +++ b/tests/advection/1d_advection_xyvxvy.cpp @@ -17,42 +17,42 @@ namespace { // Continuous dimensions /// @brief A class which describes the real space in the first spatial direction X. -struct RDimX +struct X { /// @brief A boolean indicating if the dimension is periodic. static bool constexpr PERIODIC = true; }; /// @brief A class which describes the real space in the second spatial direction Y. -struct RDimY +struct Y { /// @brief A boolean indicating if the dimension is periodic. static bool constexpr PERIODIC = true; }; /// @brief A class which describes the real space in the second velocity direction X. -struct RDimVx +struct Vx { }; /// @brief A class which describes the real space in the second velocity direction Y. -struct RDimVy +struct Vy { }; -using CoordX = ddc::Coordinate; -using CoordY = ddc::Coordinate; -using CoordXY = ddc::Coordinate; +using CoordX = Coord; +using CoordY = Coord; +using CoordXY = Coord; -using CoordVx = ddc::Coordinate; -using CoordVy = ddc::Coordinate; +using CoordVx = Coord; +using CoordVy = Coord; // Splines -struct BSplinesX : ddc::UniformBSplines +struct BSplinesX : ddc::UniformBSplines { }; -struct BSplinesY : ddc::UniformBSplines +struct BSplinesY : ddc::UniformBSplines { }; @@ -60,16 +60,16 @@ ddc::BoundCond constexpr SplineXBoundary = ddc::BoundCond::PERIODIC; ddc::BoundCond constexpr SplineYBoundary = ddc::BoundCond::PERIODIC; // Discrete dimensions -struct IDimX : ddc::UniformPointSampling +struct GridX : UniformGridBase { }; -struct IDimY : ddc::UniformPointSampling +struct GridY : UniformGridBase { }; -struct IDimVx : ddc::UniformPointSampling +struct GridVx : UniformGridBase { }; -struct IDimVy : ddc::UniformPointSampling +struct GridVy : UniformGridBase { }; @@ -80,44 +80,44 @@ using SplineInterpPointsY = ddc::GrevilleInterpolationPoints; -using IndexXY = ddc::DiscreteElement; -using IndexVx = ddc::DiscreteElement; -using IndexVy = ddc::DiscreteElement; -using IndexXYVxVy = ddc::DiscreteElement; +using IdxXY = Idx; +using IdxVx = Idx; +using IdxVy = Idx; +using IdxXYVxVy = Idx; -using IVectX = ddc::DiscreteVector; -using IVectY = ddc::DiscreteVector; -using IVectVx = ddc::DiscreteVector; -using IVectVy = ddc::DiscreteVector; +using IdxStepX = IdxStep; +using IdxStepY = IdxStep; +using IdxStepVx = IdxStep; +using IdxStepVy = IdxStep; -using IDomainX = ddc::DiscreteDomain; -using IDomainY = ddc::DiscreteDomain; -using IDomainXY = ddc::DiscreteDomain; -using IDomainVx = ddc::DiscreteDomain; -using IDomainVy = ddc::DiscreteDomain; -using IDomainXYVxVy = ddc::DiscreteDomain; +using IdxRangeX = IdxRange; +using IdxRangeY = IdxRange; +using IdxRangeXY = IdxRange; +using IdxRangeVx = IdxRange; +using IdxRangeVy = IdxRange; +using IdxRangeXYVxVy = IdxRange; // Chunks, Spans and Views template -using FieldXY = device_t>; -using DFieldXY = FieldXY; +using FieldMemXY = FieldMem; +using DFieldMemXY = FieldMemXY; template -using FieldXYVxVy = device_t>; -using DFieldXYVxVy = FieldXYVxVy; +using FieldMemXYVxVy = FieldMem; +using DFieldMemXYVxVy = FieldMemXYVxVy; template -using SpanXY = device_t>; -using DSpanXY = SpanXY; +using FieldXY = Field; +using DFieldXY = FieldXY; template -using SpanXYVxVy = device_t>; -using DSpanXYVxVy = SpanXYVxVy; +using FieldXYVxVy = Field; +using DFieldXYVxVy = FieldXYVxVy; // Operators @@ -125,90 +125,90 @@ using SplineXBuilder_2d = ddc::SplineBuilder< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesX, - IDimX, + GridX, SplineXBoundary, SplineXBoundary, ddc::SplineSolver::LAPACK, - IDimX, - IDimY>; + GridX, + GridY>; using SplineXEvaluator_2d = ddc::SplineEvaluator< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesX, - IDimX, - ddc::PeriodicExtrapolationRule, - ddc::PeriodicExtrapolationRule, - IDimX, - IDimY>; + GridX, + ddc::PeriodicExtrapolationRule, + ddc::PeriodicExtrapolationRule, + GridX, + GridY>; using SplineYBuilder_2d = ddc::SplineBuilder< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesY, - IDimY, + GridY, SplineYBoundary, SplineYBoundary, ddc::SplineSolver::LAPACK, - IDimX, - IDimY>; + GridX, + GridY>; using SplineYEvaluator_2d = ddc::SplineEvaluator< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesY, - IDimY, - ddc::PeriodicExtrapolationRule, - ddc::PeriodicExtrapolationRule, - IDimX, - IDimY>; + GridY, + ddc::PeriodicExtrapolationRule, + ddc::PeriodicExtrapolationRule, + GridX, + GridY>; using SplineXBuilder_4d = ddc::SplineBuilder< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesX, - IDimX, + GridX, SplineXBoundary, SplineXBoundary, ddc::SplineSolver::LAPACK, - IDimX, - IDimY, - IDimVx, - IDimVy>; + GridX, + GridY, + GridVx, + GridVy>; using SplineXEvaluator_4d = ddc::SplineEvaluator< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesX, - IDimX, - ddc::PeriodicExtrapolationRule, - ddc::PeriodicExtrapolationRule, - IDimX, - IDimY, - IDimVx, - IDimVy>; + GridX, + ddc::PeriodicExtrapolationRule, + ddc::PeriodicExtrapolationRule, + GridX, + GridY, + GridVx, + GridVy>; using SplineYBuilder_4d = ddc::SplineBuilder< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesY, - IDimY, + GridY, SplineYBoundary, SplineYBoundary, ddc::SplineSolver::LAPACK, - IDimX, - IDimY, - IDimVx, - IDimVy>; + GridX, + GridY, + GridVx, + GridVy>; using SplineYEvaluator_4d = ddc::SplineEvaluator< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesY, - IDimY, - ddc::PeriodicExtrapolationRule, - ddc::PeriodicExtrapolationRule, - IDimX, - IDimY, - IDimVx, - IDimVy>; + GridY, + ddc::PeriodicExtrapolationRule, + ddc::PeriodicExtrapolationRule, + GridX, + GridY, + GridVx, + GridVy>; @@ -217,35 +217,39 @@ class XYVxVyAdvection1DTest : public ::testing::Test protected: static constexpr CoordX x_min = CoordX(-.5); static constexpr CoordX x_max = CoordX(.5); - static constexpr IVectX x_size = IVectX(60); + static constexpr IdxStepX x_size = IdxStepX(60); static constexpr CoordY y_min = CoordY(-.5); static constexpr CoordY y_max = CoordY(.5); - static constexpr IVectY y_size = IVectY(60); + static constexpr IdxStepY y_size = IdxStepY(60); - static constexpr IndexVx idx0_vx = IndexVx(0); - static constexpr IVectVx vx_size = IVectVx(2); + static constexpr IdxVx idx0_vx = IdxVx(0); + static constexpr IdxStepVx vx_size = IdxStepVx(2); - static constexpr IndexVy idx0_vy = IndexVy(0); - static constexpr IVectVy vy_size = IVectVy(2); + static constexpr IdxVy idx0_vy = IdxVy(0); + static constexpr IdxStepVy vy_size = IdxStepVy(2); - IDomainX const interpolation_domain_x; - IDomainY const interpolation_domain_y; - IDomainXY const xy_grid; + IdxRangeX const interpolation_idx_range_x; + IdxRangeY const interpolation_idx_range_y; + IdxRangeXY const xy_grid; - IDomainVx const domain_vx; - IDomainVy const domain_vy; - IDomainXYVxVy const xyvxvy_grid; + IdxRangeVx const idx_range_vx; + IdxRangeVy const idx_range_vy; + IdxRangeXYVxVy const xyvxvy_grid; public: XYVxVyAdvection1DTest() - : interpolation_domain_x(SplineInterpPointsX::get_domain()) - , interpolation_domain_y(SplineInterpPointsY::get_domain()) - , xy_grid(interpolation_domain_x, interpolation_domain_y) - , domain_vx(idx0_vx, vx_size) - , domain_vy(idx0_vy, vy_size) - , xyvxvy_grid(interpolation_domain_x, interpolation_domain_y, domain_vx, domain_vy) {}; + : interpolation_idx_range_x(SplineInterpPointsX::get_domain()) + , interpolation_idx_range_y(SplineInterpPointsY::get_domain()) + , xy_grid(interpolation_idx_range_x, interpolation_idx_range_y) + , idx_range_vx(idx0_vx, vx_size) + , idx_range_vy(idx0_vy, vy_size) + , xyvxvy_grid( + interpolation_idx_range_x, + interpolation_idx_range_y, + idx_range_vx, + idx_range_vy) {}; ~XYVxVyAdvection1DTest() = default; @@ -255,8 +259,8 @@ class XYVxVyAdvection1DTest : public ::testing::Test ddc::init_discrete_space(x_min, x_max, x_size); ddc::init_discrete_space(y_min, y_max, y_size); - ddc::init_discrete_space(SplineInterpPointsX::get_sampling()); - ddc::init_discrete_space(SplineInterpPointsY::get_sampling()); + ddc::init_discrete_space(SplineInterpPointsX::get_sampling()); + ddc::init_discrete_space(SplineInterpPointsY::get_sampling()); } template @@ -273,12 +277,12 @@ class XYVxVyAdvection1DTest : public ::testing::Test double const yc = 0.2; double const a = 0.5; - DFieldXYVxVy function_alloc(xyvxvy_grid); - DSpanXYVxVy function = function_alloc.span_view(); + DFieldMemXYVxVy function_alloc(xyvxvy_grid); + DFieldXYVxVy function = get_field(function_alloc); ddc::parallel_for_each( Kokkos::DefaultExecutionSpace(), xyvxvy_grid, - KOKKOS_LAMBDA(IndexXYVxVy const idx) { + KOKKOS_LAMBDA(IdxXYVxVy const idx) { CoordXY coord_xy = CoordXY(ddc::coordinate(idx)); double const x = CoordX(coord_xy); double const y = CoordY(coord_xy); @@ -295,18 +299,18 @@ class XYVxVyAdvection1DTest : public ::testing::Test /* The advection field is a Chunk of double instead of a Chunk of coordinates, because inside the advection operator - we use an interpolator which needs the DFieldXY format. + we use an interpolator which needs the DFieldMemXY format. */ - DFieldXY advection_field_x_alloc(xy_grid); - DSpanXY advection_field_x = advection_field_x_alloc.span_view(); + DFieldMemXY advection_field_x_alloc(xy_grid); + DFieldXY advection_field_x = get_field(advection_field_x_alloc); - DFieldXY advection_field_y_alloc(xy_grid); - DSpanXY advection_field_y = advection_field_y_alloc.span_view(); + DFieldMemXY advection_field_y_alloc(xy_grid); + DFieldXY advection_field_y = get_field(advection_field_y_alloc); ddc::parallel_for_each( Kokkos::DefaultExecutionSpace(), xy_grid, - KOKKOS_LAMBDA(IndexXY const idx) { + KOKKOS_LAMBDA(IdxXY const idx) { CoordXY coord_xy(ddc::coordinate(idx)); double const x = CoordX(coord_xy); advection_field_x(idx) = Kokkos::sin(x * 2 * M_PI) / M_PI / 2.; @@ -317,8 +321,8 @@ class XYVxVyAdvection1DTest : public ::testing::Test // EXACT ADVECTED FUNCTION ------------------------------------------------------------------- - host_t exact_function(xyvxvy_grid); - ddc::for_each(xyvxvy_grid, [&](IndexXYVxVy const idx) { + host_t exact_function(xyvxvy_grid); + ddc::for_each(xyvxvy_grid, [&](IdxXYVxVy const idx) { CoordXY coord_xy = CoordXY(ddc::coordinate(idx)); double const x0 = CoordX(coord_xy); double const y0 = CoordY(coord_xy); @@ -326,12 +330,12 @@ class XYVxVyAdvection1DTest : public ::testing::Test double x = 2 * std::atan(std::tan(x0 * M_PI) * std::exp(-final_t)) / M_PI / 2.; double y = 2 * std::atan(std::tan(y0 * M_PI) * std::exp(-final_t)) / M_PI / 2.; - // Replace inside the domain the feet if the dimension if periodic - if (RDimX::PERIODIC) { + // Replace inside the index range the feet if the dimension if periodic + if (X::PERIODIC) { x = fmod(x - double(x_min), double(x_max - x_min)) + double(x_min); x = x > double(x_min) ? x : x + double(x_max - x_min); } - if (RDimY::PERIODIC) { + if (Y::PERIODIC) { y = fmod(y - double(y_min), double(y_max - y_min)) + double(y_min); y = y > double(y_min) ? y : y + double(y_max - y_min); } @@ -358,7 +362,7 @@ class XYVxVyAdvection1DTest : public ::testing::Test */ auto function_host = ddc::create_mirror_view_and_copy(function); double max_relative_error = 0; - ddc::for_each(xyvxvy_grid, [&](IndexXYVxVy const idx) { + ddc::for_each(xyvxvy_grid, [&](IdxXYVxVy const idx) { double const relative_error = abs(function_host(idx) - exact_function(idx)); max_relative_error = max_relative_error > relative_error ? max_relative_error : relative_error; @@ -380,13 +384,13 @@ TEST_F(XYVxVyAdvection1DTest, AdvectionXY) SplineYBuilder_4d const function_builder_y(xyvxvy_grid); - ddc::PeriodicExtrapolationRule bv_x_min; - ddc::PeriodicExtrapolationRule bv_x_max; + ddc::PeriodicExtrapolationRule bv_x_min; + ddc::PeriodicExtrapolationRule bv_x_max; SplineXEvaluator_2d const adv_field_spline_evaluator_x(bv_x_min, bv_x_max); SplineXEvaluator_4d const function_spline_evaluator_x(bv_x_min, bv_x_max); - ddc::PeriodicExtrapolationRule bv_y_min; - ddc::PeriodicExtrapolationRule bv_y_max; + ddc::PeriodicExtrapolationRule bv_y_min; + ddc::PeriodicExtrapolationRule bv_y_max; SplineYEvaluator_2d const adv_field_spline_evaluator_y(bv_y_min, bv_y_max); SplineYEvaluator_4d const function_spline_evaluator_y(bv_y_min, bv_y_max); @@ -397,28 +401,28 @@ TEST_F(XYVxVyAdvection1DTest, AdvectionXY) function_spline_y_interpolator(function_builder_y, function_spline_evaluator_y); - RK2, DFieldXY> time_stepper_x(xy_grid); - RK2, DFieldXY> time_stepper_y(xy_grid); + RK2, DFieldMemXY> time_stepper_x(xy_grid); + RK2, DFieldMemXY> time_stepper_y(xy_grid); BslAdvection1D< - IDimX, - IDomainXY, - IDomainXYVxVy, + GridX, + IdxRangeXY, + IdxRangeXYVxVy, SplineXBuilder_2d, SplineXEvaluator_2d, - RK2, DFieldXY>> const + RK2, DFieldMemXY>> const advection_x( function_spline_x_interpolator, adv_field_builder_x, adv_field_spline_evaluator_x, time_stepper_x); BslAdvection1D< - IDimY, - IDomainXY, - IDomainXYVxVy, + GridY, + IdxRangeXY, + IdxRangeXYVxVy, SplineYBuilder_2d, SplineYEvaluator_2d, - RK2, DFieldXY>> const + RK2, DFieldMemXY>> const advection_y( function_spline_y_interpolator, adv_field_builder_y, diff --git a/tests/advection/spatial_advection_1d.cpp b/tests/advection/spatial_advection_1d.cpp index 9ffb28e1e..d9e3fe550 100644 --- a/tests/advection/spatial_advection_1d.cpp +++ b/tests/advection/spatial_advection_1d.cpp @@ -16,13 +16,13 @@ namespace { // Continuous dimensions /// @brief A class which describes the real space in the first spatial direction X. -struct RDimX +struct X { /// @brief A boolean indicating if the dimension is periodic. static bool constexpr PERIODIC = true; }; /// @brief A class which describes the real space in the first velocity direction Vx. -struct RDimVx +struct Vx { /// @brief A boolean indicating if the dimension is periodic. static bool constexpr PERIODIC = false; @@ -30,14 +30,14 @@ struct RDimVx -using CoordX = ddc::Coordinate; -using CoordVx = ddc::Coordinate; +using CoordX = Coord; +using CoordVx = Coord; // Splines -struct BSplinesX : ddc::UniformBSplines +struct BSplinesX : ddc::UniformBSplines { }; -struct BSplinesVx : ddc::UniformBSplines +struct BSplinesVx : ddc::UniformBSplines { }; @@ -46,10 +46,10 @@ ddc::BoundCond constexpr SplineVxBoundary = ddc::BoundCond::HERMITE; // Discrete dimensions -struct IDimX : ddc::UniformPointSampling +struct GridX : UniformGridBase { }; -struct IDimVx : ddc::UniformPointSampling +struct GridVx : UniformGridBase { }; @@ -60,46 +60,46 @@ using SplineInterpPointsVx = ddc::GrevilleInterpolationPoints; -using IDomainX = ddc::DiscreteDomain; -using IndexX = ddc::DiscreteElement; -using IVectX = ddc::DiscreteVector; +using IdxRangeX = IdxRange; +using IdxX = Idx; +using IdxStepX = IdxStep; -using IDomainVx = ddc::DiscreteDomain; -using IndexVx = ddc::DiscreteElement; -using IVectVx = ddc::DiscreteVector; +using IdxRangeVx = IdxRange; +using IdxVx = Idx; +using IdxStepVx = IdxStep; -using IDomainXVx = ddc::DiscreteDomain; +using IdxRangeXVx = IdxRange; -using IdxRangeSp = ddc::DiscreteDomain; -using IdxSp = ddc::DiscreteElement; -using IdxStepSp = ddc::DiscreteVector; +using IdxRangeSp = IdxRange; +using IdxSp = Idx; +using IdxStepSp = IdxStep; -using IDomainSpXVx = ddc::DiscreteDomain; -using IndexSpXVx = ddc::DiscreteElement; +using IdxRangeSpXVx = IdxRange; +using IdxSpXVx = Idx; // Chunks, Spans and Views template -using FieldMemSp = device_t>; +using FieldMemSp = FieldMem; using DFieldMemSp = DFieldMemSp; template -using FieldSpXVx = device_t>; -using DFieldSpXVx = FieldSpXVx; +using FieldMemSpXVx = FieldMem; +using DFieldMemSpXVx = FieldMemSpXVx; template -using FieldSp = device_t>; +using FieldSp = Field; using DFieldSp = FieldSp; template -using SpanSpXVx = device_t>; -using DSpanSpXVx = SpanSpXVx; +using FieldSpXVx = Field; +using DFieldSpXVx = FieldSpXVx; template -using FieldXVx = device_t>; +using FieldMemXVx = FieldMem; template -using SpanXVx = device_t>; +using FieldXVx = Field; @@ -108,38 +108,38 @@ using SplineXBuilder = ddc::SplineBuilder< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesX, - IDimX, + GridX, SplineXBoundary, SplineXBoundary, ddc::SplineSolver::LAPACK, Species, - IDimX, - IDimVx>; + GridX, + GridVx>; using SplineXEvaluator = ddc::SplineEvaluator< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesX, - IDimX, - ddc::PeriodicExtrapolationRule, - ddc::PeriodicExtrapolationRule, + GridX, + ddc::PeriodicExtrapolationRule, + ddc::PeriodicExtrapolationRule, Species, - IDimX, - IDimVx>; + GridX, + GridVx>; class Spatial1DAdvectionTest : public ::testing::Test { protected: - IDomainX const x_dom; - IDomainVx const vx_dom; + IdxRangeX const x_dom; + IdxRangeVx const vx_dom; IdxRangeSp const dom_allsp; static constexpr IdxStepSp nb_species = IdxStepSp(2); public: Spatial1DAdvectionTest() - : x_dom(SplineInterpPointsX::get_domain()) - , vx_dom(SplineInterpPointsVx::get_domain()) + : x_dom(SplineInterpPointsX::get_domain()) + , vx_dom(SplineInterpPointsVx::get_domain()) , dom_allsp(IdxSp(0), nb_species) {}; ~Spatial1DAdvectionTest() = default; @@ -149,24 +149,24 @@ class Spatial1DAdvectionTest : public ::testing::Test { CoordX const x_min(-M_PI); CoordX const x_max(M_PI); - IVectX const x_size(100); + IdxStepX const x_size(100); CoordVx const vx_min(-6); CoordVx const vx_max(6); - IVectVx const vx_size(50); + IdxStepVx const vx_size(50); ddc::init_discrete_space(x_min, x_max, x_size); ddc::init_discrete_space(vx_min, vx_max, vx_size); - ddc::init_discrete_space(SplineInterpPointsX::get_sampling()); - ddc::init_discrete_space(SplineInterpPointsVx::get_sampling()); + ddc::init_discrete_space(SplineInterpPointsX::get_sampling()); + ddc::init_discrete_space(SplineInterpPointsVx::get_sampling()); } template double SpatialAdvection(AdvectionOperator const& advection_x) { // Mesh ---------------------------------------------------------------------------------- - IDomainSpXVx const meshSpXVx(dom_allsp, x_dom, vx_dom); + IdxRangeSpXVx const meshSpXVx(dom_allsp, x_dom, vx_dom); IdxSp const i_elec = dom_allsp.front(); IdxSp const i_ion = dom_allsp.back(); @@ -177,25 +177,25 @@ class Spatial1DAdvectionTest : public ::testing::Test masses_host(i_elec) = 1; masses_host(i_ion) = 1; auto masses_alloc = ddc:: - create_mirror_and_copy(Kokkos::DefaultExecutionSpace(), masses_host.span_view()); - ddc::ChunkSpan masses = masses_alloc.span_view(); + create_mirror_and_copy(Kokkos::DefaultExecutionSpace(), get_field(masses_host)); + ddc::ChunkSpan masses = get_field(masses_alloc); // Initialization of the distribution function and advection field - DFieldSpXVx allfdistribu_alloc(meshSpXVx); - DSpanSpXVx allfdistribu = allfdistribu_alloc.span_view(); + DFieldMemSpXVx allfdistribu_alloc(meshSpXVx); + DFieldSpXVx allfdistribu = get_field(allfdistribu_alloc); - DFieldSpXVx advection_field_alloc(meshSpXVx); - DSpanSpXVx advection_field = advection_field_alloc.span_view(); + DFieldMemSpXVx advection_field_alloc(meshSpXVx); + DFieldSpXVx advection_field = get_field(advection_field_alloc); ddc::parallel_for_each( Kokkos::DefaultExecutionSpace(), meshSpXVx, - KOKKOS_LAMBDA(IndexSpXVx const ispxvx) { - IndexX const ix(ispxvx); + KOKKOS_LAMBDA(IdxSpXVx const ispxvx) { + IdxX const ix(ispxvx); allfdistribu(ispxvx) = Kokkos::cos(ddc::coordinate(ix)); - IndexVx const ivx(ispxvx); + IdxVx const ivx(ispxvx); IdxSp const isp(ispxvx); advection_field(ispxvx) = -Kokkos::sqrt(masses(i_elec) / masses(isp)) * ddc::coordinate(ivx); @@ -213,9 +213,9 @@ class Spatial1DAdvectionTest : public ::testing::Test meshSpXVx, 0.0, ddc::reducer::max(), - KOKKOS_LAMBDA(IndexSpXVx const ispxvx) { - IndexX const ix(ispxvx); - IndexVx const ivx(ispxvx); + KOKKOS_LAMBDA(IdxSpXVx const ispxvx) { + IdxX const ix(ispxvx); + IdxVx const ivx(ispxvx); return Kokkos::abs( allfdistribu(ispxvx) - Kokkos::cos( @@ -230,27 +230,27 @@ class Spatial1DAdvectionTest : public ::testing::Test TEST_F(Spatial1DAdvectionTest, SpatialAdvection) { - IDomainSpXVx meshSpXVx(dom_allsp, x_dom, vx_dom); + IdxRangeSpXVx meshSpXVx(dom_allsp, x_dom, vx_dom); SplineXBuilder const builder_x(meshSpXVx); - ddc::PeriodicExtrapolationRule bv_x_min; - ddc::PeriodicExtrapolationRule bv_x_max; + ddc::PeriodicExtrapolationRule bv_x_min; + ddc::PeriodicExtrapolationRule bv_x_max; SplineXEvaluator const spline_x_evaluator(bv_x_min, bv_x_max); PreallocatableSplineInterpolator const spline_x_interpolator(builder_x, spline_x_evaluator); - Euler, DFieldSpXVx> euler(meshSpXVx); + Euler, DFieldMemSpXVx> euler(meshSpXVx); BslAdvection1D< - IDimX, - IDomainSpXVx, - IDomainSpXVx, + GridX, + IdxRangeSpXVx, + IdxRangeSpXVx, SplineXBuilder, SplineXEvaluator, - Euler, DFieldSpXVx>> const + Euler, DFieldMemSpXVx>> const spline_advection_x(spline_x_interpolator, builder_x, spline_x_evaluator, euler); double const err = SpatialAdvection(spline_advection_x); EXPECT_LE(err, 1.e-6); std::cout << "Max absolute difference to the exact function: " << err << std::endl; -} \ No newline at end of file +} diff --git a/tests/advection/velocity_advection_1d.cpp b/tests/advection/velocity_advection_1d.cpp index f4b2a276e..8c74fff62 100644 --- a/tests/advection/velocity_advection_1d.cpp +++ b/tests/advection/velocity_advection_1d.cpp @@ -17,13 +17,13 @@ namespace { // Continuous dimensions /// @brief A class which describes the real space in the first spatial direction X. -struct RDimX +struct X { /// @brief A boolean indicating if the dimension is periodic. static bool constexpr PERIODIC = true; }; /// @brief A class which describes the real space in the first velocity direction Vx. -struct RDimVx +struct Vx { /// @brief A boolean indicating if the dimension is periodic. static bool constexpr PERIODIC = false; @@ -31,14 +31,14 @@ struct RDimVx -using CoordX = ddc::Coordinate; -using CoordVx = ddc::Coordinate; +using CoordX = Coord; +using CoordVx = Coord; // Splines -struct BSplinesX : ddc::UniformBSplines +struct BSplinesX : ddc::UniformBSplines { }; -struct BSplinesVx : ddc::UniformBSplines +struct BSplinesVx : ddc::UniformBSplines { }; @@ -47,10 +47,10 @@ ddc::BoundCond constexpr SplineVxBoundary = ddc::BoundCond::HERMITE; // Discrete dimensions -struct IDimX : ddc::UniformPointSampling +struct GridX : UniformGridBase { }; -struct IDimVx : ddc::UniformPointSampling +struct GridVx : UniformGridBase { }; @@ -61,53 +61,53 @@ using SplineInterpPointsVx = ddc::GrevilleInterpolationPoints; -using IDomainX = ddc::DiscreteDomain; -using IndexX = ddc::DiscreteElement; -using IVectX = ddc::DiscreteVector; +using IdxRangeX = IdxRange; +using IdxX = Idx; +using IdxStepX = IdxStep; -using IDomainVx = ddc::DiscreteDomain; -using IndexVx = ddc::DiscreteElement; -using IVectVx = ddc::DiscreteVector; +using IdxRangeVx = IdxRange; +using IdxVx = Idx; +using IdxStepVx = IdxStep; -using IdxRangeSp = ddc::DiscreteDomain; -using IdxSp = ddc::DiscreteElement; -using IdxStepSp = ddc::DiscreteVector; +using IdxRangeSp = IdxRange; +using IdxSp = Idx; +using IdxStepSp = IdxStep; -using IDomainSpX = ddc::DiscreteDomain; -using IndexSpX = ddc::DiscreteElement; -using IVectSpX = ddc::DiscreteVector; +using IdxRangeSpX = IdxRange; +using IdxSpX = Idx; +using IdxStepSpX = IdxStep; -using IDomainSpXVx = ddc::DiscreteDomain; -using IndexSpXVx = ddc::DiscreteElement; +using IdxRangeSpXVx = IdxRange; +using IdxSpXVx = Idx; // Chunks, Spans and Views template -using FieldMemSp = device_t>; +using FieldMemSp = FieldMem; using DFieldMemSp = DFieldMemSp; template -using FieldSpXVx = device_t>; -using DFieldSpXVx = FieldSpXVx; +using FieldMemSpXVx = FieldMem; +using DFieldMemSpXVx = FieldMemSpXVx; template -using FieldSp = device_t>; +using FieldSp = Field; using DFieldSp = FieldSp; template -using SpanSpXVx = device_t>; -using DSpanSpXVx = SpanSpXVx; +using FieldSpXVx = Field; +using DFieldSpXVx = FieldSpXVx; // For the derivatives -using IDomainSpVDerivVx = ddc::DiscreteDomain>; +using IdxRangeSpVDerivVx = IdxRange>; template -using DerivFieldSpX = device_t>; -using DDerivFieldSpX = DerivFieldSpX; +using DerivFieldMemSpX = FieldMem; +using DDerivFieldMemSpX = DerivFieldMemSpX; template -using DerivSpanSpX = device_t>; -using DDerivSpanSpX = DerivSpanSpX; +using DerivFieldSpX = Field; +using DDerivFieldSpX = DerivFieldSpX; @@ -116,38 +116,38 @@ using SplineVxBuilder = ddc::SplineBuilder< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesVx, - IDimVx, + GridVx, SplineVxBoundary, SplineVxBoundary, ddc::SplineSolver::LAPACK, Species, - IDimX, - IDimVx>; + GridX, + GridVx>; using SplineVxEvaluator = ddc::SplineEvaluator< Kokkos::DefaultExecutionSpace, Kokkos::DefaultExecutionSpace::memory_space, BSplinesVx, - IDimVx, - ddc::ConstantExtrapolationRule, - ddc::ConstantExtrapolationRule, + GridVx, + ddc::ConstantExtrapolationRule, + ddc::ConstantExtrapolationRule, Species, - IDimX, - IDimVx>; + GridX, + GridVx>; class Velocity1DAdvectionTest : public ::testing::Test { protected: - IDomainX const x_dom; - IDomainVx const vx_dom; + IdxRangeX const x_dom; + IdxRangeVx const vx_dom; IdxRangeSp const dom_allsp; static constexpr IdxStepSp nb_species = IdxStepSp(2); public: Velocity1DAdvectionTest() - : x_dom(SplineInterpPointsX::get_domain()) - , vx_dom(SplineInterpPointsVx::get_domain()) + : x_dom(SplineInterpPointsX::get_domain()) + , vx_dom(SplineInterpPointsVx::get_domain()) , dom_allsp(IdxSp(0), nb_species) {}; ~Velocity1DAdvectionTest() = default; @@ -157,17 +157,17 @@ class Velocity1DAdvectionTest : public ::testing::Test { CoordX const x_min(0); CoordX const x_max(2 * M_PI); - IVectX const x_size(50); + IdxStepX const x_size(50); CoordVx const vx_min(-10); CoordVx const vx_max(10); - IVectVx const vx_size(100); + IdxStepVx const vx_size(100); ddc::init_discrete_space(x_min, x_max, x_size); ddc::init_discrete_space(vx_min, vx_max, vx_size); - ddc::init_discrete_space(SplineInterpPointsX::get_sampling()); - ddc::init_discrete_space(SplineInterpPointsVx::get_sampling()); + ddc::init_discrete_space(SplineInterpPointsX::get_sampling()); + ddc::init_discrete_space(SplineInterpPointsVx::get_sampling()); } template @@ -176,8 +176,8 @@ class Velocity1DAdvectionTest : public ::testing::Test SplineVxBuilder const& builder_vx) { // Mesh ---------------------------------------------------------------------------------- - IDomainSpXVx const meshSpXVx(dom_allsp, x_dom, vx_dom); - IDomainSpX const meshSpX(dom_allsp, x_dom); + IdxRangeSpXVx const meshSpXVx(dom_allsp, x_dom, vx_dom); + IdxRangeSpX const meshSpX(dom_allsp, x_dom); IdxSp const i_elec = dom_allsp.front(); IdxSp const i_ion = dom_allsp.back(); @@ -188,33 +188,33 @@ class Velocity1DAdvectionTest : public ::testing::Test charges_host(i_elec) = -1.; charges_host(i_ion) = 1.; auto charges_alloc = ddc:: - create_mirror_and_copy(Kokkos::DefaultExecutionSpace(), charges_host.span_view()); - ddc::ChunkSpan charges = charges_alloc.span_view(); + create_mirror_and_copy(Kokkos::DefaultExecutionSpace(), get_field(charges_host)); + ddc::ChunkSpan charges = get_field(charges_alloc); // Initialization of the masses host_t masses_host(dom_allsp); masses_host(i_elec) = 1.; masses_host(i_ion) = 1.; auto masses_alloc = ddc:: - create_mirror_and_copy(Kokkos::DefaultExecutionSpace(), masses_host.span_view()); - ddc::ChunkSpan masses = masses_alloc.span_view(); + create_mirror_and_copy(Kokkos::DefaultExecutionSpace(), get_field(masses_host)); + ddc::ChunkSpan masses = get_field(masses_alloc); // Initialization of the distribution function and advection field - DFieldSpXVx allfdistribu_alloc(meshSpXVx); - DSpanSpXVx allfdistribu = allfdistribu_alloc.span_view(); + DFieldMemSpXVx allfdistribu_alloc(meshSpXVx); + DFieldSpXVx allfdistribu = get_field(allfdistribu_alloc); - DFieldSpXVx advection_field_alloc(meshSpXVx); - DSpanSpXVx advection_field = advection_field_alloc.span_view(); + DFieldMemSpXVx advection_field_alloc(meshSpXVx); + DFieldSpXVx advection_field = get_field(advection_field_alloc); ddc::parallel_for_each( Kokkos::DefaultExecutionSpace(), meshSpXVx, - KOKKOS_LAMBDA(IndexSpXVx const ispxvx) { - double const v = ddc::coordinate(IndexVx(ispxvx)); + KOKKOS_LAMBDA(IdxSpXVx const ispxvx) { + double const v = ddc::coordinate(IdxVx(ispxvx)); allfdistribu(ispxvx) = Kokkos::exp(-0.5 * v * v); - IndexX const ix(ispxvx); + IdxX const ix(ispxvx); IdxSp const isp(ispxvx); double const electric_field = ddc::distance_at_right(ix); advection_field(ispxvx) = charges(isp) @@ -224,15 +224,15 @@ class Velocity1DAdvectionTest : public ::testing::Test // Initialization of the derivatives of the advection field - DDerivFieldSpX advection_field_derivatives_min_alloc( + DDerivFieldMemSpX advection_field_derivatives_min_alloc( builder_vx.batched_derivs_xmin_domain()); - DDerivSpanSpX advection_field_derivatives_min - = advection_field_derivatives_min_alloc.span_view(); + DDerivFieldSpX advection_field_derivatives_min + = get_field(advection_field_derivatives_min_alloc); - DDerivFieldSpX advection_field_derivatives_max_alloc( + DDerivFieldMemSpX advection_field_derivatives_max_alloc( builder_vx.batched_derivs_xmax_domain()); - DDerivSpanSpX advection_field_derivatives_max - = advection_field_derivatives_max_alloc.span_view(); + DDerivFieldSpX advection_field_derivatives_max + = get_field(advection_field_derivatives_max_alloc); ddc::parallel_fill(advection_field_derivatives_min_alloc, 1.); ddc::parallel_fill(advection_field_derivatives_max_alloc, 1.); @@ -245,8 +245,8 @@ class Velocity1DAdvectionTest : public ::testing::Test allfdistribu, advection_field, timestep, - advection_field_derivatives_min.span_cview(), - advection_field_derivatives_max.span_cview()); + get_const_field(advection_field_derivatives_min), + get_const_field(advection_field_derivatives_max)); double const max_advection_error = ddc::parallel_transform_reduce( @@ -254,10 +254,10 @@ class Velocity1DAdvectionTest : public ::testing::Test meshSpXVx, 0.0, ddc::reducer::max(), - KOKKOS_LAMBDA(IndexSpXVx const ispxvx) { - IndexX const ix(ispxvx); - IndexVx const ivx(ispxvx); - double const v = ddc::coordinate(IndexVx(ispxvx)); + KOKKOS_LAMBDA(IdxSpXVx const ispxvx) { + IdxX const ix(ispxvx); + IdxVx const ivx(ispxvx); + double const v = ddc::coordinate(IdxVx(ispxvx)); return Kokkos::abs( allfdistribu(ispxvx) - Kokkos::exp( @@ -274,39 +274,39 @@ class Velocity1DAdvectionTest : public ::testing::Test TEST_F(Velocity1DAdvectionTest, BatchedLagrange) { - IDomainSpXVx meshSpXVx(dom_allsp, x_dom, vx_dom); + IdxRangeSpXVx meshSpXVx(dom_allsp, x_dom, vx_dom); // Interpolator for the function - IVectVx static constexpr n_ghosts_vx {0}; + IdxStepVx static constexpr n_ghosts_vx {0}; - LagrangeInterpolator const + LagrangeInterpolator const lagrange_vx_non_preallocatable_interpolator(3, n_ghosts_vx); PreallocatableLagrangeInterpolator< - IDimVx, + GridVx, BCond::DIRICHLET, BCond::DIRICHLET, Species, - IDimX, - IDimVx> const lagrange_vx_interpolator(lagrange_vx_non_preallocatable_interpolator); + GridX, + GridVx> const lagrange_vx_interpolator(lagrange_vx_non_preallocatable_interpolator); // Interpolator of the advection field SplineVxBuilder const builder_vx(meshSpXVx); CoordVx const vx_min = ddc::coordinate(vx_dom.front()); CoordVx const vx_max = vx_min + ddcHelper::total_interval_length(vx_dom); - ddc::ConstantExtrapolationRule bv_v_min(vx_min); - ddc::ConstantExtrapolationRule bv_v_max(vx_max); + ddc::ConstantExtrapolationRule bv_v_min(vx_min); + ddc::ConstantExtrapolationRule bv_v_max(vx_max); SplineVxEvaluator const spline_vx_evaluator(bv_v_min, bv_v_max); - Euler, DFieldSpXVx> euler(meshSpXVx); + Euler, DFieldMemSpXVx> euler(meshSpXVx); BslAdvection1D< - IDimVx, - IDomainSpXVx, - IDomainSpXVx, + GridVx, + IdxRangeSpXVx, + IdxRangeSpXVx, SplineVxBuilder, SplineVxEvaluator, - Euler, DFieldSpXVx>> const + Euler, DFieldMemSpXVx>> const lagrange_advection_vx(lagrange_vx_interpolator, builder_vx, spline_vx_evaluator, euler); @@ -318,27 +318,27 @@ TEST_F(Velocity1DAdvectionTest, BatchedLagrange) TEST_F(Velocity1DAdvectionTest, SplineBatched) { - IDomainSpXVx meshSpXVx(dom_allsp, x_dom, vx_dom); + IdxRangeSpXVx meshSpXVx(dom_allsp, x_dom, vx_dom); SplineVxBuilder const builder_vx(meshSpXVx); CoordVx const vx_min = ddc::coordinate(vx_dom.front()); CoordVx const vx_max = vx_min + ddcHelper::total_interval_length(vx_dom); - ddc::ConstantExtrapolationRule bv_v_min(vx_min); - ddc::ConstantExtrapolationRule bv_v_max(vx_max); + ddc::ConstantExtrapolationRule bv_v_min(vx_min); + ddc::ConstantExtrapolationRule bv_v_max(vx_max); SplineVxEvaluator const spline_vx_evaluator(bv_v_min, bv_v_max); PreallocatableSplineInterpolator const spline_vx_interpolator(builder_vx, spline_vx_evaluator); - Euler, DFieldSpXVx> euler(meshSpXVx); + Euler, DFieldMemSpXVx> euler(meshSpXVx); BslAdvection1D< - IDimVx, - IDomainSpXVx, - IDomainSpXVx, + GridVx, + IdxRangeSpXVx, + IdxRangeSpXVx, SplineVxBuilder, SplineVxEvaluator, - Euler, DFieldSpXVx>> const + Euler, DFieldMemSpXVx>> const spline_advection_vx(spline_vx_interpolator, builder_vx, spline_vx_evaluator, euler);