libMesh
Loading...
Searching...
No Matches
Classes | Functions | Variables
libMeshTest::KokkosVectorOracle Namespace Reference

Classes

struct  host_oracle
 
struct  vector_case
 

Functions

template<typename Vec >
LIBMESH_DEVICE_INLINE Vec make_vector (const Real x, const Real y=0, const Real z=0)
 
libMesh::TypeVector< Real > as_type_vector (const libMesh::TypeVector< Real > &v)
 
libMesh::TypeVector< Real > as_type_vector (const libMesh::VectorValue< Real > &v)
 
template<typename Vec >
host_oracle< Vec > build_host_oracle (const Vec &a, const Vec &b, const Vec &c)
 
template<typename StoragePolicy , typename Vec >
static int test_vector_ops_case (const vector_case &info)
 
template<typename StoragePolicy , typename Vec >
int run_vector_cases (const char *suite_name)
 
int test_vector_host_only_traits ()
 
template<typename StoragePolicy , typename Vec >
static int test_mixed_representation_ops ()
 
int run_all_oracles ()
 

Variables

static constexpr double tol = 2.0e-13
 
static constexpr double unit_tol = 1.0e-14
 
static constexpr Real golden_ratio = 1.6180339887498948482
 
static constexpr unsigned int solid_angle_results
 
static constexpr unsigned int vector_results
 
static constexpr unsigned int scalar_results = 12 + solid_angle_results
 
static const vector_case cases []
 

Function Documentation

◆ as_type_vector() [1/2]

libMesh::TypeVector< Real > libMeshTest::KokkosVectorOracle::as_type_vector ( const libMesh::TypeVector< Real > &  v)
inline

Definition at line 76 of file kokkos_vector_ops_oracle_fixtures.h.

77{
78 return v;
79}

Referenced by build_host_oracle(), and test_mixed_representation_ops().

◆ as_type_vector() [2/2]

libMesh::TypeVector< Real > libMeshTest::KokkosVectorOracle::as_type_vector ( const libMesh::VectorValue< Real > &  v)
inline

Definition at line 82 of file kokkos_vector_ops_oracle_fixtures.h.

83{
84 return make_vector<libMesh::TypeVector<Real>>(v(0)
85#if LIBMESH_DIM > 1
86 ,
87 v(1)
88#endif
89#if LIBMESH_DIM > 2
90 ,
91 v(2)
92#endif
93 );
94}

◆ build_host_oracle()

template<typename Vec >
host_oracle< Vec > libMeshTest::KokkosVectorOracle::build_host_oracle ( const Vec &  a,
const Vec &  b,
const Vec &  c 
)
inline

Definition at line 137 of file kokkos_vector_ops_oracle_fixtures.h.

