Line data Source code
1 0 : // Distributed under the MIT License.
2 : // See LICENSE.txt for details.
3 :
4 : #pragma once
5 :
6 : #include <cstddef>
7 : #include <iomanip>
8 : #include <map>
9 : #include <sstream>
10 : #include <string>
11 : #include <unordered_map>
12 : #include <unordered_set>
13 : #include <variant>
14 :
15 : #include "DataStructures/DataBox/Tag.hpp"
16 : #include "DataStructures/TaggedTuple.hpp"
17 : #include "DataStructures/Tensor/TypeAliases.hpp"
18 : #include "IO/Importers/ObservationSelector.hpp"
19 : #include "NumericalAlgorithms/Spectral/Mesh.hpp"
20 : #include "Options/Auto.hpp"
21 : #include "Options/String.hpp"
22 : #include "Parallel/ArrayComponentId.hpp"
23 : #include "Parallel/InboxInserters.hpp"
24 : #include "Utilities/PrettyType.hpp"
25 :
26 : /// Items related to loading data from files
27 : namespace importers {
28 :
29 : /// The input file options associated with the data importer
30 1 : namespace OptionTags {
31 :
32 : /*!
33 : * \brief The file to read data from.
34 : */
35 1 : struct FileGlob {
36 0 : using type = std::string;
37 0 : static constexpr Options::String help = "Path to the data file";
38 : };
39 :
40 : /*!
41 : * \brief The subgroup within the file to read data from.
42 : *
43 : * This subgroup should conform to the `h5::VolumeData` format.
44 : */
45 1 : struct Subgroup {
46 0 : using type = std::string;
47 0 : static constexpr Options::String help =
48 : "The subgroup within the file, excluding extensions";
49 : };
50 :
51 : /*!
52 : * \brief The observation value at which to read data from the file.
53 : */
54 1 : struct ObservationValue {
55 0 : using type = std::variant<double, ObservationSelector>;
56 0 : static constexpr Options::String help =
57 : "The observation value at which to read data";
58 : };
59 :
60 0 : struct ObservationValueEpsilon {
61 0 : using type = Options::Auto<double>;
62 0 : static constexpr Options::String help =
63 : "Look for observations in the data within this epsilon of the "
64 : "'ObservationValue'. Set to 'Auto' to use default of 1e-12. This option "
65 : "is ignored if the 'ObservationValue' is a selector like 'First' or "
66 : "'Last'.";
67 : };
68 :
69 : /*!
70 : * \brief Toggle interpolation of numeric data to the target domain
71 : */
72 1 : struct ElementsAreIdentical {
73 0 : using type = bool;
74 0 : static constexpr Options::String help =
75 : "Indicate that the elements of the source and target domain are the "
76 : "same, meaning that the domains are the same and their h-refinement is "
77 : "the same. In this case, data can be transferred between the source and "
78 : "target elements one-to-one, and interpolations only happen if the "
79 : "elements have different meshes (p-refinement). "
80 : "For example, you can enable this option if you have generated data "
81 : "on the target points, or if you have already interpolated your data, "
82 : "or if you import data from a simulation that differs only by "
83 : "p-refinement. "
84 : "When this option is enabled, datasets "
85 : "'InertialCoordinates(_x,_y,_z)' must exist in the files. They are used "
86 : "to verify that the target points indeed match the source data.";
87 : };
88 :
89 : /*!
90 : * \brief Extrapolate data into excised regions of the source domain.
91 : */
92 1 : struct ExtrapolateIntoExcisions {
93 0 : using type = bool;
94 0 : static constexpr Options::String help =
95 : "Fill target points that fall inside excised regions of the source "
96 : "domain by extrapolating the source data into the excision (see "
97 : "'spectre::Exporter::interpolate_to_points').";
98 : };
99 :
100 : /*!
101 : * \brief Number of threads to use to accelerate the import with OpenMP, or
102 : * 'Auto' to use all available threads.
103 : */
104 1 : struct NumThreads {
105 0 : using type = Options::Auto<size_t>;
106 0 : static constexpr Options::String help =
107 : "Number of threads to use to read and interpolate the volume data with "
108 : "OpenMP, or 'Auto' to use all available threads. Keep this at 1 (serial) "
109 : "unless you know the node is otherwise idle during the import (e.g. when "
110 : "loading initial data), because the importer shares the node with the "
111 : "Charm++ worker threads and additional threads can oversubscribe them. "
112 : "Has no effect if the code was built without OpenMP support.";
113 : };
114 : } // namespace OptionTags
115 :
116 : /// Options that specify the volume data to load. See the option tags for
117 : /// details.
118 1 : struct ImporterOptions
119 : : tuples::TaggedTuple<
120 : OptionTags::FileGlob, OptionTags::Subgroup,
121 : OptionTags::ObservationValue, OptionTags::ObservationValueEpsilon,
122 : OptionTags::ElementsAreIdentical,
123 : OptionTags::ExtrapolateIntoExcisions, OptionTags::NumThreads> {
124 0 : using options = tags_list;
125 0 : static constexpr Options::String help = "The volume data to load.";
126 : using TaggedTuple::TaggedTuple;
127 : };
128 :
129 : namespace OptionTags {
130 : /// Bundles all \ref importers::ImporterOptions for use in factory-creatable
131 : /// classes
132 1 : struct VolumeData {
133 0 : using type = ImporterOptions;
134 0 : static constexpr Options::String help = ImporterOptions::help;
135 : };
136 : } // namespace OptionTags
137 :
138 : /// The \ref DataBoxGroup tags associated with the data importer
139 : namespace Tags {
140 :
141 : /// Options that specify the volume data to load. See the option tags for
142 : /// details.
143 : template <typename OptionsGroup>
144 1 : struct ImporterOptions : db::SimpleTag {
145 0 : static std::string name() { return "VolumeData"; }
146 0 : using type = importers::ImporterOptions;
147 0 : static constexpr Options::String help = importers::ImporterOptions::help;
148 0 : using group = OptionsGroup;
149 0 : using option_tags = tmpl::list<ImporterOptions>;
150 0 : static constexpr bool pass_metavariables = false;
151 0 : static type create_from_options(type value) { return value; }
152 : };
153 :
154 : /*!
155 : * \brief The elements that will receive data from the importer.
156 : *
157 : * \details Identifiers for elements from multiple parallel components can be
158 : * stored. Each element is identified by an `Parallel::ArrayComponentId` and
159 : * also needs to provide the inertial coordinates of its grid points. The
160 : * imported data will be interpolated to these grid points.
161 : */
162 : template <size_t Dim>
163 1 : struct RegisteredElements : db::SimpleTag {
164 0 : using type = std::unordered_map<
165 : Parallel::ArrayComponentId,
166 : std::pair<tnsr::I<DataVector, Dim, Frame::Inertial>, ::Mesh<Dim>>>;
167 : };
168 :
169 : /// Indicates which volume data files have already been read.
170 1 : struct ElementDataAlreadyRead : db::SimpleTag {
171 0 : using type = std::unordered_set<size_t>;
172 : };
173 :
174 : /*!
175 : * \brief Inbox tag that carries the data read from a volume data file.
176 : *
177 : * Since we read a volume data file only once, this tag's map will only ever
178 : * hold data at the index (i.e. the temporal ID) with value `0`.
179 : */
180 : template <typename FieldTagsList>
181 1 : struct VolumeData : Parallel::InboxInserters::Value<VolumeData<FieldTagsList>> {
182 0 : using temporal_id = size_t;
183 0 : using type =
184 : std::map<temporal_id, tuples::tagged_tuple_from_typelist<FieldTagsList>>;
185 :
186 0 : static std::string output_inbox(const type& inbox,
187 : const size_t padding_size) {
188 : std::stringstream ss{};
189 : const std::string pad(padding_size, ' ');
190 :
191 : ss << std::scientific << std::setprecision(16);
192 : ss << pad << "VolumeDataInbox:\n";
193 : // We don't really care about the variables, just the times
194 : for (const auto& [index, variables] : inbox) {
195 : (void)variables;
196 : ss << pad << " Index: " << index << "\n";
197 : }
198 :
199 : return ss.str();
200 : }
201 : };
202 : } // namespace Tags
203 :
204 : } // namespace importers
|
