Line data Source code
1 1 : // Distributed under the MIT License.
2 : // See LICENSE.txt for details.
3 :
4 : /// \file
5 : /// Defines DataBox tags for the linear solver
6 :
7 : #pragma once
8 :
9 : #include <cstddef>
10 : #include <string>
11 : #include <utility>
12 : #include <vector>
13 :
14 : #include "DataStructures/DataBox/PrefixHelpers.hpp"
15 : #include "DataStructures/DataBox/Prefixes.hpp"
16 : #include "DataStructures/DataBox/Tag.hpp"
17 : #include "DataStructures/DataBox/TagName.hpp"
18 : #include "DataStructures/DynamicMatrix.hpp"
19 : #include "Options/String.hpp"
20 : #include "Utilities/Gsl.hpp"
21 : #include "Utilities/TMPL.hpp"
22 : #include "Utilities/TypeTraits/GetFundamentalType.hpp"
23 :
24 : /*!
25 : * \ingroup LinearSolverGroup
26 : * \brief Functionality for solving linear systems of equations
27 : */
28 : namespace LinearSolver {
29 :
30 : namespace OptionTags {
31 :
32 : template <typename OptionsGroup>
33 0 : struct OutputVolumeData {
34 0 : using type = bool;
35 0 : static constexpr Options::String help =
36 : "Record volume data for debugging purposes.";
37 0 : using group = OptionsGroup;
38 0 : static bool suggested_value() { return false; }
39 : };
40 :
41 : } // namespace OptionTags
42 :
43 : /*!
44 : * \ingroup LinearSolverGroup
45 : * \brief The \ref DataBoxGroup tags associated with the linear solver
46 : */
47 : namespace Tags {
48 :
49 : /*!
50 : * \brief The operand that the local linear operator \f$A\f$ is applied to
51 : *
52 : * \details The result of the operation should be wrapped in
53 : * `LinearSolver::Tags::OperatorAppliedTo`.
54 : */
55 : template <typename Tag>
56 1 : struct Operand : db::PrefixTag, db::SimpleTag {
57 0 : static std::string name() {
58 : // Add "Linear" prefix to abbreviate the namespace for uniqueness
59 : return "LinearOperand(" + db::tag_name<Tag>() + ")";
60 : }
61 0 : using type = typename Tag::type;
62 0 : using tag = Tag;
63 : };
64 :
65 : /*!
66 : * \brief The linear operator \f$A\f$ applied to the data in `Tag`
67 : */
68 : template <typename Tag>
69 1 : struct OperatorAppliedTo : db::PrefixTag, db::SimpleTag {
70 0 : static std::string name() {
71 : // Add "Linear" prefix to abbreviate the namespace for uniqueness
72 : return "LinearOperatorAppliedTo(" + db::tag_name<Tag>() + ")";
73 : }
74 0 : using type = typename Tag::type;
75 0 : using tag = Tag;
76 : };
77 :
78 : /*!
79 : * \brief The residual \f$r=b - Ax\f$
80 : */
81 : template <typename Tag>
82 1 : struct Residual : db::PrefixTag, db::SimpleTag {
83 0 : static std::string name() {
84 : // Add "Linear" prefix to abbreviate the namespace for uniqueness
85 : return "LinearResidual(" + db::tag_name<Tag>() + ")";
86 : }
87 0 : using type = typename Tag::type;
88 0 : using tag = Tag;
89 : };
90 :
91 : /// Compute the residual \f$r=b - Ax\f$ from the `SourceTag` \f$b\f$ and the
92 : /// `db::add_tag_prefix<LinearSolver::Tags::OperatorAppliedTo, FieldsTag>`
93 : /// \f$Ax\f$.
94 : template <typename FieldsTag, typename SourceTag>
95 1 : struct ResidualCompute : db::add_tag_prefix<Residual, FieldsTag>,
96 : db::ComputeTag {
97 0 : using base = db::add_tag_prefix<Residual, FieldsTag>;
98 0 : using argument_tags =
99 : tmpl::list<SourceTag, db::add_tag_prefix<OperatorAppliedTo, FieldsTag>>;
100 0 : using return_type = typename base::type;
101 0 : static void function(
102 : const gsl::not_null<return_type*> residual,
103 : const typename SourceTag::type& source,
104 : const typename db::add_tag_prefix<OperatorAppliedTo, FieldsTag>::type&
105 : operator_applied_to_fields) {
106 : *residual = source - operator_applied_to_fields;
107 : }
108 : };
109 :
110 : /*!
111 : * \brief The magnitude square \f$\langle \cdot,\cdot\rangle\f$ w.r.t.
112 : * the `LinearSolver::inner_product`
113 : */
114 : template <typename Tag>
115 1 : struct MagnitudeSquare : db::PrefixTag, db::SimpleTag {
116 0 : static std::string name() {
117 : // Add "Linear" prefix to abbreviate the namespace for uniqueness
118 : return "LinearMagnitudeSquare(" + db::tag_name<Tag>() + ")";
119 : }
120 0 : using type = double;
121 0 : using tag = Tag;
122 : };
123 :
124 : /*!
125 : * \brief The magnitude \f$\sqrt{\langle \cdot,\cdot\rangle}\f$ w.r.t.
126 : * the `LinearSolver::inner_product`
127 : */
128 : template <typename Tag>
129 1 : struct Magnitude : db::PrefixTag, db::SimpleTag {
130 0 : static std::string name() {
131 : // Add "Linear" prefix to abbreviate the namespace for uniqueness
132 : return "LinearMagnitude(" + db::tag_name<Tag>() + ")";
133 : }
134 0 : using type = double;
135 0 : using tag = Tag;
136 : };
137 :
138 : /*!
139 : * \brief The prefix for tags related to an orthogonalization procedure
140 : */
141 : template <typename Tag>
142 1 : struct Orthogonalization : db::PrefixTag, db::SimpleTag {
143 0 : static std::string name() {
144 : // Add "Linear" prefix to abbreviate the namespace for uniqueness
145 : return "LinearOrthogonalization(" + db::tag_name<Tag>() + ")";
146 : }
147 0 : using type = typename Tag::type;
148 0 : using tag = Tag;
149 : };
150 :
151 : /*!
152 : * \brief A Hessenberg matrix built up during an orthogonalization procedure
153 : */
154 : template <typename Tag>
155 1 : struct OrthogonalizationHistory : db::PrefixTag, db::SimpleTag {
156 0 : using ValueType = tt::get_complex_or_fundamental_type_t<typename Tag::type>;
157 0 : static std::string name() {
158 : // Add "Linear" prefix to abbreviate the namespace for uniqueness
159 : return "LinearOrthogonalizationHistory(" + db::tag_name<Tag>() + ")";
160 : }
161 0 : using type = blaze::DynamicMatrix<ValueType>;
162 0 : using tag = Tag;
163 : };
164 :
165 : /*!
166 : * \brief A set of \f$n\f$ vectors that form a basis of the \f$n\f$-th Krylov
167 : * subspace \f$K_n(A,b)\f$
168 : *
169 : * \details The Krylov subspace \f$K_n(A,b)\f$ spanned by this basis is the one
170 : * generated by the linear operator \f$A\f$ and source \f$b\f$ that are
171 : * represented by the tags
172 : * `db::add_tag_prefix<LinearSolver::Tags::OperatorAppliedTo,
173 : * db::add_tag_prefix<LinearSolver::Tags::Operand, Tag>>` and
174 : * `db::add_tag_prefix<::Tags::FixedSource, Tag>`, respectively. Therefore, each
175 : * basis vector is of the type db::add_tag_prefix<Operand, Tag>::type.
176 : */
177 : template <typename Tag>
178 1 : struct KrylovSubspaceBasis : db::PrefixTag, db::SimpleTag {
179 : // Use automatically generated name because a Krylov subspace always refers to
180 : // a linear operator
181 0 : using type = std::vector<typename Tag::type>;
182 0 : using tag = Tag;
183 : };
184 :
185 : /// Indicates the `Tag` is related to preconditioning of the linear solve
186 : template <typename Tag>
187 1 : struct Preconditioned : db::PrefixTag, db::SimpleTag {
188 0 : using type = typename Tag::type;
189 0 : using tag = Tag;
190 : };
191 :
192 : /// Whether or not volume data should be recorded for debugging purposes
193 : template <typename OptionsGroup>
194 1 : struct OutputVolumeData : db::SimpleTag {
195 0 : using type = bool;
196 0 : static constexpr bool pass_metavariables = false;
197 0 : using option_tags = tmpl::list<OptionTags::OutputVolumeData<OptionsGroup>>;
198 0 : static type create_from_options(const type value) { return value; };
199 0 : static std::string name() {
200 : return "OutputVolumeData(" + pretty_type::name<OptionsGroup>() + ")";
201 : }
202 : };
203 :
204 : /// Continuously incrementing ID for volume observations
205 : template <typename OptionsGroup>
206 1 : struct ObservationId : db::SimpleTag {
207 0 : using type = size_t;
208 0 : static std::string name() {
209 : return "ObservationId(" + pretty_type::name<OptionsGroup>() + ")";
210 : }
211 : };
212 :
213 : } // namespace Tags
214 : } // namespace LinearSolver
|