138{
139 host_oracle<Vec> result;
140 result.vectors.reserve(vector_results);
141 result.scalars.reserve(scalar_results);
142
143 const auto copied = a;
144
145 Vec mix = a + b;
146 mix -= c;
147
148 Vec scaled = 1.25 * a;
149 scaled += (-0.5) * b;
150 scaled += (0.25) * c;
151
152 Vec plus_assign = a;
153 plus_assign += b;
154
155 Vec minus_assign = a;
156 minus_assign -= b;
157
158 Vec accum;
159 accum.zero();
160 accum.add_scaled(a, 1.25);
161 accum.add_scaled(b, -0.5);
162 accum.subtract_scaled(c, -0.25);
163
164 const auto divided = a / 5.0;
165
166 // The device side computes these as scalar products (5.0 * a_ref and
167 // a_ref * 5.0); for real scalars the vector/scalar outer_product() is
168 // the same thing, so it doubles as the host reference.
169 const auto outer_right = libMesh::outer_product(a, 5.0);
170 const auto outer_left = libMesh::outer_product(5.0, a);
171
172 Vec mult_assign = a;
173 mult_assign *= 5.0;
174
175 Vec div_assign = a;
176 div_assign /= 5.0;
177
178 Vec assign_zero = a;
179 assign_zero = 0.0;
180
181 result.vectors.push_back(copied);
182 result.vectors.push_back(mix);
183 result.vectors.push_back(scaled);
184 result.vectors.push_back(accum);
185 result.vectors.push_back(plus_assign);
186 result.vectors.push_back(minus_assign);
187 result.vectors.push_back(divided);
188 result.vectors.push_back(outer_right);
189 result.vectors.push_back(outer_left);
190 result.vectors.push_back(mult_assign);
191 result.vectors.push_back(div_assign);
192
193 // a * b appears twice because the kernel records the dot product both
194 // via operator* and via vector_dot().
195 result.scalars.push_back(a * b);
196 result.scalars.push_back(a * b);
197 result.scalars.push_back(a.contract(b));
198 result.scalars.push_back(mix.norm());
199 result.scalars.push_back(mix.norm_sq());
200 result.scalars.push_back(make_vector<Vec>(0.0, 0.0, 0.0).is_zero() ? 1.0 : 0.0);
201 result.scalars.push_back(mix.is_zero() ? 1.0 : 0.0);
202 result.scalars.push_back((a == a) ? 1.0 : 0.0);
203 result.scalars.push_back((a == b) ? 1.0 : 0.0);
204 result.scalars.push_back((a != a) ? 1.0 : 0.0);
205 result.scalars.push_back((a != b) ? 1.0 : 0.0);
206 result.scalars.push_back(assign_zero.is_zero() ? 1.0 : 0.0);
207
208 // Solid angle cases, from degenerate (all edges collinear) through
209 // planar to genuinely 3D configurations; the icosahedron-vertex case
210 // exercises a nontrivial angle with an analytically clean geometry.
211 const auto xvec = make_vector<Vec>(1.3);
212 result.scalars.push_back(libMesh::solid_angle(as_type_vector(xvec),
213 as_type_vector(xvec),
214 as_type_vector(xvec)));
215
216#if LIBMESH_DIM > 1
217 const auto yvec = make_vector<Vec>(0.0, 2.7);
218 const auto xydiag = make_vector<Vec>(3.1, 3.1);
219 result.scalars.push_back(libMesh::solid_angle(as_type_vector(xvec),
220 as_type_vector(xvec),
221 as_type_vector(yvec)));
222 result.scalars.push_back(libMesh::solid_angle(as_type_vector(xvec),
223 as_type_vector(yvec),
224 as_type_vector(xydiag)));
225#endif
226
227#if LIBMESH_DIM > 2
228 const auto xypdiag = make_vector<Vec>(0.8, -0.8);
229 const auto zvec = make_vector<Vec>(0.0, 0.0, 1.1);
230 const auto xzdiag = make_vector<Vec>(0.0, 0.7, 0.7);
231 const auto icosa1 = make_vector<Vec>(1.0, golden_ratio, 0.0);
232 const auto icosa2 = make_vector<Vec>(-1.0, golden_ratio, 0.0);
233 const auto icosa3 = make_vector<Vec>(0.0, 1.0, golden_ratio);
234 result.scalars.push_back(libMesh::solid_angle(as_type_vector(xydiag),
235 as_type_vector(yvec),
236 as_type_vector(zvec)));
237 result.scalars.push_back(libMesh::solid_angle(as_type_vector(xvec),
238 as_type_vector(yvec),
239 as_type_vector(xzdiag)));
240 result.scalars.push_back(libMesh::solid_angle(as_type_vector(xypdiag),
241 as_type_vector(xydiag),
242 as_type_vector(zvec)));
243 result.scalars.push_back(libMesh::solid_angle(as_type_vector(icosa1),
244 as_type_vector(icosa2),
245 as_type_vector(icosa3)));
246#endif
247
248#if LIBMESH_DIM > 2
249 // unit() asserts on an exactly zero norm and normalizing a tiny one
250 // is numerically unstable, so skip normalizing when a and b are
251 // (nearly) parallel; the device side applies the same guard.
252 const auto cross = a.cross(b);
253 auto unit_cross = cross;
254 if (cross.norm() > unit_tol)
255 unit_cross = cross.unit();
256
257 result.vectors.push_back(cross);
258 result.vectors.push_back(unit_cross);
259#endif
260
261 libmesh_assert_equal_to(result.vectors.size(), vector_results);
262 libmesh_assert_equal_to(result.scalars.size(), scalar_results);
263
264 return result;
265}
b
static const Real b
Definition disjoint_neighbor_test.C:24
libMeshTest::KokkosVectorOracle::as_type_vector
libMesh::TypeVector< Real > as_type_vector(const libMesh::TypeVector< Real > &v)
Definition kokkos_vector_ops_oracle_fixtures.h:76
libMesh::solid_angle
LIBMESH_DEVICE_INLINE T solid_angle(const TypeVector< T > &v01, const TypeVector< T > &v02, const TypeVector< T > &v03)
Definition type_vector.h:1122
libMesh::outer_product
LIBMESH_DEVICE_INLINE TypeTensor< typename CompareTypes< T, T2 >::supertype > outer_product(const TypeVector< T > &a, const TypeVector< T2 > &b)
Definition type_tensor.h:1526
libMeshTest::KokkosVectorOracle::host_oracle
Definition kokkos_vector_ops_oracle_fixtures.h:100
libMeshTest::KokkosVectorOracle::host_oracle::vectors
std::vector< Vec > vectors
Definition kokkos_vector_ops_oracle_fixtures.h:101
libMeshTest::KokkosVectorOracle::host_oracle::scalars
std::vector< Real > scalars
Definition kokkos_vector_ops_oracle_fixtures.h:102

