SimiLie
Loading...
Searching...
No Matches
quadrature.hpp
1// SPDX-FileCopyrightText: 2026 Baptiste Legouix
2// SPDX-License-Identifier: AGPL-3.0-or-later
3// AI-GENERATED
4
5#pragma once
6
7#include <array>
8#include <cstddef>
9
10#include <Kokkos_Core.hpp>
11
12namespace sil::exterior {
13
19template <std::size_t Dimension>
21{
22 static_assert(Dimension > 0);
23 static constexpr std::size_t size = std::size_t(1) << Dimension;
24
25 [[nodiscard]] KOKKOS_FUNCTION static std::array<double, Dimension> point(std::size_t sample)
26 {
27 std::array<double, Dimension> result {};
28 for (std::size_t axis = 0; axis < Dimension; ++axis)
29 result[axis] = (sample >> axis) & 1;
30 return result;
31 }
32
33 [[nodiscard]] KOKKOS_FUNCTION static constexpr double weight(std::size_t)
34 {
35 return 1.0 / size;
36 }
37};
38
43template <std::size_t Dimension, std::size_t Order>
45{
46 static_assert(Dimension > 0 && Order >= 1 && Order <= 3);
47 static constexpr std::size_t size = [] {
48 std::size_t result = 1;
49 for (std::size_t axis = 0; axis < Dimension; ++axis)
50 result *= Order;
51 return result;
52 }();
53
54 [[nodiscard]] KOKKOS_FUNCTION static std::array<double, Dimension> point(std::size_t sample)
55 {
56 std::array<double, Dimension> result {};
57 for (std::size_t axis = 0; axis < Dimension; ++axis) {
58 std::size_t const index = sample % Order;
59 sample /= Order;
60 if constexpr (Order == 1)
61 result[axis] = 0.5;
62 else if constexpr (Order == 2)
63 result[axis] = 0.5 + (index == 0 ? -1.0 : 1.0) * Kokkos::sqrt(3.0) / 6.0;
64 else
65 result[axis] = 0.5 + (static_cast<double>(index) - 1.0) * Kokkos::sqrt(15.0) / 10.0;
66 }
67 return result;
68 }
69
70 [[nodiscard]] KOKKOS_FUNCTION static double weight(std::size_t sample)
71 {
72 double result = 1.0;
73 for (std::size_t axis = 0; axis < Dimension; ++axis) {
74 std::size_t const index = sample % Order;
75 sample /= Order;
76 if constexpr (Order == 2)
77 result *= 0.5;
78 else if constexpr (Order == 3)
79 result *= index == 1 ? 4.0 / 9.0 : 5.0 / 18.0;
80 }
81 return result;
82 }
83};
84
92template <class Rule, class Evaluator, class Measure>
93[[nodiscard]] KOKKOS_FUNCTION double quadrature(
94 Rule const& rule,
95 Evaluator const& evaluator,
96 Measure const& measure)
97{
98 double result = 0.0;
99 for (std::size_t sample = 0; sample < Rule::size; ++sample)
100 result += rule.weight(sample) * measure(rule.point(sample), sample)
101 * evaluator(rule.point(sample), sample);
102 return result;
103}
104
109template <class Rule, class Measure, class TrialResponse, class Pairing, class Accumulate>
110KOKKOS_FUNCTION void assemble_bilinear_form(
111 Rule const& rule,
112 std::size_t trial_count,
113 std::size_t test_count,
114 Measure const& measure,
115 TrialResponse const& response,
116 Pairing const& pairing,
117 Accumulate const& accumulate)
118{
119 for (std::size_t sample = 0; sample < Rule::size; ++sample) {
120 auto const point = rule.point(sample);
121 double const weight = rule.weight(sample) * measure(point, sample);
122 for (std::size_t trial = 0; trial < trial_count; ++trial) {
123 auto const trial_response = response(trial, point, sample);
124 for (std::size_t test = 0; test < test_count; ++test)
125 accumulate(test, trial, weight * pairing(test, trial_response, point, sample));
126 }
127 }
128}
129
130} // namespace sil::exterior
KOKKOS_FUNCTION double quadrature(Rule const &rule, Evaluator const &evaluator, Measure const &measure)
Integrate a scalar evaluator with an independent reference-cell rule.
KOKKOS_FUNCTION void assemble_bilinear_form(Rule const &rule, std::size_t trial_count, std::size_t test_count, Measure const &measure, TrialResponse const &response, Pairing const &pairing, Accumulate const &accumulate)
Assemble a local bilinear form from independently evaluated trial responses and test functions.
Tensor product Gauss-Legendre rule on [0,1]^Dimension, with one, two or three points per axis (exact ...
static KOKKOS_FUNCTION double weight(std::size_t sample)
static KOKKOS_FUNCTION std::array< double, Dimension > point(std::size_t sample)
static constexpr std::size_t size
Tensor product trapezoidal rule on the reference cube [0,1]^Dimension.
static constexpr std::size_t size
static KOKKOS_FUNCTION std::array< double, Dimension > point(std::size_t sample)
static KOKKOS_FUNCTION constexpr double weight(std::size_t)