Line data Source code
1 0 : // Distributed under the MIT License.
2 : // See LICENSE.txt for details.
3 :
4 : #pragma once
5 :
6 : #include <boost/container/small_vector.hpp>
7 : #include <cstddef>
8 : #include <tuple>
9 :
10 : #include "Time/TimeStepId.hpp"
11 : #include "Time/TimeSteppers/AdamsCoefficients.hpp"
12 :
13 : /// \cond
14 : class Time;
15 : namespace TimeSteppers {
16 : template <typename T>
17 : class BoundaryHistoryEvaluator;
18 : class ConstBoundaryHistoryTimes;
19 : } // namespace TimeSteppers
20 : namespace gsl {
21 : template <class T>
22 : class not_null;
23 : } // namespace gsl
24 : /// \endcond
25 :
26 : /// Shared LTS implementation for the two Adams-based methods.
27 1 : namespace TimeSteppers::adams_lts {
28 : /// Get the time of a substep as a `Time`, assuming substeps are at
29 : /// the end of the step.
30 1 : Time exact_substep_time(const TimeStepId& id);
31 :
32 : // For order-k 2:1 stepping, in each small step, half the points will
33 : // require interpolation (k entries each) and the others will not (1
34 : // entry each). So (2 small steps) * ((k/2 interpolations) * (from k
35 : // points) + (k/2 non-interpolations)) = k (k + 1). (The small steps
36 : // round k/2 in different directions and the effect cancels out.)
37 0 : constexpr size_t lts_coefficients_static_size =
38 : adams_coefficients::maximum_order * (adams_coefficients::maximum_order + 1);
39 :
40 : /// Storage for LTS coefficients that should not allocate in typical
41 : /// cases. Each entry is a tuple of (local id, remote id,
42 : /// coefficient). The contents should be kept sorted, as some
43 : /// functions assume that.
44 1 : struct LtsCoefficients
45 : : boost::container::small_vector<std::tuple<TimeStepId, TimeStepId, double>,
46 : lts_coefficients_static_size> {
47 : using boost::container::small_vector<
48 : std::tuple<TimeStepId, TimeStepId, double>,
49 : lts_coefficients_static_size>::small_vector;
50 : };
51 :
52 0 : LtsCoefficients& operator+=(LtsCoefficients& a, const LtsCoefficients& b);
53 0 : LtsCoefficients& operator-=(LtsCoefficients& a, const LtsCoefficients& b);
54 :
55 0 : LtsCoefficients operator+(LtsCoefficients&& a, LtsCoefficients&& b);
56 0 : LtsCoefficients operator+(LtsCoefficients&& a, const LtsCoefficients& b);
57 0 : LtsCoefficients operator+(const LtsCoefficients& a, LtsCoefficients&& b);
58 0 : LtsCoefficients operator+(const LtsCoefficients& a, const LtsCoefficients& b);
59 :
60 0 : LtsCoefficients operator-(LtsCoefficients&& a, LtsCoefficients&& b);
61 0 : LtsCoefficients operator-(LtsCoefficients&& a, const LtsCoefficients& b);
62 0 : LtsCoefficients operator-(const LtsCoefficients& a, LtsCoefficients&& b);
63 0 : LtsCoefficients operator-(const LtsCoefficients& a, const LtsCoefficients& b);
64 :
65 : /// Add the LTS boundary terms for to \p result for the given set of
66 : /// coefficients.
67 : template <typename T>
68 1 : void apply_coefficients(gsl::not_null<T*> result,
69 : const LtsCoefficients& coefficients,
70 : const BoundaryHistoryEvaluator<T>& coupling);
71 :
72 : /// Type of coefficients used for an Adams scheme
73 0 : enum class SchemeType { Explicit, Implicit };
74 :
75 : /*!
76 : * Calculate the nonzero terms in an Adams LTS boundary contribution.
77 : *
78 : * The coefficients are generated for a step from \p start_time to \p
79 : * end_time. Interpolation from the elements is performed using
80 : * polynomials appropriate for the given \p local_scheme and \p
81 : * remote_scheme. The orders for the interpolations are taken from
82 : * the \p local_times and \p remote_times, adjusted by \p
83 : * local_order_offset and \p remote_order_offset, which can be either
84 : * 0 or -1. The small-step integration is performed with an implicit
85 : * method if either \p local_scheme or \p remote_scheme is implicit,
86 : * and the order is the larger of the integration orders on the two
87 : * sides, reduced by one if both sides have offset -1.
88 : *
89 : * This function returns the sum of the coefficients for the small
90 : * steps, i.e., the steps between all the times either side updates
91 : * between the time bounds. Each small step is calculated as
92 : *
93 : * \f{equation}
94 : * \Delta \tilde{y}_n = \Delta \tilde{t}_n \sum_{ij} D(y^L_{n,-i}, y^R_{n,-j})
95 : * \sum_q \tilde{\alpha}_{nq}
96 : * \ell_i(\tilde{t}_{n-q}; t^L_\cdots, \ldots)
97 : * \ell_j(\tilde{t}_{n-q}; t^R_\cdots, \ldots),
98 : * \f}
99 : *
100 : * where $y^L_{n,0}$ and $y^R_{n,0}$ are the values of the local and
101 : * remote variables at the start of the step containing small step
102 : * $n$, $y^L_{n,1}$ and $y^R_{n,1}$ are the predictor values for those
103 : * steps, and other index values count backwards in the history of
104 : * that side. The range of $i$ and choice of the control times
105 : * $t^L_\cdots$ are determined by \p local_scheme and the local order,
106 : * $j$ and $t^R_\cdots$ are determined by \p remote_scheme and the
107 : * remote order, and the Adams coefficients $\tilde{\alpha}_{nq}$
108 : * correspond to the larger of the two orders, and are implicit if
109 : * either set of interpolation coefficients is.
110 : *
111 : * When called for dense output, the arguments must represent a
112 : * single small step, i.e., the step cannot cross any of the control
113 : * times. Any additional terms can be generated by a second call
114 : * treating the remainder of the step as non-dense.
115 : *
116 : * \tparam TimeType The type `Time` for a step aligned with the
117 : * control times or `ApproximateTime` for dense output.
118 : */
119 : template <typename TimeType>
120 1 : LtsCoefficients lts_coefficients(
121 : const ConstBoundaryHistoryTimes& local_times,
122 : const ConstBoundaryHistoryTimes& remote_times, const Time& start_time,
123 : const TimeType& end_time, SchemeType local_scheme, SchemeType remote_scheme,
124 : int local_order_offset, int remote_order_offset);
125 : } // namespace TimeSteppers::adams_lts
|