References as_type_vector(), b, golden_ratio, libMesh::outer_product(), scalar_results, libMeshTest::KokkosVectorOracle::host_oracle< Vec >::scalars, libMesh::solid_angle(), unit_tol, vector_results, and libMeshTest::KokkosVectorOracle::host_oracle< Vec >::vectors.

Referenced by test_vector_ops_case().

◆ make_vector()

template<typename Vec >
LIBMESH_DEVICE_INLINE Vec libMeshTest::KokkosVectorOracle::make_vector ( const Real  x,
const Real  y = 0,
const Real  z = 0 
)

Definition at line 58 of file kokkos_vector_ops_oracle_fixtures.h.

59{
60 Vec v;
61 v.zero();
62 v(0) = x;
63#if LIBMESH_DIM > 1
64 v(1) = y;
65#endif
66#if LIBMESH_DIM > 2
67 v(2) = z;
68#endif
69 return v;
70}

◆ run_all_oracles()

int libMeshTest::KokkosVectorOracle::run_all_oracles ( )
inline

Definition at line 304 of file kokkos_vector_ops_oracle_runners.h.

305{
306 int total_fail = 0;
307
308 total_fail += run_vector_cases<libMesh::Kokkos::layout_left_storage_policy, libMesh::TypeVector<Real>>(
309 "typevector_kernel_oracle");
310 total_fail += run_vector_cases<libMesh::Kokkos::layout_right_storage_policy, libMesh::TypeVector<Real>>(
311 "typevector_kernel_oracle");
312 total_fail += run_vector_cases<libMesh::Kokkos::layout_left_storage_policy, libMesh::VectorValue<Real>>(
313 "vectorvalue_kernel_oracle");
314 total_fail += run_vector_cases<libMesh::Kokkos::layout_right_storage_policy, libMesh::VectorValue<Real>>(
315 "vectorvalue_kernel_oracle");
316
317 const int mixed_typevector_left =
318 test_mixed_representation_ops<libMesh::Kokkos::layout_left_storage_policy, libMesh::TypeVector<Real>>();
319 std::printf("[vector_mixed_representation_oracle] [%s] [typevector] %s (%d failures)\n",
320 libMesh::Kokkos::storage_policy_name<libMesh::Kokkos::layout_left_storage_policy>(),
321 mixed_typevector_left ? "FAIL" : "PASS",
322 mixed_typevector_left);
323 total_fail += mixed_typevector_left;
324
325 const int mixed_typevector_right =
326 test_mixed_representation_ops<libMesh::Kokkos::layout_right_storage_policy, libMesh::TypeVector<Real>>();
327 std::printf("[vector_mixed_representation_oracle] [%s] [typevector] %s (%d failures)\n",
328 libMesh::Kokkos::storage_policy_name<libMesh::Kokkos::layout_right_storage_policy>(),
329 mixed_typevector_right ? "FAIL" : "PASS",
330 mixed_typevector_right);
331 total_fail += mixed_typevector_right;
332
333 const int mixed_vectorvalue_left =
334 test_mixed_representation_ops<libMesh::Kokkos::layout_left_storage_policy, libMesh::VectorValue<Real>>();
335 std::printf("[vector_mixed_representation_oracle] [%s] [vectorvalue] %s (%d failures)\n",
336 libMesh::Kokkos::storage_policy_name<libMesh::Kokkos::layout_left_storage_policy>(),
337 mixed_vectorvalue_left ? "FAIL" : "PASS",
338 mixed_vectorvalue_left);
339 total_fail += mixed_vectorvalue_left;
340
341 const int mixed_vectorvalue_right =
342 test_mixed_representation_ops<libMesh::Kokkos::layout_right_storage_policy, libMesh::VectorValue<Real>>();
343 std::printf("[vector_mixed_representation_oracle] [%s] [vectorvalue] %s (%d failures)\n",
344 libMesh::Kokkos::storage_policy_name<libMesh::Kokkos::layout_right_storage_policy>(),
345 mixed_vectorvalue_right ? "FAIL" : "PASS",
346 mixed_vectorvalue_right);
347 total_fail += mixed_vectorvalue_right;
348
349 const int host_fail = test_vector_host_only_traits();
350 std::printf("[vector_host_traits_oracle] %s (%d failures)\n",
351 host_fail ? "FAIL" : "PASS",
352 host_fail);
353 total_fail += host_fail;
354
355 return total_fail;
356}

