OptionTags.hpp
1 // Distributed under the MIT License.
2 // See LICENSE.txt for details.
3 
4 #pragma once
5 
6 #include <cstddef>
7 #include <limits>
8 #include <optional>
9 
10 #include "DataStructures/DataBox/Tag.hpp"
11 #include "Evolution/Systems/Cce/AnalyticBoundaryDataManager.hpp"
12 #include "Evolution/Systems/Cce/AnalyticSolutions/WorldtubeData.hpp"
13 #include "Evolution/Systems/Cce/Initialize/InitializeJ.hpp"
14 #include "Evolution/Systems/Cce/InterfaceManagers/GhInterfaceManager.hpp"
15 #include "Evolution/Systems/Cce/InterfaceManagers/GhInterpolationStrategies.hpp"
16 #include "Evolution/Systems/Cce/InterfaceManagers/GhLockstep.hpp"
17 #include "Evolution/Systems/Cce/WorldtubeDataManager.hpp"
18 #include "NumericalAlgorithms/Interpolation/SpanInterpolator.hpp"
19 #include "Options/Auto.hpp"
20 #include "Options/Options.hpp"
21 #include "Parallel/Printf.hpp"
22 #include "Time/Tags.hpp"
23 
24 namespace Cce {
25 namespace OptionTags {
26 
27 /// %Option group
28 struct Cce {
29  static constexpr Options::String help = {
30  "Options for the Cce evolution system"};
31 };
32 
33 /// %Option group
34 struct Filtering {
35  static constexpr Options::String help = {"Options for the filtering in Cce"};
36  using group = Cce;
37 };
38 
39 /// %Option group for evolution-related quantities in the CCE system
40 struct Evolution {
41  static constexpr Options::String help = {"Options for the CCE evolution"};
42  using group = Cce;
43 };
44 
45 /// A prefix for common tags (e.g. from Time/Tags.hpp) that are specific to CCE,
46 /// so should be in the Cce::Evolution group.
47 template <typename OptionTag>
49  using type = typename OptionTag::type;
50  static std::string name() noexcept {
51  return Options::template name<OptionTag>();
52  }
53  static constexpr Options::String help = OptionTag::help;
54  using group = Evolution;
55 };
56 
57 struct LMax {
58  using type = size_t;
59  static constexpr Options::String help{
60  "Maximum l value for spin-weighted spherical harmonics"};
61  using group = Cce;
62 };
63 
64 struct FilterLMax {
65  using type = size_t;
66  static constexpr Options::String help{"l mode cutoff for angular filtering"};
67  using group = Filtering;
68 };
69 
71  using type = double;
72  static constexpr Options::String help{
73  "alpha parameter in exponential radial filter"};
74  using group = Filtering;
75 };
76 
78  using type = size_t;
79  static constexpr Options::String help{
80  "Half-power of the exponential radial filter argument"};
81  using group = Filtering;
82 };
83 
85  using type = size_t;
86  static constexpr Options::String help{"Maximum l value for swsh output"};
87  using group = Cce;
88 };
89 
91  using type = size_t;
92  static constexpr Options::String help{
93  "Number of radial grid points in the spherical domain"};
94  using group = Cce;
95 };
96 
98  using type = double;
99  static constexpr Options::String help{"Extraction radius of the CCE system."};
100  using group = Cce;
101 };
102 
104  static std::string name() noexcept { return "ExtractionRadius"; }
105  using type = Options::Auto<double>;
106 
107  static constexpr Options::String help{
108  "Extraction radius of the CCE system for a standalone run. This may be "
109  "set to \"Auto\" to infer the radius from the filename (often used for "
110  "SpEC worldtube data). This option is unused if `H5IsBondiData` is "
111  "`true`, and should be \"Auto\" for such runs."};
112  using group = Cce;
113 };
114 
115 struct EndTime {
116  using type = Options::Auto<double>;
117  static constexpr Options::String help{"End time for the Cce Evolution."};
118  static type suggested_value() noexcept { return {}; }
119  using group = Cce;
120 };
121 
122 struct StartTime {
123  using type = Options::Auto<double>;
124  static constexpr Options::String help{
125  "Cce Start time (default to earliest possible time)."};
126  static type suggested_value() noexcept { return {}; }
127  using group = Cce;
128 };
129 
131  using type = std::string;
132  static constexpr Options::String help{
133  "H5 file to read the wordltube data from."};
134  using group = Cce;
135 };
136 
138  using type = size_t;
139  static constexpr Options::String help{
140  "Number of times steps from the h5 to cache each read."};
141  static size_t suggested_value() noexcept { return 200; }
142  using group = Cce;
143 };
144 
147  static constexpr Options::String help{
148  "The interpolator for imported h5 worldtube data."};
149  using group = Cce;
150 };
151 
153  using type = bool;
154  static constexpr Options::String help{
155  "true for boundary data in Bondi form, false for metric data. Metric "
156  "data is more readily available from Cauchy simulations, so historically "
157  "has been the typical format provided by SpEC simulations. Bondi data is "
158  "much more efficient for storage size and performance, but both must be "
159  "supported for compatibility with current CCE data sources."};
160  using group = Cce;
161 };
162 
164  using type = bool;
165  static constexpr Options::String help{
166  "Set to true if corrections for SpEC data impurities should be applied "
167  "automatically based on the `VersionHist.ver` data set in the H5. "
168  "Typically, this should be set to true if the metric data is created "
169  "from SpEC, and false otherwise."};
170  using group = Cce;
171 };
172 
175  static constexpr Options::String help{
176  "Analytic worldtube data for tests of CCE."};
177  using group = Cce;
178 };
179 
182  static constexpr Options::String help{
183  "Class to manage worldtube data from a GH system."};
184  using group = Cce;
185 };
186 
188  static std::string name() noexcept { return "ScriInterpOrder"; }
189  using type = size_t;
190  static constexpr Options::String help{
191  "Order of time interpolation at scri+."};
192  static size_t suggested_value() noexcept { return 5; }
193  using group = Cce;
194 };
195 
197  using type = size_t;
198  static constexpr Options::String help{
199  "Number of scri output points per timestep."};
200  static size_t suggested_value() noexcept { return 1; }
201  using group = Cce;
202 };
203 
204 struct InitializeJ {
206  static constexpr Options::String help{
207  "The initialization for the first hypersurface for J"};
208  using group = Cce;
209 };
210 
211 } // namespace OptionTags
212 
213 namespace InitializationTags {
215  using type = size_t;
216  using option_tags = tmpl::list<OptionTags::ScriInterpolationOrder>;
217 
218  static constexpr bool pass_metavariables = false;
219  static size_t create_from_options(
220  const size_t scri_plus_interpolation_order) noexcept {
221  return scri_plus_interpolation_order;
222  }
223 };
224 
226  using type = double;
227  using option_tags = tmpl::list<OptionTags::ExtractionRadius>;
228 
229  static constexpr bool pass_metavariables = false;
230  static double create_from_options(const double extraction_radius) noexcept {
231  return extraction_radius;
232  }
233 };
234 
236  using type = size_t;
237  using option_tags = tmpl::list<OptionTags::ScriOutputDensity>;
238 
239  static constexpr bool pass_metavariables = false;
240  static size_t create_from_options(const size_t scri_output_density) noexcept {
241  return scri_output_density;
242  }
243 };
244 } // namespace InitializationTags
245 
246 namespace Tags {
247 /// Tag for duplicating functionality of another tag, but allows creation from
248 /// options in the Cce::Evolution option group.
249 template <typename Tag>
250 struct CceEvolutionPrefix : Tag {
251  using type = typename Tag::type;
253  typename Tag::option_tags>;
254  static std::string name() noexcept { return Options::template name<Tag>(); }
255 
256  static constexpr bool pass_metavariables = Tag::pass_metavariables;
257  template <typename Metavariables, typename... Args>
258  static type create_from_options(const Args&... args) noexcept {
259  return Tag::template create_from_options<Metavariables>(args...);
260  }
261 
262  template <typename... Args>
263  static type create_from_options(const Args&... args) noexcept {
264  return Tag::create_from_options(args...);
265  }
266 };
267 
268 /// A tag that constructs a `MetricWorldtubeDataManager` from options
271  using option_tags =
276 
277  static constexpr bool pass_metavariables = false;
278  static type create_from_options(
279  const size_t l_max, const std::string& filename,
280  const size_t number_of_lookahead_times,
281  const std::unique_ptr<intrp::SpanInterpolator>& interpolator,
282  const bool h5_is_bondi_data, const bool fix_spec_normalization,
283  const std::optional<double> extraction_radius) noexcept {
284  if (h5_is_bondi_data) {
285  if (static_cast<bool>(extraction_radius)) {
287  "Warning: Option ExtractionRadius is set to a specific value and "
288  "H5IsBondiData is set to `true` -- the ExtractionRadius will not "
289  "be used, because all radius information is specified in the input "
290  "file for the Bondi worldtube data format. It is recommended to "
291  "set `ExtractionRadius` to `\"Auto\"` to make the input file "
292  "clearer.");
293  }
294  return std::make_unique<BondiWorldtubeDataManager>(
295  std::make_unique<BondiWorldtubeH5BufferUpdater>(filename,
296  extraction_radius),
297  l_max, number_of_lookahead_times, interpolator->get_clone());
298  } else {
299  return std::make_unique<MetricWorldtubeDataManager>(
300  std::make_unique<MetricWorldtubeH5BufferUpdater>(filename,
301  extraction_radius),
302  l_max, number_of_lookahead_times, interpolator->get_clone(),
303  fix_spec_normalization);
304  }
305  }
306 };
307 
309  using type = size_t;
310  using option_tags = tmpl::list<OptionTags::LMax>;
311 
312  static constexpr bool pass_metavariables = false;
313  static size_t create_from_options(const size_t l_max) noexcept {
314  return l_max;
315  }
316 };
317 
320  using type = size_t;
321  using option_tags = tmpl::list<OptionTags::NumberOfRadialPoints>;
322 
323  static constexpr bool pass_metavariables = false;
324  static size_t create_from_options(
325  const size_t number_of_radial_points) noexcept {
326  return number_of_radial_points;
327  }
328 };
329 
331  using type = size_t;
332  using option_tags = tmpl::list<OptionTags::ObservationLMax>;
333 
334  static constexpr bool pass_metavariables = false;
335  static size_t create_from_options(const size_t observation_l_max) noexcept {
336  return observation_l_max;
337  }
338 };
339 
341  using type = size_t;
342  using option_tags = tmpl::list<OptionTags::FilterLMax>;
343 
344  static constexpr bool pass_metavariables = false;
345  static size_t create_from_options(const size_t filter_l_max) noexcept {
346  return filter_l_max;
347  }
348 };
349 
351  using type = double;
352  using option_tags = tmpl::list<OptionTags::RadialFilterAlpha>;
353 
354  static constexpr bool pass_metavariables = false;
355  static double create_from_options(const double radial_filter_alpha) noexcept {
356  return radial_filter_alpha;
357  }
358 };
359 
361  using type = size_t;
362  using option_tags = tmpl::list<OptionTags::RadialFilterHalfPower>;
363 
364  static constexpr bool pass_metavariables = false;
365  static size_t create_from_options(
366  const size_t radial_filter_half_power) noexcept {
367  return radial_filter_half_power;
368  }
369 };
370 
371 /// \brief Represents the start time of a bounded CCE evolution, determined
372 /// either from option specification or from the file
373 ///
374 /// \details If no start time is specified in the input file (so the option
375 /// `OptionTags::StartTime` is set to "Auto"), this will find the start time
376 /// from the provided H5 file. If `OptionTags::StartTime` takes any other value,
377 /// it will be used directly as the start time for the CCE evolution instead.
379  using type = double;
380  using option_tags =
383 
384  static constexpr bool pass_metavariables = false;
385  static double create_from_options(const std::optional<double> start_time,
386  const std::string& filename,
387  const bool is_bondi_data) noexcept {
388  if (start_time) {
389  return *start_time;
390  }
391  if (is_bondi_data) {
392  BondiWorldtubeH5BufferUpdater h5_boundary_updater{filename};
393  const auto& time_buffer = h5_boundary_updater.get_time_buffer();
394  return time_buffer[0];
395  } else {
396  MetricWorldtubeH5BufferUpdater h5_boundary_updater{filename};
397  const auto& time_buffer = h5_boundary_updater.get_time_buffer();
398  return time_buffer[0];
399  }
400  }
401 };
402 
403 /// \brief Represents the start time of a bounded CCE evolution that must be
404 /// supplied in the input file (for e.g. analytic tests).
406  using type = double;
407  using option_tags = tmpl::list<OptionTags::StartTime>;
408 
409  static constexpr bool pass_metavariables = false;
410  static double create_from_options(
411  const std::optional<double> start_time) noexcept {
412  if (not start_time.has_value()) {
413  ERROR(
414  "The start time must be explicitly specified for the tag "
415  "`SpecifiedStartTime`");
416  }
417  return *start_time;
418  }
419 };
420 
421 /// \brief Represents the final time of a bounded CCE evolution, determined
422 /// either from option specification or from the file
423 ///
424 /// \details If no end time is specified in the input file (so the option
425 /// `OptionTags::EndTime` is set to "Auto"), this will find the end time
426 /// from the provided H5 file. If `OptionTags::EndTime` takes any other value,
427 /// it will be used directly as the final time for the CCE evolution instead.
429  using type = double;
430  using option_tags =
433 
434  static constexpr bool pass_metavariables = false;
435  static double create_from_options(const std::optional<double> end_time,
436  const std::string& filename,
437  const bool is_bondi_data) {
438  if (end_time) {
439  return *end_time;
440  }
441  if (is_bondi_data) {
442  BondiWorldtubeH5BufferUpdater h5_boundary_updater{filename};
443  const auto& time_buffer = h5_boundary_updater.get_time_buffer();
444  return time_buffer[time_buffer.size() - 1];
445  } else {
446  MetricWorldtubeH5BufferUpdater h5_boundary_updater{filename};
447  const auto& time_buffer = h5_boundary_updater.get_time_buffer();
448  return time_buffer[time_buffer.size() - 1];
449  }
450  }
451 };
452 
453 /// \brief Represents the final time of a CCE evolution that should just proceed
454 /// until it receives no more boundary data and becomes quiescent.
456  using type = double;
457  using option_tags = tmpl::list<>;
458 
459  static constexpr bool pass_metavariables = false;
460  static double create_from_options() noexcept {
462  }
463 };
464 
465 /// \brief Represents the final time of a bounded CCE evolution that must be
466 /// supplied in the input file (for e.g. analytic tests).
468  using type = double;
469  using option_tags = tmpl::list<OptionTags::EndTime>;
470 
471  static constexpr bool pass_metavariables = false;
472  static double create_from_options(
473  const std::optional<double> end_time) noexcept {
474  if (not end_time.has_value()) {
475  ERROR(
476  "The end time must be explicitly specified for the tag "
477  "`SpecifiedEndTime`");
478  }
479  return *end_time;
480  }
481 };
482 
485  using option_tags = tmpl::list<OptionTags::GhInterfaceManager>;
486 
487  static constexpr bool pass_metavariables = false;
489  create_from_options(
491  interface_manager) noexcept {
492  return interface_manager->get_clone();
493  }
494 };
495 
496 /// \brief Intended for use in the const global cache to communicate to the
497 /// sending elements when they should be sending worldtube data for CCE to the
498 /// interpolator.
499 ///
500 /// \details This tag is not specifiable by independent options in the yaml, and
501 /// instead is entirely determined by the choice of interface manager, which
502 /// sets by virtual member function the interpolation strategy that is
503 /// compatible with the interface manager. The choice to extract this
504 /// information at option-parsing is to avoid needing to pass any information
505 /// from the interpolation manager that is typically stored in the
506 /// `WorldtubeBoundary` component \ref DataBoxGroup to the components that
507 /// provide data for CCE.
510  using option_tags = tmpl::list<OptionTags::GhInterfaceManager>;
511 
512  static constexpr bool pass_metavariables = false;
513  static InterfaceManagers::InterpolationStrategy create_from_options(
515  interface_manager) noexcept {
516  return interface_manager->get_interpolation_strategy();
517  }
518 };
519 
520 /// Base tag for first-hypersurface initialization procedure
522 
523 /// Tag for first-hypersurface initialization procedure specified by input
524 /// options.
527  using option_tags = tmpl::list<OptionTags::InitializeJ>;
528 
529  static constexpr bool pass_metavariables = false;
530  static std::unique_ptr<::Cce::InitializeJ::InitializeJ> create_from_options(
532  initialize_j) noexcept {
533  return initialize_j->get_clone();
534  }
535 };
536 
537 // Tags that generates an `Cce::InitializeJ::InitializeJ` derived class from an
538 // analytic solution.
541  using option_tags =
542  tmpl::list<OptionTags::AnalyticSolution, OptionTags::StartTime>;
543  static constexpr bool pass_metavariables = false;
544  static std::unique_ptr<::Cce::InitializeJ::InitializeJ> create_from_options(
546  const std::optional<double> start_time) noexcept {
547  return worldtube_data->get_initialize_j(*start_time);
548  }
549 };
550 
551 /// A tag that constructs a `AnalyticBoundaryDataManager` from options
554  using option_tags = tmpl::list<OptionTags::ExtractionRadius, OptionTags::LMax,
556 
557  static constexpr bool pass_metavariables = false;
558  static Cce::AnalyticBoundaryDataManager create_from_options(
559  const double extraction_radius, const size_t l_max,
561  worldtube_data) noexcept {
562  return ::Cce::AnalyticBoundaryDataManager(l_max, extraction_radius,
563  worldtube_data->get_clone());
564  }
565 };
566 
567 /// Represents whether the news should be provided at noninertial times.
568 ///
569 /// \details Currently, this is only useful for analytic solutions for which the
570 /// inertial-time news is difficult to compute.
572  using type = bool;
573  using option_tags =
574  tmpl::list<OptionTags::AnalyticSolution>;
575  static constexpr bool pass_metavariables = false;
576  static bool create_from_options(
578  worldtube_data) noexcept {
579  return worldtube_data->use_noninertial_news();
580  }
581 };
582 } // namespace Tags
583 } // namespace Cce
Cce::MetricWorldtubeH5BufferUpdater
A WorldtubeBufferUpdater specialized to the CCE input worldtube H5 file produced by SpEC.
Definition: WorldtubeBufferUpdater.hpp:175
Cce::Tags::CceEvolutionPrefix
Tag for duplicating functionality of another tag, but allows creation from options in the Cce::Evolut...
Definition: OptionTags.hpp:250
Cce::OptionTags::CceEvolutionPrefix
A prefix for common tags (e.g. from Time/Tags.hpp) that are specific to CCE, so should be in the Cce:...
Definition: OptionTags.hpp:48
std::string
Cce::OptionTags::AnalyticSolution
Definition: OptionTags.hpp:173
Cce::InitializationTags::ScriOutputDensity
Definition: OptionTags.hpp:235
Cce::OptionTags::ScriOutputDensity
Definition: OptionTags.hpp:196
Cce::Tags::InterfaceManagerInterpolationStrategy
Intended for use in the const global cache to communicate to the sending elements when they should be...
Definition: OptionTags.hpp:508
Cce::Tags::NumberOfRadialPoints
Definition: OptionTags.hpp:318
Options.hpp
Parallel::printf
void printf(const std::string &format, Args &&... args)
Print an atomic message to stdout with C printf usage.
Definition: Printf.hpp:103
Cce::OptionTags::Evolution
Option group for evolution-related quantities in the CCE system
Definition: OptionTags.hpp:40
Cce::OptionTags::ObservationLMax
Definition: OptionTags.hpp:84
Cce::OptionTags::H5LookaheadTimes
Definition: OptionTags.hpp:137
Cce::OptionTags::LMax
Definition: OptionTags.hpp:57
db::SimpleTag
Mark a struct as a simple tag by inheriting from this.
Definition: Tag.hpp:36
Cce::OptionTags::StandaloneExtractionRadius
Definition: OptionTags.hpp:103
Cce::OptionTags::FilterLMax
Definition: OptionTags.hpp:64
Cce::OptionTags::StartTime
Definition: OptionTags.hpp:122
Cce::OptionTags::EndTime
Definition: OptionTags.hpp:115
Cce::BondiWorldtubeH5BufferUpdater
A WorldtubeBufferUpdater specialized to the CCE input worldtube H5 file produced by the reduced SpEC ...
Definition: WorldtubeBufferUpdater.hpp:261
Cce::Tags::EndTime
Definition: Tags.hpp:312
ERROR
#define ERROR(m)
prints an error message to the standard error stream and aborts the program.
Definition: Error.hpp:37
Cce::Tags::SpecifiedEndTime
Represents the final time of a bounded CCE evolution that must be supplied in the input file (for e....
Definition: OptionTags.hpp:467
Cce::Tags::ObservationLMax
Definition: OptionTags.hpp:330
Cce::OptionTags::H5IsBondiData
Definition: OptionTags.hpp:152
Cce::Tags::InitializeJBase
Base tag for first-hypersurface initialization procedure.
Definition: OptionTags.hpp:521
Parallel::create_from_options
tuples::TaggedTuple< Tags... > create_from_options(const tuples::TaggedTuple< OptionTags... > &options, tmpl::list< Tags... >) noexcept
Given a list of tags and a tagged tuple containing items created from input options,...
Definition: CreateFromOptions.hpp:40
Printf.hpp
std::numeric_limits::infinity
T infinity(T... args)
Cce::OptionTags::Cce
Option group
Definition: OptionTags.hpp:28
Spectral::Swsh::Tags::NumberOfRadialPointsBase
Base Tag for the number of radial grid points in the three-dimensional representation of radially con...
Definition: SwshTags.hpp:209
cstddef
Cce::OptionTags::ExtractionRadius
Definition: OptionTags.hpp:97
Spectral::Swsh::Tags::LMaxBase
Base Tag for the maximum spin-weighted spherical harmonic l; sets angular resolution.
Definition: SwshTags.hpp:197
Cce::OptionTags::RadialFilterHalfPower
Definition: OptionTags.hpp:77
Cce::Tags::NoEndTime
Represents the final time of a CCE evolution that should just proceed until it receives no more bound...
Definition: OptionTags.hpp:455
Cce::OptionTags::FixSpecNormalization
Definition: OptionTags.hpp:163
Cce::Tags::AnalyticBoundaryDataManager
A tag that constructs a AnalyticBoundaryDataManager from options.
Definition: OptionTags.hpp:552
Cce::Tags::EndTimeFromFile
Represents the final time of a bounded CCE evolution, determined either from option specification or ...
Definition: OptionTags.hpp:428
db::BaseTag
Mark a (usually) empty struct as a base tag by inheriting from this.
Definition: Tag.hpp:69
Options::Auto
A class indicating that a parsed value can be automatically computed instead of specified.
Definition: Auto.hpp:36
Cce::AnalyticBoundaryDataManager
A boundary data manager that constructs the desired boundary data into the Variables from the data pr...
Definition: AnalyticBoundaryDataManager.hpp:38
Cce::Tags::RadialFilterAlpha
Definition: OptionTags.hpp:350
Cce::Tags::GhInterfaceManager
Definition: OptionTags.hpp:483
Cce
The set of utilities for performing Cauchy characteristic evolution and Cauchy characteristic matchin...
Definition: CharacteristicExtractFwd.hpp:6
limits
Cce::Tags::FilterLMax
Definition: OptionTags.hpp:340
Options::String
const char *const String
The string used in option structs.
Definition: Options.hpp:32
Cce::Tags::InitializeJ
Tag for first-hypersurface initialization procedure specified by input options.
Definition: OptionTags.hpp:525
Cce::Tags::RadialFilterHalfPower
Definition: OptionTags.hpp:360
Cce::Tags::H5WorldtubeBoundaryDataManager
A tag that constructs a MetricWorldtubeDataManager from options.
Definition: OptionTags.hpp:269
Cce::Tags::OutputNoninertialNews
Represents whether the news should be provided at noninertial times.
Definition: OptionTags.hpp:571
db::wrap_tags_in
tmpl::transform< TagList, tmpl::bind< Wrapper, tmpl::_1, tmpl::pin< Args >... > > wrap_tags_in
Create a new tmpl::list of tags by wrapping each tag in TagList in Wrapper<_, Args....
Definition: PrefixHelpers.hpp:30
Cce::OptionTags::InitializeJ
Definition: OptionTags.hpp:204
Cce::OptionTags::ScriInterpolationOrder
Definition: OptionTags.hpp:187
Cce::OptionTags::RadialFilterAlpha
Definition: OptionTags.hpp:70
optional
Cce::Tags::LMax
Definition: OptionTags.hpp:308
Cce::OptionTags::H5Interpolator
Definition: OptionTags.hpp:145
Cce::OptionTags::Filtering
Option group
Definition: OptionTags.hpp:34
Cce::OptionTags::GhInterfaceManager
Definition: OptionTags.hpp:180
Cce::OptionTags::NumberOfRadialPoints
Definition: OptionTags.hpp:90
Cce::InitializationTags::ScriInterpolationOrder
Definition: OptionTags.hpp:214
Cce::Tags::SpecifiedStartTime
Represents the start time of a bounded CCE evolution that must be supplied in the input file (for e....
Definition: OptionTags.hpp:405
std::unique_ptr< intrp::SpanInterpolator >
Cce::Tags::StartTimeFromFile
Represents the start time of a bounded CCE evolution, determined either from option specification or ...
Definition: OptionTags.hpp:378
Cce::Tags::StartTime
Definition: Tags.hpp:314
Cce::Tags::AnalyticInitializeJ
Definition: OptionTags.hpp:539
Cce::InterfaceManagers::InterpolationStrategy
InterpolationStrategy
Enumeration of possibilities for the collection of worldtube data that will be collected by the inter...
Definition: GhInterpolationStrategies.hpp:31
Cce::InitializationTags::ExtractionRadius
Definition: OptionTags.hpp:225
Cce::OptionTags::BoundaryDataFilename
Definition: OptionTags.hpp:130