Line data Source code
1 0 : // Distributed under the MIT License.
2 : // See LICENSE.txt for details.
3 :
4 : #pragma once
5 :
6 : #include <array>
7 : #include <optional>
8 : #include <pup.h>
9 : #include <vector>
10 :
11 : #include "Options/Context.hpp"
12 : #include "Options/String.hpp"
13 : #include "Utilities/Serialization/CharmPupable.hpp"
14 : #include "Utilities/TMPL.hpp"
15 :
16 : /// Represents a sequence of times.
17 : ///
18 : /// The template parameter \p T can either be `double` for a sequence
19 : /// of simulation times or std::uint64_t for a sequence of slab
20 : /// numbers.
21 : template <typename T>
22 1 : class TimeSequence : public PUP::able {
23 : protected:
24 : /// \cond HIDDEN_SYMBOLS
25 : TimeSequence() = default;
26 : TimeSequence(const TimeSequence&) = default;
27 : TimeSequence(TimeSequence&&) = default;
28 : TimeSequence& operator=(const TimeSequence&) = default;
29 : TimeSequence& operator=(TimeSequence&&) = default;
30 : /// \endcond
31 :
32 : public:
33 0 : ~TimeSequence() override = default;
34 :
35 0 : WRAPPED_PUPable_abstract(TimeSequence); // NOLINT
36 :
37 : /// Returns the time in the sequence nearest to \p time, the time
38 : /// before that, and the time after, in numerical order. These
39 : /// values allow a consumer to find the times in the sequence
40 : /// bracketing the given time and give enough additional information
41 : /// so that exact or roundoff matches can be handled however the
42 : /// consumer wishes. Any time that does not exist (because the
43 : /// sequence terminates) is returned as an empty std::optional. The
44 : /// central std::optional will be populated unless the sequence is
45 : /// empty.
46 1 : virtual std::array<std::optional<T>, 3> times_near(T time) const = 0;
47 : };
48 :
49 : /// \ingroup TimeGroup
50 : ///
51 : /// Holds all the TimeSequences
52 1 : namespace TimeSequences {
53 : /*!
54 : * \brief A sequence of evenly spaced times.
55 : *
56 : * The sequence of times
57 : * \f{equation}{
58 : * n \times \mathrm{Interval} + \mathrm{Offset}
59 : * \f}
60 : * for all integers $n$.
61 : */
62 : template <typename T>
63 1 : class EvenlySpaced : public TimeSequence<T> {
64 : public:
65 : /// \cond
66 : EvenlySpaced() = default;
67 : explicit EvenlySpaced(CkMigrateMessage* /*unused*/) {}
68 : using PUP::able::register_constructor;
69 : WRAPPED_PUPable_decl_template(EvenlySpaced); // NOLINT
70 : /// \endcond
71 :
72 0 : struct Interval {
73 0 : static constexpr Options::String help = "Spacing between times";
74 0 : using type = T;
75 0 : static constexpr T lower_bound() { return 0; }
76 : };
77 :
78 0 : struct Offset {
79 0 : static constexpr Options::String help = "Offset of sequence";
80 0 : using type = T;
81 : };
82 :
83 0 : static constexpr Options::String help =
84 : "The sequence of times n * Interval + Offset for all integers n.";
85 0 : using options = tmpl::list<Interval, Offset>;
86 :
87 0 : explicit EvenlySpaced(T interval, T offset = 0,
88 : const Options::Context& context = {});
89 :
90 1 : std::array<std::optional<T>, 3> times_near(T time) const override;
91 :
92 : // NOLINTNEXTLINE(google-runtime-references)
93 0 : void pup(PUP::er& p) override;
94 :
95 : private:
96 : // This is
97 : // tmpl::conditional<std::is_integral_v<T>, std::make_signed<T>,
98 : // tmpl::identity<T>>::type
99 : // except avoiding instantiating std::make_signed<double> because,
100 : // depending on the standard version, that is either undefined
101 : // behavior or makes the program ill-formed.
102 0 : using SignedT = tmpl::apply<tmpl::apply<
103 : tmpl::if_<std::is_integral<tmpl::pin<T>>,
104 : tmpl::defer<tmpl::bind<std::make_signed_t, tmpl::pin<T>>>,
105 : tmpl::defer<tmpl::always<tmpl::pin<T>>>>>>;
106 :
107 0 : SignedT interval_{};
108 0 : SignedT offset_{};
109 : };
110 :
111 : /// An explicitly specified sequence of times.
112 : template <typename T>
113 1 : class Specified : public TimeSequence<T> {
114 : public:
115 : /// \cond
116 : Specified() = default;
117 : explicit Specified(CkMigrateMessage* /*unused*/) {}
118 : using PUP::able::register_constructor;
119 : WRAPPED_PUPable_decl_template(Specified); // NOLINT
120 : /// \endcond
121 :
122 0 : struct Values {
123 0 : static constexpr Options::String help = "The times in the sequence";
124 0 : using type = std::vector<T>;
125 : };
126 :
127 0 : static constexpr Options::String help =
128 : "An explicitly specified sequence of times.";
129 0 : using options = tmpl::list<Values>;
130 :
131 0 : explicit Specified(std::vector<T> values);
132 :
133 1 : std::array<std::optional<T>, 3> times_near(T time) const override;
134 :
135 : // NOLINTNEXTLINE(google-runtime-references)
136 0 : void pup(PUP::er& p) override;
137 :
138 : private:
139 0 : std::vector<T> values_;
140 : };
141 :
142 : template <typename T>
143 0 : using all_time_sequences = tmpl::list<EvenlySpaced<T>, Specified<T>>;
144 : } // namespace TimeSequences
|