References test_vector_host_only_traits().

◆ run_vector_cases()

template<typename StoragePolicy , typename Vec >
int libMeshTest::KokkosVectorOracle::run_vector_cases ( const char *  suite_name)

Definition at line 146 of file kokkos_vector_ops_oracle_runners.h.

147{
148 int fail = 0;
149
150 for (const auto & info : cases)
151 {
152 const int f = test_vector_ops_case<StoragePolicy, Vec>(info);
153 std::printf("[%s] [%s] [%s] %s (%d failures)\n",
154 suite_name,
155 libMesh::Kokkos::storage_policy_name<StoragePolicy>(),
156 info.name,
157 f ? "FAIL" : "PASS",
158 f);
159 fail += f;
160 }
161
162 return fail;
163}

References cases.

◆ test_mixed_representation_ops()

template<typename StoragePolicy , typename Vec >
static int libMeshTest::KokkosVectorOracle::test_mixed_representation_ops ( )
static

Definition at line 207 of file kokkos_vector_ops_oracle_runners.h.

208{
209 int fail = 0;
210
211 const auto a = make_vector<Vec>(2.0, 3.0, 4.0);
212 const auto b = make_vector<Vec>(5.0, -6.0, 7.0);
213 const auto c = make_vector<Vec>(1.25, -0.5, 2.0);
214
215 auto d_a = libMesh::Kokkos::upload_vector_storage<StoragePolicy>(std::vector<Vec>{a}, "mixed_vector_a");
216 auto d_b = libMesh::Kokkos::upload_vector_storage<StoragePolicy>(std::vector<Vec>{b}, "mixed_vector_b");
217
218 auto d_vectors =
219 libMesh::Kokkos::make_vector_storage<StoragePolicy>("mixed_vector_vectors", (LIBMESH_DIM > 2) ? 5 : 3);
220 ::Kokkos::View<double *> d_scalars("mixed_vector_scalars", (LIBMESH_DIM > 2) ? 7 : 5);
221
222 const auto ref_sum = a + b;
223 const auto ref_diff = a - b;
224 const auto ref_scaled = 1.5 * a;
225 const auto ref_dot = a * b;
226 const auto ref_contract = a.contract(b);
227 const auto ref_solid_angle =
228 libMesh::solid_angle(as_type_vector(a), as_type_vector(b), as_type_vector(c));
229 const auto ref_cross_norm_sq = libMesh::cross_norm_sq(as_type_vector(a), as_type_vector(b));
230
231#if LIBMESH_DIM > 2
232 const auto ref_cross = a.cross(b);
233 auto ref_unit_cross = ref_cross;
234 if (ref_cross.norm() > unit_tol)
235 ref_unit_cross = ref_cross.unit();
236#endif
237
238 ::Kokkos::parallel_for(
239 1,
240 KOKKOS_LAMBDA(int) {
241 const auto a_ref = libMesh::Kokkos::make_vector_ref(d_a, 0);
242 const auto b_ref = libMesh::Kokkos::make_vector_ref(d_b, 0);
243
244 const auto sum = a_ref + b;
245 const auto diff = a - b_ref;
246 const auto scaled = Real(1.5) * a_ref;
247
248 libMesh::Kokkos::store_vector(d_vectors, 0, sum);
249 libMesh::Kokkos::store_vector(d_vectors, 1, diff);
250 libMesh::Kokkos::store_vector(d_vectors, 2, scaled);
251
252 d_scalars(0) = a_ref * b;
253 d_scalars(1) = b_ref.contract(a);
254 d_scalars(2) = (a_ref == a) ? 1.0 : 0.0;
255 d_scalars(3) = (a_ref != b) ? 1.0 : 0.0;
256 d_scalars(4) = libMesh::Kokkos::vector_solid_angle(a_ref, b, c);
257
258#if LIBMESH_DIM > 2
259 const auto cross = a_ref.cross(b);
260 Vec unit_cross = cross;
261 if (cross.norm() > unit_tol)
262 unit_cross = libMesh::Kokkos::vector_unit<Vec>(cross);
263
264 libMesh::Kokkos::store_vector(d_vectors, 3, cross);
265 libMesh::Kokkos::store_vector(d_vectors, 4, unit_cross);
266 d_scalars(5) = libMesh::Kokkos::vector_cross_norm_sq(a_ref, b);
267 d_scalars(6) = (cross == libMesh::Kokkos::vector_cross<Vec>(a, b_ref)) ? 1.0 : 0.0;
268#endif
269 });
270 ::Kokkos::fence();
271
272 fail += libMeshTest::KokkosOracle::compare_device_vectors(
273 d_vectors,
274 [&]() {
275 std::vector<Vec> ref = {ref_sum, ref_diff, ref_scaled};
276#if LIBMESH_DIM > 2
277 ref.push_back(ref_cross);
278 ref.push_back(ref_unit_cross);
279#endif
280 return ref;
281 }(),
282 tol);
283
284 fail += libMeshTest::KokkosOracle::compare_device_scalars(
285 d_scalars,
286 [&]() {
287 std::vector<Real> ref = {ref_dot, ref_contract, 1.0, 1.0, ref_solid_angle};
288#if LIBMESH_DIM > 2
289 ref.push_back(ref_cross_norm_sq);
290 ref.push_back(1.0);
291#endif
292 return ref;
293 }(),
294 tol);
295
296 return fail;
297}
libMeshTest::KokkosOracle::compare_device_scalars
int compare_device_scalars(const ::Kokkos::View< double * > &d_values, const std::vector< Real > &ref_values, const double tol)
Definition kokkos_numerics_oracle_test_utils.h:53
libMeshTest::KokkosOracle::compare_device_vectors
int compare_device_vectors(const ViewType &d_values, const std::vector< VectorType > &ref_values, const double tol)
Definition kokkos_numerics_oracle_test_utils.h:70
libMesh::Kokkos::make_vector_ref
LIBMESH_DEVICE_INLINE vector_ref< typename std::remove_reference< ViewType >::type > make_vector_ref(ViewType &&view, const unsigned int index)
Definition kokkos_linalg_base.h:632
libMesh::Kokkos::store_vector
LIBMESH_DEVICE_INLINE void store_vector(const ViewType &view, const unsigned int i, const VectorType &v)
Copies the components of the vector v into entry i of the vector view view, overwriting whatever that...
Definition kokkos_storage.h:68
libMesh::Kokkos::vector_solid_angle
LIBMESH_DEVICE_INLINE auto vector_solid_angle(const VectorA &v01, const VectorB &v02, const VectorC &v03)
Definition kokkos_vector_ops.h:342
libMesh::Kokkos::vector_cross_norm_sq
LIBMESH_DEVICE_INLINE auto vector_cross_norm_sq(const LeftVector &left, const RightVector &right)
Definition kokkos_vector_ops.h:320
libMesh::cross_norm_sq
LIBMESH_DEVICE_INLINE T cross_norm_sq(const TypeVector< T > &b, const TypeVector< T > &c)
Compute |b x c|^2 without creating the extra temporary produced by calling b.cross(c)....
Definition type_vector.h:1179

