DDC 0.6.0
Loading...
Searching...
No Matches
non_uniform_point_sampling.hpp
1// Copyright (C) The DDC development team, see COPYRIGHT.md file
2//
3// SPDX-License-Identifier: MIT
4
5#pragma once
6
7#include <algorithm>
8#include <cassert>
9#include <cstddef>
10#include <initializer_list>
11#include <ostream>
12#include <stdexcept>
13#include <tuple>
14#include <type_traits>
15#include <utility>
16#include <vector>
17
18#include <Kokkos_Core.hpp>
19
20#include "ddc/coordinate.hpp"
21#include "ddc/discrete_domain.hpp"
22#include "ddc/discrete_element.hpp"
23#include "ddc/discrete_space.hpp"
24#include "ddc/discrete_vector.hpp"
25
26namespace ddc {
27
28namespace detail {
29
30struct NonUniformPointSamplingBase
31{
32};
33
34} // namespace detail
35
36/// `NonUniformPointSampling` models a non-uniform discretization of the `CDim` segment \f$[a, b]\f$.
37template <class CDim>
38class NonUniformPointSampling : detail::NonUniformPointSamplingBase
39{
40public:
41 using continuous_dimension_type = CDim;
42
43 using discrete_dimension_type = NonUniformPointSampling;
44
45public:
46 template <class DDim, class MemorySpace>
47 class Impl
48 {
49 template <class ODDim, class OMemorySpace>
50 friend class Impl;
51
52 Kokkos::View<Coordinate<CDim>*, MemorySpace> m_points;
53
54 DiscreteElement<DDim> m_reference;
55
56 public:
57 using discrete_dimension_type = NonUniformPointSampling;
58
59 using discrete_domain_type = DiscreteDomain<DDim>;
60
61 using discrete_element_type = DiscreteElement<DDim>;
62
63 using discrete_vector_type = DiscreteVector<DDim>;
64
65 Impl() = default;
66
67 /// @brief Construct a `NonUniformPointSampling` using a brace-list, i.e. `NonUniformPointSampling mesh({0., 1.})`
68 Impl(std::initializer_list<Coordinate<CDim>> const points)
69 : Impl(points.begin(), points.end())
70 {
71 }
72
73 /// @brief Construct a `NonUniformPointSampling` using a C++20 "common range".
74 template <class InputRange>
75 explicit Impl(InputRange const& points) : Impl(points.begin(), points.end())
76 {
77 }
78
79 /// @brief Construct a `NonUniformPointSampling` using a pair of iterators.
80 template <class InputIt>
81 Impl(InputIt const points_begin, InputIt const points_end)
82 : m_reference(create_reference_discrete_element<DDim>())
83 {
84 using view_type = Kokkos::View<Coordinate<CDim>*, MemorySpace>;
85 if (!std::is_sorted(points_begin, points_end)) {
86 throw std::runtime_error("Input points must be sorted");
87 }
88 // Make a contiguous copy of [points_begin, points_end[
89 std::vector<Coordinate<CDim>> host_points(points_begin, points_end);
90 m_points = view_type("NonUniformPointSampling::points", host_points.size());
91 Kokkos::deep_copy(m_points, view_type(host_points.data(), host_points.size()));
92 }
93
94 template <class OriginMemorySpace>
95 explicit Impl(Impl<DDim, OriginMemorySpace> const& impl)
96 : m_points(Kokkos::create_mirror_view_and_copy(MemorySpace(), impl.m_points))
97 , m_reference(impl.m_reference)
98 {
99 }
100
101 Impl(Impl const& x) = delete;
102
103 Impl(Impl&& x) = default;
104
105 ~Impl() = default;
106
107 Impl& operator=(Impl const& x) = delete;
108
109 Impl& operator=(Impl&& x) = default;
110
111 KOKKOS_FUNCTION std::size_t size() const
112 {
113 return m_points.size();
114 }
115
116 /// @brief Lower bound index of the mesh
117 KOKKOS_FUNCTION discrete_element_type front() const noexcept
118 {
119 return m_reference;
120 }
121
122 /// @brief Convert a mesh index into a position in `CDim`
123 KOKKOS_FUNCTION Coordinate<CDim> coordinate(
124 discrete_element_type const& icoord) const noexcept
125 {
126 return m_points((icoord - front()).value());
127 }
128 };
129
130 /** Construct an Impl<Kokkos::HostSpace> and associated discrete_domain_type from a range
131 * containing the points coordinates along the `DDim` dimension.
132 *
133 * @param non_uniform_points a range (std::vector, std::array, ...) containing the coordinates of the points of the domain.
134 */
135 template <class DDim, class InputRange>
136 static std::tuple<typename DDim::template Impl<DDim, Kokkos::HostSpace>, DiscreteDomain<DDim>>
137 init(InputRange const& non_uniform_points)
138 {
139 assert(!non_uniform_points.empty());
140 DiscreteVector<DDim> const n(non_uniform_points.size());
141 typename DDim::template Impl<DDim, Kokkos::HostSpace> disc(non_uniform_points);
142 DiscreteDomain<DDim> domain(disc.front(), n);
143 return std::make_tuple(std::move(disc), std::move(domain));
144 }
145
146 /** Construct 4 non-uniform `DiscreteDomain` and an Impl<Kokkos::HostSpace> from 3 ranges containing the points coordinates along the `DDim` dimension.
147 *
148 * @param domain_r a range containing the coordinates of the points of the main domain along the DDim position
149 * @param pre_ghost_r a range containing the positions of the ghost points before the main domain the DDim position
150 * @param post_ghost_r a range containing the positions of the ghost points after the main domain the DDim position
151 */
152 template <class DDim, class InputRange>
153 static std::tuple<
154 typename DDim::template Impl<DDim, Kokkos::HostSpace>,
155 DiscreteDomain<DDim>,
156 DiscreteDomain<DDim>,
157 DiscreteDomain<DDim>,
158 DiscreteDomain<DDim>>
160 InputRange const& domain_r,
161 InputRange const& pre_ghost_r,
162 InputRange const& post_ghost_r)
163 {
164 assert(!domain_r.empty());
165
166 DiscreteVector<DDim> const n(domain_r.size());
167 DiscreteVector<DDim> const n_ghosts_before(pre_ghost_r.size());
168 DiscreteVector<DDim> const n_ghosts_after(post_ghost_r.size());
169
170 std::vector<typename InputRange::value_type> full_domain;
171
172 std::copy(pre_ghost_r.begin(), pre_ghost_r.end(), std::back_inserter(full_domain));
173 std::copy(domain_r.begin(), domain_r.end(), std::back_inserter(full_domain));
174 std::copy(post_ghost_r.begin(), post_ghost_r.end(), std::back_inserter(full_domain));
175
176 typename DDim::template Impl<DDim, Kokkos::HostSpace> disc(full_domain);
177
178 DiscreteDomain<DDim> ghosted_domain(disc.front(), n + n_ghosts_before + n_ghosts_after);
179 DiscreteDomain<DDim> pre_ghost = ghosted_domain.take_first(n_ghosts_before);
180 DiscreteDomain<DDim> main_domain = ghosted_domain.remove(n_ghosts_before, n_ghosts_after);
181 DiscreteDomain<DDim> post_ghost = ghosted_domain.take_last(n_ghosts_after);
182 return std::make_tuple(
183 std::move(disc),
184 std::move(main_domain),
185 std::move(ghosted_domain),
186 std::move(pre_ghost),
187 std::move(post_ghost));
188 }
189};
190
191template <class DDim>
193 : public std::is_base_of<detail::NonUniformPointSamplingBase, DDim>::type
194{
195};
196
197template <class DDim>
199
200template <
201 class DDimImpl,
202 std::enable_if_t<
203 is_non_uniform_point_sampling_v<typename DDimImpl::discrete_dimension_type>,
204 int>
205 = 0>
206std::ostream& operator<<(std::ostream& out, DDimImpl const& mesh)
207{
208 return out << "NonUniformPointSampling(" << mesh.size() << ")";
209}
210
211template <class DDim, std::enable_if_t<is_non_uniform_point_sampling_v<DDim>, int> = 0>
212KOKKOS_FUNCTION Coordinate<typename DDim::continuous_dimension_type> coordinate(
213 DiscreteElement<DDim> const& c)
214{
215 return discrete_space<DDim>().coordinate(c);
216}
217
218template <class DDim, std::enable_if_t<is_non_uniform_point_sampling_v<DDim>, int> = 0>
220 DiscreteElement<DDim> i)
221{
222 return coordinate(i) - coordinate(i - 1);
223}
224
225template <class DDim, std::enable_if_t<is_non_uniform_point_sampling_v<DDim>, int> = 0>
227 DiscreteElement<DDim> i)
228{
229 return coordinate(i + 1) - coordinate(i);
230}
231
232template <class DDim, std::enable_if_t<is_non_uniform_point_sampling_v<DDim>, int> = 0>
233KOKKOS_FUNCTION Coordinate<typename DDim::continuous_dimension_type> rmin(
234 DiscreteDomain<DDim> const& d)
235{
236 return coordinate(d.front());
237}
238
239template <class DDim, std::enable_if_t<is_non_uniform_point_sampling_v<DDim>, int> = 0>
240KOKKOS_FUNCTION Coordinate<typename DDim::continuous_dimension_type> rmax(
241 DiscreteDomain<DDim> const& d)
242{
243 return coordinate(d.back());
244}
245
246template <class DDim, std::enable_if_t<is_non_uniform_point_sampling_v<DDim>, int> = 0>
247KOKKOS_FUNCTION Coordinate<typename DDim::continuous_dimension_type> rlength(
248 DiscreteDomain<DDim> const& d)
249{
250 return rmax(d) - rmin(d);
251}
252
253} // namespace ddc
friend class DiscreteDomain
KOKKOS_FUNCTION constexpr bool operator!=(DiscreteVector< OTags... > const &rhs) const noexcept
KOKKOS_FUNCTION std::size_t size() const
KOKKOS_FUNCTION Coordinate< CDim > coordinate(discrete_element_type const &icoord) const noexcept
Convert a mesh index into a position in CDim
Impl(Impl< DDim, OriginMemorySpace > const &impl)
Impl & operator=(Impl &&x)=default
Impl & operator=(Impl const &x)=delete
Impl(InputIt const points_begin, InputIt const points_end)
Construct a NonUniformPointSampling using a pair of iterators.
KOKKOS_FUNCTION discrete_element_type front() const noexcept
Lower bound index of the mesh.
Impl(InputRange const &points)
Construct a NonUniformPointSampling using a C++20 "common range".
Impl(std::initializer_list< Coordinate< CDim > > const points)
Construct a NonUniformPointSampling using a brace-list, i.e. NonUniformPointSampling mesh({0....
NonUniformPointSampling models a non-uniform discretization of the CDim segment .
static std::tuple< typename DDim::template Impl< DDim, Kokkos::HostSpace >, DiscreteDomain< DDim > > init(InputRange const &non_uniform_points)
Construct an Impl<Kokkos::HostSpace> and associated discrete_domain_type from a range containing the ...
static std::tuple< typename DDim::template Impl< DDim, Kokkos::HostSpace >, DiscreteDomain< DDim >, DiscreteDomain< DDim >, DiscreteDomain< DDim >, DiscreteDomain< DDim > > init_ghosted(InputRange const &domain_r, InputRange const &pre_ghost_r, InputRange const &post_ghost_r)
Construct 4 non-uniform DiscreteDomain and an Impl<Kokkos::HostSpace> from 3 ranges containing the po...
The top-level namespace of DDC.
constexpr bool is_non_uniform_point_sampling_v
KOKKOS_FUNCTION Coordinate< typename DDim::continuous_dimension_type > rmax(DiscreteDomain< DDim > const &d)
KOKKOS_FUNCTION Coordinate< typename DDim::continuous_dimension_type > rlength(DiscreteDomain< DDim > const &d)
KOKKOS_FUNCTION Coordinate< typename DDim::continuous_dimension_type > distance_at_left(DiscreteElement< DDim > i)
KOKKOS_FUNCTION Coordinate< typename DDim::continuous_dimension_type > rmin(DiscreteDomain< DDim > const &d)
KOKKOS_FUNCTION Coordinate< typename DDim::continuous_dimension_type > coordinate(DiscreteElement< DDim > const &c)
KOKKOS_FUNCTION Coordinate< typename DDim::continuous_dimension_type > distance_at_right(DiscreteElement< DDim > i)