BinaryCompactObject.hpp
1 // Distributed under the MIT License.
2 // See LICENSE.txt for details.
3 
4 #pragma once
5 
6 #include <array>
7 #include <cstddef>
8 #include <limits>
9 #include <memory>
10 #include <optional>
11 #include <string>
12 #include <type_traits>
13 #include <unordered_map>
14 #include <vector>
15 
16 #include "Domain/BoundaryConditions/BoundaryCondition.hpp"
17 #include "Domain/BoundaryConditions/GetBoundaryConditionsBase.hpp"
20 #include "Domain/Domain.hpp"
21 #include "Options/Auto.hpp"
22 #include "Options/Options.hpp"
24 #include "Utilities/TMPL.hpp"
25 
26 /// \cond
27 namespace domain {
28 namespace CoordinateMaps {
29 class Affine;
30 class Equiangular;
31 template <size_t VolumeDim>
32 class Identity;
33 template <typename Map1, typename Map2>
34 class ProductOf2Maps;
35 template <typename Map1, typename Map2, typename Map3>
36 class ProductOf3Maps;
37 template <size_t Dim>
38 class Wedge;
39 template <size_t VolumeDim>
40 class DiscreteRotation;
41 class Frustum;
42 namespace TimeDependent {
43 template <size_t VolumeDim>
44 class CubicScale;
45 template <size_t VolumeDim>
46 class Rotation;
47 template <bool InteriorMap>
48 class SphericalCompression;
49 template <typename Map1, typename Map2>
50 class ProductOf2Maps;
51 } // namespace TimeDependent
52 } // namespace CoordinateMaps
53 
54 template <typename SourceFrame, typename TargetFrame, typename... Maps>
55 class CoordinateMap;
56 
57 namespace FunctionsOfTime {
58 class FunctionOfTime;
59 } // namespace FunctionsOfTime
60 } // namespace domain
61 
62 namespace Frame {
63 struct Inertial;
64 struct Logical;
65 } // namespace Frame
66 
67 namespace BinaryCompactObject_detail {
68 // If `Metavariables` has a `domain_parameters` member struct and
69 // `domain_parameters::enable_time_dependent_maps` is `true`, then
70 // inherit from `std::true_type`; otherwise, inherit from `std::false_type`.
71 template <typename Metavariables, typename = std::void_t<>>
72 struct enable_time_dependent_maps : std::false_type {};
73 
74 template <typename Metavariables>
75 struct enable_time_dependent_maps<Metavariables,
76  std::void_t<typename Metavariables::domain>>
77  : std::bool_constant<Metavariables::domain::enable_time_dependent_maps> {};
78 
79 template <typename Metavariables>
80 constexpr bool enable_time_dependent_maps_v =
81  enable_time_dependent_maps<Metavariables>::value;
82 } // namespace BinaryCompactObject_detail
83 /// \endcond
84 
85 namespace domain {
86 namespace creators {
87 
88 /*!
89  * \ingroup ComputationalDomainGroup
90  *
91  * \brief A general domain for two compact objects.
92  *
93  * \image html binary_compact_object_domain.png "A BHNS domain."
94  *
95  * Creates a 3D Domain that represents a binary compact object solution. The
96  * Domain consists of 4, 5, or 6 nested layers of blocks; these layers are,
97  * working from the interior toward the exterior:
98  * - 0: (optionally) The block at the center of each compact object, if not
99  * excised. If present, this block is a cube. If excised, the hole left
100  * by its absence is spherical.
101  * - 1: The blocks that resolve each individual compact object. This layer has
102  * a spherical outer boundary - if the corresponding layer-0 block exists,
103  * then the layer is a cube-to-sphere transition; if the layer-0 block is
104  * excised, then the layer is a spherical shell.
105  * - 2: The blocks that surround each object with a cube. Around each compact
106  * object, this layer transitions from a sphere to a cube.
107  * - 3: The blocks that surround each cube with a half-cube. At this layer, the
108  * two compact objects are enclosed in a single cube-shaped grid.
109  * - 4: The 10 blocks that form the first outer shell. This layer transitions
110  * back to spherical. The gridpoints are distributed linearly with respect
111  * to radius.
112  * - 5: The 10 blocks that form a second outer shell. This layer is
113  * spherical, so a logarithmic map can optionally be used in this layer.
114  * This allows the domain to extend to large radial distances from the
115  * compact objects. This layer can be h-refined radially,
116  * creating a layer of multiple concentric spherical shells.
117  *
118  * In the code and options below, `ObjectA` and `ObjectB` refer to the two
119  * compact objects, and by extension, also refer to the layers that immediately
120  * surround each compact object. Note that `ObjectA` is located to the left of
121  * the origin (along the negative x-axis) and `ObjectB` is located to the right
122  * of the origin. `enveloping cube` refers to the outer surface of Layer 3.
123  * `outer sphere` is the radius of the spherical outer boundary, which is
124  * the outer boundary of Layer 5. The `enveloping cube` and `outer sphere`
125  * are both centered at the origin. `cutting plane` refers to the plane along
126  * which the domain divides into two hemispheres. In the final coordinates, the
127  * cutting plane always intersects the x-axis at the origin.
128  *
129  * \note The x-coordinate locations of the `ObjectA` and `ObjectB` should be
130  * chosen such that the center of mass is located at x=0.
131  *
132  * \note When using this domain, the
133  * metavariables struct can contain a struct named `domain`
134  * that conforms to domain::protocols::Metavariables. If
135  * domain::enable_time_dependent_maps is either set to `false`
136  * or not specified in the metavariables, then this domain will be
137  * time-independent. If domain::enable_time_dependent_maps is set
138  * to `true`, then this domain also includes a time-dependent map, along with
139  * additional options (and a corresponding constructor) for initializing the
140  * time-dependent map. These options include `InitialTime` and
141  * `InitialExpirationDeltaT`, which specify the initial time and the
142  * initial updating time interval, respectively, for the FunctionsOfTime
143  * controlling the map. The time-dependent map itself consists of a composition
144  * of a CubicScale expansion map and a Rotation map about the z axis everywhere
145  * except possibly in layer 1; in that case, if `ObjectA` or `ObjectB` is
146  * excised, then the time-dependent map in the corresponding blocks in
147  * layer 1 is a composition of a SphericalCompression size map, a CubicScale
148  * expansion map, and a Rotation map about the z axis.
149  */
151  public:
152  using maps_list = tmpl::list<
203 
204  /// Options for an excision region in the domain
205  struct Excision {
206  static constexpr Options::String help = {
207  "Excise the interior of the object, leaving a spherical hole in its "
208  "absence."};
209  template <typename BoundaryConditionsBase>
211  static std::string name() noexcept {
212  return "ExciseWithBoundaryCondition";
213  }
215  static constexpr Options::String help = {
216  "The boundary condition to impose on the excision surface."};
217  };
218  template <typename Metavariables>
219  using options = tmpl::list<BoundaryCondition<
221  typename Metavariables::system>>>;
223  boundary_condition;
224  };
225 
226  /// Options for one of the two objects in the binary domain
227  struct Object {
228  static constexpr Options::String help = {
229  "Options for an object in a binary domain."};
230  struct InnerRadius {
231  using type = double;
232  static constexpr Options::String help = {
233  "Inner coordinate radius of Layer 1."};
234  static double lower_bound() noexcept { return 0.; }
235  };
236  struct OuterRadius {
237  using type = double;
238  static constexpr Options::String help = {
239  "Outer coordinate radius of Layer 1"};
240  static double lower_bound() noexcept { return 0.; }
241  };
242  struct XCoord {
243  using type = double;
244  static constexpr Options::String help = {"x-coordinate of center."};
245  };
246  struct Interior {
248  static constexpr Options::String help = {
249  "Specify 'ExciseWithBoundaryCondition' and a boundary condition to "
250  "excise Layer 0, leaving a spherical hole in its absence, or set to "
251  "'Auto' to fill the interior."};
252  };
253  struct ExciseInterior {
254  using type = bool;
255  static constexpr Options::String help = {
256  "Excise Layer 0, leaving a spherical hole in its absence."};
257  };
259  using type = bool;
260  static constexpr Options::String help = {
261  "Use a logarithmically spaced radial grid in the part of Layer 1 "
262  "enveloping the object (requires the interior is excised)"};
263  };
265  using type = size_t;
266  static constexpr Options::String help = {
267  "Addition to radial refinement level in the part of Layer 1 "
268  "enveloping the object, beyond the refinement level set by "
269  "InitialRefinement."};
270  };
271  template <typename Metavariables>
272  using options = tmpl::list<
274  tmpl::conditional_t<
275  domain::BoundaryConditions::has_boundary_conditions_base_v<
276  typename Metavariables::system>,
279  Object() = default;
280  Object(double local_inner_radius, double local_outer_radius,
281  double local_x_coord, std::optional<Excision> interior,
282  bool local_use_logarithmic_map,
283  size_t local_addition_to_radial_refinement_level) noexcept
284  : inner_radius(local_inner_radius),
285  outer_radius(local_outer_radius),
286  x_coord(local_x_coord),
287  inner_boundary_condition(
288  interior.has_value()
289  ? std::make_optional(std::move(interior->boundary_condition))
290  : std::nullopt),
291  use_logarithmic_map(local_use_logarithmic_map),
292  addition_to_radial_refinement_level(
293  local_addition_to_radial_refinement_level) {}
294  Object(double local_inner_radius, double local_outer_radius,
295  double local_x_coord, bool local_excise_interior,
296  bool local_use_logarithmic_map,
297  size_t local_addition_to_radial_refinement_level) noexcept
298  : inner_radius(local_inner_radius),
299  outer_radius(local_outer_radius),
300  x_coord(local_x_coord),
301  inner_boundary_condition(
302  local_excise_interior
305  : std::nullopt),
306  use_logarithmic_map(local_use_logarithmic_map),
307  addition_to_radial_refinement_level(
308  local_addition_to_radial_refinement_level) {}
309 
310  /// Whether or not the object should be excised from the domain, leaving a
311  /// spherical hole. When this is true, `inner_boundary_condition` is
312  /// guaranteed to hold a value (though it might be a `nullptr` if we are not
313  /// working with boundary conditions).
314  bool is_excised() const noexcept;
315 
316  double inner_radius;
317  double outer_radius;
318  double x_coord;
319  std::optional<
320  std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>>
321  inner_boundary_condition;
322  bool use_logarithmic_map;
323  size_t addition_to_radial_refinement_level;
324  };
325 
326  struct ObjectA {
327  using type = Object;
328  static constexpr Options::String help = {
329  "Options for the object to the left of the origin (along the negative "
330  "x-axis)."};
331  };
332 
333  struct ObjectB {
334  using type = Object;
335  static constexpr Options::String help = {
336  "Options for the object to the right of the origin (along the positive "
337  "x-axis)."};
338  };
339 
340  struct EnvelopingCube {
341  static constexpr Options::String help = {
342  "Options for the cube enveloping the two objects."};
343  };
344 
346  using group = EnvelopingCube;
347  static std::string name() noexcept { return "Radius"; }
348  using type = double;
349  static constexpr Options::String help = {
350  "Radius of Layer 3 which circumscribes the Frustums."};
351  };
352 
353  struct OuterSphere {
354  static constexpr Options::String help = {
355  "Options for the outer spherical shell."};
356  };
357 
359  using group = OuterSphere;
360  static std::string name() noexcept { return "Radius"; }
361  using type = double;
362  static constexpr Options::String help = {"Radius of the entire domain."};
363  };
364 
366  using type = size_t;
367  static constexpr Options::String help = {
368  "Initial refinement level. Applied to each dimension."};
369  };
370 
372  using type = size_t;
373  static constexpr Options::String help = {
374  "Initial number of grid points in each dim per element."};
375  };
376 
378  using type = bool;
379  static constexpr Options::String help = {
380  "Use projective scaling on the frustal cloak."};
381  };
382 
384  using group = OuterSphere;
385  static std::string name() noexcept { return "UseLogarithmicMap"; }
386  using type = bool;
387  static constexpr Options::String help = {
388  "Use a logarithmically spaced radial grid in Layer 5, the outer "
389  "spherical shell that covers the wave zone."};
390  };
391 
393  using group = OuterSphere;
394  static std::string name() noexcept {
395  return "AdditionToRadialRefinementLevel";
396  }
397  using type = size_t;
398  static constexpr Options::String help = {
399  "Addition to radial refinement level in Layer 5 (the outer spherical "
400  "shell that covers that wave zone), beyond the refinement "
401  "level set by InitialRefinement."};
402  };
403 
404  template <typename BoundaryConditionsBase>
406  using group = OuterSphere;
407  static std::string name() noexcept { return "BoundaryCondition"; }
408  static constexpr Options::String help =
409  "Options for the outer boundary conditions.";
411  };
412 
413  // The following options are for optional time dependent maps
415  static constexpr Options::String help = {"Options for time-dependent maps"};
416  };
417 
418  /// \brief The initial time of the functions of time.
419  struct InitialTime {
420  using type = double;
421  static constexpr Options::String help = {
422  "The initial time of the functions of time"};
423  using group = TimeDependentMaps;
424  };
425  /// \brief The initial time interval for updates of the functions of time.
427  using type = Options::Auto<double>;
428  static constexpr Options::String help = {
429  "The initial time interval for updates of the functions of time. If "
430  "Auto, then the functions of time do not expire, nor can they be "
431  "updated."};
432  using group = TimeDependentMaps;
433  };
434 
435  struct ExpansionMap {
436  static constexpr Options::String help = {
437  "Options for a time-dependent expansion map (specifically, a "
438  "CubicScale map)"};
439  using group = TimeDependentMaps;
440  };
441 
442  /// \brief The outer boundary or pivot point of the
443  /// `domain::CoordinateMaps::TimeDependent::CubicScale` map
445  using type = double;
446  static constexpr Options::String help = {
447  "Outer boundary or pivot point of the map"};
448  using group = ExpansionMap;
449  static std::string name() noexcept { return "OuterBoundary"; }
450  };
451  /// \brief The initial values of the expansion factors.
453  using type = std::array<double, 2>;
454  static constexpr Options::String help = {
455  "Expansion values at initial time."};
456  using group = ExpansionMap;
457  };
458  /// \brief The velocity of the expansion factors.
460  using type = std::array<double, 2>;
461  static constexpr Options::String help = {"The rate of expansion."};
462  using group = ExpansionMap;
463  };
464  /// \brief The names of the functions of times to be added to the DataBox for
465  /// the expansion map.
466  ///
467  /// If the two names are same then a linear radial scaling is used instead of
468  /// a cubic scaling.
471  static constexpr Options::String help = {"Names of the functions of time."};
472  using group = ExpansionMap;
473  static std::string name() noexcept { return "FunctionOfTimeNames"; }
474  };
475 
477  static constexpr Options::String help = {
478  "Options for a time-dependent rotation map about the z axis"};
479  using group = TimeDependentMaps;
480  };
481  /// \brief The initial value of the rotation angle.
483  using type = double;
484  static constexpr Options::String help = {"Rotation angle at initial time."};
486  };
487  /// \brief The angular velocity of the rotation.
489  using type = double;
490  static constexpr Options::String help = {"The angular velocity."};
492  };
493  /// \brief The name of the function of time to be added to the added to the
494  /// DataBox for the rotation-about-the-z-axis map.
496  using type = std::string;
497  static constexpr Options::String help = {"Name of the function of time."};
499  static std::string name() noexcept { return "FunctionOfTimeName"; }
500  };
501 
502  struct SizeMap {
503  static constexpr Options::String help = {
504  "Options for a time-dependent size maps."};
505  using group = TimeDependentMaps;
506  };
507 
508  /// \brief Initial values for functions of time for size maps for objects A,B.
509  ///
510  /// \details If object A is not excised, no size map is applied for object A,
511  /// and this option is ignored for object A. If object B is not excised, no
512  /// size map is applied for object B, and this option is ignored for object B.
513  /// If neither object A nor object B are excised, this option is completely
514  /// ignored.
516  using type = std::array<double, 2>;
517  static constexpr Options::String help = {
518  "SizeMapA, SizeMapB values at initial time."};
519  using group = SizeMap;
520  static std::string name() noexcept { return "InitialValues"; }
521  };
522  /// \brief Initial velocities for functions of time for size maps for objects
523  /// A,B.
524  ///
525  /// \details If object A is not excised, no size map is applied for object A,
526  /// and this option is ignored for object A. If object B is not excised, no
527  /// size map is applied for object B, and this option is ignored for object B.
528  /// If neither object A nor object B are excised, this option is completely
529  /// ignored.
531  using type = std::array<double, 2>;
532  static constexpr Options::String help = {
533  "SizeMapA, SizeMapB initial velocities."};
534  using group = SizeMap;
535  static std::string name() noexcept { return "InitialVelocities"; }
536  };
537  /// \brief Initial accelerations for functions of time for size maps for
538  /// objects A,B
539  ///
540  /// \details If object A is not excised, no size map is applied for object A,
541  /// and this option is ignored for object A. If object B is not excised, no
542  /// size map is applied for object B, and this option is ignored for object B.
543  /// If neither object A nor object B are excised, this option is completely
544  /// ignored.
546  using type = std::array<double, 2>;
547  static constexpr Options::String help = {
548  "SizeMapA, SizeMapB initial accelerations."};
549  using group = SizeMap;
550  static std::string name() noexcept { return "InitialAccelerations"; }
551  };
552  /// \brief The names of the functions of times to be added to the added to the
553  /// DataBox for the size map.
554  ///
555  /// \details If object A is not excised, no size map is applied for object A,
556  /// and this option is ignored for object A. If object B is not excised, no
557  /// size map is applied for object B, and this option is ignored for object B.
558  /// If neither object A nor object B are excised, this option is completely
559  /// ignored.
562  static constexpr Options::String help = {
563  "Names of SizeMapA, SizeMapB functions of time."};
564  using group = SizeMap;
565  static std::string name() noexcept { return "FunctionOfTimeNames"; }
566  };
567 
568  template <typename Metavariables>
569  using time_independent_options = tmpl::append<
574  tmpl::conditional_t<
575  domain::BoundaryConditions::has_boundary_conditions_base_v<
576  typename Metavariables::system>,
577  tmpl::list<OuterBoundaryCondition<
579  typename Metavariables::system>>>,
580  tmpl::list<>>>;
581 
582  using time_dependent_options =
590 
591  template <typename Metavariables>
592  using options = tmpl::conditional_t<
593  BinaryCompactObject_detail::enable_time_dependent_maps_v<Metavariables>,
594  tmpl::append<time_dependent_options,
595  time_independent_options<Metavariables>>,
596  time_independent_options<Metavariables>>;
597 
598  static constexpr Options::String help{
599  "The BinaryCompactObject domain is a general domain for two compact "
600  "objects. The user must provide the inner and outer radii of the "
601  "spherical shells surrounding each of the two compact objects A and "
602  "B. The radial refinement levels for these shells are (InitialRefinement "
603  "+ Object{A,B}.AdditionToRadialRefinementLevel).\n\n"
604  "The user must also provide the radius of the sphere that "
605  "circumscribes the cube containing both compact objects, and the "
606  "radius of the outer boundary. The options Object{A,B}.Interior (or "
607  "Object{A,B}.ExciseInterior if we're not working with boundary "
608  "conditions) determine whether the layer-zero blocks are present "
609  "inside each compact object. If set to a boundary condition or 'false', "
610  "the domain will not contain layer zero for that object. The user "
611  "specifies Object{A,B}.XCoord, the x-coordinates of the locations of the "
612  "centers of each compact object. In these coordinates, the location for "
613  "the axis of rotation is x=0. ObjectA is located on the left and ObjectB "
614  "is located on the right. Please make sure that your choices of "
615  "x-coordinate locations are such that the resulting center of mass "
616  "is located at zero.\n\n"
617  "Two radial layers join the enveloping cube to the spherical outer "
618  "boundary. The first of these layers transitions from sphericity == 0.0 "
619  "on the inner boundary to sphericity == 1.0 on the outer boundary. The "
620  "second has sphericity == 1 (so either linear or logarithmic mapping can "
621  "be used in the radial direction), extends to the spherical outer "
622  "boundary of the domain, and has a radial refinement level of "
623  "(InitialRefinement + OuterSphere.AdditionToRadialRefinementLevel)."
624  "Note that the domain optionally includes time-dependent maps; enabling "
625  "the time-dependent maps requires adding a "
626  "struct named domain to the Metavariables, with this "
627  "struct conforming to domain::protocols::Metavariables. To enable the "
628  "time-dependent maps, set "
629  "Metavariables::domain::enable_time_dependent_maps to "
630  "true."};
631 
632  // Constructor for time-independent version of the domain
633  // (i.e., for when
634  // Metavariables::domain::enable_time_dependent_maps == false or
635  // when the metavariables do not define
636  // Metavariables::domain::enable_time_dependent_maps)
638  Object object_A, Object object_B, double radius_enveloping_cube,
639  double radius_enveloping_sphere, size_t initial_refinement,
640  size_t initial_grid_points_per_dim, bool use_projective_map = true,
641  bool use_logarithmic_map_outer_spherical_shell = false,
642  size_t addition_to_outer_layer_radial_refinement_level = 0,
644  outer_boundary_condition = nullptr,
645  const Options::Context& context = {});
646 
647  // Constructor for time-dependent version of the domain
648  // (i.e., for when
649  // Metavariables::domain::enable_time_dependent_maps == true),
650  // with parameters corresponding to the additional options
651  BinaryCompactObject(
652  double initial_time, std::optional<double> initial_expiration_delta_t,
653  double expansion_map_outer_boundary,
654  std::array<double, 2> initial_expansion,
655  std::array<double, 2> initial_expansion_velocity,
656  std::array<std::string, 2> expansion_function_of_time_names,
657  double initial_rotation_angle, double initial_angular_velocity,
658  std::string rotation_about_z_axis_function_of_time_name,
659  std::array<double, 2> initial_size_map_values,
660  std::array<double, 2> initial_size_map_velocities,
661  std::array<double, 2> initial_size_map_accelerations,
662  std::array<std::string, 2> size_map_function_of_time_names,
663  Object object_A, Object object_B, double radius_enveloping_cube,
664  double radius_enveloping_sphere, size_t initial_refinement,
665  size_t initial_grid_points_per_dim, bool use_projective_map = true,
666  bool use_logarithmic_map_outer_spherical_shell = false,
667  size_t addition_to_outer_layer_radial_refinement_level = 0,
669  outer_boundary_condition = nullptr,
670  const Options::Context& context = {});
671 
672  BinaryCompactObject() = default;
673  BinaryCompactObject(const BinaryCompactObject&) = delete;
674  BinaryCompactObject(BinaryCompactObject&&) noexcept = default;
675  BinaryCompactObject& operator=(const BinaryCompactObject&) = delete;
676  BinaryCompactObject& operator=(BinaryCompactObject&&) noexcept = default;
677  ~BinaryCompactObject() noexcept override = default;
678 
679  Domain<3> create_domain() const noexcept override;
680 
681  std::vector<std::array<size_t, 3>> initial_extents() const noexcept override;
682 
683  std::vector<std::array<size_t, 3>> initial_refinement_levels() const
684  noexcept override;
685 
686  auto functions_of_time() const noexcept -> std::unordered_map<
687  std::string,
688  std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>> override;
689 
690  private:
691  void check_for_parse_errors(const Options::Context& context) const;
692  void initialize_calculated_member_variables() noexcept;
693 
694  Object object_A_{};
695  Object object_B_{};
696  double radius_enveloping_cube_{};
697  double radius_enveloping_sphere_{};
698  size_t initial_refinement_{};
699  size_t initial_grid_points_per_dim_{};
700  static constexpr bool use_equiangular_map_ =
701  false; // Doesn't work properly yet
702  bool use_projective_map_ = true;
703  bool use_logarithmic_map_outer_spherical_shell_ = false;
704  size_t addition_to_outer_layer_radial_refinement_level_{};
705  double projective_scale_factor_{};
706  double translation_{};
707  double length_inner_cube_{};
708  double length_outer_cube_{};
709  size_t number_of_blocks_{};
711  outer_boundary_condition_;
712 
713  // Variables for FunctionsOfTime options
714  bool enable_time_dependence_;
715  double initial_time_;
716  std::optional<double> initial_expiration_delta_t_;
717  double expansion_map_outer_boundary_;
718  std::array<double, 2> initial_expansion_;
719  std::array<double, 2> initial_expansion_velocity_;
720  std::array<std::string, 2> expansion_function_of_time_names_;
721  double initial_rotation_angle_;
722  double initial_angular_velocity_;
723  std::string rotation_about_z_axis_function_of_time_name_;
724  std::array<double, 2> initial_size_map_values_;
725  std::array<double, 2> initial_size_map_velocities_;
726  std::array<double, 2> initial_size_map_accelerations_;
727  std::array<std::string, 2> size_map_function_of_time_names_;
728 };
729 } // namespace creators
730 } // namespace domain
domain::creators::BinaryCompactObject::ExpansionMap
Definition: BinaryCompactObject.hpp:435
domain::CoordinateMaps::ProductOf3Maps
Product of three one-dimensional CoordinateMaps.
Definition: ProductMaps.hpp:90
std::false_type
domain::BoundaryConditions::get_boundary_conditions_base
typename detail::get_boundary_conditions_base< T >::type get_boundary_conditions_base
Returns T::boundary_condition_base or a placeholder class.
Definition: GetBoundaryConditionsBase.hpp:33
domain::creators::BinaryCompactObject::Excision::BoundaryCondition
Definition: BinaryCompactObject.hpp:210
std::string
domain::creators::BinaryCompactObject::EnvelopingCube
Definition: BinaryCompactObject.hpp:340
domain::BoundaryConditions::BoundaryCondition
Base class from which all system-specific base classes must inherit.
Definition: BoundaryCondition.hpp:18
domain::creators::BinaryCompactObject::RadiusEnvelopingCube
Definition: BinaryCompactObject.hpp:345
Frame::Inertial
Definition: IndexType.hpp:44
domain::creators::BinaryCompactObject::OuterBoundaryCondition
Definition: BinaryCompactObject.hpp:405
Frame::Grid
Definition: IndexType.hpp:43
domain::creators::BinaryCompactObject::Object::UseLogarithmicMap
Definition: BinaryCompactObject.hpp:258
Options.hpp
domain::CoordinateMaps::TimeDependent::Rotation< 2 >
Time-dependent spatial rotation in two dimensions.
Definition: Rotation.hpp:57
vector
domain::creators::BinaryCompactObject
A general domain for two compact objects.
Definition: BinaryCompactObject.hpp:150
domain::CoordinateMaps::TimeDependent::ProductOf2Maps
Product of two codimension=0 CoordinateMaps, where one or both must be time-dependent.
Definition: ProductMaps.hpp:39
domain::creators::BinaryCompactObject::InitialAngularVelocity
The angular velocity of the rotation.
Definition: BinaryCompactObject.hpp:488
domain::creators::BinaryCompactObject::InitialSizeMapAccelerations
Initial accelerations for functions of time for size maps for objects A,B.
Definition: BinaryCompactObject.hpp:545
Domain.hpp
domain::creators::BinaryCompactObject::UseProjectiveMap
Definition: BinaryCompactObject.hpp:377
domain::CoordinateMaps::ProductOf2Maps
Product of two codimension=0 CoordinateMaps.
Definition: ProductMaps.hpp:35
domain::creators::BinaryCompactObject::Object
Options for one of the two objects in the binary domain.
Definition: BinaryCompactObject.hpp:227
domain::CoordinateMaps::Equiangular
Non-linear map from .
Definition: Equiangular.hpp:53
CoordinateMap.hpp
domain::creators::BinaryCompactObject::SizeMap
Definition: BinaryCompactObject.hpp:502
Options::Context
Definition: Options.hpp:41
domain::creators::BinaryCompactObject::RadiusOuterSphere
Definition: BinaryCompactObject.hpp:358
domain::CoordinateMaps::DiscreteRotation
A CoordinateMap that swaps/negates the coordinate axes.
Definition: DiscreteRotation.hpp:32
domain::CoordinateMaps::Affine
Affine map from .
Definition: Affine.hpp:37
domain::creators::BinaryCompactObject::TimeDependentMaps
Definition: BinaryCompactObject.hpp:414
domain::creators::BinaryCompactObject::OuterSphere
Definition: BinaryCompactObject.hpp:353
domain::creators::BinaryCompactObject::InitialExpirationDeltaT
The initial time interval for updates of the functions of time.
Definition: BinaryCompactObject.hpp:426
Options
Utilities for parsing input files.
Definition: MinmodType.hpp:8
domain::creators::BinaryCompactObject::InitialSizeMapVelocities
Initial velocities for functions of time for size maps for objects A,B.
Definition: BinaryCompactObject.hpp:530
cstddef
domain::CoordinateMaps::TimeDependent::CubicScale
Maps the radius as where is the radius of the source coordinates.
Definition: CubicScale.hpp:99
Assert.hpp
domain::creators::BinaryCompactObject::SizeMapFunctionOfTimeNames
The names of the functions of times to be added to the added to the DataBox for the size map.
Definition: BinaryCompactObject.hpp:560
domain::creators::BinaryCompactObject::InitialRefinement
Definition: BinaryCompactObject.hpp:365
array
domain::creators::BinaryCompactObject::InitialExpansionVelocity
The velocity of the expansion factors.
Definition: BinaryCompactObject.hpp:459
domain::creators::BinaryCompactObject::InitialTime
The initial time of the functions of time.
Definition: BinaryCompactObject.hpp:419
domain::CoordinateMaps::TimeDependent::SphericalCompression
Time-dependent compression of a finite 3D spherical volume.
Definition: SphericalCompression.hpp:252
Domain
A wrapper around a vector of Blocks that represent the computational domain.
Definition: Domain.hpp:40
domain::creators::BinaryCompactObject::ObjectA
Definition: BinaryCompactObject.hpp:326
memory
domain::creators::BinaryCompactObject::InitialGridPoints
Definition: BinaryCompactObject.hpp:371
domain::creators::BinaryCompactObject::UseLogarithmicMapOuterSphericalShell
Definition: BinaryCompactObject.hpp:383
domain::creators::BinaryCompactObject::ExpansionFunctionOfTimeNames
The names of the functions of times to be added to the DataBox for the expansion map.
Definition: BinaryCompactObject.hpp:469
Options::Auto
A class indicating that a parsed value can be automatically computed instead of specified.
Definition: Auto.hpp:36
domain::creators::BinaryCompactObject::Excision
Options for an excision region in the domain.
Definition: BinaryCompactObject.hpp:205
DomainCreator
Base class for creating Domains from an option string.
Definition: DomainCreator.hpp:32
domain::creators::BinaryCompactObject::ExpansionMapOuterBoundary
The outer boundary or pivot point of the domain::CoordinateMaps::TimeDependent::CubicScale map.
Definition: BinaryCompactObject.hpp:444
limits
domain::creators::BinaryCompactObject::InitialRotationAngle
The initial value of the rotation angle.
Definition: BinaryCompactObject.hpp:482
domain::creators::BinaryCompactObject::Object::Interior
Definition: BinaryCompactObject.hpp:246
domain::CoordinateMaps::Identity
Definition: Identity.hpp:28
domain::creators::BinaryCompactObject::Object::AdditionToRadialRefinementLevel
Definition: BinaryCompactObject.hpp:264
domain::CoordinateMaps::Frustum
A reorientable map from the cube to a frustum.
Definition: Frustum.hpp:164
Options::String
const char *const String
The string used in option structs.
Definition: Options.hpp:32
Frame
Definition: IndexType.hpp:36
domain::creators::BinaryCompactObject::AdditionToOuterLayerRadialRefinementLevel
Definition: BinaryCompactObject.hpp:392
domain::creators::BinaryCompactObject::Object::XCoord
Definition: BinaryCompactObject.hpp:242
domain::creators::BinaryCompactObject::ObjectB
Definition: BinaryCompactObject.hpp:333
Frame::Logical
Definition: IndexType.hpp:42
optional
domain::creators::BinaryCompactObject::InitialSizeMapValues
Initial values for functions of time for size maps for objects A,B.
Definition: BinaryCompactObject.hpp:515
domain::creators::BinaryCompactObject::RotationAboutZAxisMap
Definition: BinaryCompactObject.hpp:476
domain::creators::BinaryCompactObject::Object::ExciseInterior
Definition: BinaryCompactObject.hpp:253
domain::creators::BinaryCompactObject::InitialExpansion
The initial values of the expansion factors.
Definition: BinaryCompactObject.hpp:452
DomainCreator.hpp
domain::creators::BinaryCompactObject::RotationAboutZAxisFunctionOfTimeName
The name of the function of time to be added to the added to the DataBox for the rotation-about-the-z...
Definition: BinaryCompactObject.hpp:495
std::unique_ptr
unordered_map
type_traits
domain::creators::BinaryCompactObject::Object::OuterRadius
Definition: BinaryCompactObject.hpp:236
TMPL.hpp
domain::creators::BinaryCompactObject::Object::is_excised
bool is_excised() const noexcept
Whether or not the object should be excised from the domain, leaving a spherical hole....
domain::creators::BinaryCompactObject::Object::InnerRadius
Definition: BinaryCompactObject.hpp:230
domain::CoordinateMaps::Wedge
Map from a square or cube to a wedge.
Definition: Wedge.hpp:255
domain::CoordinateMap
A coordinate map or composition of coordinate maps.
Definition: CoordinateMap.hpp:240
string