References as_type_vector(), b, libMeshTest::KokkosOracle::compare_device_scalars(), libMeshTest::KokkosOracle::compare_device_vectors(), libMesh::cross_norm_sq(), libMesh::Kokkos::make_vector_ref(), libMesh::solid_angle(), libMesh::Kokkos::store_vector(), tol, unit_tol, libMesh::Kokkos::vector_cross_norm_sq(), and libMesh::Kokkos::vector_solid_angle().

◆ test_vector_host_only_traits()

int libMeshTest::KokkosVectorOracle::test_vector_host_only_traits ( )
inline

Definition at line 171 of file kokkos_vector_ops_oracle_runners.h.

172{
173 int fail = 0;
174
175#ifdef LIBMESH_HAVE_METAPHYSICL
176 typedef typename MetaPhysicL::ReplaceAlgebraicType<
177 std::vector<libMesh::TypeVector<double>>,
178 typename libMesh::TensorTools::IncrementRank<
179 typename MetaPhysicL::ValueType<std::vector<libMesh::TypeVector<double>>>::type>::type>::type
180 ReplacedType;
181 constexpr bool typevector_assertion =
182 std::is_same<ReplacedType, std::vector<libMesh::TensorValue<double>>>::value;
183 fail += typevector_assertion ? 0 : 1;
184
185 typedef typename MetaPhysicL::ReplaceAlgebraicType<
186 std::vector<libMesh::VectorValue<double>>,
187 typename libMesh::TensorTools::IncrementRank<
188 typename MetaPhysicL::ValueType<std::vector<libMesh::VectorValue<double>>>::type>::type>::type
189 ReplacedValueType;
190 constexpr bool vectorvalue_assertion =
191 std::is_same<ReplacedValueType, std::vector<libMesh::TensorValue<double>>>::value;
192 fail += vectorvalue_assertion ? 0 : 1;
193#endif
194
195 return fail;
196}
value
static const bool value
Definition xdr_io.C:55

References value.

Referenced by run_all_oracles().

◆ test_vector_ops_case()

template<typename StoragePolicy , typename Vec >
static int libMeshTest::KokkosVectorOracle::test_vector_ops_case ( const vector_case &  info)
static

Definition at line 35 of file kokkos_vector_ops_oracle_runners.h.

36{
37 const auto a = make_vector<Vec>(info.ax, info.ay, info.az);
38 const auto b = make_vector<Vec>(info.bx, info.by, info.bz);
39 const auto c = make_vector<Vec>(info.cx, info.cy, info.cz);
40
41 const auto expected = build_host_oracle(a, b, c);
42
43 auto d_a = libMesh::Kokkos::upload_vector_storage<StoragePolicy>(std::vector<Vec>{a}, "vector_ops_a");
44 auto d_b = libMesh::Kokkos::upload_vector_storage<StoragePolicy>(std::vector<Vec>{b}, "vector_ops_b");
45 auto d_c = libMesh::Kokkos::upload_vector_storage<StoragePolicy>(std::vector<Vec>{c}, "vector_ops_c");
46 auto d_vectors = libMesh::Kokkos::make_vector_storage<StoragePolicy>("vector_ops_vectors", vector_results);
47 ::Kokkos::View<double *> d_scalars("vector_ops_scalars", scalar_results);
48
49 ::Kokkos::parallel_for(
50 1,
51 KOKKOS_LAMBDA(int) {
52 const auto a_ref = libMesh::Kokkos::make_vector_ref(d_a, 0);
53 const auto b_ref = libMesh::Kokkos::make_vector_ref(d_b, 0);
54 const auto c_ref = libMesh::Kokkos::make_vector_ref(d_c, 0);
55
56 const Vec copied = libMesh::Kokkos::copy_vector<Vec>(a_ref);
57 const Vec mix = a_ref + b_ref - c_ref;
58 const Vec scaled = Real(1.25) * a_ref + Real(-0.5) * b_ref + Real(0.25) * c_ref;
59 const Vec plus_assign = a_ref + b_ref;
60 const Vec minus_assign = a_ref - b_ref;
61 const Vec accum = Real(1.25) * a_ref + Real(-0.5) * b_ref + Real(0.25) * c_ref;
62 const Vec divided = a_ref / Real(5.0);
63 const Vec outer_right = Real(5.0) * a_ref;
64 const Vec outer_left = a_ref * Real(5.0);
65 const Vec mult_assign = a_ref * Real(5.0);
66 const Vec div_assign = a_ref / Real(5.0);
67
68 const Real dot = libMesh::Kokkos::vector_dot(a_ref, b_ref);
69 const Real contract = a_ref.contract(b_ref);
70 const Real norm = mix.norm();
71 const Real norm_sq = mix.norm_sq();
72 const Vec zero; // By default initialization
73 const Vec assign_zero = zero;
74
75 unsigned int vector_offset = 0;
76 libMesh::Kokkos::store_vector(d_vectors, vector_offset++, copied);
77 libMesh::Kokkos::store_vector(d_vectors, vector_offset++, mix);
78 libMesh::Kokkos::store_vector(d_vectors, vector_offset++, scaled);
79 libMesh::Kokkos::store_vector(d_vectors, vector_offset++, accum);
80 libMesh::Kokkos::store_vector(d_vectors, vector_offset++, plus_assign);
81 libMesh::Kokkos::store_vector(d_vectors, vector_offset++, minus_assign);
82 libMesh::Kokkos::store_vector(d_vectors, vector_offset++, divided);
83 libMesh::Kokkos::store_vector(d_vectors, vector_offset++, outer_right);
84 libMesh::Kokkos::store_vector(d_vectors, vector_offset++, outer_left);
85 libMesh::Kokkos::store_vector(d_vectors, vector_offset++, mult_assign);
86 libMesh::Kokkos::store_vector(d_vectors, vector_offset++, div_assign);
87
88 unsigned int scalar_offset = 0;
89 d_scalars(scalar_offset++) = a_ref * b_ref;
90 d_scalars(scalar_offset++) = dot;
91 d_scalars(scalar_offset++) = contract;
92 d_scalars(scalar_offset++) = norm;
93 d_scalars(scalar_offset++) = norm_sq;
94 d_scalars(scalar_offset++) = zero.is_zero() ? 1.0 : 0.0;
95 d_scalars(scalar_offset++) = mix.is_zero() ? 1.0 : 0.0;
96 d_scalars(scalar_offset++) = (a_ref == a_ref) ? 1.0 : 0.0;
97 d_scalars(scalar_offset++) = (a_ref == b_ref) ? 1.0 : 0.0;
98 d_scalars(scalar_offset++) = (a_ref != a_ref) ? 1.0 : 0.0;
99 d_scalars(scalar_offset++) = (a_ref != b_ref) ? 1.0 : 0.0;
100 d_scalars(scalar_offset++) = assign_zero.is_zero() ? 1.0 : 0.0;
101
102 const Vec xvec = make_vector<Vec>(1.3);
103 d_scalars(scalar_offset++) = libMesh::Kokkos::vector_solid_angle(xvec, xvec, xvec);
104
105#if LIBMESH_DIM > 1
106 const Vec yvec = make_vector<Vec>(0.0, 2.7);
107 const Vec xydiag = make_vector<Vec>(3.1, 3.1);
108 d_scalars(scalar_offset++) = libMesh::Kokkos::vector_solid_angle(xvec, xvec, yvec);
109 d_scalars(scalar_offset++) = libMesh::Kokkos::vector_solid_angle(xvec, yvec, xydiag);
110#endif
111
112#if LIBMESH_DIM > 2
113 const Vec xypdiag = make_vector<Vec>(0.8, -0.8);
114 const Vec zvec = make_vector<Vec>(0.0, 0.0, 1.1);
115 const Vec xzdiag = make_vector<Vec>(0.0, 0.7, 0.7);
116 const Vec icosa1 = make_vector<Vec>(1.0, golden_ratio, 0.0);
117 const Vec icosa2 = make_vector<Vec>(-1.0, golden_ratio, 0.0);
118 const Vec icosa3 = make_vector<Vec>(0.0, 1.0, golden_ratio);
119 d_scalars(scalar_offset++) = libMesh::Kokkos::vector_solid_angle(xydiag, yvec, zvec);
120 d_scalars(scalar_offset++) = libMesh::Kokkos::vector_solid_angle(xvec, yvec, xzdiag);
121 d_scalars(scalar_offset++) = libMesh::Kokkos::vector_solid_angle(xypdiag, xydiag, zvec);
122 d_scalars(scalar_offset++) = libMesh::Kokkos::vector_solid_angle(icosa1, icosa2, icosa3);
123#endif
124
125#if LIBMESH_DIM > 2
126 const Vec cross = a_ref.cross(b_ref);
127 Vec unit_cross = cross;
128 if (cross.norm() > unit_tol)
129 unit_cross = libMesh::Kokkos::vector_unit<Vec>(cross);
130
131 libMesh::Kokkos::store_vector(d_vectors, vector_offset++, cross);
132 libMesh::Kokkos::store_vector(d_vectors, vector_offset++, unit_cross);
133#endif
134
135 libmesh_assert_equal_to(vector_offset, vector_results);
136 libmesh_assert_equal_to(scalar_offset, scalar_results);
137 });
138 ::Kokkos::fence();
139
140 return libMeshTest::KokkosOracle::compare_device_vectors(d_vectors, expected.vectors, tol) +
141 libMeshTest::KokkosOracle::compare_device_scalars(d_scalars, expected.scalars, tol);
142}
libMeshTest::KokkosVectorOracle::build_host_oracle
host_oracle< Vec > build_host_oracle(const Vec &a, const Vec &b, const Vec &c)
Definition kokkos_vector_ops_oracle_fixtures.h:137
libMesh::Kokkos::vector_dot
LIBMESH_DEVICE_INLINE auto vector_dot(const LeftVector &left, const RightVector &right)
Definition kokkos_vector_ops.h:220
libMesh::Kokkos::contract
LIBMESH_DEVICE_INLINE auto contract(const LeftTensor &left, const RightTensor &right)
Definition kokkos_tensor_ops.h:479
libMesh::TensorTools::norm_sq
LIBMESH_DEVICE_INLINE auto norm_sq(const T &a)
Definition tensor_tools.h:104
libMesh::TensorTools::norm
LIBMESH_DEVICE_INLINE auto norm(const T &a)
Definition tensor_tools.h:74
libMesh::zero
const Number zero
.
Definition libmesh.h:297
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition libmesh_common.h:148

References b, build_host_oracle(), libMeshTest::KokkosOracle::compare_device_scalars(), libMeshTest::KokkosOracle::compare_device_vectors(), golden_ratio, libMesh::Kokkos::make_vector_ref(), scalar_results, libMesh::Kokkos::store_vector(), tol, unit_tol, libMesh::Kokkos::vector_dot(), vector_results, and libMesh::Kokkos::vector_solid_angle().

Variable Documentation

◆ cases

const vector_case libMeshTest::KokkosVectorOracle::cases[]
static
Initial value:
= {
#if LIBMESH_DIM >= 1
{ "line_case_a", 2.0, 0.0, 0.0, -3.0, 0.0, 0.0, 0.5, 0.0, 0.0 },
{ "line_case_b", -1.25, 0.0, 0.0, 4.5, 0.0, 0.0, -2.0, 0.0, 0.0 },
#endif
#if LIBMESH_DIM >= 2
{ "plane_case_a", 2.0, 3.0, 0.0, 5.0, -6.0, 0.0, 1.25, -0.5, 0.0 },
{ "plane_case_b", -1.0, 4.0, 0.0, 0.5, 2.5, 0.0, -3.0, 1.5, 0.0 },
#endif
#if LIBMESH_DIM >= 3
{ "space_case_a", 2.0, 3.0, 4.0, 5.0, -6.0, 7.0, 1.25, -0.5, 2.0 },
{ "space_case_b", -1.0, 4.0, 0.75, 0.5, 2.5, -3.5, -3.0, 1.5, 2.25 },
#endif
}

Definition at line 116 of file kokkos_vector_ops_oracle_fixtures.h.

116 {
117#if LIBMESH_DIM >= 1
118 { "line_case_a", 2.0, 0.0, 0.0, -3.0, 0.0, 0.0, 0.5, 0.0, 0.0 },
119 { "line_case_b", -1.25, 0.0, 0.0, 4.5, 0.0, 0.0, -2.0, 0.0, 0.0 },
120#endif
121#if LIBMESH_DIM >= 2
122 { "plane_case_a", 2.0, 3.0, 0.0, 5.0, -6.0, 0.0, 1.25, -0.5, 0.0 },
123 { "plane_case_b", -1.0, 4.0, 0.0, 0.5, 2.5, 0.0, -3.0, 1.5, 0.0 },
124#endif
125#if LIBMESH_DIM >= 3
126 { "space_case_a", 2.0, 3.0, 4.0, 5.0, -6.0, 7.0, 1.25, -0.5, 2.0 },
127 { "space_case_b", -1.0, 4.0, 0.75, 0.5, 2.5, -3.5, -3.0, 1.5, 2.25 },
128#endif
129};

Referenced by run_vector_cases().

◆ golden_ratio

constexpr Real libMeshTest::KokkosVectorOracle::golden_ratio = 1.6180339887498948482
staticconstexpr

Definition at line 44 of file kokkos_vector_ops_oracle_fixtures.h.

Referenced by build_host_oracle(), and test_vector_ops_case().

◆ scalar_results

constexpr unsigned int libMeshTest::KokkosVectorOracle::scalar_results = 12 + solid_angle_results
staticconstexpr

Definition at line 51 of file kokkos_vector_ops_oracle_fixtures.h.

Referenced by build_host_oracle(), and test_vector_ops_case().

◆ solid_angle_results

constexpr unsigned int libMeshTest::KokkosVectorOracle::solid_angle_results
staticconstexpr
Initial value:
=
1 + ((LIBMESH_DIM > 1) ? 2u : 0u) + ((LIBMESH_DIM > 2) ? 4u : 0u)

Definition at line 47 of file kokkos_vector_ops_oracle_fixtures.h.

◆ tol

constexpr double libMeshTest::KokkosVectorOracle::tol = 2.0e-13
staticconstexpr

Definition at line 40 of file kokkos_vector_ops_oracle_fixtures.h.

Referenced by test_mixed_representation_ops(), and test_vector_ops_case().

◆ unit_tol

constexpr double libMeshTest::KokkosVectorOracle::unit_tol = 1.0e-14
staticconstexpr

Definition at line 42 of file kokkos_vector_ops_oracle_fixtures.h.

Referenced by build_host_oracle(), test_mixed_representation_ops(), and test_vector_ops_case().

◆ vector_results

constexpr unsigned int libMeshTest::KokkosVectorOracle::vector_results
staticconstexpr
Initial value:
=
11 + ((LIBMESH_DIM > 2) ? 2u : 0u)

Definition at line 49 of file kokkos_vector_ops_oracle_fixtures.h.

Referenced by build_host_oracle(), and test_vector_ops_case().

Generated on Thu Nov 5 2026 20:16:21 for libMesh by doxygen 1.9.8